progress detecting collision between enemy and player's projectile, and decrementing enemy's health once detected

fcore/game-type.sml

@@ -181,9 +181,9 @@ struct
       val platforms = Vector.fromList [plat1]
       val platformTree = Platform.generateTree platforms
 
-      val enemy1 = {id = 1, x = 300, y = 945, health = 5}
+      val enemy1 = {id = 1, x = 300, y = 945, health = 2}
-      val enemy2 = {id = 2, x = 555, y = 945, health = 5}
+      val enemy2 = {id = 2, x = 555, y = 945, health = 2}
-      val enemy3 = {id = 3, x = 979, y = 945, health = 5}
+      val enemy3 = {id = 3, x = 979, y = 945, health = 2}
       val enemies = Vector.fromList [enemy1, enemy2, enemy3]
       val enemyTree = Enemy.generateTree enemies
     in

fcore/game-update.sml

@@ -7,11 +7,15 @@ struct
 
       val player = Player.runPhysicsAndInput (game, input)
 
-      (* check player-enemy collisions and react *)
+      (* check and react to enemy collisions with player projectile *)
-      val (player, enemies) = PlayerEnemy.checkCollisions (player, game)
+      val enemies =
-
+        ProjectileEnemy.checkCollisions
-      (* create enemy quad tree from list of new enemies *)
+          (#projectiles player, enemies, enemyTree)
       val enemyTree = Enemy.generateTree enemies
+
+      (* check player-enemy collisions and react *)
+      val (player, enemies, enemyTree) =
+        PlayerEnemy.checkCollisions (player, enemies, enemyTree)
     in
       { player = player
       , walls = walls

fcore/player-enemy.sml

@@ -47,15 +47,16 @@ struct
         end
     | [] => acc
 
-  fun checkEnemiesWhileAttacking (player, enemies, lst, acc) =
+  fun helpExists (pos, id, collisions) =
-    let
+    if pos = Vector.length collisions then
-      open QuadTree
+      false
-    in
+    else
-      case lst of
+      let val current = Vector.sub (collisions, pos)
-        enemyID :: tl => (* placeholder *) acc
+      in current = id orelse helpExists (pos + 1, id, collisions)
-      | [] => acc
       end
 
+  fun exists (id, collisions) = helpExists (0, id, collisions)
+
   (* removes enemies from `enemies` vector when that enemy is in collisions *)
   fun filterEnemyCollisions (pos, collisions, enemies: enemy vector, acc) =
     if pos < 0 then
@@ -63,19 +64,16 @@ struct
     else
       let
         val enemy = Vector.sub (enemies, pos)
+        val acc =
+          if exists (#id enemy, collisions) then (* filter out *) acc
+          else (* don't filter out *) enemy :: acc
       in
-        if BinSearch.exists (#id enemy, collisions) then
-          (* filter out *)
         filterEnemyCollisions (pos - 1, collisions, enemies, acc)
-        else
-          (* don't filter out *)
-          filterEnemyCollisions (pos - 1, collisions, enemies, enemy :: acc)
       end
 
-  fun checkCollisions (player, game: game_type) =
+  fun checkCollisions (player, enemies, enemyTree) =
     let
       val {x, y, mainAttack, attacked, ...} = player
-      val {enemies, enemyTree, ...} = game
       val size = Player.size
     in
       case mainAttack of
@@ -86,27 +84,25 @@ struct
             val y = y - Player.halfSize
             val size = size * 2
 
+            (* get list of enemies player has collided with *)
             val enemyCollisions = QuadTree.getCollisions
               (x, y, size, size, 0, 0, 1920, 1080, 0, enemyTree)
-            val patches =
-              checkEnemiesWhileAttacking (player, enemies, enemyCollisions, [])
-            val player = Player.withPatches (player, patches)
 
+            (* filter enemies based on collisions *)
             val enemyCollisions = Vector.fromList enemyCollisions
             val enemies = filterEnemyCollisions
               (Vector.length enemies - 1, enemyCollisions, enemies, [])
+            val enemyTree = Enemy.generateTree enemies
 
             (* add collided enemies to player record, 
              * concatenating with the previous enemies defeated *)
             val newDefeated =
               Vector.map (fn id => {angle = 360}) enemyCollisions
-
             val oldDefeated = #enemies player
             val allDefeated = Vector.concat [oldDefeated, newDefeated]
-
             val player = Player.withPatches (player, [W_ENEMIES allDefeated])
           in
-            (player, enemies)
+            (player, enemies, enemyTree)
           end
       | _ =>
           (case attacked of
@@ -119,7 +115,7 @@ struct
                    checkEnemies (player, enemies, enemyCollisions, [])
                  val player = Player.withPatches (player, patches)
                in
-                 (player, enemies)
+                 (player, enemies, enemyTree)
                end
            | ATTACKED amt =>
                if amt = Player.attackedLimit then
@@ -132,7 +128,7 @@ struct
                      checkEnemies (player, enemies, enemyCollisions, lst)
                    val player = Player.withPatches (player, patches)
                  in
-                   (player, enemies)
+                   (player, enemies, enemyTree)
                  end
                else
                  (* if attacked, don't detect collisions, 
@@ -144,7 +140,7 @@ struct
                    val player = Player.withPatches
                      (player, [W_ATTACKED attacked])
                  in
-                   (player, enemies)
+                   (player, enemies, enemyTree)
                  end)
     end
 end

fcore/player.sml

@@ -298,6 +298,7 @@ struct
   val defeatedPi = Real32.Math.pi / 180.0
   val defeatedSize = 9.0
   val defeatedDistance = 13.0
+  val defeatedSizeInt = 9
 
   (* timing variables; always start at 0, 
    * and revert to default state when limit is hit *)

fcore/projectile-enemy.sml

@@ -0,0 +1,61 @@
+structure ProjectileEnemy =
+struct
+  open GameType
+
+  fun helpCheckColisions (pos, projectileTree, enemies, acc) =
+    if pos < 0 then
+      Vector.fromList acc
+    else
+      let
+        val enemy = Vector.sub (enemies, pos)
+
+        val {id, health, x, y} = enemy
+        val size = Enemy.size
+
+        val collisions = QuadTree.helpGetCollisions
+          (x, y, size, size, 0, 0, 1920, 1080, 0, [], projectileTree)
+
+        (* react to collisions here, possibly removing enemy from acc *)
+        val acc =
+          case collisions of
+            _ :: _ =>
+              if health = 1 then
+                (* filter enemy out if decrementing their health by 1 
+                 * leads to a health of 0 *)
+                acc
+              else
+                let
+                  (* decrement health by 1 and add to acc *)
+                  val enemy = {id = id, health = health - 1, x = x, y = y}
+                in
+                  enemy :: acc
+                end
+          | [] => enemy :: acc
+      in
+        helpCheckColisions (pos - 1, projectileTree, enemies, acc)
+      end
+
+  fun helpGenerateTree (pos, projectiles, acc) =
+    if pos = Vector.length projectiles then
+      acc
+    else
+      let
+        val size = Player.defeatedSizeInt
+
+        val {x, y, facing = _} = Vector.sub (projectiles, pos)
+        val acc = QuadTree.insert (x, y, size, size, 0, 0, 1920, 1080, pos, acc)
+      in
+        helpGenerateTree (pos + 1, projectiles, acc)
+      end
+
+  fun generateTree projectiles =
+    helpGenerateTree (0, projectiles, QuadTree.empty)
+
+  fun checkCollisions (projectiles, enemies, enemyTree) =
+    let
+      val projectileTree = generateTree projectiles
+    in
+      helpCheckColisions
+        (Vector.length enemies - 1, projectileTree, enemies, [])
+    end
+end

fcore/quad-tree.sml

@@ -20,6 +20,11 @@ sig
                      int * int * int * int * 
                      int * t -> int list
 
+  val helpGetCollisions: int * int * int * int * 
+                         int * int * int * int * 
+                         int * int list * t 
+                         -> int list
+
   val getCollisionSides: int * int * int * int * int * int * int * int * int * t
                          -> (collision_side * int) list
 

oms.mlb

@@ -18,6 +18,7 @@ fcore/game-type.sml
 
 fcore/player.sml
 
+fcore/projectile-enemy.sml
 fcore/player-enemy.sml
 fcore/game-update.sml