Read me and comments

.gitignore

···
 /target
-.idea
+.idea
+
+.DS_Store

README.md

···
+# HonkBird?
+
+Idk i'm still working on the name. A gba game written in rust
+with [agb-rs](https://agbrs.dev/). Heavily wip, just need it in a git repo so I can hack on it on another computer.
+
+If you're really wanting to run this, check the [agb book out](https://agbrs.dev/book/), first couple chapters will get
+you going
+
+Special thanks
+
+- The goose is from [here](https://duckhive.itch.io/goose). Just scaled it down to 16x16 and animated it in aseprite 

src/game.rs

···
+use crate::{Fixed, goose_sprites};
+use agb::display::object::Object;
+use agb::display::{GraphicsFrame, HEIGHT, Priority, WIDTH};
+use agb::fixnum::{Num, Vector2D, num, vec2};
+use agb::input::Button;
+
+pub enum GameState {
+    Start,
+    Playing,
+    GameOver,
+}
+
+pub struct GameLoop {
+    pub score: u16,
+    pub game_state: GameState,
+}
+
+impl GameLoop {
+    pub fn new() -> Self {
+        Self {
+            score: 0,
+            game_state: GameState::Start,
+        }
+    }
+
+    pub fn run(&mut self, gba: &mut agb::Gba) {
+        let mut gfx = gba.graphics.get();
+
+        let mut button_controller = agb::input::ButtonController::new();
+        let mut goose = Goose::new();
+
+        loop {
+            button_controller.update();
+            let mut frame = gfx.frame();
+
+            let just_pressed = button_controller.is_just_pressed(Button::A);
+            goose.move_goose(just_pressed);
+            goose.show(&mut frame);
+            frame.commit();
+        }
+    }
+}
+
+/// I really don't have a better name for these
+#[derive(Copy, Clone)]
+pub enum GooseState {
+    Zero = 0,
+    One = 1,
+    Two = 2,
+    Three = 3,
+}
+
+pub struct Goose {
+    pos: Vector2D<Fixed>,
+    velocity: Vector2D<Fixed>,
+    current_state: GooseState,
+    //Should increase every game play loop and reset at 64
+    tick_counter: u8,
+}
+
+impl Goose {
+    pub fn new() -> Self {
+        Self {
+            pos: vec2(num!(5), num!(5)),
+            velocity: vec2(num!(0.20), num!(0)),
+            current_state: GooseState::Zero,
+            tick_counter: 0,
+        }
+    }
+
+    pub fn show(&mut self, frame: &mut GraphicsFrame) {
+        let _ = Object::new(goose_sprites::GOOSE.sprite(self.current_state as usize))
+            .set_pos(self.pos.round())
+            .set_priority(Priority::P1)
+            .show(frame);
+    }
+
+    fn animate(&mut self) {
+        // Advance animation every 8 ticks
+        self.tick_counter = self.tick_counter.wrapping_add(1);
+        if self.tick_counter % 8 == 0 {
+            self.current_state = match self.current_state {
+                GooseState::Zero => GooseState::One,
+                GooseState::One => GooseState::Two,
+                GooseState::Two => GooseState::Three,
+                GooseState::Three => GooseState::Zero,
+            }
+        }
+        //Just a catch to not let that number get too big
+        if self.tick_counter >= 64 {
+            self.tick_counter = 0;
+        }
+    }
+
+    fn reset(&mut self) {
+        self.pos = vec2(num!(5), num!(5));
+        self.velocity = vec2(num!(0.20), num!(0));
+    }
+
+    pub fn move_goose(&mut self, button_pressed: bool) {
+        //If the button is pressed, go up a bit
+        if button_pressed {
+            self.velocity.y = num!(-1);
+        } else {
+            self.velocity.y += num!(0.02);
+        }
+
+        self.pos += self.velocity;
+
+        //Right now just cycling through may change animations around
+        self.animate();
+
+        //Keep in frame right now. Will later do the scrolling map thing
+        if self.pos.y < num!(0) {
+            self.pos.y = num!(0);
+            self.velocity.y = num!(0);
+        }
+        if self.pos.y >= num!(HEIGHT) {
+            //TODO call game end here later
+            self.reset();
+        }
+
+        // Keep X within screen horizontally (optional: clamp)
+        if self.pos.x < num!(0) {
+            self.pos.x = num!(0);
+        }
+        let max_x = num!(WIDTH - 1);
+        if self.pos.x > max_x {
+            self.pos.x = max_x;
+        }
+    }
+}

src/main.rs

···
 #![cfg_attr(test, reexport_test_harness_main = "test_main")]
 #![cfg_attr(test, test_runner(agb::test_runner::test_runner))]
 
+mod game;
+
 // By default no_std crates don't get alloc, so you won't be able to use things like Vec
 // until you declare the extern crate. `agb` provides an allocator so it will all work
 extern crate alloc;
 
-use agb::display::{GraphicsFrame, Priority, Rgb15};
+use crate::game::{GameLoop, GameState};
 use agb::display::font::{AlignmentKind, Font, Layout, RegularBackgroundTextRenderer};
-use agb::display::object::Object;
 use agb::display::tiled::{RegularBackground, RegularBackgroundSize, TileFormat, VRAM_MANAGER};
-use agb::fixnum::{num, vec2, FixedNum, Num, Vector2D};
+use agb::display::{Priority, Rgb15};
+use agb::fixnum::Num;
+use agb::input::Button;
 use agb::{include_aseprite, include_font};
-use agb::input::Button;
-
-const SCREEN_W: i32 = 240;
-const SCREEN_H: i32 = 160;
 
 include_aseprite!(
     mod goose_sprites,
     "gfx/flap_animated.aseprite"
 );
 
-static FONT: Font = include_font!("fnt/Born2bSportyV2.ttf", 20);
+static FONT: Font = include_font!("fnt/Born2bSportyV2.ttf", 24);
 
 type Fixed = Num<i32, 8>;
-
 
 #[agb::entry]
 fn main(mut gba: agb::Gba) -> ! {
···
         TileFormat::FourBpp,
     );
 
-
     let mut text_layout = Layout::new(
-        "Hello, this is some text that I want to display!",
+        "HonkBird\nPress Start to play",
         &FONT,
         AlignmentKind::Left,
         32,
         200,
     );
 
-    let mut text_renderer = RegularBackgroundTextRenderer::new((4, 0));
+    let mut text_renderer = RegularBackgroundTextRenderer::new((4, 50));
     let mut button_controller = agb::input::ButtonController::new();
-
     loop {
         match game.game_state {
             GameState::Start => {
···
                 if let Some(letter) = text_layout.next() {
                     text_renderer.show(&mut bg, &letter);
                 }
-                if button_controller.is_just_pressed(Button::A) {
+                if button_controller.is_just_pressed(Button::START) {
                     game.game_state = GameState::Playing;
                 }
-                // Scope the graphics borrow to this arm only
                 let mut gfx = gba.graphics.get();
                 let mut frame = gfx.frame();
 
···
                 frame.commit();
             }
             GameState::Playing => {
-                 game.run(&mut gba);
+                game.run(&mut gba);
             }
             GameState::GameOver => {}
         }
-
     }
 }
-
-
-pub enum GameState {
-    Start,
-    Playing,
-    GameOver,
-}
-
-struct GameLoop {
-    still_going: bool,
-    score: u16,
-    game_state: GameState
-}
-
-impl GameLoop {
-    pub fn new() -> Self {
-        Self {
-            still_going: true,
-            score: 0,
-            game_state: GameState::Start,
-        }
-    }
-
-    pub fn run(&mut self, gba: &mut agb::Gba) {
-        let mut gfx = gba.graphics.get();
-
-        let mut button_controller = agb::input::ButtonController::new();
-        let mut goose = Goose::new();
-
-        loop {
-            button_controller.update();
-            let mut frame = gfx.frame();
-
-            let just_pressed = button_controller.is_just_pressed(Button::A);
-            goose.move_goose(just_pressed);
-            goose.show(&mut frame);
-            frame.commit();
-        }
-    }
-}
-
-
-
-
-/// I really don't have a better name for these
-#[derive(Copy, Clone)]
-pub enum GooseState {
-    Zero = 0,
-    One = 1,
-    Two = 2,
-    Three = 3,
-}
-
-
-struct Goose {
-    pos: Vector2D<Fixed>,
-    velocity: Vector2D<Fixed>,
-    current_state: GooseState,
-    frame_counter: u16,
-}
-
-impl Goose {
-    pub fn new() -> Self {
-        Self {
-            pos: vec2(num!(5), num!(5)),
-            velocity: vec2(num!(0.20), num!(0)),
-            current_state: GooseState::Zero,
-            frame_counter: 0,
-        }
-    }
-
-    pub fn show(&mut self, frame: &mut GraphicsFrame) {
-        let _ = Object::new(goose_sprites::GOOSE.sprite(self.current_state as usize))
-            .set_pos(self.pos.round())
-            .set_priority(Priority::P1)
-            .show(frame);
-
-    }
-
-    fn animate(&mut self) {
-        // Advance animation every 8 frames
-        self.frame_counter = self.frame_counter.wrapping_add(1);
-        if self.frame_counter % 8 == 0 {
-            self.current_state = match self.current_state {
-                GooseState::Zero => GooseState::One,
-                GooseState::One => GooseState::Two,
-                GooseState::Two => GooseState::Three,
-                GooseState::Three => GooseState::Zero,
-            }
-        }
-    }
-
-    fn reset(&mut self) {
-        self.pos = vec2(num!(5), num!(5));
-        self.velocity = vec2(num!(0), num!(0));
-    }
-
-    pub fn move_goose(&mut self, button_pressed: bool) {
-        // Flap impulse
-        if button_pressed {
-            // Give an upward kick similar to Flappy Bird
-            self.velocity.y = num!(-1);
-        }else{
-            // Gravity pulls down constantly
-            self.velocity.y += num!(0.02);
-        }
-
-
-        // Apply velocity to position
-        self.pos += self.velocity;
-
-        // Animate sprite
-        self.animate();
-
-        // Screen bounds checking (top-left is 0,0; bottom-right is 240,160)
-        // Loop/reset when going out of vertical bounds
-        if self.pos.y < num!(0) {
-            self.pos.y = num!(0);
-            self.velocity.y = num!(0);
-        }
-        if self.pos.y >= Num::<i32, 8>::from_raw((SCREEN_H as i32) << 8) {
-            // Off the bottom of the screen — reset to start like a flappy-bird loop
-            self.reset();
-        }
-
-        // Keep X within screen horizontally (optional: clamp)
-        if self.pos.x < num!(0) {
-            self.pos.x = num!(0);
-        }
-        let max_x = Num::<i32, 8>::from_raw((SCREEN_W as i32 - 1) << 8);
-        if self.pos.x > max_x {
-            self.pos.x = max_x;
-        }
-    }
-}