(#26) GameEngine: support collision of player with walls

Author: ForNeVeR

O21.Game/Engine/Entities.fs

@@ -23,12 +23,23 @@ type Player = {
         match this.Direction with
         | HorizontalDirection.Left -> this.TopLeft
         | HorizontalDirection.Right -> this.TopRight
+        
+    member this.Box: Box = { TopLeft = this.TopLeft; Size = GameRules.PlayerSize }
+
+    member this.Update(level: Level, timeDelta: int): PlayerEffect =
+        let newPlayer =
+            { this with
+                TopLeft = this.TopLeft + this.Velocity * timeDelta
+                ShotCooldown = max (this.ShotCooldown - timeDelta) 0
+            }
+        match CheckCollision level newPlayer.Box with
+        | Collision.OutOfBounds -> PlayerEffect.Update newPlayer // TODO[#28]: Level progression
+        | Collision.CollidesBrick -> PlayerEffect.Die
+        | Collision.None -> PlayerEffect.Update newPlayer
 
-    member this.Update(timeDelta: int): Player =
-        { this with
-            TopLeft = this.TopLeft + this.Velocity * timeDelta
-            ShotCooldown = max (this.ShotCooldown - timeDelta) 0
-        }
+and [<RequireQualifiedAccess>] PlayerEffect =
+    | Update of Player
+    | Die
 
 type Bullet = {
     TopLeft: Point
@@ -54,7 +65,7 @@ type Bullet = {
             else
                 match CheckCollision level newBullet.Box with
                 | Collision.OutOfBounds -> None
-                | Collision.TouchesBrick -> None
+                | Collision.CollidesBrick -> None
                 | Collision.None -> Some newBullet
         else
             this.Update(level, maxTimeToProcessInOneStep)
@@ -72,5 +83,5 @@ type Particle = {
         let newParticle = { this with TopLeft = newPosition }
         match CheckCollision level newParticle.Box with
         | Collision.OutOfBounds -> None
-        | Collision.TouchesBrick -> None
+        | Collision.CollidesBrick -> None
         | Collision.None -> Some newParticle

O21.Game/Engine/GameEngine.fs

@@ -36,17 +36,17 @@ type GameEngine = {
             Period = 0
         }
     }
-
-    member this.Update(time: Time): GameEngine =
+    
+    member this.Update(time: Time): GameEngine * ExternalEffect[] =
         let newTick = int <| (time.Total - this.StartTime.Total) * GameRules.TicksPerSecond
         let timeDelta = newTick - this.Tick
+        let playerEffect = this.Player.Update(this.CurrentLevel, timeDelta)
         // TODO[#26]: Bullet collisions
         { this with
             Tick = newTick
-            Player = this.Player.Update(timeDelta)
             Bullets = this.Bullets |> Array.choose(_.Update(this.CurrentLevel, timeDelta))
             ParticlesSource = this.ParticlesSource.Update(this.CurrentLevel, this.Player, timeDelta) 
-        }
+        } |> GameEngine.ProcessPlayerEffect playerEffect
 
     member this.ApplyCommand(command: PlayerCommand): GameEngine * ExternalEffect[] =
         match command with
@@ -71,3 +71,13 @@ type GameEngine = {
                     Bullets = Array.append this.Bullets [| newBullet |] // TODO[#130]: Make more efficient (persistent vector?)
                 }, [| PlaySound SoundType.Shot |]
             else this, Array.empty
+
+    static member private ProcessPlayerEffect effect (engine: GameEngine) =
+        match effect with
+        | PlayerEffect.Update player -> { engine with Player = player }, Array.empty
+        | PlayerEffect.Die ->
+            { engine with GameEngine.Player.Velocity = Vector.Zero }, [| PlaySound SoundType.LifeLost |]
+            // TODO[#26]: Lose a life: keep lives in the player object and add updated player to PlayerEffect.Die
+            // TODO[#26]: Player sprite should be replaced with explosion for a while
+            // TODO[#26]: Investigate how shot cooldown and direction should behave on resurrect: are they reset or not?
+            // TODO[#27]: Investigate if enemy collision should stop the player from moving

O21.Game/Engine/GameField.fs

@@ -9,6 +9,7 @@ type Point =
     | Point of int * int
 
     static member (+) (Point(x1, y1), Vector(x2, y2)): Point = Point(x1 + x2, y1 + y2)
+    static member (-) (Point(x1, y1), Vector(x2, y2)): Point = Point(x1 - x2, y1 - y2)
 
     member this.X: int = let (Point(x, _)) = this in x
     member this.Y: int = let (Point(_, y)) = this in y
@@ -21,14 +22,16 @@ and [<Struct>] Vector =
 
     member this.X: int = let (Vector(x, _)) = this in x
     member this.Y: int = let (Vector(_, y)) = this in y
+    
+    static member Zero: Vector = Vector(0, 0)
 
 [<Struct>]
 type Box =
     { TopLeft: Point; Size: Vector }
 
-    member this.TopRight: Point = this.TopLeft + Vector(this.Size.X, 0)
-    member this.BottomLeft: Point = this.TopLeft + Vector(0, this.Size.Y)
-    member this.BottomRight: Point = this.TopLeft + this.Size
+    member this.TopRight: Point = this.TopLeft + Vector(this.Size.X - 1, 0)
+    member this.BottomLeft: Point = this.TopLeft + Vector(0, this.Size.Y - 1)
+    member this.BottomRight: Point = this.TopLeft + this.Size - Vector(1, 1)
 
 [<Struct>]
 type HorizontalDirection =
@@ -61,5 +64,7 @@ type ObliqueDirection = {
 [<Struct; RequireQualifiedAccess>]
 type Collision =
     | None
+    /// Means the object is completely out of bounds, i.e. not visible on the game field.
     | OutOfBounds
-    | TouchesBrick
+    /// At least one pixel of the object intersects with a brick.
+    | CollidesBrick

O21.Game/Engine/Geometry.fs

@@ -28,5 +28,5 @@ let CheckCollision (level: Level) (box: Box): Collision =
             || isBrickCell box.TopRight
             || isBrickCell box.BottomLeft
             || isBrickCell box.BottomRight
-        then Collision.TouchesBrick
+        then Collision.CollidesBrick
         else Collision.None    

O21.Game/Scenes/PlayScene.fs

@@ -84,12 +84,14 @@ type PlayScene = {
             this.Camera.zoom <- (GetScreenHeight() |> float32) / (GameRules.GameScreenHeight |> float32)
             let cameraTargetX = ((GetScreenWidth() |> float32) - (GameRules.GameScreenWidth |> float32) * this.Camera.zoom) / -2f / this.Camera.zoom
             this.Camera.target <- System.Numerics.Vector2(cameraTargetX, 0f)
+            // TODO[#26]: Merge ApplyCommands and Update into single function on GameEngine
             let game, effects = state.Game |> InputProcessor.ProcessKeys input this.HUD
-
-            let state = { state with Game = game.Update time }
+            let game', effects' = game.Update time 
+            let state = { state with Game = game' }
+            let allEffects = Seq.concat [| effects; effects' |]
             let sounds =
                 state.SoundsToStartPlaying +
-                (effects |> Seq.map(fun (PlaySound s) -> s) |> Set.ofSeq)
+                (allEffects |> Seq.map(fun (PlaySound s) -> s) |> Set.ofSeq)
             let navigationEvent =
                 if this.HUD.Lives < 0 then
                     // TODO[#32]: Should be handled by the game engine

O21.Game/U95/Sound.fs

@@ -17,9 +17,9 @@ type SoundType =
     | GameStarted = 0
     | GameOver = 1
     | NewRecord = 2
-    | LifeTaken = 3
-    | LifebuoyTaken = 4
-    | TreasureTaken = 5
+    | LifePickedUp = 3
+    | LifebuoyPickedUp = 4
+    | TreasurePickedUp = 5
     | ItemDestroyed = 6
     | Shot = 7
     | StationaryEnemyDestroyed = 8

O21.Tests/GameEngineTests.fs

@@ -14,7 +14,8 @@ let private frameUp time =
     let mutable currentTime = time
     fun (gameEngine: GameEngine) ->
         let newTime = { Total = currentTime.Total + 0.1; Delta = 0.1f }
-        gameEngine.Update newTime
+        let gameEngine, _ = gameEngine.Update newTime
+        gameEngine
 
 let private frameUpN time n gameEngine =
     let mutable newTime = time
@@ -50,10 +51,10 @@ module Movement =
     let ``GameEngine reacts to the speed change``(): unit =
         let gameEngine = newEngine
         let frameUp = frameUp timeZero
-        Assert.Equal(Point(0, 0), gameEngine.Player.TopLeft)
+        Assert.Equal(GameRules.PlayerStartingPosition, gameEngine.Player.TopLeft)
         let gameEngine, _ = gameEngine.ApplyCommand <| VelocityDelta(Vector(1, 0))
         let gameEngine = frameUp gameEngine
-        Assert.Equal(Point(1, 0), gameEngine.Player.TopLeft)
+        Assert.Equal(GameRules.PlayerStartingPosition + Vector(1, 0), gameEngine.Player.TopLeft)
 
 module Shooting =
 
@@ -85,6 +86,30 @@ module Shooting =
         let gameEngine, _ = gameEngine.ApplyCommand Shoot
         Assert.Equal(bulletCount + 1, gameEngine.Bullets.Length)
 
+module Player =
+    [<Fact>]
+    let ``Moving towards a brick kills the player``(): unit =
+        let level = {
+            LevelMap = [|
+                [| Empty; Brick 0 |]
+            |]
+        }
+        let player = {
+            TopLeft = Point(GameRules.BrickSize.X - GameRules.PlayerSize.X, 0)
+            Velocity = Vector(0, 0)
+            Direction = HorizontalDirection.Right
+            ShotCooldown = 0 
+        }
+        let player' = player.Update(level, 1)
+        Assert.Equal(PlayerEffect.Update player, player')
+        
+        let player = {
+            player with
+                Velocity = Vector(1, 0) 
+        }
+        let player' = player.Update(level, 1)
+        Assert.Equal(PlayerEffect.Die, player')
+
 module ParticleSystem =
 
     [<Fact>]
@@ -168,4 +193,4 @@ module Geometry =
         Assert.Equal(Collision.None, CheckCollision level box1)
 
         let box2 = { TopLeft = Point(GameRules.BrickSize.X, 0); Size = Vector(1, 1) }
-        Assert.Equal(Collision.TouchesBrick, CheckCollision level box2)
+        Assert.Equal(Collision.CollidesBrick, CheckCollision level box2)