Game Engine Prototype

Example Code

use std::time::{Instant, Duration};

// --- Core Engine Components ---

// A trait representing a drawable object
pub trait Drawable {
    fn draw(&self, renderer: &mut dyn Renderer);
}

// A trait representing an updatable object
pub trait Updatable {
    fn update(&mut self, dt: Duration);
}

// A simple renderer interface
pub trait Renderer {
    fn clear(&mut self);
    fn draw_text(&mut self, x: i32, y: i32, text: &str);
    // In a real engine, this would have more sophisticated drawing methods
}

// A console-based renderer for our prototype
pub struct ConsoleRenderer {
    width: usize,
    height: usize,
    buffer: Vec<char>,
}

impl ConsoleRenderer {
    pub fn new(width: usize, height: usize) -> Self {
        Self {
            width,
            height,
            buffer: vec![' '; width * height],
        }
    }

    fn put_char(&mut self, x: i32, y: i32, ch: char) {
        if x >= 0 && x < self.width as i32 && y >= 0 && y < self.height as i32 {
            let index = y as usize * self.width + x as usize;
            self.buffer[index] = ch;
        }
    }

    pub fn present(&self) {
        print!("\x1b[H"); // Move cursor to top-left
        for y in 0..self.height {
            let row_start = y * self.width;
            let row_end = (y + 1) * self.width;
            let row_str: String = self.buffer[row_start..row_end].iter().collect();
            println!("{}", row_str);
        }
    }
}

impl Renderer for ConsoleRenderer {
    fn clear(&mut self) {
        for c in self.buffer.iter_mut() {
            *c = ' ';
        }
    }

    fn draw_text(&mut self, x: i32, y: i32, text: &str) {
        for (i, ch) in text.chars().enumerate() {
            self.put_char(x + i as i32, y, ch);
        }
    }
}

// --- Game State & Entities ---

pub struct Player {
    x: i32,
    y: i32,
    name: String,
}

impl Player {
    pub fn new(name: String, x: i32, y: i32) -> Self {
        Self { name, x, y }
    }

    pub fn move_player(&mut self, dx: i32, dy: i32) {
        self.x += dx;
        self.y += dy;
    }
}

impl Updatable for Player {
    fn update(&mut self, _dt: Duration) {
        // Player logic could go here, e.g., AI movement, animation updates
    }
}

impl Drawable for Player {
    fn draw(&self, renderer: &mut dyn Renderer) {
        renderer.draw_text(self.x, self.y, &format!("P ({})", self.name.chars().next().unwrap_or('?')));
    }
}

pub struct GameState {
    player: Player,
    enemies: Vec<Player>, // Using Player struct for simplicity
    message: String,
    running: bool,
}

impl GameState {
    pub fn new() -> Self {
        Self {
            player: Player::new("Hero".to_string(), 1, 1),
            enemies: vec![
                Player::new("Goblin".to_string(), 10, 5),
                Player::new("Orc".to_string(), 5, 8),
            ],
            message: "Welcome to the Prototype!".to_string(),
            running: true,
        }
    }

    pub fn process_input(&mut self, input: char) {
        match input {
            'w' => self.player.move_player(0, -1),
            's' => self.player.move_player(0, 1),
            'a' => self.player.move_player(-1, 0),
            'd' => self.player.move_player(1, 0),
            'q' => {
                self.running = false;
                self.message = "Exiting game.".to_string();
            },
            _ => self.message = format!("Unknown input: {}", input),
        }
    }

    pub fn update(&mut self, dt: Duration) {
        self.player.update(dt);
        for enemy in &mut self.enemies {
            enemy.update(dt);
            // Simple collision check for prototype:
            if self.player.x == enemy.x && self.player.y == enemy.y {
                self.message = format!("{} encountered {}!", self.player.name, enemy.name);
            }
        }
    }

    pub fn draw(&self, renderer: &mut dyn Renderer) {
        renderer.clear();
        self.player.draw(renderer);
        for enemy in &self.enemies {
            enemy.draw(renderer);
        }
        renderer.draw_text(0, 0, &self.message);
        renderer.draw_text(0, 11, &format!("Player @ ({},{})", self.player.x, self.player.y));
        renderer.draw_text(0, 12, "Use WASD to move, Q to quit.");
    }
}

