Houses have energy that interact with ghosts #18

Merged
msrd0 merged 2 commits from house-energy into main 2024-07-07 15:18:32 +00:00
5 changed files with 117 additions and 40 deletions

View file

@ -3,7 +3,7 @@ mod grid;
mod player; mod player;
mod room; mod room;
use comfy::{main_camera_mut, random_i32, vec2, EngineContext}; use comfy::{main_camera_mut, random_i32, vec2, EngineContext, RandomRange as _};
use grid::Grid; use grid::Grid;
use log::error; use log::error;
use player::Player; use player::Player;
@ -18,7 +18,12 @@ pub struct HouseState {
rooms: Vec<Room>, rooms: Vec<Room>,
//grid: Grid, //grid: Grid,
player: Player, player: Player,
human_layer: bool //Human, magnetic, electric human_layer: bool, //Human, magnetic, electric
/// 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
} }
impl HouseState { impl HouseState {
@ -31,12 +36,16 @@ impl HouseState {
} }
let player = Player::new(rooms.first().unwrap()); let player = Player::new(rooms.first().unwrap());
let max_charge = f32::gen_range(2_000.0, 5_000.0);
HouseState { HouseState {
current_room_id: 0, current_room_id: 0,
room_count, room_count,
rooms, rooms,
player, player,
human_layer: false human_layer: false,
// TODO this should be lower depending on the time elapsed
charge: max_charge,
max_charge
} }
} }
} }

View file

@ -1,7 +1,8 @@
use super::{furniture::Furniture, grid::Grid}; use super::{furniture::Furniture, grid::Grid};
use crate::game; use crate::game;
use comfy::{ use comfy::{
draw_rect, draw_rect_outline, draw_sprite, error, random_i32, vec2, EngineContext, HashSet, Index, RandomRange as _, Vec2, GREEN, PURPLE, RED, WHITE draw_rect, draw_rect_outline, draw_sprite, error, random_i32, vec2, EngineContext,
HashSet, Index, RandomRange as _, Vec2, GREEN, PURPLE, RED, WHITE
}; };
use indexmap::IndexSet; use indexmap::IndexSet;
@ -88,14 +89,17 @@ impl Room {
empty_spots.swap_remove_index(random_idx) empty_spots.swap_remove_index(random_idx)
} }
fn random_empty_spot_size(empty_spots: &mut IndexSet<u8>, size: u8) -> Option<u8> { fn random_empty_spot_size(
empty_spots: &mut IndexSet<u8>,
size: u8
) -> Option<u8> {
let mut empty_spots_size = IndexSet::<u8>::new(); let mut empty_spots_size = IndexSet::<u8>::new();
for &index in empty_spots.iter() { for &index in empty_spots.iter() {
let mut is_valid = true; let mut is_valid = true;
for offset in 0..size{ for offset in 0 .. size {
if !empty_spots.contains(&(index + offset)){ if !empty_spots.contains(&(index + offset)) {
is_valid = false; is_valid = false;
break; break;
} }
@ -109,7 +113,7 @@ impl Room {
return None; return None;
} }
let random_idx = usize::gen_range(0, empty_spots_size.len()); let random_idx = usize::gen_range(0, empty_spots_size.len());
for offset in (0..size).rev() { for offset in (0 .. size).rev() {
empty_spots.swap_remove_index(random_idx + offset as usize); empty_spots.swap_remove_index(random_idx + offset as usize);
} }
Some(random_idx as u8) Some(random_idx as u8)
@ -293,10 +297,9 @@ impl Room {
pos: vec2(pos as f32, 0.0), pos: vec2(pos as f32, 0.0),
size: vec2(3.0, 1.0), size: vec2(3.0, 1.0),
f: Furniture::new("bedroom", "couch", ctx), f: Furniture::new("bedroom", "couch", ctx),
z:0 z: 0
}); });
} }
} }
if let Some(pos) = random_empty_spot(&mut empty_spots) { if let Some(pos) = random_empty_spot(&mut empty_spots) {
@ -304,7 +307,7 @@ impl Room {
pos: vec2(pos as f32, 0.0), pos: vec2(pos as f32, 0.0),
size: vec2(1.0, 2.0), size: vec2(1.0, 2.0),
f: Furniture::new("bedroom", "bookshelf", ctx), f: Furniture::new("bedroom", "bookshelf", ctx),
z:0 z: 0
}); });
} }
@ -313,10 +316,9 @@ impl Room {
pos: vec2(pos as f32, 0.0), pos: vec2(pos as f32, 0.0),
size: vec2(0.5, 0.9), size: vec2(0.5, 0.9),
f: Furniture::new("bedroom", "mini_ac", ctx), f: Furniture::new("bedroom", "mini_ac", ctx),
z:0 z: 0
}); });
} }
}, },
_ => {} _ => {}

