Using alpha value

.forgejo/workflows/rust.yml

@@ -59,11 +59,10 @@ jobs:
             target
           key: "${{runner.os}} Rust ${{steps.rust-toolchain.outputs.cachekey}}"
       - run: mkdir .ci-destdir
-      - run: cargo install --path . --locked --root .
+      - run: cargo install --path . --locked --root .ci-destdir
       - run: find .ci-destdir
       - uses: forgejo/upload-artifact@v3
         with:
           name: Powercreep
-          path: |
-            bin
-            assets
+          path:
+            .ci-destdir/*

build.rs

@@ -122,20 +122,16 @@ impl AssetsWriter {
 			writeln!(file, "{indent}impl Assets {{")?;
 			writeln!(
 				file,
-				"{indent}\tpub fn load(_ctx: &mut comfy::EngineContext<'_>) {{"
+				"{indent}\tpub fn load(c: &mut comfy::EngineContext<'_>) {{"
 			)?;
 			for asset_const_name in root.assets.values() {
-				writeln!(file, "{indent}\t\t_ctx.load_texture_from_bytes({asset_const_name:?}, {asset_const_name});")?;
+				writeln!(file, "{indent}\t\tc.load_texture_from_bytes({asset_const_name:?}, {asset_const_name});")?;
 			}
 			for asset_const_name in root.sound_assets.values() {
-				writeln!(file, "{indent}\t\tcomfy::load_sound_from_bytes({asset_const_name:?}, {asset_const_name},")?;
-				writeln!(
-					file,
-					"{indent}\t\t\tcomfy::StaticSoundSettings::new().loop_region(..));"
-				)?;
+				writeln!(file, "{indent}\t\tcomfy::load_sound_from_bytes({asset_const_name:?}, {asset_const_name}, Default::default());")?;
 			}
 			for group_name in root.groups.keys() {
-				writeln!(file, "{indent}\t\t{group_name}::Assets::load(_ctx);")?;
+				writeln!(file, "{indent}\t\t{group_name}::Assets::load(c);")?;
 			}
 			writeln!(file, "{indent}\t}}")?;
 			writeln!(file, "{indent}}}")?;

src/activities/house/furniture.rs

@@ -1,5 +1,5 @@
 use comfy::{error, texture_id, EngineContext, HashSet, Lazy, Mutex, TextureHandle};
-use std::{fmt::Debug, fs, io, path::PathBuf, sync::Arc};
+use std::{fmt::Debug, fs, io, sync::Arc};
 
 static ASSETS_LOADED: Lazy<Arc<Mutex<HashSet<String>>>> =
 	Lazy::new(|| Arc::new(Mutex::new(HashSet::new())));
@@ -39,13 +39,10 @@ impl FurnitureAsset {
 		if loaded.contains(&path) {
 			return Some(texture_id(&path));
 		}
-
-		let mut asset_path = PathBuf::from(format!("assets/furniture/{path}"));
-		if !asset_path.exists() {
-			asset_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(asset_path);
-		}
-
-		let bytes = match fs::read(asset_path) {
+		let bytes = match fs::read(format!(
+			"{}/assets/furniture/{path}",
+			env!("CARGO_MANIFEST_DIR")
+		)) {
 			Ok(bytes) => bytes,
 			Err(err) if err.kind() == io::ErrorKind::NotFound => return None,
 			Err(err) => {

src/activities/house/magnet-shader.wgsl

@@ -0,0 +1,7 @@
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let global_coord: vec3<f32> = in.world_position;
+    let tex = textureSample(t_diffuse, s_diffuse, in.tex_coords);
+    var final_color: vec4<f32> = tex * in.color;
+    return vec4(global_coord, final_color.a);
+}

src/activities/house/mod.rs

@@ -3,59 +3,36 @@ mod grid;
 mod player;
 mod room;
 
-use crate::assets::ASSETS;
-use comfy::{
-	delta, main_camera_mut, play_sound_id, random_i32, stop_sound_id, vec2,
-	EngineContext, RandomRange as _
-};
+use comfy::{main_camera_mut, random_i32, vec2, EngineContext, RandomRange as _};
 use grid::Grid;
-use indexmap::IndexSet;
 use log::error;
 use player::Player;
 use room::Room;
 
-use super::Activity;
-
 const MAX_ROOMS: i32 = 6;
 
 #[derive(Debug)]
 pub struct HouseState {
 	current_room_id: usize,
 	room_count: usize,
-	human_count: usize,
 	rooms: Vec<Room>,
-	human_rooms: Vec<usize>,
 	//grid: Grid,
 	player: Player,
 	human_layer: bool, //Human, magnetic, electric
-	exit_time: f32,
 
 	/// The energy level remaining in the house. Should decrease by itself, and much
 	/// faster when inhabited by the ghost.
 	pub charge: f32,
-	pub max_charge: f32,
-
-	pub sound_playing: bool
+	pub max_charge: f32
 }
 
 impl HouseState {
 	pub fn generate_new_house(ctx: &mut EngineContext<'_>) -> Self {
 		let room_count = random_i32(2, MAX_ROOMS) as usize;
-		let human_count = random_i32(1, room_count as i32) as usize;
-
-		let mut possible_rooms: IndexSet<usize> = (0 .. room_count).collect();
-		let mut human_rooms = Vec::new();
-		for _ in 0 .. human_count {
-			if !possible_rooms.is_empty() {
-				let random_idx = usize::gen_range(0, possible_rooms.len());
-
-				human_rooms.push(possible_rooms.swap_remove_index(random_idx).unwrap());
-			}
-		}
 
 		let mut rooms = Vec::new();
-		for i in 0 .. room_count {
-			rooms.push(Room::new(ctx, human_rooms.contains(&i)));
+		for _ in 0 .. room_count {
+			rooms.push(Room::new(ctx));
 		}
 
 		let player = Player::new(rooms.first().unwrap());
@@ -63,33 +40,29 @@ impl HouseState {
 		HouseState {
 			current_room_id: 0,
 			room_count,
-			human_count,
 			rooms,
-			human_rooms,
 			player,
 			human_layer: false,
-			exit_time: 0.0,
 			// TODO this should be lower depending on the time elapsed
 			charge: max_charge,
-			max_charge,
-
-			sound_playing: false
+			max_charge
 		}
 	}
 }
 
-pub fn draw(state: &crate::State, _ctx: &EngineContext<'_>) {
+pub fn draw(state: &crate::State, _ctx: &mut comfy::EngineContext<'_>) {
 	let Some(house) = state.house() else {
 		error!("How can I render a house when I'm not in one?!?");
 		return;
 	};
 
 	//Draw House
-	house
-		.rooms
-		.get(house.current_room_id)
-		.unwrap()
-		.draw(house.human_layer, house.player.can_see_metal(0.1));
+	house.rooms.get(house.current_room_id).unwrap().draw(
+		house.human_layer,
+		house.player.can_see_metal(0.1),
+		house.player.get_position(),
+		_ctx
+	);
 
 	//Draw Grid
 	//state.house.grid.draw();
@@ -98,27 +71,13 @@ pub fn draw(state: &crate::State, _ctx: &EngineContext<'_>) {
 	house.player.draw();
 }
 
-pub fn update(state: &mut crate::State, ctx: &mut EngineContext<'_>) {
-	if state.overworld.sound_playing {
-		stop_sound_id(ASSETS.music.galactic_rap_speedup);
-		state.overworld.sound_playing = false;
-	}
-
+pub fn update(state: &mut crate::State, ctx: &mut comfy::EngineContext<'_>) {
 	let mut camera = main_camera_mut();
 	camera.center = vec2(0.0, 0.0);
-	drop(camera);
 
-	let Some(house) = state.house_mut(ctx) else {
-		error!("WTF I cannot update a house without a house");
-		return;
-	};
+	let house = state.house_mut(ctx);
 	let current_room = house.rooms.get(house.current_room_id).unwrap();
-	house.player.update(&current_room);
-
-	if !house.sound_playing {
-		play_sound_id(ASSETS.music.mesmerizing_galaxy_loop);
-		house.sound_playing = true;
-	}
+	house.player.update(&current_room.grid);
 
 	if house.player.is_moving_to_right_room(current_room) {
 		if house.current_room_id < (house.room_count - 1) {
@@ -139,18 +98,4 @@ pub fn update(state: &mut crate::State, ctx: &mut EngineContext<'_>) {
 			house.player.reset_on_room(current_room, true);
 		}
 	}
-
-	if house.player.successfull_attack {
-		house.human_layer = true;
-	}
-
-	if house.human_layer {
-		house.exit_time += delta();
-	}
-
-	if house.exit_time >= 2.0 {
-		state.score += 500.0;
-		state.ghost.overworld_pos -= vec2(0.0, 1.0);
-		state.activity = Activity::Overworld;
-	}
 }

src/activities/house/player.rs

@@ -2,11 +2,7 @@ use super::{
 	room::{Room, SCALE},
 	Grid
 };
-use comfy::{
-	delta, draw_circle, draw_sprite, is_key_down, is_key_pressed, main_camera_mut,
-	texture_id, vec2, KeyCode, Vec2, RED, WHITE
-};
-use log::error;
+use comfy::{delta, draw_circle, is_key_down, vec2, KeyCode, Vec2, RED};
 use std::collections::HashSet;
 
 #[derive(Debug)]
@@ -17,8 +13,7 @@ pub struct Player {
 	current_acceleration: f32,
 	movement_time: f32,
 	connection: usize,
-	next_connections: Vec<usize>,
-	pub successfull_attack: bool
+	next_connections: Vec<usize>
 }
 
 impl Player {
@@ -33,24 +28,18 @@ impl Player {
 			current_acceleration: 0.0,
 			movement_time: 0.0,
 			connection: 0,
-			next_connections: vec![1],
-			successfull_attack: false
+			next_connections: vec![1]
 		}
 	}
 
+	pub fn get_position(&self) -> Vec2 {
+		self.position
+	}
 	pub fn draw(&self) {
-		//draw_circle(self.position, 0.5, RED, 0);
-		draw_sprite(
-			texture_id("ghost_house"),
-			self.position,
-			WHITE,
-			5,
-			vec2(1.25, 1.25)
-		);
+		draw_circle(self.position, 0.5, RED, 0);
 	}
 
-	pub fn update(&mut self, room: &Room) {
-		let grid = &room.grid;
+	pub fn update(&mut self, grid: &Grid) {
 		let allowed_movement = get_allowed_movement(self, grid);
 
 		move_player(self, allowed_movement);
@@ -58,8 +47,6 @@ impl Player {
 		if !on_current_connection(self, grid) && !update_connections(self, grid) {
 			snap_to_closest_node(self, grid);
 		}
-
-		attack_human_routine(self, room);
 	}
 
 	pub fn is_moving_to_right_room(&self, room: &Room) -> bool {
@@ -369,42 +356,3 @@ fn snap_to_closest_node(player: &mut Player, grid: &Grid) {
 
 	player.position = *closest_node;
 }
-
-fn attack_human_routine(player: &mut Player, room: &Room) {
-	let range = 1.0;
-
-	if is_key_pressed(KeyCode::Space) {
-		//In some node range?
-		let mut in_range = false;
-		for node in &room.grid.nodes {
-			if in_node_range(&player.position, node, range) {
-				in_range = true;
-				break;
-			}
-		}
-
-		if in_range {
-			let (human_pos, human_nodes) = room.get_human_information();
-
-			let mut human_attacked = false;
-
-			if human_pos.is_some() {
-				for node_index in human_nodes {
-					if in_node_range(
-						&player.position,
-						room.grid.nodes.get(*node_index).unwrap(),
-						range
-					) {
-						human_attacked = true;
-					}
-				}
-			}
-
-			if human_attacked {
-				player.successfull_attack = true;
-			} else {
-				main_camera_mut().shake(1.0, 1.0);
-			}
-		}
-	}
-}

src/activities/house/room.rs

@@ -1,8 +1,7 @@
 use super::{furniture::Furniture, grid::Grid};
-use crate::game::{self, ZLayer};
+use crate::game;
 use comfy::{
-	draw_rect, draw_rect_outline, draw_sprite, error, random_i32, texture_id, vec2,
-	EngineContext, HashSet, RandomRange as _, Vec2, BLUE, GREEN, PURPLE, RED, WHITE
+	create_reloadable_sprite_shader, draw_rect, draw_rect_outline, draw_sprite, error, hashmap, random_i32, set_uniform_f32, use_default_shader, use_shader, vec2, EngineContext, HashSet, Index, RandomRange as _, ReloadableShaderSource, UniformDef, Vec2, GREEN, PURPLE, RED, WHITE
 };
 use indexmap::IndexSet;
 
@@ -30,9 +29,7 @@ pub struct Room {
 	_room_type: RoomType,
 	pub size: (u8, u8), //(width, height)
 	pub grid: Grid,
-	furnitures: Vec<Tile>,
-	human_pos: Option<Vec2>,
-	human_nodes: Vec<usize>
+	furnitures: Vec<Tile>
 }
 
 impl RoomType {
@@ -49,60 +46,20 @@ impl RoomType {
 }
 
 impl Room {
-	pub fn new(ctx: &mut EngineContext<'_>, with_human: bool) -> Self {
+	pub fn new(ctx: &mut EngineContext<'_>) -> Self {
 		let room_type = RoomType::random();
 		let size = Self::random_size(&room_type);
 
 		let furnitures = Self::random_room_furniture(&room_type, size, ctx);
 
-		let grid = Self::create_grid(size.0, size.1);
-
-		let (human_pos, human_nodes) = if with_human {
-			let mut human_pos = vec2(random_i32(1, size.0 as i32) as f32 + 0.5, 1.0f32);
-			human_pos -= vec2(size.0 as f32 / 2.0, size.1 as f32 / 2.0);
-			human_pos *= SCALE;
-
-			let node_index_left = grid
-				.nodes
-				.iter()
-				.enumerate()
-				.filter(|(_i, &node)| node.y <= size.1 as f32 / 6.0)
-				.filter(|(_i, &node)| node.x <= (human_pos.x - 0.5 * SCALE))
-				.max_by_key(|(_i, &node)| node.x as i32)
-				.map(|(i, _)| i)
-				.unwrap();
-			let node_index_right = grid
-				.nodes
-				.iter()
-				.enumerate()
-				.filter(|(_i, &node)| node.y <= size.1 as f32 / 6.0)
-				.filter(|(_i, &node)| node.x >= (human_pos.x + 0.5 * SCALE))
-				.min_by_key(|(_i, &node)| node.x as i32)
-				.map(|(i, _)| i)
-				.unwrap();
-
-			(
-				Some(human_pos),
-				(node_index_left ..= node_index_right).collect()
-			)
-		} else {
-			(None, Vec::new())
-		};
-
 		Room {
 			_room_type: room_type,
 			size,
-			grid,
-			furnitures,
-			human_pos,
-			human_nodes
+			grid: Self::create_grid(size.0, size.1),
+			furnitures
 		}
 	}
 
-	pub fn get_human_information(&self) -> (Option<Vec2>, &Vec<usize>) {
-		(self.human_pos, &self.human_nodes)
-	}
-
 	fn random_size(room_type: &RoomType) -> (u8, u8) {
 		//Kitchen + Living Room 5-8
 		//Bath + sleepingroom 4-6
@@ -327,7 +284,8 @@ impl Room {
 				}
 			},
 
-			RoomType::LivingRoom => {
+			_ => {
+				//RoomType::LivingRoom => {
 				let has_couch = match u8::gen_range(0, 2) {
 					0 => false,
 					1 => true,
@@ -361,9 +319,8 @@ impl Room {
 						z: 0
 					});
 				}
-			},
-
-			_ => {}
+			}
+			//_ => {}
 		}
 
 		furnitures
@@ -419,7 +376,13 @@ impl Room {
 		Grid::new(nodes, connections)
 	}
 
-	pub fn draw(&self, human_layer: bool, magnet_layer: bool) {
+	pub fn draw(
+		&self,
+		human_layer: bool,
+		magnet_layer: bool,
+		position: Vec2,
+		_ctx: &mut comfy::EngineContext<'_>
+	) {
 		let (width, height) = self.size;
 
 		draw_rect(
@@ -460,16 +423,37 @@ impl Room {
 				}
 			}
 
-			if magnet_layer {
+			if true {
+				let magnet_shader_id = Some(
+					create_reloadable_sprite_shader(
+						&mut _ctx.renderer.shaders.borrow_mut(),
+						"magnet-shader",
+						ReloadableShaderSource {
+							static_source: include_str!("magnet-shader.wgsl").to_string(),
+							path: "src/activities/house/magnet-shader.wgsl".to_string()
+						},
+						hashmap! {
+							// "px".to_string() => UniformDef::F32(None),
+							// "py".to_string() => UniformDef::F32(None),
+						}
+					)
+					.unwrap()
+				).unwrap();
+
+				use_shader(magnet_shader_id);
+				// set_uniform_f32("px", position.x);
+				// set_uniform_f32("py", position.y);
+
 				if let Some(texture) = tile.f.get_magnet_texture_handle() {
 					draw_sprite(
 						texture,
 						pos * SCALE,
-						BLUE,
+						WHITE,
 						game::ZLayer::MagneticLayer as i32 + tile.z,
 						tile.size * SCALE
 					);
 				}
+				use_default_shader();
 			}
 
 			if tile.f.is_on() {
@@ -485,24 +469,6 @@ impl Room {
 			}
 		}
 
-		if human_layer {
-			if let Some(human_pos) = self.human_pos {
-				//draw_circle(human_pos, 0.5, RED, 20);
-				draw_sprite(
-					texture_id("human_house"),
-					human_pos,
-					WHITE,
-					ZLayer::Human.into(),
-					vec2(1.0, 2.0) * SCALE
-				);
-			}
-		}
-
-		/* Debug draw
-		for node_index in &self.human_nodes {
-			draw_circle(*self.grid.nodes.get(*node_index).unwrap(), 0.5, GREEN, ZLayer::Human.into());
-		}*/
-
 		self.grid.draw();
 	}
 }

