From 0a37f84263b96090d1b7da963b9d352b448c41ee Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 25 Feb 2023 14:05:59 +0100 Subject: [PATCH] Added all blocks from base pack --- src/blocks.rs | 407 +++++++++++++++++++++++++++++++++++++-- src/main.rs | 3 +- src/screens/build.rs | 8 +- src/screens/inventory.rs | 4 +- src/screens/mod.rs | 6 +- src/screens/welcome.rs | 2 +- src/textures.rs | 20 +- src/types.rs | 2 +- 8 files changed, 411 insertions(+), 41 deletions(-) diff --git a/src/blocks.rs b/src/blocks.rs index ea8495f..3137be2 100644 --- a/src/blocks.rs +++ b/src/blocks.rs @@ -1,34 +1,411 @@ -use crate::textures::{ - AssetStore, - DirectionalTexture -}; +use std::collections::HashMap; +use crate::textures::DirectionalTexture; + +static mut CACHE: Option> = None; #[derive(Eq, Hash, Clone, PartialEq)] pub enum Block { - Dirt, - GrassCenter + Bridge, + + BuildingCenter, + BuildingCenterBeige, + BuildingCorner, + BuildingCornerBeige, + BuildingDoor, + BuildingDoorBeige, + BuildingDoorWindows, + BuildingDoorWindowsBeige, + BuildingWindow, + BuildingWindowBeige, + BuildingWindows, + BuildingWindowsBeige, + + CastleBend, + CastleCenter, + CastleCorner, + CastleGate, + CastleGateOpen, + CastleSlope, + CastleTower, + CastleTowerBeige, + CastleTowerBrown, + CastleTowerGreen, + CastleTowerPurple, + CastleWall, + CastelWindow, + + DirtCenter, + DirtLow, + + GrassCenter, + GrassCorner, + GrassPath, + GrassPathBend, + GrassPathCorner, + GrassPathCrossing, + GrassPathEnd, + GrassPathEndSquare, + GrassPathSlope, + GrassPathSplit, + GrassRiver, + GrassRiverBend, + GrassRiverBridge, + GrassRiverCorner, + GrassRiverCrossing, + GrassRiverEnd, + GrassRiverEndSquare, + GrassRiverSlope, + GrassRiverSplit, + GrassSlope, + GrassSlopeConcave, + GrassSlopeConvex, + GrassWater, + GrassWaterConcave, + GrassWaterConvex, + GrassWaterRiver, + + RocksDirt, + RocksGrass, + + RoofChurchBeige, + RoofChuchBrown, + RoofChurchGreen, + RoofChurchPurple, + RoofGableBeige, + RoofGableBrown, + RoofGableGreen, + RoofGablePurple, + RoofPointBeige, + RoofPointBrown, + RoofPointGreen, + RoofPointPurple, + RoofRoundBeige, + RoofRoundBrown, + RoofRoundGreen, + RoofRoundPurple, + RoofRoundedBeige, + RoofRoundedBrown, + RoofRoundedGreen, + RoofRoundedPurple, + RoofSlantBeige, + RoofSlantBrown, + RoofSlantGreen, + RoofSlantPurple, + + StructureArch, + StructureHigh, + StructureLow, + + /// tree_multiple_ + Trees, + /// tree_single_ + Tree, + + WaterCenter, + WaterFall } impl Block { /// returns the texture for the block - /// with the direction the block is facing - pub fn get_texture<'a>(&self, assets: &'a AssetStore) -> &'a DirectionalTexture { - match self { - Block::Dirt => &assets.blocks.dirt, - Block::GrassCenter => &assets.blocks.grass_center + pub async fn get_texture(&self) -> DirectionalTexture { + let file_name = match self { + Block::Bridge => "bridge", + Block::BuildingCenter => "building_center", + Block::BuildingCenterBeige => "building_centerBeige", + Block::BuildingCorner => "building_corner", + Block::BuildingCornerBeige => "building_cornerBeige", + Block::BuildingDoor => "building_door", + Block::BuildingDoorBeige => "building_doorBeige", + Block::BuildingDoorWindows => "building_doorWindows", + Block::BuildingDoorWindowsBeige => "building_doorWindowsBeige", + Block::BuildingWindow => "building_window", + Block::BuildingWindowBeige => "building_windowBeige", + Block::BuildingWindows => "building_windows", + Block::BuildingWindowsBeige => "building_windowsBeige", + + Block::CastleBend => "castle_bend", + Block::CastleCenter => "castle_center", + Block::CastleCorner => "castle_corner", + Block::CastleGate => "castle_gate", + Block::CastleGateOpen => "castle_gateOpen", + Block::CastleSlope => "castle_slope", + Block::CastleTower => "castle_tower", + Block::CastleTowerBeige => "castle_towerBeige", + Block::CastleTowerBrown => "castle_towerBrown", + Block::CastleTowerGreen => "castle_towerGreen", + Block::CastleTowerPurple => "castle_towerPurple", + Block::CastleWall => "castle_wall", + Block::CastelWindow => "castle_window", + + Block::DirtCenter => "dirt_center", + Block::DirtLow => "dirt_low", + + Block::GrassCenter => "grass_center", + Block::GrassCorner => "grass_corner", + Block::GrassPath => "grass_path", + Block::GrassPathBend => "grass_pathBend", + Block::GrassPathCorner => "grass_pathCorner", + Block::GrassPathCrossing => "grass_pathCrossing", + Block::GrassPathEnd => "grass_pathEnd", + Block::GrassPathEndSquare => "grass_pathEndSquare", + Block::GrassPathSlope => "grass_pathSlope", + Block::GrassPathSplit => "grass_pathSplit", + Block::GrassRiver => "grass_river", + Block::GrassRiverBend => "grass_riverBend", + Block::GrassRiverBridge => "grass_riverBridge", + Block::GrassRiverCorner => "grass_riverCorner", + Block::GrassRiverCrossing => "grass_riverCrossing", + Block::GrassRiverEnd => "grass_riverEnd", + Block::GrassRiverEndSquare => "grass_riverEndSquare", + Block::GrassRiverSlope => "grass_riverSlope", + Block::GrassRiverSplit => "grass_riverSplit", + Block::GrassSlope => "grass_slope", + Block::GrassSlopeConcave => "grass_slopeConcave", + Block::GrassSlopeConvex => "grass_slopeConvex", + Block::GrassWater => "grass_water", + Block::GrassWaterConcave => "grass_waterConcave", + Block::GrassWaterConvex => "grass_waterConvex", + Block::GrassWaterRiver => "grass_waterRiver", + + Block::RocksDirt => "rocks_dirt", + Block::RocksGrass => "rocks_grass", + + Block::RoofChurchBeige => "roof_churchBeige", + Block::RoofChuchBrown => "roof_churchBrown", + Block::RoofChurchGreen => "roof_churchGreen", + Block::RoofChurchPurple => "roof_churchPurple", + Block::RoofGableBeige => "roof_gableBeige", + Block::RoofGableBrown => "roof_gableBrown", + Block::RoofGableGreen => "roof_gableGreen", + Block::RoofGablePurple => "roof_gablePurple", + Block::RoofPointBeige => "roof_pointBeige", + Block::RoofPointBrown => "roof_pointBrown", + Block::RoofPointGreen => "roof_pointGreen", + Block::RoofPointPurple => "roof_pointPurple", + Block::RoofRoundBeige => "roof_roundBeige", + Block::RoofRoundBrown => "roof_roundBrown", + Block::RoofRoundGreen => "roof_roundGreen", + Block::RoofRoundPurple => "roof_roundPurple", + Block::RoofRoundedBeige => "roof_roundedBeige", + Block::RoofRoundedBrown => "roof_roundedBrown", + Block::RoofRoundedGreen => "roof_roundedGreen", + Block::RoofRoundedPurple => "roof_roundedPurple", + Block::RoofSlantBeige => "roof_slantBeige", + Block::RoofSlantBrown => "roof_slantBrown", + Block::RoofSlantGreen => "roof_slantGreen", + Block::RoofSlantPurple => "roof_slantPurple", + + Block::StructureArch => "structure_arch", + Block::StructureHigh => "structure_high", + Block::StructureLow => "structure_low", + + Block::Trees => "tree_multiple", + Block::Tree => "tree_single", + + Block::WaterCenter => "water_center", + Block::WaterFall => "water_fall" + }; + + + unsafe { + if CACHE.is_none() { + CACHE = Some(HashMap::new()); + } + + if let Some(map) = &CACHE { + if let Some(tx) = map.get(file_name) { + return tx.clone(); + } + } + }; + + let texture = DirectionalTexture::from_auto_png(file_name).await; + + unsafe { + if let Some(map) = &mut CACHE { + map.insert(file_name, texture.clone()); + } } + + return texture.clone(); } /// returns a list of all blocks pub fn all() -> Vec { vec![ - Block::Dirt, - Block::GrassCenter + Block::Bridge, + Block::BuildingCenter, + Block::BuildingCenterBeige, + Block::BuildingCorner, + Block::BuildingCornerBeige, + Block::BuildingDoor, + Block::BuildingDoorBeige, + Block::BuildingDoorWindows, + Block::BuildingDoorWindowsBeige, + Block::BuildingWindow, + Block::BuildingWindowBeige, + Block::BuildingWindows, + Block::BuildingWindowsBeige, + Block::CastleBend, + Block::CastleCenter, + Block::CastleCorner, + Block::CastleGate, + Block::CastleGateOpen, + Block::CastleSlope, + Block::CastleTower, + Block::CastleTowerBeige, + Block::CastleTowerBrown, + Block::CastleTowerGreen, + Block::CastleTowerPurple, + Block::CastleWall, + Block::CastelWindow, + Block::DirtCenter, + Block::DirtLow, + Block::GrassCenter, + Block::GrassCorner, + Block::GrassPath, + Block::GrassPathBend, + Block::GrassPathCorner, + Block::GrassPathCrossing, + Block::GrassPathEnd, + Block::GrassPathEndSquare, + Block::GrassPathSlope, + Block::GrassPathSplit, + Block::GrassRiver, + Block::GrassRiverBend, + Block::GrassRiverBridge, + Block::GrassRiverCorner, + Block::GrassRiverCrossing, + Block::GrassRiverEnd, + Block::GrassRiverEndSquare, + Block::GrassRiverSlope, + Block::GrassRiverSplit, + Block::GrassSlope, + Block::GrassSlopeConcave, + Block::GrassSlopeConvex, + Block::GrassWater, + Block::GrassWaterConcave, + Block::GrassWaterConvex, + Block::GrassWaterRiver, + Block::RocksDirt, + Block::RocksGrass, + Block::RoofChurchBeige, + Block::RoofChuchBrown, + Block::RoofChurchGreen, + Block::RoofChurchPurple, + Block::RoofGableBeige, + Block::RoofGableBrown, + Block::RoofGableGreen, + Block::RoofGablePurple, + Block::RoofPointBeige, + Block::RoofPointBrown, + Block::RoofPointGreen, + Block::RoofPointPurple, + Block::RoofRoundBeige, + Block::RoofRoundBrown, + Block::RoofRoundGreen, + Block::RoofRoundPurple, + Block::RoofRoundedBeige, + Block::RoofRoundedBrown, + Block::RoofRoundedGreen, + Block::RoofRoundedPurple, + Block::RoofSlantBeige, + Block::RoofSlantBrown, + Block::RoofSlantGreen, + Block::RoofSlantPurple, + Block::StructureArch, + Block::StructureHigh, + Block::StructureLow, + Block::Trees, + Block::Tree, + Block::WaterCenter, + Block::WaterFall ] } pub fn get_name(&self) -> &str { match self { - Block::Dirt => "Dirt", - Block::GrassCenter => "Grass", + Block::Bridge => "Bridge", + Block::BuildingDoor | Block::BuildingDoorBeige => "Building door", + Block::BuildingDoorWindows | Block::BuildingDoorWindowsBeige => "Building door", + Block::BuildingCenter | Block::BuildingCenterBeige => "Building", + Block::BuildingCorner | Block::BuildingCornerBeige => "Building corner", + Block::BuildingWindow | Block::BuildingWindowBeige => "Building window", + Block::BuildingWindows | Block::BuildingWindowsBeige => "Building windows", + Block::CastleBend => "Castle bend", + Block::CastleCenter | Block::CastleCorner => "Castle", + Block::CastleGate => "Castle Gate", + Block::CastleGateOpen => "Open castle gate", + Block::CastleSlope => "Castle slope", + Block::CastleTower + | Block::CastleTowerBeige + | Block::CastleTowerBrown + | Block::CastleTowerGreen + | Block::CastleTowerPurple => "Castle tower", + Block::CastleWall => "Castle wall", + Block::CastelWindow => "Castle window", + + Block::DirtCenter | Block::DirtLow => "Dirt", + Block::GrassCenter | Block::GrassCorner => "Grass", + Block::GrassPath + | Block::GrassPathBend + | Block::GrassPathCorner + | Block::GrassPathCrossing + | Block::GrassPathEnd + | Block::GrassPathSplit + | Block::GrassPathEndSquare => "Grass path", + Block::GrassPathSlope => "Grass slope", + Block::GrassRiver + | Block::GrassRiverBend + | Block::GrassRiverBridge + | Block::GrassRiverCorner + | Block::GrassRiverCrossing + | Block::GrassRiverEnd + | Block::GrassRiverEndSquare + | Block::GrassRiverSplit + | Block::GrassRiverSlope => "River", + Block::GrassSlope + | Block::GrassSlopeConcave + | Block::GrassSlopeConvex => "Grass slope", + Block::GrassWater + | Block::GrassWaterConcave + | Block::GrassWaterConvex + | Block::GrassWaterRiver => "Grass water", + Block::RocksDirt | Block::RocksGrass => "Rocks", + Block::RoofChurchBeige + | Block::RoofChuchBrown + | Block::RoofChurchGreen + | Block::RoofChurchPurple => "Church roof", + Block::RoofGableBeige + | Block::RoofGableBrown + | Block::RoofGableGreen + | Block::RoofGablePurple => "Gable roof", + Block::RoofPointBeige + | Block::RoofPointBrown + | Block::RoofPointGreen + | Block::RoofPointPurple => "Point roof", + Block::RoofRoundBeige + | Block::RoofRoundBrown + | Block::RoofRoundGreen + | Block::RoofRoundPurple => "Round roof", + Block::RoofRoundedBeige + | Block::RoofRoundedBrown + | Block::RoofRoundedGreen + | Block::RoofRoundedPurple => "Rounded roof", + Block::RoofSlantBeige + | Block::RoofSlantBrown + | Block::RoofSlantGreen + | Block::RoofSlantPurple => "Slant roof", + Block::StructureArch + | Block::StructureHigh + | Block::StructureLow => "Scaffold", + Block::Trees => "Trees", + Block::Tree => "Tree", + Block::WaterCenter => "Water", + Block::WaterFall => "Waterfall" } } } +impl Default for Block { + fn default() -> Self { + Block::StructureHigh + } +} diff --git a/src/main.rs b/src/main.rs index d431ab0..62d2630 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,6 @@ #![feature(int_roundings)] #![feature(let_chains)] +#![feature(async_fn_in_trait)] use macroquad::prelude::*; @@ -27,7 +28,7 @@ async fn main() { loop { clear_background(Color::from_rgba(215, 189, 165, 255)); - screen.draw(&assets); + screen.draw(&assets).await; match screen.ev_loop() { GameEvent::Quit => break, diff --git a/src/screens/build.rs b/src/screens/build.rs index 1a957aa..83d6101 100644 --- a/src/screens/build.rs +++ b/src/screens/build.rs @@ -152,10 +152,10 @@ impl Face { } impl GameComponent for BuildScreen { - fn draw(&self, assets: &AssetStore) { + async fn draw(&self, assets: &AssetStore) { if self.show_inv { // draw inventory - self.inv.draw(&assets); + self.inv.draw(&assets).await; return; } // order: x (inc) -> y (inc) -> z (inc) @@ -163,7 +163,7 @@ impl GameComponent for BuildScreen { render_order.sort_by_key(|(pos, _)| pos.x + pos.y*2 + pos.z*3 ); for (pos, (block, dir)) in render_order.iter() { - let texture = block.get_texture(&assets).get_dir(dir); + let texture = block.get_texture().await.get_dir(dir); let width = TEXTURE_WIDTH * self.cam.scale; let height = TEXTURE_HEIGHT * self.cam.scale; @@ -219,7 +219,7 @@ impl GameComponent for BuildScreen { if let Some(block) = &self.inv.selected { // draw block draw_texture_ex( - block.get_texture(&assets).get_dir(&self.inv.direction), + block.get_texture().await.get_dir(&self.inv.direction), tx + slot_render_dim / 6.0, ty + width / 2.0 - (slot_render_dim * 2.0/3.0 * TEXTURE_HEIGHT / TEXTURE_WIDTH) / 2.0 diff --git a/src/screens/inventory.rs b/src/screens/inventory.rs index 5377a99..0232de3 100644 --- a/src/screens/inventory.rs +++ b/src/screens/inventory.rs @@ -87,7 +87,7 @@ const SLOTS_PER_PAGE: usize = 9; impl GameComponent for Inventory { - fn draw(&self, assets: &AssetStore) { + async fn draw(&self, assets: &AssetStore) { let mid_x = screen_width()/2.0; let mid_y = screen_height()/2.0; @@ -148,7 +148,7 @@ impl GameComponent for Inventory { if let Some((block, amount)) = list.get(self.page * SLOTS_PER_PAGE + x + y * hslot_count) { // draw block draw_texture_ex( - block.get_texture(&assets).get_dir(&self.direction), + block.get_texture().await.get_dir(&self.direction), tx + slot_render_dim / 6.0, ty + slot_dim / 2.0 - TEXTURE_HEIGHT / 2.0 + TEXTURE_Y_WHITESPACE / 2.0, WHITE, diff --git a/src/screens/mod.rs b/src/screens/mod.rs index 3a3e255..87999c8 100644 --- a/src/screens/mod.rs +++ b/src/screens/mod.rs @@ -16,10 +16,10 @@ pub enum Screen { Build(BuildScreen), } impl GameComponent for Screen { - fn draw(&self, assets: &AssetStore) { + async fn draw(&self, assets: &AssetStore) { match self { - Screen::Welcome(w) => w.draw(&assets), - Screen::Build(b) => b.draw(&assets), + Screen::Welcome(w) => w.draw(&assets).await, + Screen::Build(b) => b.draw(&assets).await, } } fn ev_loop(&mut self) -> GameEvent { diff --git a/src/screens/welcome.rs b/src/screens/welcome.rs index cf63f15..30b9ff5 100644 --- a/src/screens/welcome.rs +++ b/src/screens/welcome.rs @@ -18,7 +18,7 @@ impl WelcomeScreen { } } impl GameComponent for WelcomeScreen { - fn draw(&self, assets: &AssetStore) { + async fn draw(&self, assets: &AssetStore) { draw_centered_text( "Welcome", screen_width()/2.0, screen_height()/2.0, diff --git a/src/textures.rs b/src/textures.rs index ea9b06c..8a6279b 100644 --- a/src/textures.rs +++ b/src/textures.rs @@ -28,7 +28,6 @@ fn in_font_folder(path: &str) -> String { pub struct AssetStore { pub font: Font, pub ui: UIAssetCollection, - pub blocks: BlockAssetCollection } pub struct UIAssetCollection { pub long_button: (Texture2D, Texture2D), @@ -38,6 +37,7 @@ pub struct UIAssetCollection { pub arrow_right: Texture2D, pub close_button: Texture2D } +#[derive(Clone)] pub struct DirectionalTexture { pub north: Texture2D, pub south: Texture2D, @@ -45,19 +45,19 @@ pub struct DirectionalTexture { pub west: Texture2D, } impl DirectionalTexture { - async fn from_auto_png(name: &str) -> Self { + pub async fn from_auto_png(name: &str) -> Self { Self { north: load_texture( - &in_base_folder(&format!("{}_N.png", name))) + &in_base_folder(&format!("Tiles/{}_N.png", name))) .await.expect("Unable to load texture N"), south: load_texture( - &in_base_folder(&format!("{}_S.png", name))) + &in_base_folder(&format!("Tiles/{}_S.png", name))) .await.expect("Unable to load texture S"), west: load_texture( - &in_base_folder(&format!("{}_W.png", name))) + &in_base_folder(&format!("Tiles/{}_W.png", name))) .await.expect("Unable to load texture W"), east: load_texture( - &in_base_folder(&format!("{}_E.png", name))) + &in_base_folder(&format!("Tiles/{}_E.png", name))) .await.expect("Unable to load texture E"), } } @@ -70,10 +70,6 @@ impl DirectionalTexture { } } } -pub struct BlockAssetCollection { - pub dirt: DirectionalTexture, - pub grass_center: DirectionalTexture -} impl AssetStore { /// loads all the textures @@ -113,10 +109,6 @@ impl AssetStore { &in_ui_folder("PNG/iconCross_brown.png")) .await.expect("Unable to load texture") }, - blocks: BlockAssetCollection { - dirt: DirectionalTexture::from_auto_png("Tiles/dirt_center").await, - grass_center: DirectionalTexture::from_auto_png("Tiles/grass_center").await - } } } } diff --git a/src/types.rs b/src/types.rs index 7802168..e955cdf 100644 --- a/src/types.rs +++ b/src/types.rs @@ -48,7 +48,7 @@ pub enum Direction { /// but the serve different purposes pub trait GameComponent { /// Callback used to redraw the component - fn draw(&self, assets: &AssetStore) {} + async fn draw(&self, assets: &AssetStore) {} /// Callback used to perform background tasks /// e.g. keyboard input /// NOTE: this is currently not being run asynchronously -- 2.38.5