fix compile errors after previous commit (which involved reimplementing the quad tree to eliminate the possibility of a class of bugs I was experiencing; the problem was that the quad bounds were being passed recursively in different functions, but the long argument list in these functions made it difficult to see where the mismatch was)

fcore/enemy-behaviour.sml

@@ -8,11 +8,10 @@ struct
       val searchHeight = 10
       val searchWidth = Constants.moveEnemyBy
     in
-      QuadHelp.hasCollisionAt
+      QuadTree.hasCollisionAt (x, y, searchWidth, searchHeight, ~1, wallTree)
-        (x, y, searchWidth, searchHeight, wallTree)
       orelse
-      QuadHelp.hasCollisionAt
+      QuadTree.hasCollisionAt
-        (x, y, searchWidth, searchHeight, platformTree)
+        (x, y, searchWidth, searchHeight, ~1, platformTree)
     end
 
   (* same function takes either wallTree or platformTree and returns true
@@ -29,7 +28,7 @@ struct
       val width = Constants.enemySize
       val height = Platform.platHeight
     in
-      QuadHelp.hasCollisionAt (ex, ey, width, height, tree)
+      QuadTree.hasCollisionAt (ex, ey, width, height, ~1, tree)
     end
 
   fun getPatrollPatches (enemy: enemy, wallTree, platformTree, acc) =
@@ -62,22 +61,17 @@ struct
             val searchWidth = Constants.moveEnemyBy
             val searchHeight = Constants.enemySize - 5
 
-            val hasWallAhead = QuadHelp.hasCollisionAt
+            val hasWallAhead = QuadTree.hasCollisionAt
-              ( searchStartX
+              (searchStartX, y, searchWidth, searchHeight, ~1, wallTree)
-              , y
-              , searchWidth
-              , searchHeight
-              , wallTree
-              )
           in
-            if
+            if hasWallAhead then
-              hasWallAhead
+              EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
-            then EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
+            else if canWalkAhead (searchStartX, y, wallTree, platformTree) then
-            else if canWalkAhead (searchStartX, y, wallTree, platformTree) then 
               (* invert direction if moving further left 
-               * will result in falling down  *) 
+               * will result in falling down  *)
               acc
-            else EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
+            else
+              EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
           end
       | MOVE_RIGHT =>
           let
@@ -88,22 +82,17 @@ struct
             val searchWidth = Constants.moveEnemyBy
             val searchHeight = Constants.enemySize - 5
 
-            val hasWallAhead = QuadHelp.hasCollisionAt
+            val hasWallAhead = QuadTree.hasCollisionAt
-              ( searchStartX
+              (searchStartX, y, searchWidth, searchHeight, ~1, wallTree)
-              , y
-              , searchWidth
-              , searchHeight
-              , wallTree
-              )
           in
-            if
+            if hasWallAhead then
-              hasWallAhead
+              EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
-            then EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+            else if canWalkAhead (searchStartX, y, wallTree, platformTree) then
-            else if canWalkAhead (searchStartX, y, wallTree, platformTree) then 
               (* invert direction if moving further right
-               * will result in falling down  *) 
+               * will result in falling down  *)
               acc
-            else EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+            else
+              EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
           end
       | STAY_STILL => acc
     end
@@ -119,9 +108,9 @@ struct
         in
           (* platY < highestY is correct because lowest number = highest 
            * in * this case *)
-          if platY < highestY andalso checkY <= platY then 
+          if platY < highestY andalso checkY <= platY then
             getHighestPlatform (tl, platforms, platY, id, checkY)
-          else 
+          else
             getHighestPlatform (tl, platforms, highestY, highestID, checkY)
         end
     | [] => highestID
@@ -133,8 +122,8 @@ struct
       val searchWidth = Constants.playerSize
       val searchHeight = Constants.worldHeight - y
 
-      val collisions = QuadHelp.getCollisions
+      val collisions = QuadTree.getCollisions
-        (x, y, searchWidth, searchHeight, platformTree)
+        (x, y, searchWidth, searchHeight, ~1, platformTree)
       val checkY = y + Constants.playerSize
 
       val wh = Constants.worldHeight
@@ -151,8 +140,8 @@ struct
 
       val y = y + Constants.enemySize
 
