Fixed minor issues in Pong tutorial book (#1051)

- [x] Fixed a reference to `hblank` in Chapter 4.2
- [x] Fixed ButtonController variable name in Chapter 4.4
- [x] Fixed background aseprite file name in Chapter 4.6
- [x] Fixed missing use path to `Mixer` and `SoundChannel` in Chapter
4.8
- [x] Fixed use path to `sound::mixer::SoundData` in Chapter 4.8
- [x] ~~Fixed missing path to Priority in Ball's code snippet in Chapter
4.9~~
- [x] Added getter and decrement function for Paddle's health in Chapter
4.9
- [x] Added note to call `show_cpu_health(...);`  in Chapter 4.9
- [x] Fixed missing `pub` keywords for Ball and Paddle's structs and
their functions in multiple chapters. While this is fine when both
structs are in the same module as main function, it won't compile when
user moves them into separate files.

I hope you will find my changes useful :smile:

Author: corwinkuiper

book/src/pong/02_sprites.md

@@ -89,9 +89,7 @@ After it has finished rendering to each pixel of the screen, it briefly pauses r
 This period of no drawing is called the 'vertical blanking interval' which is shortened to `vblank`.
 There is also a 'horizontal blanking interval', but that is outside of the scope of this tutorial[^hblank].
 
-[^hblank]:
-    Timing this can give you some really cool effects allowing you to push the hardware.
-    `agb` provides support for this by using `dma`, this is an advanced technique that is out of scope of this tutorial.
+[^hblank]: Timing this can give you some really cool effects allowing you to push the hardware. `agb` provides support for this by using `dma`, this is an advanced technique that is out of scope of this tutorial.
 
 The `frame.commit()` method automatically waits for this `vblank` state before rendering your sprites to avoid moving a sprite while it is being rendered which could cause tearing of your objects.
 

book/src/pong/03_meta_sprites.md

@@ -40,25 +40,25 @@ paddle_end.set_vflip(true);
 Now the paddle will display correctly. It's rather awkward to use, however, having to set all these positions correctly. Therefore we should encapsulate the logic of this object.
 
 ```rust
-struct Paddle {
+pub struct Paddle {
     x: i32,
     y: i32,
 }
 
 impl Paddle {
-    fn new(start_x: i32, start_y: i32) -> Self {
+    pub fn new(start_x: i32, start_y: i32) -> Self {
         Self {
             x: start_x,
             y: start_y,
         }
     }
 
-    fn set_pos(&mut self, x: i32, y: i32) {
+    pub fn set_pos(&mut self, x: i32, y: i32) {
         self.x = x;
         self.y = y;
     }
 
-    fn show(&self, frame: &mut GraphicsFrame) {
+    pub fn show(&self, frame: &mut GraphicsFrame) {
         Object::new(sprites::PADDLE_END.sprite(0))
             .set_pos((self.x, self.y))
             .show(frame);

book/src/pong/04_paddle_movement.md

@@ -26,7 +26,7 @@ To add button control to our game, we will need a [`ButtonController`](https://d
 Add this near the top of your main function:
 
 ```rust
-let mut input = agb::input::ButtonController::new();
+let mut button_controller = agb::input::ButtonController::new();
 ```
 
 The button controller is not part of the `Gba` struct because it only allows for reading and not writing so does not need to be controlled by the borrow checker.
@@ -40,7 +40,7 @@ button_controller.update();
 To handle the movement of the paddles, let's add a new method to the `Paddle` struct.
 
 ```rust
-fn move_by(&mut self, y: i32) {
+pub fn move_by(&mut self, y: i32) {
     self.y += y;
 }
 ```

book/src/pong/05_paddle_collision.md

@@ -53,23 +53,23 @@ ball.set_pos(ball_pos);
 You can store the paddle position as `pos` instead of `x` and `y` separately:
 
 ```rust
-struct Paddle {
+pub struct Paddle {
     pos: Vector2D<i32>,
 }
 ```
 
 You can change the `set_pos()` method on `Paddle` to take a `Vector2D<i32>` instead of separate `x` and `y` arguments as follows:
 
 ```rust
-fn set_pos(&mut self, pos: Vector2D<i32>) {
+pub fn set_pos(&mut self, pos: Vector2D<i32>) {
     self.pos = pos;
 }
 ```
 
 And when rendering:
 
 ```rust
-fn show(frame: &mut GraphicsFrame) {
+pub fn show(frame: &mut GraphicsFrame) {
     Object::new(sprites::PADDLE_END.sprite(0))
         .set_pos(self.pos)
         .show(frame);
@@ -86,7 +86,7 @@ fn show(frame: &mut GraphicsFrame) {
 `move_by()` can also be updated as follows:
 
 ```rust
-fn move_by(&mut self, y: i32) {
+pub fn move_by(&mut self, y: i32) {
     self.y += vec2(0, y);
 }
 ```
@@ -105,7 +105,7 @@ We will assume that the ball and the paddle both have axis-aligned bounding boxe
 Lets add a simple method to the `Paddle` impl which returns the collision rectangle for it:
 
 ```rust
-fn collision_rect(&self) -> Rect<i32> {
+pub fn collision_rect(&self) -> Rect<i32> {
     Rect::new(self.pos, vec2(16, 16 * 3))
 }
 ```

book/src/pong/06_background.md

@@ -44,7 +44,7 @@ use agb::include_background_gfx;
 
 include_background_gfx!(
     mod background,
-    PLAY_FIELD => deduplicate "gfx/play_field.aseprite",
+    PLAY_FIELD => deduplicate "gfx/background.aseprite",
 );
 ```
 

book/src/pong/07_fixnums.md

@@ -18,17 +18,17 @@ The solution to this problem used by almost every Game Boy Advance game is to us
 Before we go to put fixed point numbers in the game, we need to do a quick change to pull the ball into its own struct.
 
 ```rust
-struct Ball {
+pub struct Ball {
     pos: Vector2D<i32>,
     velocity: Vector2D<i32>,
 }
 
 impl Ball {
-    fn new(pos: Vector2D<i32>, velocity: Vector2D<i32>) -> Self {
+    pub fn new(pos: Vector2D<i32>, velocity: Vector2D<i32>) -> Self {
         Self { pos, velocity }
     }
 
-    fn update(&mut self, paddle_a: &Paddle, paddle_b: &Paddle) {
+    pub fn update(&mut self, paddle_a: &Paddle, paddle_b: &Paddle) {
         // Speculatively move the ball, we'll update the velocity if this causes it to intersect with either the
         // edge of the map or a paddle.
         let potential_ball_pos = self.pos + self.velocity;
@@ -54,7 +54,7 @@ impl Ball {
         self.pos += self.velocity;
     }
 
-    fn show(&self, frame: &mut GraphicsFrame) {
+    pub fn show(&self, frame: &mut GraphicsFrame) {
         Object::new(sprites::BALL.sprite(0))
             .set_pos(self.pos)
             .show(frame);
@@ -101,14 +101,14 @@ We'll now replace the paddle position and the ball position and velocity with `F
 Some notable changes:
 
 ```rust
-fn move_by(&mut self, y: Fixed) {
+pub fn move_by(&mut self, y: Fixed) {
     // we now need to cast the 0 to a Fixed which you can do with
     // `Fixed::from(0)` or `0.into()`. But the preferred one is the `num!` macro
     // which we imported above.
     self.pos += vec2(num!(0), y);
 }
 
-fn collision_rect(&self) -> Rect<Fixed> {
+pub fn collision_rect(&self) -> Rect<Fixed> {
     // Same idea here with creating a fixed point rectangle
     Rect::new(self.pos, vec2(num!(16), num!(16 * 3)))
 }
@@ -118,7 +118,7 @@ Since you can only show things on the Game Boy Advance's screen in whole pixel c
 integer to show the paddle in a specific location:
 
 ```rust
-fn show(&self, frame: &mut GraphicsFrame) {
+pub fn show(&self, frame: &mut GraphicsFrame) {
     let sprite_pos = self.pos.round();
 
     Object::new(sprites::PADDLE_END.sprite(0))

book/src/pong/08_bgm.md

@@ -49,7 +49,7 @@ ffmpeg -i ~/Downloads/laserShoot.wav -ar 32768 sfx/ball-paddle-hit.wav
 Import the wav file using [`include_wav!()`](https://docs.rs/agb/latest/agb/macro.include_wav.html).
 
 ```rust
-use agb::{include_wav, mixer::SoundData};
+use agb::{include_wav, sound::mixer::SoundData};
 
 static BALL_PADDLE_HIT: SoundData = include_wav!("sfx/ball-paddle-hit.wav");
 ```
@@ -68,6 +68,8 @@ mixer.play_sound(hit_sound);
 We'll do this in a separate function:
 
 ```rust
+use agb::sound::mixer::{Mixer, SoundChannel};
+
 fn play_hit(mixer: &mut Mixer) {
     let hit_sound = SoundChannel::new(BALL_PADDLE_HIT);
     mixer.play_sound(hit_sound);

book/src/pong/09_keeping_score.md

@@ -28,23 +28,35 @@ If you lose while you have 0 lives, you lose the game.
 Firstly, let's add the score to the `Paddle` objects:
 
 ```rust
-struct Paddle {
+pub struct Paddle {
     pos: Vector2D<Fixed>,
     health: i32,
 }
 ```
 
 and in the `new()` function, initialise it to 3.
 
+We're going to use it for displaying the health as hearts and decrementing it when ball touches the side of the screen. Add these functions to `Paddle` struct.
+
+```rust
+pub fn health(&self) -> i32 {
+    self.health
+}
+
+pub fn decrement_health(&mut self) {
+    self.health -= 1;
+}
+```
+
 We can then reduce the health in the ball's update function (you'll have to change the `update` function to take `&mut Paddle`):
 
 ```rust
 if potential_ball_pos.x <= num!(0) {
     self.velocity.x *= -1;
-    paddle_a.health -= 1;
+    paddle_a.decrement_health();
 } else if potential_ball_pos.x >= num!(agb::display::WIDTH - 16) {
     self.velocity.x *= -1;
-    paddle_b.health -= 1;
+    paddle_b.decrement_health();
 }
 ```
 
@@ -131,7 +143,7 @@ So let's display up to 3 hearts with the given tile indexes by placing the follo
 
 ```rust
 for i in 0..3 {
-    let tile_index = if i < paddle_a.health { 4 } else { 5 };
+    let tile_index = if i < paddle_a.health() { 4 } else { 5 };
     player_health_background.set_tile(
         (i + 4, 0),
         &background::SCORE.tiles,
@@ -183,7 +195,7 @@ fn show_cpu_health(paddle: &Paddle, frame: &mut GraphicsFrame) {
 
     // For each heart frame, show that too
     for i in 0..3 {
-        let heart_frame = if i < paddle.health { 0 } else { 1 };
+        let heart_frame = if i < paddle.health() { 0 } else { 1 };
 
         Object::new(sprites::HEART.sprite(heart_frame))
             .set_pos(top_left + vec2(16 + i * 8 + TEXT_HEART_GAP, 0))
@@ -192,6 +204,8 @@ fn show_cpu_health(paddle: &Paddle, frame: &mut GraphicsFrame) {
 }
 ```
 
+Don't forget to call `show_cpu_health(&paddle_b, &mut frame);` before `frame.commit()`!
+
 Running the example again you'll see the health bar for the player and the CPU, and you wouldn't be able
 to tell that they are using completely different rendering mechanisms.