#![no_std]
#![no_main]

mod game;
mod sprites;

use embassy_executor::Spawner;
use embassy_time::Timer;
use crate::game::{Game, GameState};
use esp_backtrace as _;
use esp_hal::{
    gpio::{Input, Pull},
    i2c::{self, master::I2c},
    prelude::*,
};
use log::info;
use ssd1306::mode::DisplayConfig;
use ssd1306::prelude::DisplayRotation;
use ssd1306::size::DisplaySize128x64;
use ssd1306::{I2CDisplayInterface, Ssd1306};

#[main]
async fn main(_spawner: Spawner) {
    let peripherals = esp_hal::init(esp_hal::Config::default());


    esp_println::logger::init_logger_from_env();

    let timg0 = esp_hal::timer::timg::TimerGroup::new(peripherals.TIMG0);
    esp_hal_embassy::init(timg0.timer0);

    // Setting up I2C send text to OLED display
    // let i2c = i2c::I2c::new_async(peripherals.I2C1, scl, sda, Irqs, i2c::Config::default());
    let i2c = I2c::new(peripherals.I2C0, i2c::master::Config::default())
        .with_sda(peripherals.GPIO21)
        .with_scl(peripherals.GPIO22);

    // Setup the OLED Display
    let interface = I2CDisplayInterface::new(i2c);
    let mut display = Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
        .into_buffered_graphics_mode();
    display.init().unwrap();
    display.flush().unwrap();

    let button = Input::new(peripherals.GPIO4, Pull::Up);

    let random_gen = RandomGen::new(esp_hal::rng::Rng::new(peripherals.RNG));
    let mut game = Game::new(random_gen, display);
    game.draw_trex().unwrap();
    let mut clicked_count = 0; // To restart the game when it two times button clicked

    info!("Starting Game!");

    loop {
        if game.state == GameState::GameOver {
            if button.is_low() {
                clicked_count += 1;
            }
            if clicked_count > 2 {
                clicked_count = 0;
                game = Game::new(game.obstacles.rng, game.display);
                Timer::after_millis(500).await;
            }
            Timer::after_millis(50).await;
            continue;
        }

        game.clear_screen().unwrap();
        game.draw_score().unwrap();

        if button.is_low() {
            game.trex_jump();
        }

        game.move_world().unwrap();
        game.draw_ground().unwrap();
        game.draw_trex().unwrap();

        if game.check_collison() {
            game.game_over().unwrap();
            game.display.flush().unwrap();
            Timer::after_millis(500).await;
            continue;
        }

        game.display.flush().unwrap();
        Timer::after_millis(5).await;
    }
}

pub trait Rng {
    fn random_u32(&mut self) -> u32;
}


// Helper struct for Random number generation
struct RandomGen {
    rng: esp_hal::rng::Rng,
}

impl RandomGen {
    fn new(rng: esp_hal::rng::Rng) -> Self {
        Self { rng }
    }
}

impl Rng for RandomGen {
    fn random_u32(&mut self) -> u32 {
        self.rng.random()
    }
}


main.rs

diagram.json

[package]
name = "rust_project_esp32"
version = "0.1.0"
authors = ["Sergio Gasquez <sergio.gasquez@gmail.com>"]
edition = "2021"
license = "MIT OR Apache-2.0"

[dependencies]
esp-backtrace = { version = "0.14.1", features = [
    "esp32",
    "exception-handler",
    "panic-handler",
    "println",
] }

esp-hal = { version = "0.22.0", features = ["esp32"] }
esp-println = { version = "0.12.0", features = ["esp32", "log"] }
log = { version = "0.4.21" }
embassy-executor = { version = "0.6.0", features = ["task-arena-size-12288"] }
embassy-time = { version = "0.3.1", features = ["generic-queue-8"] }
esp-hal-embassy = { version = "0.5.0", features = ["esp32"] }

ssd1306 = "0.9.0"
heapless = "0.8.0"
embedded-graphics = "0.8.1"

Cargo.toml

sprites.rs

use crate::sprites::{self, Ground, Obstacles, Trex, TrexState};
use core::fmt::Write;
use embedded_graphics::geometry::Dimensions;
use embedded_graphics::{
    image::Image,
    mono_font::{ascii::FONT_6X10, MonoTextStyle, MonoTextStyleBuilder},
    pixelcolor::{self, BinaryColor},
    prelude::*,
    primitives::{PrimitiveStyle, Rectangle},
    text::{Baseline, Text},
};
use heapless::String;

const SCORE_BOARD_X: i32 = 60;
const SCORE_BOARD_Y: i32 = 5;

#[derive(PartialEq)]
pub enum GameState {
    // MainMenu,
    Playing,
    GameOver,
}

pub struct Game<D, R>
where
    D: DrawTarget<Color = pixelcolor::BinaryColor>,
    R: crate::Rng,
{
    pub state: GameState,
    pub display: D,
    pub obstacles: Obstacles<R>,
    score: u32,
    trex: Trex,
    ground: Ground,
    text_style: MonoTextStyle<'static, BinaryColor>,
}