-      val collisions = QuadHelp.getCollisions
+      val collisions = QuadTree.getCollisions
-        (x, y, searchWidth, searchHeight, platformTree)
+        (x, y, searchWidth, searchHeight, ~1, platformTree)
       val wh = Constants.worldHeight
     in
       getHighestPlatform (collisions, platforms, wh, ~1, y)
@@ -191,12 +180,12 @@ struct
             ON_GROUND => EnemyPatch.W_Y_AXIS (JUMPING 0) :: acc
           | FALLING => EnemyPatch.W_Y_AXIS (JUMPING 0) :: acc
           | _ => acc
-        else 
+        else (* have to travel either left or right before jumping *) if
-          (* have to travel either left or right before jumping *) 
+          ecx < platX
-          if ecx < platX then
+        then
-            EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
+          EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
-          else
+        else
-            EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+          EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
       else
         acc
     end
@@ -234,12 +223,12 @@ struct
             ON_GROUND => EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM :: acc
           | FALLING => EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM :: acc
           | _ => acc
-        else 
+        else (* have to travel either left or right before jumping *) if
-          (* have to travel either left or right before jumping *) 
+          ecx < platX
-          if ecx < platX then
+        then
-            EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
+          EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
-          else
+        else
-            EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+          EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
       else
         acc
     end
@@ -282,7 +271,7 @@ struct
               EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
             end
           else