src/activities/overworld/mod.rs

@@ -1,30 +1,18 @@
 use crate::{
 	activities::Activity,
-	assets::ASSETS,
 	game::{ZLayer, GHOST_DISCHARGE_RATE, GHOST_DISCHARGE_RATE_MOVEMENT},
 	State
 };
 use comfy::{
-	draw_rect_outline, draw_sprite, error, info, is_key_down, main_camera_mut,
-	play_sound_id, stop_sound_id, texture_id, vec2, EngineContext, IVec2, KeyCode, Vec2,
-	RED, WHITE
+	delta, draw_circle, draw_rect_outline, draw_sprite, error, info, is_key_down,
+	main_camera_mut, EngineContext, IVec2, KeyCode, Vec2, RED, WHITE
 };
 use std::time::Instant;
 use worldgen::MovementCost;
 
 pub mod worldgen;
 
-pub fn setup(_state: &State, ctx: &EngineContext<'_>) {
-	ctx.load_texture_from_bytes(
-		"human_overworld",
-		include_bytes!(concat!(
-			env!("CARGO_MANIFEST_DIR"),
-			"/assets/entities/human_overworld.png"
-		))
-	);
-}
-
-pub fn draw(state: &State, _ctx: &EngineContext<'_>) {
+pub fn draw(state: &crate::State, _engine: &comfy::EngineContext<'_>) {
 	for (coords, tile) in state.overworld.iter_tiles() {
 		for (i, texture) in tile.textures().iter().rev().enumerate() {
 			let i = i as i32;
@@ -40,32 +28,12 @@ pub fn draw(state: &State, _ctx: &EngineContext<'_>) {
 			}
 		}
 	}
-
-	let mut ghost_pos = state.ghost.overworld_pos;
-	ghost_pos.y += 0.5;
-	draw_sprite(
-		texture_id("human_overworld"),
-		ghost_pos,
-		WHITE,
-		ZLayer::Ghost.into(),
-		vec2(1.0, 1.25)
-	);
+	draw_circle(state.ghost.overworld_pos, 0.5, RED, ZLayer::Ghost.into());
 }
 
-fn update_move_player(state: &mut State, ctx: &mut EngineContext<'_>) {
+fn update_move_player(state: &mut State, _ctx: &mut EngineContext<'_>) {
 	let now = Instant::now();
 
-	if !state.overworld.sound_playing {
-		if let Some(house) = state.house_mut(ctx) {
-			if house.sound_playing {
-				stop_sound_id(ASSETS.music.mesmerizing_galaxy_loop);
-				house.sound_playing = false;
-			}
-		}
-		play_sound_id(ASSETS.music.galactic_rap_speedup);
-		state.overworld.sound_playing = true;
-	}
-
 	// Are there any pending position updates? If so, we ignore all user input and execute
 	// the pending updates.
 	if state.ghost.overworld_movement_pending != Vec2::ZERO {
@@ -173,10 +141,10 @@ fn update_move_player(state: &mut State, ctx: &mut EngineContext<'_>) {
 		},
 
 		// we are walking on a path
-		(MovementCost::Path, MovementCost::Path) => 7.0,
+		(MovementCost::Path, MovementCost::Path) => 10.0,
 
 		// we are walking across an obstacle
-		(MovementCost::Obstacle, _) | (_, MovementCost::Obstacle) => 2.0,
+		(MovementCost::Obstacle, _) | (_, MovementCost::Obstacle) => 1.0,
 
 		// we are walking on grass
 		_ => 5.0

src/activities/overworld/worldgen.rs

@@ -422,9 +422,7 @@ impl Chunk {
 
 #[derive(Debug, Default)]
 pub struct Overworld {
-	chunks: HashMap<IVec2, Chunk>,
-
-	pub sound_playing: bool
+	chunks: HashMap<IVec2, Chunk>
 }
 
 fn world_to_chunk_and_local_coords(world_coords: IVec2) -> (IVec2, UVec2) {

src/game.rs

@@ -75,8 +75,7 @@ pub enum ZLayer {
 	MapMax = -1,
 	Human = 0,
 	Ghost = 1,
-	UI = 100,
-	GameOver = 1000
+	UI = 100
 }
 
 impl From<ZLayer> for i32 {
@@ -102,40 +101,22 @@ impl Add<i32> for ZLayer {
 	}
 }
 
-pub fn setup(state: &mut State, ctx: &mut EngineContext<'_>) {
+pub fn setup(_state: &mut State, ctx: &mut EngineContext<'_>) {
 	Assets::load(ctx);
 
-	overworld::setup(state, ctx);
 	//house::setup(state, ctx);
-
-	ctx.load_texture_from_bytes(
-		"ghost_house",
-		include_bytes!(concat!(
-			env!("CARGO_MANIFEST_DIR"),
-			"/assets/entities/ghost.png"
-		))
-	);
-
-	ctx.load_texture_from_bytes(
-		"human_house",
-		include_bytes!(concat!(
-			env!("CARGO_MANIFEST_DIR"),
-			"/assets/entities/human_captured.png"
-		))
-	);
 }
 
 /// The amount of energy a ghost consumes idle.
-pub const GHOST_DISCHARGE_RATE: f32 = 40.0;
+pub const GHOST_DISCHARGE_RATE: f32 = 70.0;
 /// The amount of energy additionally consumed by a moving ghost.
-pub const GHOST_DISCHARGE_RATE_MOVEMENT: f32 = 40.0;
+pub const GHOST_DISCHARGE_RATE_MOVEMENT: f32 = 70.0;
 /// The amount of energy a house consumes idle.
 pub const HOUSE_DISCHARGE_RATE: f32 = 30.0;
 /// The amount of energy a ghost can charge when inside a house.
 pub const GHOST_CHARGE_RATE: f32 = 200.0;
 
 pub fn update(state: &mut State, ctx: &mut EngineContext<'_>) {
-	if state.ghost.charge > 0.0 {
 	// Update the score. It's based on time.
 	state.score += ctx.delta * 10.0;
 
@@ -171,21 +152,15 @@ pub fn update(state: &mut State, ctx: &mut EngineContext<'_>) {
 			_ => {}
 		}
 	}
-	} else {
-		crate::game_over::update(state, ctx);
-	}
 
 	// Make sure the ghost's charge never drops below 0.
 	state.ghost.charge = state.ghost.charge.max(0.0);
 }
 
-pub fn draw(state: &State, engine: &EngineContext<'_>) {
+pub fn draw(state: &State, engine: &mut EngineContext<'_>) {
 	match state.activity {
 		Activity::House(_) => house::draw(state, engine),
 		Activity::Overworld => overworld::draw(state, engine)
 	}
 	crate::ui::draw(state, engine);
-	if state.ghost.charge <= 0.0 {
-		crate::game_over::draw(state, engine);
-	}
 }

src/game_over.rs

@@ -1,52 +0,0 @@
-use std::mem::take;
-
-use crate::{game::ZLayer, State};
-use comfy::{
-	draw_rect, egui,
-	egui::{Align, Layout},
-	is_key_pressed, main_camera, Color, EngineContext, WHITE
-};
-use egui::{Align2, RichText};
-use log::info;
-
-pub fn update(state: &mut State, _engine: &mut EngineContext<'_>) {
-	if is_key_pressed(comfy::KeyCode::Return) {
-		info!("Restart game");
-		take(state); //reset to default
-	}
-}
-
-pub fn draw(state: &State, _engine: &EngineContext<'_>) {
-	let cam = main_camera();
-	draw_rect(
-		cam.center,
-		cam.world_viewport() * 1.2,
-		Color::new(0.0, 0.0, 0.0, 0.5),
-		ZLayer::GameOver.into()
-	);
-
-	egui::Area::new("game_over")
-		.anchor(Align2::CENTER_CENTER, egui::vec2(0.0, 0.0))
-		.show(egui(), |ui| {
-			ui.with_layout(Layout::top_down_justified(Align::Center), |ui| {
-				ui.heading(
-					RichText::new(
-						"The poor spirit lost all their energy and starved to death"
-					)
-					.color(WHITE)
-					.strong()
-					.size(50.0)
-				);
-				ui.label(
-					RichText::new(format!("\nYour Score:\n{:.0}", state.score))
-						.color(WHITE)
-						.size(30.0)
-				);
-				ui.label(
-					RichText::new("\n\n\npress enter to restart")
-						.color(WHITE)
-						.size(30.0)
-				);
-			})
-		});
-}

src/main.rs

@@ -5,9 +5,9 @@
 mod assets {
 	include!(env!("ASSETS_RS"));
 }
+
 mod activities;
 mod game;
-mod game_over;
 mod ui;
 
 use std::env::var;
@@ -59,23 +59,23 @@ impl State {
 		self.houses.get(&self.get_house_pos()?)
 	}
 
-	fn house_mut(&mut self, ctx: &mut EngineContext<'_>) -> Option<&mut HouseState> {
-		Some(
+	fn house_mut(&mut self, ctx: &mut EngineContext<'_>) -> &mut HouseState {
 		self.houses
-				.entry(self.get_house_pos()?)
+			.entry(self.get_house_pos().unwrap())
 			.or_insert_with(|| HouseState::generate_new_house(ctx))
-		)
 	}
 }
 
 impl GameLoop for State {
 	fn new(_c: &mut EngineState) -> Self {
-		Default::default()
+		Self {
+			dev: dev_from_env(),
+			..Default::default()
+		}
 	}
 
 	fn update(&mut self, ctx: &mut EngineContext<'_>) {
 		if !self.setup_called {
-			self.dev = dev_from_env();
 			game::setup(self, ctx);
 			game::setup(self, ctx);
 			self.setup_called = true;