impl<D, R> Game<D, R>
where
    D: DrawTarget<Color = pixelcolor::BinaryColor>,
    R: crate::Rng,
{
    pub fn new(rng: R, display: D) -> Self {
        let text_style = MonoTextStyleBuilder::new()
            .font(&FONT_6X10)
            .text_color(BinaryColor::On)
            .build();
        Self {
            score: 0,
            display,
            text_style,
            trex: Trex::new(sprites::TREX_X, sprites::TREX_GROUND_Y),
            ground: Ground::default(),
            obstacles: Obstacles::new(rng),
            // TODO: Start with GameState::MainMenu
            state: GameState::Playing,
        }
    }

    pub fn move_world(&mut self) -> Result<(), D::Error> {
        if self.obstacles.update_state() {
            self.score += 1;
        }
        self.ground.move_by_velocity(sprites::OBSTACLE_VELOCITY);
        self.draw_obstacles()?;
        Ok(())
    }

    pub fn draw_obstacles(&mut self) -> Result<(), D::Error> {
        for obs in self.obstacles.get_current().iter() {
            obs.img.draw(&mut self.display)?;
        }
        Ok(())
    }

    pub fn clear_screen(&mut self) -> Result<(), D::Error> {
        let text_area = Rectangle::new(Point::new(0, self.trex.position.y), Size::new(128, 64));
        text_area
            .into_styled(PrimitiveStyle::with_fill(BinaryColor::Off))
            .draw(&mut self.display)?;
        Ok(())
    }

    pub fn draw_score(&mut self) -> Result<(), D::Error> {
        let text_area =
            Rectangle::new(Point::new(SCORE_BOARD_X, SCORE_BOARD_Y), Size::new(128, 64));
        text_area
            .into_styled(PrimitiveStyle::with_fill(BinaryColor::Off))
            .draw(&mut self.display)?;

        let mut buff: String<32> = String::new();
        write!(buff, "Score: {}", self.score).unwrap();
        Text::with_baseline(
            &buff,
            Point::new(SCORE_BOARD_X, SCORE_BOARD_Y),
            self.text_style,
            Baseline::Top,
        )
        .draw(&mut self.display)?;
        Ok(())
    }

    pub fn draw_game_over(&mut self) -> Result<(), D::Error> {
        self.clear_screen()?;
        Image::new(&sprites::RAW_GAME_OVER, Point::new(16, 32)).draw(&mut self.display)?;
        Ok(())
    }

    pub fn draw_trex(&mut self) -> Result<(), D::Error> {
        if self.trex.state != TrexState::Running {
            self.trex.update_state();
        }

        self.trex.img.draw(&mut self.display)?;

        Ok(())
    }

    pub fn draw_ground(&mut self) -> Result<(), D::Error> {
        self.ground.img.draw(&mut self.display)?;
        Ok(())
    }

    pub fn trex_jump(&mut self) -> bool {
        if self.trex.state == TrexState::Running {
            self.trex.state = TrexState::Jumping;
            self.trex.update_state();
            return true;
        }
        false
    }

    pub fn check_collison(&mut self) -> bool {
        let trex_bbox = self.trex.img.bounding_box();

        for obs in self.obstacles.get_current().iter() {
            let obs_bbox = obs.img.bounding_box();
            if bounding_boxes_overlap(trex_bbox, obs_bbox) {
                return true;
            }
        }
        false
    }

    pub fn game_over(&mut self) -> Result<(), D::Error> {
        self.state = GameState::GameOver;
        self.draw_game_over()?;
        Ok(())
    }
}

/// Checks if two rectangular bounding boxes overlap.
///
/// This function determines whether two rectangles intersect by comparing their
/// coordinates. It's typically used to detect collisions between game objects,
/// such as the T-Rex and obstacles.
///
/// # Arguments
///
/// * `bbox1` - A `Rectangle` representing the first bounding box (typically the T-Rex's).
/// * `bbox2` - A `Rectangle` representing the second bounding box (typically an obstacle's).
///
/// # Returns
///
/// Returns `true` if the bounding boxes overlap, `false` otherwise.
fn bounding_boxes_overlap(bbox1: Rectangle, bbox2: Rectangle) -> bool {
    if let (Some(bbox1_bottom_right), Some(bbox2_bottom_right)) =
        (bbox1.bottom_right(), bbox2.bottom_right())
    {
        let x_overlap =
            bbox1.top_left.x < bbox2_bottom_right.x && bbox1_bottom_right.x > bbox2.top_left.x;
        let y_overlap =
            bbox1.top_left.y < bbox2_bottom_right.y && bbox1_bottom_right.y > bbox2.top_left.y;
        x_overlap && y_overlap
    } else {
        false
    }
}
