attack-human (#21)
Some checks failed
Rust / rustfmt (push) Successful in 28s
Rust / clippy (push) Failing after 1m34s
Rust / build (push) Successful in 3m18s

Reviewed-on: #21
Co-authored-by: Glaeder <niklas@vousten.dev>
Co-committed-by: Glaeder <niklas@vousten.dev>
This commit is contained in:
Glaeder 2024-07-07 16:24:01 +00:00 committed by Glaeder
parent 6115ef4aa2
commit 2d0b613df1
4 changed files with 184 additions and 18 deletions

View file

@ -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;
}
}

View file

@ -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);
}
}
}
}

View file

@ -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();
}
}

View file

@ -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.