xevion/Pac-Man
1
0
Fork 0
mirror of https://github.com/Xevion/Pac-Man.git synced 2025-12-15 08:12:32 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactor: add ticks to DeltaTime, rewrite Blinking system for tick-based calculations with absolute calculations, rewrite Blinking/Direction tests

Browse Source
This commit is contained in:
Ryan Walters
2025-09-05 19:20:58 -05:00
parent 132067c573
commit 3c50bfeab6
15 changed files with 413 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/constants.rs
View File

@@ -72,8 +72,8 @@ pub mod collider {
pub mod ui {
/// Debug font size in points
pub const DEBUG_FONT_SIZE: u16 = 12;
/// Power pellet blink rate in seconds
pub const POWER_PELLET_BLINK_RATE: f32 = 0.2;
/// Power pellet blink rate in ticks (at 60 FPS, 12 ticks = 0.2 seconds)
pub const POWER_PELLET_BLINK_RATE: u32 = 12;
}
/// Map tile types that define gameplay behavior and collision properties.

4
src/game.rs
View File

@@ -372,7 +372,7 @@ impl Game {
world.insert_resource(SystemTimings::default());
world.insert_resource(Timing::default());
world.insert_resource(Bindings::default());
world.insert_resource(DeltaTime(0f32));
world.insert_resource(DeltaTime { seconds: 0.0, ticks: 0 });
world.insert_resource(RenderDirty::default());
world.insert_resource(DebugState::default());
world.insert_resource(AudioState::default());
@@ -633,7 +633,7 @@ impl Game {
///
/// `true` if the game should terminate (exit command received), `false` to continue
pub fn tick(&mut self, dt: f32) -> bool {
self.world.insert_resource(DeltaTime(dt));
self.world.insert_resource(DeltaTime { seconds: dt, ticks: 1 });
// Note: We don't need to read the current tick here since we increment it after running systems

54
src/systems/blinking.rs
View File

@@ -12,20 +12,24 @@ use crate::systems::{
#[derive(Component, Debug)]
pub struct Blinking {
pub timer: f32,
pub interval: f32,
pub tick_timer: u32,
pub interval_ticks: u32,
}
impl Blinking {
pub fn new(interval: f32) -> Self {
Self { timer: 0.0, interval }
pub fn new(interval_ticks: u32) -> Self {
Self {
tick_timer: 0,
interval_ticks,
}
}
}
/// Updates blinking entities by toggling their visibility at regular intervals.
///
/// This system manages entities that have both `Blinking` and `Renderable` components,
/// accumulating time and toggling visibility when the specified interval is reached.
/// accumulating ticks and toggling visibility when the specified interval is reached.
/// Uses integer arithmetic for deterministic behavior.
#[allow(clippy::type_complexity)]
pub fn blinking_system(
mut commands: Commands,
@@ -42,22 +46,40 @@ pub fn blinking_system(
continue;
}
// Increase the timer by the delta time
blinking.timer += time.0;
// Increase the timer by the delta ticks
blinking.tick_timer += time.ticks;
// If the timer is less than the interval, there's nothing to do yet
if blinking.timer < blinking.interval {
// Handle zero interval case (immediate toggling)
if blinking.interval_ticks == 0 {
if time.ticks > 0 {
if hidden {
commands.entity(entity).remove::<Hidden>();
} else {
commands.entity(entity).insert(Hidden);
}
}
continue;
}
// Subtract the interval (allows for the timer to retain partial interval progress)
blinking.timer -= blinking.interval;
// Calculate how many complete intervals have passed
let complete_intervals = blinking.tick_timer / blinking.interval_ticks;
// Toggle the Hidden component
if hidden {
commands.entity(entity).remove::<Hidden>();
} else {
commands.entity(entity).insert(Hidden);
// If no complete intervals have passed, there's nothing to do yet
if complete_intervals == 0 {
continue;
}
// Update the timer to the remainder after complete intervals
blinking.tick_timer %= blinking.interval_ticks;
// Toggle the Hidden component for each complete interval
// Since toggling twice is a no-op, we only need to toggle if the count is odd
if complete_intervals % 2 == 1 {
if hidden {
commands.entity(entity).remove::<Hidden>();
} else {
commands.entity(entity).insert(Hidden);
}
}
}
}

30
src/systems/components.rs
View File

@@ -162,7 +162,35 @@ pub struct GlobalState {
pub struct ScoreResource(pub u32);
#[derive(Resource)]
pub struct DeltaTime(pub f32);
pub struct DeltaTime {
/// Floating-point delta time in seconds
pub seconds: f32,
/// Integer tick delta (usually 1, but can be different for testing)
pub ticks: u32,
}
#[allow(dead_code)]
impl DeltaTime {
/// Creates a new DeltaTime from a floating-point delta time in seconds
///
/// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
pub fn from_seconds(seconds: f32) -> Self {
Self {
seconds,
ticks: (seconds * 60.0).round() as u32,
}
}
/// Creates a new DeltaTime from an integer tick delta
///
/// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
pub fn from_ticks(ticks: u32) -> Self {
Self {
seconds: ticks as f32 / 60.0,
ticks,
}
}
}
/// Movement modifiers that can affect Pac-Man's speed or handling.
#[derive(Component, Debug, Clone, Copy)]

4
src/systems/ghost.rs
View File

@@ -25,7 +25,7 @@ pub fn ghost_movement_system(
mut ghosts: Query<(&Ghost, &mut Velocity, &mut Position), Without<Frozen>>,
) {
for (_ghost, mut velocity, mut position) in ghosts.iter_mut() {
let mut distance = velocity.speed * 60.0 * delta_time.0;
let mut distance = velocity.speed * 60.0 * delta_time.seconds;
loop {
match *position {
Position::Stopped { node: current_node } => {
@@ -111,7 +111,7 @@ pub fn eaten_ghost_system(
}
}
Position::Moving { to, .. } => {
let distance = velocity.speed * 60.0 * delta_time.0;
let distance = velocity.speed * 60.0 * delta_time.seconds;
if let Some(_overflow) = position.tick(distance) {
// Reached target node, check if we're at ghost house center
if to == ghost_house_center {

4
src/systems/input.rs
View File

@@ -319,7 +319,7 @@ pub fn input_system(
// Update touch reference position with easing
if let Some(ref mut touch_data) = touch_state.active_touch {
// Apply easing to the reference position and get the delta for direction calculation
let (delta, distance) = update_touch_reference_position(touch_data, delta_time.0);
let (delta, distance) = update_touch_reference_position(touch_data, delta_time.seconds);
// Check for direction based on updated reference position
if distance >= TOUCH_DIRECTION_THRESHOLD {
@@ -336,7 +336,7 @@ pub fn input_system(
}
if let (false, CursorPosition::Some { remaining_time, .. }) = (cursor_seen, &mut *cursor) {
*remaining_time -= delta_time.0;
*remaining_time -= delta_time.seconds;
if *remaining_time <= 0.0 {
*cursor = CursorPosition::None;
}

4
src/systems/player.rs
View File

@@ -99,12 +99,12 @@ pub fn player_movement_system(
} else {
*buffered_direction = BufferedDirection::Some {
direction,
remaining_time: remaining_time - delta_time.0,
remaining_time: remaining_time - delta_time.seconds,
};
}
}
let mut distance = velocity.speed * modifiers.speed_multiplier * 60.0 * delta_time.0;
let mut distance = velocity.speed * modifiers.speed_multiplier * 60.0 * delta_time.seconds;
loop {
match *position {

4
src/systems/render.rs
View File

@@ -55,7 +55,7 @@ pub fn directional_render_system(
dt: Res<DeltaTime>,
mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable)>,
) {
let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
let stopped = matches!(position, Position::Stopped { .. });
@@ -90,7 +90,7 @@ pub fn directional_render_system(
///
/// This system handles entities that use LinearAnimation component for simple frame cycling.
pub fn linear_render_system(dt: Res<DeltaTime>, mut query: Query<(&mut LinearAnimation, &mut Renderable)>) {
let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
for (mut anim, mut renderable) in query.iter_mut() {
// Tick animation

43
src/texture/blinking.rs
View File

@@ -4,25 +4,42 @@ use crate::texture::sprite::AtlasTile;
#[derive(Clone)]
pub struct BlinkingTexture {
tile: AtlasTile,
blink_duration: f32,
time_bank: f32,
interval_ticks: u32,
tick_timer: u32,
is_on: bool,
}
impl BlinkingTexture {
pub fn new(tile: AtlasTile, blink_duration: f32) -> Self {
pub fn new(tile: AtlasTile, interval_ticks: u32) -> Self {
Self {
tile,
blink_duration,
time_bank: 0.0,
interval_ticks,
tick_timer: 0,
is_on: true,
}
}
pub fn tick(&mut self, dt: f32) {
self.time_bank += dt;
if self.time_bank >= self.blink_duration {
self.time_bank -= self.blink_duration;
pub fn tick(&mut self, delta_ticks: u32) {
self.tick_timer += delta_ticks;
// Handle zero interval case (immediate toggling)
if self.interval_ticks == 0 {
// With zero interval, any positive ticks should toggle
if delta_ticks > 0 {
self.is_on = !self.is_on;
}
return;
}
// Calculate how many complete intervals have passed
let complete_intervals = self.tick_timer / self.interval_ticks;
// Update the timer to the remainder after complete intervals
self.tick_timer %= self.interval_ticks;
// Toggle for each complete interval, but since toggling twice is a no-op,
// we only need to toggle if the count is odd
if complete_intervals % 2 == 1 {
self.is_on = !self.is_on;
}
}
@@ -36,11 +53,11 @@ impl BlinkingTexture {
}
// Helper methods for testing
pub fn time_bank(&self) -> f32 {
self.time_bank
pub fn tick_timer(&self) -> u32 {
self.tick_timer
}
pub fn blink_duration(&self) -> f32 {
self.blink_duration
pub fn interval_ticks(&self) -> u32 {
self.interval_ticks
}
}