// --- The Engine Prototype Itself ---

pub struct GameEnginePrototype {
    game_state: GameState,
    renderer: ConsoleRenderer,
    last_frame_time: Instant,
}

impl GameEnginePrototype {
    pub fn new(width: usize, height: usize) -> Self {
        Self {
            game_state: GameState::new(),
            renderer: ConsoleRenderer::new(width, height),
            last_frame_time: Instant::now(),
        }
    }

    pub fn run(&mut self) {
        // Simulate a basic game loop
        while self.game_state.running {
            let current_time = Instant::now();
            let delta_time = current_time.duration_since(self.last_frame_time);
            self.last_frame_time = current_time;

            // 1. Process Input (simplified for console)
            // In a real engine, this would read from OS events
            if let Some(input) = self.get_mock_input() {
                self.game_state.process_input(input);
            }

            // 2. Update Game State
            self.game_state.update(delta_time);

            // 3. Render
            self.game_state.draw(&mut self.renderer);
            self.renderer.present();

            std::thread::sleep(Duration::from_millis(100)); // Simulate frame rate
        }
    }

    // This is a highly simplified mock for input, a real engine would use an event loop
    fn get_mock_input(&self) -> Option<char> {
        // For a console prototype, we'd typically use `termion` or `crossterm`
        // to read non-blocking input. For this simple example, let's simulate
        // getting input by printing a message and waiting for a line.
        // Note: This will block the engine loop. For non-blocking, a library is needed.
        // For true prototyping, one might just hardcode a sequence of inputs or remove this.
        use std::io::{self, Read};

        // Temporarily put terminal in raw mode for single char input
        // This is a minimal example, requires `crossterm` or `termion` for a real solution
        // We'll skip complex terminal setup for this core engine prototype example.
        // Instead, we'll just check if there's *any* pending input that's easy to get.
        // A simpler way for a prototype: just return None or a predetermined sequence.
        
        // Let's make it truly non-blocking by using a simple hack for demonstration
        // (this will likely not work universally or correctly without a proper TUI library)
        // A better approach for prototype would be to use `crossterm::event::poll`
        // For this basic example, let's just make it a 'passive' input, meaning it simulates
        // no input for most frames, and only sometimes an action.
        
        if rand::random::<f32>() < 0.1 { // ~10% chance to simulate input
            match rand::random::<u8>() % 5 {
                0 => Some('w'),
                1 => Some('a'),
                2 => Some('s'),
                3 => Some('d'),
                4 => Some('q'), // Simulating a quit condition randomly
                _ => None,
            }
        } else {
            None
        }
    }
}

fn main() {
    println!("\x1b[2J"); // Clear screen (ANSI escape code)
    println!("\x1b[?25l"); // Hide cursor (ANSI escape code)

    let mut engine = GameEnginePrototype::new(40, 15);
    engine.run();

    println!("\x1b[?25h"); // Show cursor again
    println!("Engine prototype finished.");
}

// Note: To run this code and see interactive console output properly,
// you would typically need a crate like `crossterm` or `termion` for raw terminal input.
// For a simple standalone `cargo run`, the `get_mock_input` function is a placeholder
// that either returns `None` or a random char, simulating very basic input without blocking.
// For actual interactive input, add `crossterm = "0.27"` to Cargo.toml and replace
// `get_mock_input` with something like:
/*
use crossterm::{
    event::{self, Event, KeyCode},
    terminal,
};

impl GameEnginePrototype {
    // ... other methods ...
    fn get_input_event(&self) -> Option<char> {
        if event::poll(Duration::from_millis(0)).unwrap() {
            match event::read().unwrap() {
                Event::Key(key_event) => match key_event.code {
                    KeyCode::Char(c) => Some(c),
                    _ => None,
                },
                _ => None,
            }
        } else {
            None
        }
    }
}
// In `run` method:
// terminal::enable_raw_mode().unwrap();
// while self.game_state.running {
//    if let Some(input) = self.get_input_event() {
//        self.game_state.process_input(input);
//    }
//    // ... rest of the loop ...
// }
// terminal::disable_raw_mode().unwrap();
*/