View file

@ -1,4 +1,8 @@
use crate::{activities::Activity, game::ZLayer, State}; use crate::{
activities::Activity,
game::{ZLayer, GHOST_DISCHARGE_RATE, GHOST_DISCHARGE_RATE_MOVEMENT},
State
};
use comfy::{ use comfy::{
delta, draw_circle, draw_rect_outline, draw_sprite, error, info, is_key_down, delta, draw_circle, draw_rect_outline, draw_sprite, error, info, is_key_down,
main_camera_mut, EngineContext, IVec2, KeyCode, Vec2, RED, WHITE main_camera_mut, EngineContext, IVec2, KeyCode, Vec2, RED, WHITE
@ -177,9 +181,9 @@ pub fn update(state: &mut State, ctx: &mut EngineContext<'_>) {
// energie lost // energie lost
{ {
let ghost = &mut state.ghost; let ghost = &mut state.ghost;
ghost.charge -= 70.0 * ctx.delta; ghost.charge -= GHOST_DISCHARGE_RATE * ctx.delta;
if ghost.overworld_movement_pending != Vec2::ZERO { if ghost.overworld_movement_pending != Vec2::ZERO {
ghost.charge -= 70.0 * ctx.delta; ghost.charge -= GHOST_DISCHARGE_RATE_MOVEMENT * ctx.delta;
} }
} }

View file

@ -107,12 +107,53 @@ pub fn setup(_state: &mut State, ctx: &mut EngineContext<'_>) {
//house::setup(state, ctx); //house::setup(state, ctx);
} }
pub fn update(state: &mut State, engine: &mut EngineContext<'_>) { /// The amount of energy a ghost consumes idle.
state.score += engine.delta * 10.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 = 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<'_>) {
// Update the score. It's based on time.
state.score += ctx.delta * 10.0;
// Update the currently active activity.
match state.activity { match state.activity {
Activity::House(_) => house::update(state, engine), Activity::House(_) => house::update(state, ctx),
Activity::Overworld => overworld::update(state, engine) Activity::Overworld => overworld::update(state, ctx)
} }
// We update the charge of houses here - the charge will always decrease, even if the
// house is not the current activity.
for (house_pos, house) in &mut state.houses {
house.charge -= ctx.delta * HOUSE_DISCHARGE_RATE;
match state.activity {
Activity::House(pos) if *house_pos == pos => {
// The ghost is currently inside the house. Increase its discarge rate.
house.charge -= ctx.delta * GHOST_DISCHARGE_RATE;
if house.charge < 0.0 {
state.ghost.charge += house.charge;
house.charge = 0.0;
}
// And possibly also charge the ghost when inside a house.
if state.ghost.charge < state.ghost.max_charge {
let charge_transfer = (ctx.delta * GHOST_CHARGE_RATE)
.min(state.ghost.max_charge - state.ghost.charge)
.min(house.charge);
state.ghost.charge += charge_transfer;
house.charge -= charge_transfer;
}
},
_ => {}
}
}
// Make sure the ghost's charge never drops below 0.
state.ghost.charge = state.ghost.charge.max(0.0); state.ghost.charge = state.ghost.charge.max(0.0);
} }

View file

@ -1,41 +1,61 @@
use crate::{game::ZLayer, State}; use crate::{game::ZLayer, State};
use comfy::{ use comfy::{
draw_rect, draw_rect_outline, egui, screen_height, screen_to_world, screen_width, draw_rect, draw_rect_outline, egui, screen_height, screen_to_world, screen_width,
EngineContext, Vec2, BLACK, BLUE, RED, WHITE vec2, Color, EngineContext, Vec2, BLACK, BLUE, PURPLE, RED, WHITE
}; };
use egui::widget_text::RichText; use egui::widget_text::RichText;
pub fn draw_batterie(state: &State, _engine: &EngineContext<'_>) { // seperate fill state into smaller section for better readability
// seperate fill state into smaller section for better readability const BATTERY_SECTION_COUNT: u8 = 5;
let section_count = 5; const BATTERY_SECTION_WIDTH: f32 = 1.0;
let mut start_positon = screen_to_world(Vec2::new(screen_width(), screen_height())); const BATTERY_SECTION_HEIGHT: f32 = 0.5;
fn draw_battery(mut start_position: Vec2, charge: f32, max_charge: f32, color: Color) {
// section size in world codinates // section size in world codinates
let section_size = Vec2::new(0.5, 0.25); let section_size = vec2(BATTERY_SECTION_WIDTH, BATTERY_SECTION_HEIGHT);
start_positon.x -= 0.5 * section_size.x + 0.5 * section_size.y; start_position.x -= 0.5 * section_size.x + 0.5 * section_size.y;
start_positon.y += 0.5 * section_size.y + 0.5 * section_size.y; start_position.y += 0.5 * section_size.y + 0.5 * section_size.y;
// draw fill level // draw fill level
{ {
let ghost = &state.ghost; let percent = charge / max_charge;
let percent = ghost.charge / ghost.max_charge;
let mut size = section_size; let mut size = section_size;
size.y = section_size.y * section_count as f32; size.y = section_size.y * BATTERY_SECTION_COUNT as f32;
let mut position = start_positon; let mut position = start_position;
position.y += 0.5 * -section_size.y + 0.5 * size.y; position.y += 0.5 * -section_size.y + 0.5 * size.y;
draw_rect(position, size, BLACK, ZLayer::UI.into()); draw_rect(position, size, BLACK, ZLayer::UI.into());
size.y *= percent; size.y *= percent;
let mut position = start_positon; let mut position = start_position;
position.y += 0.5 * -section_size.y + 0.5 * size.y; position.y += 0.5 * -section_size.y + 0.5 * size.y;
draw_rect(position, size, BLUE, ZLayer::UI + 1); draw_rect(position, size, BLUE, ZLayer::UI + 1);
} }
// draw sections // draw sections
for i in 0 .. section_count { for i in 0 .. BATTERY_SECTION_COUNT {
let mut position = start_positon; let mut position = start_position;
position.y += i as f32 * section_size.y; position.y += i as f32 * section_size.y;
draw_rect_outline(position, section_size, 0.1, RED, ZLayer::UI + 2); draw_rect_outline(position, section_size, 0.1, color, ZLayer::UI + 2);
} }
} }
pub fn draw_highscore(state: &State, _engine: &EngineContext<'_>) { pub fn draw_ghost_battery(state: &State) {
let start_position = screen_to_world(Vec2::new(screen_width(), screen_height()));
draw_battery(
start_position,
state.ghost.charge,
state.ghost.max_charge,
RED
);
}
pub fn draw_house_battery(state: &State) {
let Some(house) = state.house() else {
return;
};
let mut start_position = screen_to_world(Vec2::new(screen_width(), screen_height()));
start_position.x -= 2.0 * BATTERY_SECTION_WIDTH;
draw_battery(start_position, house.charge, house.max_charge, PURPLE)
}
pub fn draw_highscore(state: &State) {
egui::Area::new("score") egui::Area::new("score")
.anchor(egui::Align2::RIGHT_TOP, egui::vec2(0.0, 0.0)) .anchor(egui::Align2::RIGHT_TOP, egui::vec2(0.0, 0.0))
.show(egui(), |ui| { .show(egui(), |ui| {
@ -49,7 +69,8 @@ pub fn draw_highscore(state: &State, _engine: &EngineContext<'_>) {
}); });
} }
pub fn draw(state: &State, engine: &EngineContext<'_>) { pub fn draw(state: &State, _ctx: &EngineContext<'_>) {
draw_batterie(state, engine); draw_ghost_battery(state);
draw_highscore(state, engine); draw_house_battery(state);
draw_highscore(state);
} }