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

refactor: use small_rng for Emscripten only, simplify platform to top-level functions only, no trait/struct

Browse Source
This commit is contained in:
Ryan Walters
2025-09-03 11:11:04 -05:00
parent 208ad3e733
commit 4cc5816d1f
9 changed files with 256 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/app.rs
View File

@@ -4,7 +4,7 @@ use crate::error::{GameError, GameResult};
use crate::constants::{CANVAS_SIZE, LOOP_TIME, SCALE};
use crate::game::Game;
use crate::platform::get_platform;
use crate::platform;
use sdl2::{AudioSubsystem, Sdl};
/// Main application wrapper that manages SDL initialization, window lifecycle, and the game loop.
@@ -101,7 +101,7 @@ impl App {
if start.elapsed() < LOOP_TIME {
let time = LOOP_TIME.saturating_sub(start.elapsed());
if time != Duration::ZERO {
get_platform().sleep(time, self.focused);
platform::sleep(time, self.focused);
}
}

4
src/asset.rs
View File

@@ -44,7 +44,7 @@ impl Asset {
mod imp {
use super::*;
use crate::error::AssetError;
use crate::platform::get_platform;
use crate::platform;
/// Loads asset bytes using the appropriate platform-specific method.
///
@@ -58,7 +58,7 @@ mod imp {
/// Returns `AssetError::NotFound` if the asset file cannot be located (Emscripten only),
/// or `AssetError::Io` for filesystem I/O failures.
pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
get_platform().get_asset_bytes(asset)
platform::get_asset_bytes(asset)
}
}

5
src/main.rs
View File

@@ -22,13 +22,12 @@ mod texture;
/// This function initializes SDL, the window, the game state, and then enters
/// the main game loop.
pub fn main() {
let platform = platform::get_platform();
if platform.requires_console() {
if platform::requires_console() {
// Setup buffered tracing subscriber that will buffer logs until console is ready
let switchable_writer = platform::tracing_buffer::setup_switchable_subscriber();
// Initialize platform-specific console
platform.init_console().expect("Could not initialize console");
platform::init_console().expect("Could not initialize console");
// Now that console is initialized, flush buffered logs and switch to direct output
debug!("Switching to direct logging mode and flushing buffer...");

294
src/platform/desktop.rs
View File

@@ -1,173 +1,177 @@
//! Desktop platform implementation.
use std::borrow::Cow;
use std::time::Duration;
use std::time::{Duration, Instant};
use rand::rngs::ThreadRng;
use crate::asset::Asset;
use crate::error::{AssetError, PlatformError};
use crate::platform::CommonPlatform;
/// Desktop platform implementation.
pub struct Platform;
pub fn sleep(duration: Duration, focused: bool) {
if focused {
spin_sleep::sleep(duration);
} else {
std::thread::sleep(duration);
}
}
impl CommonPlatform for Platform {
fn sleep(&self, duration: Duration, focused: bool) {
if focused {
spin_sleep::sleep(duration);
pub fn get_time() -> f64 {
Instant::now().elapsed().as_secs_f64()
}
pub fn init_console() -> Result<(), PlatformError> {
#[cfg(windows)]
{
use tracing::{debug, info};
use windows::Win32::System::Console::GetConsoleWindow;
// Check if we already have a console window
if unsafe { !GetConsoleWindow().0.is_null() } {
debug!("Already have a console window");
return Ok(());
} else {
std::thread::sleep(duration);
debug!("No existing console window found");
}
if let Some(file_type) = is_output_setup()? {
debug!(r#type = file_type, "Existing output detected");
} else {
debug!("No existing output detected");
// Try to attach to parent console for direct cargo run
attach_to_parent_console()?;
info!("Successfully attached to parent console");
}
}
fn get_time(&self) -> f64 {
std::time::Instant::now().elapsed().as_secs_f64()
}
Ok(())
}
fn init_console(&self) -> Result<(), PlatformError> {
#[cfg(windows)]
{
use tracing::{debug, info};
use windows::Win32::System::Console::GetConsoleWindow;
pub fn requires_console() -> bool {
cfg!(windows)
}
// Check if we already have a console window
if unsafe { !GetConsoleWindow().0.is_null() } {
debug!("Already have a console window");
return Ok(());
} else {
debug!("No existing console window found");
}
pub fn get_canvas_size() -> Option<(u32, u32)> {
None // Desktop doesn't need this
}
if let Some(file_type) = Self::is_output_setup()? {
debug!(r#type = file_type, "Existing output detected");
} else {
debug!("No existing output detected");
// Try to attach to parent console for direct cargo run
Self::attach_to_parent_console()?;
info!("Successfully attached to parent console");
}
}
Ok(())
}
fn requires_console(&self) -> bool {
cfg!(windows)
}
fn get_canvas_size(&self) -> Option<(u32, u32)> {
None // Desktop doesn't need this
}
fn get_asset_bytes(&self, asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
match asset {
Asset::Wav1 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/1.ogg"))),
Asset::Wav2 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/2.ogg"))),
Asset::Wav3 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/3.ogg"))),
Asset::Wav4 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/4.ogg"))),
Asset::AtlasImage => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
Asset::Font => Ok(Cow::Borrowed(include_bytes!("../../assets/game/TerminalVector.ttf"))),
}
pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
match asset {
Asset::Wav1 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/1.ogg"))),
Asset::Wav2 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/2.ogg"))),
Asset::Wav3 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/3.ogg"))),
Asset::Wav4 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/4.ogg"))),
Asset::AtlasImage => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
Asset::Font => Ok(Cow::Borrowed(include_bytes!("../../assets/game/TerminalVector.ttf"))),
}
}
pub fn rng() -> ThreadRng {
rand::rng()
}
/* Internal functions */
/// Check if the output stream has been setup by a parent process
/// Windows-only
#[cfg(windows)]
impl Platform {
/// Check if the output stream has been setup by a parent process
fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
use tracing::{debug, warn};
fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
use tracing::{debug, warn};
use windows::Win32::Storage::FileSystem::{
GetFileType, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN,
};
use windows::Win32::Storage::FileSystem::{
GetFileType, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN,
};
use windows_sys::Win32::{
Foundation::INVALID_HANDLE_VALUE,
System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
};
use windows_sys::Win32::{
Foundation::INVALID_HANDLE_VALUE,
System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
};
// Get the process's standard output handle, check if it's invalid
let handle = match unsafe { GetStdHandle(STD_OUTPUT_HANDLE) } {
INVALID_HANDLE_VALUE => {
return Err(PlatformError::ConsoleInit("Invalid handle".to_string()));
}
handle => handle,
};
// Identify the file type of the handle and whether it's 'well known' (i.e. we trust it to be a reasonable output destination)
let (well_known, file_type) = match unsafe {
use windows::Win32::Foundation::HANDLE;
GetFileType(HANDLE(handle))
} {
FILE_TYPE_PIPE => (true, "pipe"),
FILE_TYPE_CHAR => (true, "char"),
FILE_TYPE_DISK => (true, "disk"),
FILE_TYPE_UNKNOWN => (false, "unknown"),
FILE_TYPE_REMOTE => (false, "remote"),
unexpected => {
warn!("Unexpected file type: {unexpected:?}");
(false, "unknown")
}
};
debug!("File type: {file_type:?}, well known: {well_known}");
// If it's anything recognizable and valid, assume that a parent process has setup an output stream
Ok(well_known.then_some(file_type))
}
/// Try to attach to parent console
fn attach_to_parent_console() -> Result<(), PlatformError> {
use windows::{
core::PCSTR,
Win32::{
Foundation::{GENERIC_READ, GENERIC_WRITE},
Storage::FileSystem::{CreateFileA, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING},
System::Console::{
AttachConsole, FreeConsole, SetStdHandle, ATTACH_PARENT_PROCESS, STD_ERROR_HANDLE, STD_OUTPUT_HANDLE,
},
},
};
// Attach the process to the parent's console
unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to attach to parent console: {:?}", e)))?;
let handle = unsafe {
let pcstr = PCSTR::from_raw(c"CONOUT$".as_ptr() as *const u8);
CreateFileA::<PCSTR>(
pcstr,
(GENERIC_READ | GENERIC_WRITE).0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None,
OPEN_EXISTING,
FILE_FLAGS_AND_ATTRIBUTES(0),
None,
)
// Get the process's standard output handle, check if it's invalid
let handle = match unsafe { GetStdHandle(STD_OUTPUT_HANDLE) } {
INVALID_HANDLE_VALUE => {
return Err(PlatformError::ConsoleInit("Invalid handle".to_string()));
}
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to create console handle: {:?}", e)))?;
handle => handle,
};
// Set the console's output and then error handles
if let Some(handle_error) = unsafe { SetStdHandle(STD_OUTPUT_HANDLE, handle) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console output handle: {:?}", e)))
.and_then(|_| {
unsafe { SetStdHandle(STD_ERROR_HANDLE, handle) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console error handle: {:?}", e)))
})
.err()
{
// If either set handle call fails, free the console
unsafe { FreeConsole() }
// Free the console if the SetStdHandle calls fail
.map_err(|free_error| {
PlatformError::ConsoleInit(format!(
"Failed to free console after SetStdHandle failed: {free_error:?} ({handle_error:?})"
))
})
// And then return the original error if the FreeConsole call succeeds
.and(Err(handle_error))?;
// Identify the file type of the handle and whether it's 'well known' (i.e. we trust it to be a reasonable output destination)
let (well_known, file_type) = match unsafe {
use windows::Win32::Foundation::HANDLE;
GetFileType(HANDLE(handle))
} {
FILE_TYPE_PIPE => (true, "pipe"),
FILE_TYPE_CHAR => (true, "char"),
FILE_TYPE_DISK => (true, "disk"),
FILE_TYPE_UNKNOWN => (false, "unknown"),
FILE_TYPE_REMOTE => (false, "remote"),
unexpected => {
warn!("Unexpected file type: {unexpected:?}");
(false, "unknown")
}
};
Ok(())
}
debug!("File type: {file_type:?}, well known: {well_known}");
// If it's anything recognizable and valid, assume that a parent process has setup an output stream
Ok(well_known.then_some(file_type))
}
/// Try to attach to parent console
/// Windows-only
#[cfg(windows)]
fn attach_to_parent_console() -> Result<(), PlatformError> {
use windows::{
core::PCSTR,
Win32::{
Foundation::{GENERIC_READ, GENERIC_WRITE},
Storage::FileSystem::{CreateFileA, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING},
System::Console::{
AttachConsole, FreeConsole, SetStdHandle, ATTACH_PARENT_PROCESS, STD_ERROR_HANDLE, STD_OUTPUT_HANDLE,
},
},
};
// Attach the process to the parent's console
unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to attach to parent console: {:?}", e)))?;
let handle = unsafe {
let pcstr = PCSTR::from_raw(c"CONOUT$".as_ptr() as *const u8);
CreateFileA::<PCSTR>(
pcstr,
(GENERIC_READ | GENERIC_WRITE).0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None,
OPEN_EXISTING,
FILE_FLAGS_AND_ATTRIBUTES(0),
None,
)
}
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to create console handle: {:?}", e)))?;
// Set the console's output and then error handles
if let Some(handle_error) = unsafe { SetStdHandle(STD_OUTPUT_HANDLE, handle) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console output handle: {:?}", e)))
.and_then(|_| {
unsafe { SetStdHandle(STD_ERROR_HANDLE, handle) }
.map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console error handle: {:?}", e)))
})
.err()
{
// If either set handle call fails, free the console
unsafe { FreeConsole() }
// Free the console if the SetStdHandle calls fail
.map_err(|free_error| {
PlatformError::ConsoleInit(format!(
"Failed to free console after SetStdHandle failed: {free_error:?} ({handle_error:?})"
))
})
// And then return the original error if the FreeConsole call succeeds
.and(Err(handle_error))?;
}
Ok(())
}

97
src/platform/emscripten.rs
View File

@@ -5,51 +5,7 @@ use std::time::Duration;
use crate::asset::Asset;
use crate::error::{AssetError, PlatformError};
use crate::platform::CommonPlatform;
/// Emscripten platform implementation.
pub struct Platform;
impl CommonPlatform for Platform {
fn sleep(&self, duration: Duration, _focused: bool) {
unsafe {
emscripten_sleep(duration.as_millis() as u32);
}
}
fn get_time(&self) -> f64 {
unsafe { emscripten_get_now() }
}
fn init_console(&self) -> Result<(), PlatformError> {
Ok(()) // No-op for Emscripten
}
fn requires_console(&self) -> bool {
false
}
fn get_canvas_size(&self) -> Option<(u32, u32)> {
Some(unsafe { get_canvas_size() })
}
fn get_asset_bytes(&self, asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
use sdl2::rwops::RWops;
use std::io::Read;
let path = format!("assets/game/{}", asset.path());
let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;
let len = rwops.len().ok_or_else(|| AssetError::NotFound(asset.path().to_string()))?;
let mut buf = vec![0u8; len];
rwops
.read_exact(&mut buf)
.map_err(|e| AssetError::Io(std::io::Error::other(e)))?;
Ok(Cow::Owned(buf))
}
}
use rand::{rngs::SmallRng, SeedableRng};
// Emscripten FFI functions
extern "C" {
@@ -58,9 +14,54 @@ extern "C" {
fn emscripten_get_element_css_size(target: *const u8, width: *mut f64, height: *mut f64) -> i32;
}
unsafe fn get_canvas_size() -> (u32, u32) {
pub fn sleep(duration: Duration, _focused: bool) {
unsafe {
emscripten_sleep(duration.as_millis() as u32);
}
}
pub fn get_time() -> f64 {
unsafe { emscripten_get_now() }
}
pub fn init_console() -> Result<(), PlatformError> {
Ok(()) // No-op for Emscripten
}
pub fn requires_console() -> bool {
false
}
pub fn get_canvas_size() -> Option<(u32, u32)> {
let mut width = 0.0;
let mut height = 0.0;
emscripten_get_element_css_size(c"canvas".as_ptr().cast(), &mut width, &mut height);
(width as u32, height as u32)
unsafe {
emscripten_get_element_css_size(c"canvas".as_ptr().cast(), &mut width, &mut height);
if width == 0.0 || height == 0.0 {
return None;
}
}
Some((width as u32, height as u32))
}
pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
use sdl2::rwops::RWops;
use std::io::Read;
let path = format!("assets/game/{}", asset.path());
let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;
let len = rwops.len().ok_or_else(|| AssetError::NotFound(asset.path().to_string()))?;
let mut buf = vec![0u8; len];
rwops
.read_exact(&mut buf)
.map_err(|e| AssetError::Io(std::io::Error::other(e)))?;
Ok(Cow::Owned(buf))
}
pub fn rng() -> SmallRng {
SmallRng::from_os_rng()
}

55
src/platform/mod.rs
View File

@@ -1,52 +1,13 @@
//! Platform abstraction layer for cross-platform functionality.
use crate::asset::Asset;
use crate::error::{AssetError, PlatformError};
use std::borrow::Cow;
use std::time::Duration;
#[cfg(not(target_os = "emscripten"))]
mod desktop;
#[cfg(target_os = "emscripten")]
mod emscripten;
pub mod buffered_writer;
pub mod tracing_buffer;
/// Cross-platform abstraction layer providing unified APIs for platform-specific operations.
pub trait CommonPlatform {
/// Platform-specific sleep function (required due to Emscripten's non-standard sleep requirements).
///
/// Provides access to current window focus state, useful for changing sleep algorithm conditionally.
fn sleep(&self, duration: Duration, focused: bool);
#[cfg(not(target_os = "emscripten"))]
mod desktop;
#[cfg(not(target_os = "emscripten"))]
pub use desktop::*;
#[allow(dead_code)]
fn get_time(&self) -> f64;
/// Configures platform-specific console and debugging output capabilities.
fn init_console(&self) -> Result<(), PlatformError>;
/// Retrieves the actual display canvas dimensions.
#[allow(dead_code)]
fn get_canvas_size(&self) -> Option<(u32, u32)>;
/// Loads raw asset data using the appropriate platform-specific method.
fn get_asset_bytes(&self, asset: Asset) -> Result<Cow<'static, [u8]>, AssetError>;
/// Whether the platform requires a console to be initialized.
fn requires_console(&self) -> bool;
}
/// Returns the appropriate platform implementation based on compile-time target.
#[allow(dead_code)]
pub fn get_platform() -> &'static dyn CommonPlatform {
#[cfg(not(target_os = "emscripten"))]
{
&desktop::Platform
}
#[cfg(target_os = "emscripten")]
{
&emscripten::Platform
}
}
#[cfg(target_os = "emscripten")]
pub use emscripten::*;
#[cfg(target_os = "emscripten")]
mod emscripten;

5
src/systems/ghost.rs
View File

@@ -1,3 +1,4 @@
use crate::platform;
use crate::systems::components::{DirectionalAnimation, Frozen, GhostAnimation, GhostState, LastAnimationState, LinearAnimation};
use crate::{
map::{
@@ -14,9 +15,7 @@ use crate::{
use crate::systems::GhostAnimations;
use bevy_ecs::query::Without;
use bevy_ecs::system::{Commands, Query, Res};
use rand::rngs::SmallRng;
use rand::seq::IndexedRandom;
use rand::SeedableRng;
use smallvec::SmallVec;
/// Autonomous ghost AI system implementing randomized movement with backtracking avoidance.
@@ -49,7 +48,7 @@ pub fn ghost_movement_system(
break;
}
} else {
*non_opposite_options.choose(&mut SmallRng::from_os_rng()).unwrap()
*non_opposite_options.choose(&mut platform::rng()).unwrap()
};
velocity.direction = new_edge.direction;