src/activities/house/mod.rs

@@ -5,24 +5,30 @@ mod room;
 
 use crate::assets::ASSETS;
 use comfy::{
-	main_camera_mut, play_sound_id, random_i32, stop_sound_id, vec2, EngineContext,
-	RandomRange as _
+	delta, main_camera_mut, play_sound_id, random_i32, stop_sound_id, 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.
@@ -35,10 +41,21 @@ pub struct HouseState {
 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 _ in 0 .. room_count {
-			rooms.push(Room::new(ctx));
+		for i in 0 .. room_count {
+			rooms.push(Room::new(ctx, human_rooms.contains(&i)));
 		}
 
 		let player = Player::new(rooms.first().unwrap());
@@ -46,10 +63,12 @@ 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,
@@ -87,13 +106,14 @@ pub fn update(state: &mut crate::State, ctx: &mut 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 current_room = house.rooms.get(house.current_room_id).unwrap();
-	house.player.update(&current_room.grid);
+	house.player.update(&current_room);
 
 	if !house.sound_playing {
 		play_sound_id(ASSETS.music.mesmerizing_galaxy_loop);
@@ -119,4 +139,18 @@ 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,7 +2,11 @@ use super::{
 	room::{Room, SCALE},
 	Grid
 };
-use comfy::{delta, draw_circle, is_key_down, vec2, KeyCode, Vec2, RED};
+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 std::collections::HashSet;
 
 #[derive(Debug)]
@@ -13,7 +17,8 @@ pub struct Player {
 	current_acceleration: f32,
 	movement_time: f32,
 	connection: usize,
-	next_connections: Vec<usize>
+	next_connections: Vec<usize>,
+	pub successfull_attack: bool
 }
 
 impl Player {
@@ -28,15 +33,24 @@ impl Player {
 			current_acceleration: 0.0,
 			movement_time: 0.0,
 			connection: 0,
-			next_connections: vec![1]
+			next_connections: vec![1],
+			successfull_attack: false
 		}
 	}
 
 	pub fn draw(&self) {
-		draw_circle(self.position, 0.5, RED, 0);
+		//draw_circle(self.position, 0.5, RED, 0);
+		draw_sprite(
+			texture_id("ghost_house"),
+			self.position,
+			WHITE,
+			5,
+			vec2(1.25, 1.25)
+		);
 	}
 
-	pub fn update(&mut self, grid: &Grid) {
+	pub fn update(&mut self, room: &Room) {
+		let grid = &room.grid;
 		let allowed_movement = get_allowed_movement(self, grid);
 
 		move_player(self, allowed_movement);
@@ -44,6 +58,8 @@ 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 {
@@ -353,3 +369,42 @@ 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,9 @@
 use super::{furniture::Furniture, grid::Grid};
-use crate::game;
+use crate::game::{self, ZLayer};
 use comfy::{
-	draw_rect, draw_rect_outline, draw_sprite, error, random_i32, vec2, EngineContext,
-	HashSet, RandomRange as _, Vec2, GREEN, PURPLE, RED, WHITE
+	draw_circle, draw_rect, draw_rect_outline, draw_sprite, error, random_i32,
+	texture_id, vec2, EngineContext, HashSet, RandomRange as _, Vec2, GOLD, GREEN,
+	PURPLE, RED, WHITE
 };
 use indexmap::IndexSet;
 
@@ -30,7 +31,9 @@ pub struct Room {
 	_room_type: RoomType,
 	pub size: (u8, u8), //(width, height)
 	pub grid: Grid,
-	furnitures: Vec<Tile>
+	furnitures: Vec<Tile>,
+	human_pos: Option<Vec2>,
+	human_nodes: Vec<usize>
 }
 
 impl RoomType {
@@ -47,20 +50,60 @@ impl RoomType {
 }
 
 impl Room {
-	pub fn new(ctx: &mut EngineContext<'_>) -> Self {
+	pub fn new(ctx: &mut EngineContext<'_>, with_human: bool) -> 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: Self::create_grid(size.0, size.1),
-			furnitures
+			grid,
+			furnitures,
+			human_pos,
+			human_nodes
 		}
 	}
 
+	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
@@ -443,6 +486,24 @@ 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/game.rs

@@ -106,6 +106,22 @@ pub fn setup(state: &mut State, ctx: &mut EngineContext<'_>) {
 
 	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.