-              EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
+            EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
         end
       else
         (* platform is below or at same y coordinat as enemy 
@@ -296,8 +285,8 @@ struct
         in
           if yDiff >= xDiff then
             (* can reach next platform by simply dropping and moving right *)
-            EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM :: EnemyPatch.W_X_AXIS
+            EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM
-            MOVE_RIGHT :: acc
+            :: EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
           else
             let
               val jumpAmt =
@@ -356,7 +345,7 @@ struct
               EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
             end
           else
-              EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+            EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
         end
       else
         (* platform is below or at same y coordinat as enemy 
@@ -370,8 +359,8 @@ struct
         in
           if yDiff >= xDiff then
             (* can reach next platform by simply dropping and moving right *)
-            EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM :: EnemyPatch.W_X_AXIS
+            EnemyPatch.W_Y_AXIS DROP_BELOW_PLATFORM
-            MOVE_LEFT :: acc
+            :: EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
           else
             let
               val jumpAmt =
@@ -413,7 +402,7 @@ struct
         getJumpPatches (nextPlatform, platformTree, enemy, acc)
       else if canDrop then
         getDropPatches (nextPlatform, platformTree, enemy, acc)
-      else 
+      else
         let
           (* if can neither jump or drop to next platform vertically
            * then remaining options are either jumping to the right or left.
@@ -439,16 +428,14 @@ struct
       val efx = ex + Constants.enemySize
     in
       if isBetween (px, ex, pfx) andalso isBetween (px, efx, pfx) then
-       acc
+        acc
-      else 
+      else
         let
           val startDiff = abs (px - ex)
           val endDiff = abs (pfx - efx)
         in
-          if startDiff > endDiff then
+          if startDiff > endDiff then EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
-            EnemyPatch.W_X_AXIS MOVE_LEFT :: acc
+          else EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
-          else
-            EnemyPatch.W_X_AXIS MOVE_RIGHT :: acc
         end
     end
 
@@ -471,35 +458,25 @@ struct
     in
       if ey < py - 65 then
         (* set to falling *)
-        EnemyPatch.W_NEXT_PLAT_ID ~1 ::
+        EnemyPatch.W_NEXT_PLAT_ID ~1 :: EnemyPatch.W_Y_AXIS FALLING :: acc
-        EnemyPatch.W_Y_AXIS FALLING ::
-        acc
       else
         acc
     end
 
   fun getLandingPatches (newPlatformID, platforms, enemy, acc) =
     case #yAxis enemy of
-      JUMPING _ =>
+      JUMPING _ => getJumpLandingPatches (enemy, newPlatformID, platforms, acc)
-        getJumpLandingPatches (enemy, newPlatformID, platforms, acc)
+    | _ => getFallingPatches (enemy, newPlatformID, platforms, acc)
-    | _ =>
-        getFallingPatches (enemy, newPlatformID, platforms, acc)
 
-  fun getFollowPatches 
+  fun getFollowPatches
     (player: player, enemy, wallTree, platformTree, platforms, acc) =
     let
       (* todo: possibly get pID and eID of player/enemy in a different way *)
       val pID = getPlatformBelowPlayer (player, platformTree, platforms)
-      val pID = 
+      val pID = if pID = ~1 then #platID player else pID
-        if pID = ~1 then
-          #platID player
-        else pID
 
       val eID = getPlatformBelowEnemy (enemy, platformTree, platforms)
-      val eID =
+      val eID = if eID = ~1 then #platID enemy else eID
-        if eID = ~1 then
-          #platID enemy
-        else eID
     in
       if eID = ~1 orelse pID = ~1 then
         (* without checking that neither of these are ~1 
@@ -521,7 +498,14 @@ struct
                 val acc = EnemyPatch.W_NEXT_PLAT_ID nextPlatformID :: acc
               in
                 getPathToNextPlatform
-                  (nextPlatformID, platforms, platformTree, enemy, eID, pID, acc)
+                  ( nextPlatformID
+                  , platforms
+                  , platformTree
+                  , enemy
+                  , eID
+                  , pID
+                  , acc
+                  )
               end
           | [] => getPatrollPatches (enemy, wallTree, platformTree, acc)
         end

fcore/enemy-patch.sml

@@ -44,10 +44,12 @@ struct
       case patch of
         W_HEALTH health =>
           mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
-      | W_X x => mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
+      | W_X x =>
+          mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
       | W_X_AXIS xAxis =>
           mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
-      | W_Y y => mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
+      | W_Y y =>
+          mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
       | W_Y_AXIS yAxis =>
           mkEnemy (id, health, x, y, xAxis, yAxis, variant, platID, nextPlatID)
       | W_PLAT_ID platID =>

fcore/enemy.sml

@@ -4,8 +4,7 @@ struct
 
   fun withDefaultYAxis (enemy: enemy) =
     case #yAxis enemy of
-      ON_GROUND =>
+      ON_GROUND => EnemyPatch.withPatch (enemy, EnemyPatch.W_Y_AXIS FALLING)
-        EnemyPatch.withPatch (enemy, EnemyPatch.W_Y_AXIS FALLING)
     | _ => enemy
 
   fun helpExists (pos, id, collisions) =
@@ -35,8 +34,8 @@ struct
 
       val size = Constants.enemySize
 
-      val hasCollision = QuadHelp.hasCollisionAt
+      val hasCollision = QuadTree.hasCollisionAt
-        (x, y, size, size, projectileTree)
+        (x, y, size, size, ~1, projectileTree)
     in
       if hasCollision then
         if health = 1 then
@@ -181,12 +180,17 @@ struct
 
         val size = Constants.enemySize
 
-        val acc = QuadHelp.insert (x, y, size, size, id, acc)
+        val acc = QuadTree.insert (x, y, size, size, id, acc)
       in
         helpGenerateTree (pos + 1, enemyVec, acc)
       end
 
-  fun generateTree enemyVec = helpGenerateTree (0, enemyVec, QuadTree.empty)
+  fun generateTree enemyVec =
+    helpGenerateTree
+      ( 0
+      , enemyVec
+      , QuadTree.create (Constants.worldWidth, Constants.worldHeight)
+      )
 
   fun helpFind (findNum, vec: enemy vector, low, high) =
     (* should only be called when we know enemy already exists in vec *)

fcore/game-type.sml

@@ -188,10 +188,26 @@ struct
       val plat18 = {id = 18, x = 155, y = 499, width = 199}
       val plat19 = {id = 19, x = 155, y = 399, width = 199}
       val platforms = Vector.fromList
-        [plat1, plat2, plat3, plat4, plat5, plat6, plat7, plat8, plat9, plat10,
+        [ plat1
-                                  plat11, plat12, plat13
+        , plat2
-                                  , plat14, plat15, plat16, plat17, plat18,
+        , plat3
-                                  plat19]
+        , plat4
+        , plat5
+        , plat6
+        , plat7
+        , plat8
+        , plat9
+        , plat10
+        , plat11
+        , plat12
+        , plat13
+        , plat14
+        , plat15
+        , plat16
+        , plat17
+        , plat18
+        , plat19
+        ]
       val platformTree = Platform.generateTree platforms
 
       val enemy1 =

fcore/physics.sml

@@ -84,7 +84,7 @@ struct
       val ww = Constants.worldWidth
       val wh = Constants.worldHeight
     in
-      QuadHelp.hasCollisionAt (x, y, width, height, tree)
+      QuadTree.hasCollisionAt (x, y, width, height, ~1, tree)
     end
 
   fun standingOnAreaID (x, y, tree) =
@@ -109,10 +109,10 @@ struct
       val wh = Constants.worldHeight
 
       val _ = print "START getItemID\n"
-      val r = 
+      val r = QuadTree.getItemID (x, y, width, height, tree)
-      QuadHelp.getItemID (x, y, width, height, tree)
       val _ = print "FINISH getItemID\n"
-    in r
+    in
+      r
     end
 
   fun getWallPatches (x, y, walls, wallTree, acc) =
@@ -125,8 +125,7 @@ struct
       (* check collision with wall to the left *)
       val acc =
         let
-          val leftWallID = QuadHelp.getItemID
+          val leftWallID = QuadTree.getItemID (x - 1, y, 1, 1, wallTree)
-            (x - 1, y, 1, 1, wallTree)
         in
           if leftWallID <> ~1 then
             let
@@ -144,8 +143,7 @@ struct
       (* check collision with wall to the right *)
       val acc =
         let
-          val rightWallID = QuadHelp.getItemID
+          val rightWallID = QuadTree.getItemID (x + size - 1, y, 1, 1, wallTree)
-            (x + size - 1, y, 1, 1, wallTree)
         in
           if rightWallID <> ~1 then
             let
@@ -160,7 +158,7 @@ struct
         end
 
       (* check collision with wall below *)
-      val downWallID = QuadHelp.getItemID
+      val downWallID = QuadTree.getItemID
         (x + moveBy + 1, y + size, 1, 1, wallTree)
     in
       if downWallID <> ~1 then
@@ -193,22 +191,24 @@ struct
 
       val acc =
         if platID <> ~1 then
-          (print ("platID: " ^ Int.toString platID ^ "\n"); case yAxis of
+          ( print ("platID: " ^ Int.toString platID ^ "\n")
-             JUMPING _ =>
+          ; case yAxis of
-               (* pass through, allowing player to jump above the platform *)
+              JUMPING _ =>
-               acc
+                (* pass through, allowing player to jump above the platform *)
-           | _ =>
+                acc
-               let
+            | _ =>
-                 (* default case: 
+                let
-                  * player will land on platform and stay on the ground there. *)
+                  (* default case: 
-                 val {y = platY, ...}: GameType.platform =
+                   * player will land on platform and stay on the ground there. *)
-                   Vector.sub (platforms, platID - 1)
+                  val {y = platY, ...}: GameType.platform =
+                    Vector.sub (platforms, platID - 1)
 
-                 val newY = platY - Fn.entitySize
+                  val newY = platY - Fn.entitySize
-                 val acc = Fn.W_Y_AXIS ON_GROUND :: Fn.W_Y newY :: acc
+                  val acc = Fn.W_Y_AXIS ON_GROUND :: Fn.W_Y newY :: acc
-               in
+                in
-                 acc
+                  acc
-               end)
+                end
+          )
         else
           acc
 
@@ -221,11 +221,10 @@ struct
             * then set new yAxis to FALLING
             * so we do not drop below any platforms again
             * *)
-            if
+            if QuadTree.hasCollisionAt (x, y, size, size, ~1, platformTree) then
-              QuadHelp.hasCollisionAt
+              acc
-                (x, y, size, size, platformTree)
+            else
-            then acc
+              Fn.W_Y_AXIS FALLING :: acc
-            else Fn.W_Y_AXIS FALLING :: acc
         | _ => acc
 
       val acc = getWallPatches (x, y, walls, wallTree, acc)

fcore/platform.sml

@@ -11,13 +11,17 @@ struct
     else
       let
         val {id, x, y, width} = Vector.sub (platVec, pos)
-        val acc = QuadHelp.insert
+        val acc = QuadTree.insert (x, y, width, platHeight, id, acc)
-          (x, y, width, platHeight, id, acc)
       in
         helpGenerateTree (pos + 1, platVec, acc)
       end
 
-  fun generateTree platVec = helpGenerateTree (0, platVec, QuadTree.empty)
+  fun generateTree platVec =
+    helpGenerateTree
+      ( 0
+      , platVec
+      , QuadTree.create (Constants.worldWidth, Constants.worldHeight)
+      )
 
   fun helpFind (findNum, vec, low, high) =
     let

fcore/player-enemy.sml

@@ -47,8 +47,8 @@ struct
           (case attacked of
              NOT_ATTACKED =>
                let
-                 val enemyCollisions = QuadHelp.getCollisions
+                 val enemyCollisions = QuadTree.getCollisions
-                   (x, y, size, size, enemyTree)
+                   (x, y, size, size, ~1, enemyTree)
 
                  val player =
                    Player.enemyCollisionReaction
@@ -72,8 +72,8 @@ struct
                if amt = Constants.attackedLimit then
                  (* if reached limit, detect enemies again *)
                  let
-                   val enemyCollisions = QuadHelp.getCollisions
+                   val enemyCollisions = QuadTree.getCollisions
-                     (x, y, size, size, enemyTree)
+                     (x, y, size, size, ~1, enemyTree)
 
                    val player =
                      Player.exitAttackedAndCheckEnemies

fcore/player.sml

@@ -320,8 +320,9 @@ struct
     let
       val player = #player game
 
-      val _ = print ("(playerX, playerY) = (" ^Int.toString (#x player) ^ ", " ^
+      val _ = print
-      Int.toString (#y player) ^ ")\n")
+        ("(playerX, playerY) = (" ^ Int.toString (#x player) ^ ", "
+         ^ Int.toString (#y player) ^ ")\n")
 
       val patches = getProjectilePatches player
       val player = PlayerPatch.withPatches (player, patches)
@@ -430,8 +431,8 @@ struct
 
       val ww = Constants.worldWidth
       val wh = Constants.worldHeight
-      val enemyCollisions = QuadHelp.getCollisions
+      val enemyCollisions = QuadTree.getCollisions
-        (x, y, size, size, enemyTree)
+        (x, y, size, size, ~1, enemyTree)
     in
       Vector.fromList enemyCollisions
     end

fcore/projectile.sml

@@ -11,13 +11,17 @@ struct
         val size = projectileSizeInt
 
         val {x, y, facing = _} = Vector.sub (projectiles, pos)
-        val acc = QuadHelp.insert (x, y, size, size, pos, acc)
+        val acc = QuadTree.insert (x, y, size, size, pos, acc)
       in
         helpGenerateTree (pos + 1, projectiles, acc)
       end
 
   fun generateTree projectiles =
-    helpGenerateTree (0, projectiles, QuadTree.empty)
+    helpGenerateTree
+      ( 0
+      , projectiles
+      , QuadTree.create (Constants.worldWidth, Constants.worldHeight)
+      )
 
   fun helpGetProjectileVec
     (pos, projectiles, width, height, ratio, xOffset, yOffset, acc) =

fcore/quad-tree.sml

@@ -8,21 +8,15 @@ sig
   | QUERY_ON_RIGHT_SIDE
   | QUERY_ON_BOTTOM_SIDE
 
-  val insert: int * int * int * int * 
+  val insert: int * int * int * int * int * t -> t
-              int * t -> t
 
-  val getCollisions: int * int * int * int * 
+  val getCollisions: int * int * int * int * int * t -> int list
-                     int * t -> int list
 
-  val helpGetCollisions: int * int * int * int * 
+  val helpGetCollisions: int * int * int * int * int * int list * t -> int list
-                         int * int list * t 
-                         -> int list
 
-  val hasCollisionAt: int * int * int * int *
+  val hasCollisionAt: int * int * int * int * int * t -> bool
-                      int * t -> bool
 
-  val getItemID: int * int * int * int *
+  val getItemID: int * int * int * int * t -> int
-                 t -> int
 
   val create: int * int -> t
 end
@@ -34,29 +28,20 @@ struct
   type item = QuadTreeType.item
 
   fun create (width, height) =
-    LEAF {
+    LEAF {items = Vector.fromList [], x = 0, y = 0, w = width, h = height}
-      items = Vector.fromList [],
-      x = 0,
-      y = 0,
-      w = width,
-      h = height
-    }
 
   fun isColliding (ix, iy, ifx, ify, cx, cy, cfx, cfy) =
-    ix < cfx andalso
+    ix < cfx andalso ifx > cx andalso iy < cfy andalso ify > cy
-    ifx > cx andalso
-    iy < cfy andalso
-    ify > cy
 
   fun isCollidingPlus (ix, iy, iw, ih, cx, cy, cw, ch) =
-  let
+    let
-    val ifx = ix + iw
+      val ifx = ix + iw
-    val ify = iy + ih
+      val ify = iy + ih
-    val cfx = cx + cw
+      val cfx = cx + cw
-    val cfy = cy + ch
+      val cfy = cy + ch
-  in
+    in
-    isColliding (ix, iy, ifx, ify, cx, cy, cfx, cfy)
+      isColliding (ix, iy, ifx, ify, cx, cy, cfx, cfy)
-  end
+    end
 
   fun visitTopLeft (iX, iY, iW, iH, qX, qY, qW, qH) =
     let
@@ -82,7 +67,7 @@ struct
 
       val ifx = iX + iW
       val ify = iY + iH
-      
+
       val qmx = qX + hw
       val qmy = qY + hh
 
@@ -99,7 +84,7 @@ struct
 
       val ifx = iX + iW
       val ify = iY + iH
-      
+
       val qmx = qX + hw
       val qmy = qY + hh
 
@@ -116,7 +101,7 @@ struct
 
       val ifx = iX + iW
       val ify = iY + iH
-      
+
       val qmx = qX + hw
       val qmy = qY + hh
 
@@ -145,13 +130,7 @@ struct
       val hw = w div 2
       val hh = h div 2
     in
-      LEAF {
+      LEAF {items = items, x = x, y = y, w = hw, h = hh}
-        items = items,
-        x = x,
-        y = y,
-        w = hw,
-        h = hh
-      }
     end
 
   fun mkTopRight (x, y, w, h, items) =
@@ -161,13 +140,7 @@ struct
       val hh = h div 2
       val x = x + hw
     in
-      LEAF {
+      LEAF {items = items, x = x, y = y, w = hw, h = hh}
-      items = items,
-      x = x,
-      y = y,
-      w = hw,
-      h = hh
-      }
     end
 
   fun mkBottomLeft (x, y, w, h, items) =
@@ -177,13 +150,7 @@ struct
       val hh = h div 2
       val y = y + hh
     in
-      LEAF {
+      LEAF {items = items, x = x, y = y, w = hw, h = hh}
-        items = items,
-        x = x,
-        y = y,
-        w = hw,
-        h = hh
-      }
     end
 
   fun mkBottomRight (x, y, w, h, items) =
@@ -194,17 +161,21 @@ struct
       val x = x + hw
       val y = y + hh
     in
-      LEAF {
+      LEAF {items = items, x = x, y = y, w = hw, h = hh}
-        items = items,
-        x = x,
-        y = y,
-        w = hw,
-        h = hh
-      }
     end
 
-  fun splitLeaf (x, y, w, h, tl: item list, tr: item list, bl: item list, br:
+  fun splitLeaf
-    item list, elements, pos) =
+    ( x
+    , y
+    , w
+    , h
+    , tl: item list
+    , tr: item list
+    , bl: item list
+    , br: item list
+    , elements
+    , pos
+    ) =
     if pos < 0 then
       let
         val tl = mkTopLeft (x, y, w, h, tl)
@@ -247,22 +218,29 @@ struct
   fun insert (iX, iY, iW, iH, itemID, tree: t) =
     case tree of
       NODE {topLeft, topRight, bottomLeft, bottomRight, x, y, w, h} =>
-      if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
+        if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
-        let
+          let
-          (* we are not necessarily inserting into all nodes.
+            (* we are not necessarily inserting into all nodes.
-           * If isCollidingPlus returns false recursively, 
+             * If isCollidingPlus returns false recursively, 
-           * we return the same node back. *)
+             * we return the same node back. *)
-          val tl = insert (iX, iY, iW, iH, itemID, topLeft)
+            val tl = insert (iX, iY, iW, iH, itemID, topLeft)
-          val tr = insert (iX, iY, iW, iH, itemID, topRight)
+            val tr = insert (iX, iY, iW, iH, itemID, topRight)
-          val bl = insert (iX, iY, iW, iH, itemID, bottomLeft)
+            val bl = insert (iX, iY, iW, iH, itemID, bottomLeft)
-          val br = insert (iX, iY, iW, iH, itemID, bottomRight)
+            val br = insert (iX, iY, iW, iH, itemID, bottomRight)
-        in
+          in
-          NODE {topLeft = tl, topRight = tr, bottomLeft = bl, bottomRight = br
+            NODE
-          , x = x, y = y, w = w, h = h
+              { topLeft = tl
-          }
+              , topRight = tr
-        end
+              , bottomLeft = bl
-      else
+              , bottomRight = br
-        tree
+              , x = x
+              , y = y
+              , w = w
+              , h = h
+              }
+          end
+        else
+          tree
     | LEAF {items, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
           if Vector.length items + 1 > maxSize then
@@ -284,18 +262,7 @@ struct
 
               val br = if vbr then [item] else []
             in
-              splitLeaf
+              splitLeaf (x, y, w, h, tl, tr, bl, br, items, pos)
-                ( x
-                , y
-                , w
-                , h
-                , tl
-                , tr
-                , bl
-                , br
-                , items
-                , pos
-                )
             end
           else
             (* can insert itemID in items vector *)
@@ -305,19 +272,23 @@ struct
             in
               LEAF {items = items, x = x, y = y, w = w, h = h}
             end
-        else 
+        else
           (* bounds of new item don't fit inside leaf so return old tree *)
           tree
 
   fun isColliding (iX, iY, iW, iH, itemID, checkWith: item) =
     let
-      val {itemID = checkID, startX = cX, startY = cY, width = cW, height = cH, ...} = checkWith
+      val
+        { itemID = checkID
+        , startX = cX
+        , startY = cY
+        , width = cW
+        , height = cH
+        , ...
+        } = checkWith
     in
-      iX < cX + cW andalso
+      iX < cX + cW andalso iX + iW > cX andalso iY < cY + cH
-      iX + iW > cX andalso
+      andalso iY + iH > cY andalso itemID <> checkID
-      iY < cY + cH andalso
-      iY + iH > cY andalso 
-      itemID <> checkID
     end
 
   fun getCollisionsVec (iX, iY, iW, iH, itemID, pos, elements, acc) =
@@ -338,93 +309,46 @@ struct
       NODE {topLeft, topRight, bottomLeft, bottomRight, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
           let
-            val acc = getCollisionsAll
+            val acc = getCollisionsAll (iX, iY, iW, iH, itemID, acc, topLeft)
-              (iX, iY, iW, iH, itemID, acc, topLeft)
 
-            val acc = getCollisionsAll
+            val acc = getCollisionsAll (iX, iY, iW, iH, itemID, acc, topRight)
-              (iX, iY, iW, iH, itemID, acc, topRight)
 
-            val acc = getCollisionsAll
+            val acc = getCollisionsAll (iX, iY, iW, iH, itemID, acc, bottomLeft)
-              (iX, iY, iW, iH, itemID, acc, bottomLeft)
           in
-            getCollisionsAll
+            getCollisionsAll (iX, iY, iW, iH, itemID, acc, bottomRight)
-              (iX, iY, iW, iH, itemID, acc, bottomRight)
           end
         else
           acc
     | LEAF {items, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
           getCollisionsVec (iX, iY, iW, iH, itemID, 0, items, acc)
-        else acc
-
-  fun helpGetCollisions
-    ( iX
-    , iY
-    , iW
-    , iH
-    , itemID
-    , acc
-    , tree: t
-    ) =
-    case tree of
-      NODE {topLeft, topRight, bottomLeft, bottomRight, x, y, w, h} =>
-      if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
-        let
-          val acc =
-              helpGetCollisions
-                (iX, iY, iW, iH, itemID, acc, topLeft)
-
-          val acc =
-              helpGetCollisions
-                (iX, iY, iW, iH, itemID, acc, topRight)
-
-          val acc =
-              helpGetCollisions
-                ( iX
-                , iY
-                , iW
-                , iH
-                , itemID
-                , acc
-                , bottomLeft
-                )
-        in
-              helpGetCollisions
-                ( iX
-                , iY
-                , iW
-                , iH
-                , itemID
-                , acc
-                , bottomRight
-                )
-        end
-      else
-        acc
-    | LEAF {items, x, y, w, h} =>
-        if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
-          getCollisionsVec
-            (iX, iY, iW, iH, itemID, 0, items, acc)
         else
           acc
 
-  fun getCollisions
+  fun helpGetCollisions (iX, iY, iW, iH, itemID, acc, tree: t) =
-    ( itemX
+    case tree of
-    , itemY
+      NODE {topLeft, topRight, bottomLeft, bottomRight, x, y, w, h} =>
-    , itemWidth
+        if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
-    , itemHeight
+          let
-    , itemID
+            val acc = helpGetCollisions (iX, iY, iW, iH, itemID, acc, topLeft)
-    , tree
+
-    ) =
+            val acc = helpGetCollisions (iX, iY, iW, iH, itemID, acc, topRight)
-    helpGetCollisions
+
-      ( itemX
+            val acc = helpGetCollisions
-      , itemY
+              (iX, iY, iW, iH, itemID, acc, bottomLeft)
-      , itemWidth
+          in
-      , itemHeight
+            helpGetCollisions (iX, iY, iW, iH, itemID, acc, bottomRight)
-      , itemID
+          end
-      , []
+        else
-      , tree
+          acc
-      )
+    | LEAF {items, x, y, w, h} =>
+        if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
+          getCollisionsVec (iX, iY, iW, iH, itemID, 0, items, acc)
+        else
+          acc
+
+  fun getCollisions (itemX, itemY, itemWidth, itemHeight, itemID, tree) =
+    helpGetCollisions (itemX, itemY, itemWidth, itemHeight, itemID, [], tree)
 
   (* no variant to represent 'no collision' case
    * because caller should only try getting collision side 
@@ -481,38 +405,25 @@ struct
       let
         val item = Vector.sub (elements, pos)
       in
-        isColliding (iX, iY, iW, iH, itemID, item) orelse
+        isColliding (iX, iY, iW, iH, itemID, item)
-        hasCollisionAtVec (iX, iY, iW, iH, itemID, pos + 1, elements)
+        orelse hasCollisionAtVec (iX, iY, iW, iH, itemID, pos + 1, elements)
       end
 
-  fun hasCollisionAt
+  fun hasCollisionAt (iX, iY, iW, iH, itemID, tree) =
-    ( iX
-    , iY
-    , iW
-    , iH
-    , itemID
-    , tree
-    ) =
     case tree of
       NODE {topLeft, topRight, bottomLeft, bottomRight, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
-                hasCollisionAt
+          hasCollisionAt (iX, iY, iW, iH, itemID, topLeft)
-                  (iX, iY, iW, iH, itemID, topLeft)
+          orelse hasCollisionAt (iX, iY, iW, iH, itemID, topRight)
-                  orelse
+          orelse hasCollisionAt (iX, iY, iW, iH, itemID, bottomLeft)
-                hasCollisionAt
+          orelse hasCollisionAt (iX, iY, iW, iH, itemID, bottomRight)
-                  (iX, iY, iW, iH, itemID, topRight)
+        else
-                  orelse
-                hasCollisionAt
-                  (iX, iY, iW, iH, itemID, bottomLeft)
-                  orelse
-                hasCollisionAt
-                  (iX, iY, iW, iH, itemID, bottomRight)
-        else 
           false
     | LEAF {items, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
           hasCollisionAtVec (iX, iY, iW, iH, itemID, 0, items)
-        else false
+        else
+          false
 
   fun getItemIDVec (iX, iY, iW, iH, pos, elements) =
     if pos = Vector.length elements then
@@ -545,7 +456,7 @@ struct
           end
         else
           ~1
-    | LEAF {items, x, y, w, h} => 
+    | LEAF {items, x, y, w, h} =>
         if isCollidingPlus (iX, iY, iW, iH, x, y, w, h) then
           getItemIDVec (iX, iY, iW, iH, 0, items)
         else

fcore/wall.sml

@@ -6,13 +6,17 @@ struct
     else
       let
         val {id, x, y, width, height} = Vector.sub (wallVec, pos)
-        val acc = QuadHelp.insert
+        val acc = QuadTree.insert (x, y, width, height, id, acc)
-          (x, y, width, height, id, acc)
       in
         helpGenerateTree (pos + 1, wallVec, acc)
       end
 
-  fun generateTree wallVec = helpGenerateTree (0, wallVec, QuadTree.empty)
+  fun generateTree wallVec =
+    helpGenerateTree
+      ( 0
+      , wallVec
+      , QuadTree.create (Constants.worldWidth, Constants.worldHeight)
+      )
 
   fun helpGetDrawVecWider
     (pos, wallVec, acc, winWidth, winHeight, ratio, yOffset) =

ffi/export.h

@@ -157,6 +157,8 @@ typedef Pointer Objptr;
 extern "C" {
 #endif
 
+MLLIB_PUBLIC(void mltonKeyCallback (Int32 x0, Int32 x1, Int32 x2, Int32 x3);)
+MLLIB_PUBLIC(void mltonFramebufferSizeCallback (Real32 x0, Real32 x1);)
 
 #undef MLLIB_PRIVATE
 #undef MLLIB_PUBLIC