humza/sml-projects
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reimplement enemy-filter loop (now enemy's reaction, and decision to possibly filter, is fully under enemy's control - physics, damage reaction, whether to filter or update enemy's state, etc.)

Browse Source
This commit is contained in:
Humza Shahid
2025-02-08 01:05:39 +00:00
parent 1be44335cb
commit 23cf480dad
7 changed files with 273 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
fcore/enemy.sml
View File

@@ -1,277 +0,0 @@
structure Enemy =
struct
open GameType
fun withDefaultYAxis (enemy: enemy) =
case #yAxis enemy of
ON_GROUND => EnemyPatch.withPatch (enemy, EnemyPatch.W_Y_AXIS FALLING)
| _ => enemy
fun helpExists (pos, id, collisions) =
if pos = Vector.length collisions then
false
else
let val current = Vector.sub (collisions, pos)
in current = id orelse helpExists (pos + 1, id, collisions)
end
fun exists (id, collisions) = helpExists (0, id, collisions)
(* called when filtering enemies,
* to adjust enemy data on collision with projectile *)
fun onCollisionWithProjectile
( enemy: enemy
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
) =
let
val {x, y, health, ...} = enemy
val size = Constants.enemySize
val hasCollision = QuadTree.hasCollisionAt
(x, y, size, size, ~1, projectileTree)
in
if hasCollision then
if health = 1 then
(* filter out if decrementing health by one = 0 *)
acc
else
let
val enemy = withDefaultYAxis enemy
(* get patches specific to this type of enemy *)
val patches = EnemyBehaviour.getVariantPatches
( enemy
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, []
)
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getPhysicsPatches enemy
val patches = EnemyPatch.W_HEALTH (health - 1) :: patches
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getEnvironmentPatches
(enemy, walls, wallTree, platforms, platformTree)
val enemy = EnemyPatch.withPatches (enemy, patches)
in
enemy :: acc
end
else
let
val enemy = withDefaultYAxis enemy
(* get patches specific to this type of enemy *)
val patches = EnemyBehaviour.getVariantPatches
(enemy, walls, wallTree, platforms, platformTree, player, graph, [])
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getPhysicsPatches enemy
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getEnvironmentPatches
(enemy, walls, wallTree, platforms, platformTree)
val enemy = EnemyPatch.withPatches (enemy, patches)
in
enemy :: acc
end
end
(* filter enemy projectiles when player is not attacking *)
fun filterProjectileCollisions
( pos
, enemies
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
) =
if pos < 0 then
Vector.fromList acc
else
let
val enemy = Vector.sub (enemies, pos)
val acc = onCollisionWithProjectile
( enemy
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
)
in
filterProjectileCollisions
( pos - 1
, enemies
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
)
end
(* removes enemies from `enemies` vector when player is attacking that enemy
* and also filter enemy (or change enemyh health)
* if enemy has collided with projectile *)
fun filterWhenAttacked
( pos
, collisions
, enemies
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
) =
if pos < 0 then
Vector.fromList acc
else
let
val enemy = Vector.sub (enemies, pos)
val acc =
if exists (#id enemy, collisions) then (* filter out *)
acc
else
onCollisionWithProjectile
( enemy
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
)
in
filterWhenAttacked
( pos - 1
, collisions
, enemies
, projectileTree
, acc
, walls
, wallTree
, platforms
, platformTree
, player
, graph
)
end
fun helpGenerateTree (pos, enemyVec: enemy vector, acc) =
if pos = Vector.length enemyVec then
acc
else
let
val {id, x, y, ...} = Vector.sub (enemyVec, pos)
val size = Constants.enemySize
val acc = QuadTree.insert (x, y, size, size, id, acc)
in
helpGenerateTree (pos + 1, enemyVec, acc)
end
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 *)
let
val mid = low + ((high - low) div 2)
val enemy = Vector.sub (vec, mid)
val {id = curNum, ...} = enemy
in
if curNum = findNum then enemy
else if curNum < findNum then helpFind (findNum, vec, mid + 1, high)
else helpFind (findNum, vec, low, mid - 1)
end
fun find (findNum, vec) =
helpFind (findNum, vec, 0, Vector.length vec - 1)
fun helpGetDrawVec (enemy: enemy, width, height) =
let
val {x, y, ...} = enemy
val wratio = width / Constants.worldWidthReal
val hratio = height / Constants.worldHeightReal
in
if wratio < hratio then
let
val scale = Constants.worldHeightReal * wratio
val yOffset =
if height > scale then (height - scale) / 2.0
else if height < scale then (scale - height) / 2.0
else 0.0
val x = Real32.fromInt x * wratio
val y = Real32.fromInt y * wratio + yOffset
val realSize = Constants.enemySizeReal * wratio
in
Block.lerp (x, y, realSize, realSize, width, height, 0.5, 0.5, 1.0)
end
else
let
val scale = Constants.worldWidthReal * hratio
val xOffset =
if width > scale then (width - scale) / 2.0
else if width < scale then (scale - width) / 2.0
else 0.0
val x = Real32.fromInt x * hratio + xOffset
val y = Real32.fromInt y * hratio
val realSize = Constants.enemySizeReal * hratio
in
Block.lerp (x, y, realSize, realSize, width, height, 0.5, 0.5, 1.0)
end
end
fun getDrawVecLoop (pos, enemies, width, height, acc) =
if pos = Vector.length enemies then
Vector.concat acc
else
let
val e = Vector.sub (enemies, pos)
val hd = helpGetDrawVec (e, width, height)
val acc = hd :: acc
in
getDrawVecLoop (pos + 1, enemies, width, height, acc)
end
fun getDrawVec (enemies, width, height) =
getDrawVecLoop (0, enemies, width, height, [])
end

113
fcore/enemy-behaviour.sml → fcore/enemy/enemy-behaviour.sml
View File

@@ -31,7 +31,7 @@ struct
QuadTree.hasCollisionAt (ex, ey, width, height, ~1, tree)
end
fun getPatrollPatches (enemy: enemy, wallTree, platformTree, acc) =
fun getPatrolPatches (enemy: enemy, wallTree, platformTree, acc) =
let
(* This function is meant to check
* if enemy should switch the horizontal direction
@@ -308,7 +308,7 @@ struct
in
acc
end
| _ => getPatrollPatches (enemy, wallTree, platformTree, acc)
| _ => getPatrolPatches (enemy, wallTree, platformTree, acc)
fun getFollowPatches
(player: player, enemy, wallTree, platformTree, platforms, graph, acc) =
@@ -352,15 +352,114 @@ struct
end
end
fun getVariantPatches
(enemy, walls, wallTree, platforms, platformTree, player, graph, acc) =
fun withDefaultYAxis (enemy: enemy) =
case #yAxis enemy of
ON_GROUND => EnemyPatch.withPatch (enemy, EnemyPatch.W_Y_AXIS FALLING)
| _ => enemy
fun updatePatrolState
(enemy, walls, wallTree, platforms, platformTree, projectileTree, enemyList) =
let
val {x, y, ...} = enemy
val size = Constants.enemySize
in
if QuadTree.hasCollisionAt (x, y, size, size, ~1, projectileTree) then
(* no matter what projectiles hits it, PATROL_SLIME should be filtered out *)
enemyList
else
(* since we're not filtering out, update the enemy's state and cons enemy *)
let
val enemy = withDefaultYAxis enemy
val patches = getPatrolPatches (enemy, wallTree, platformTree, [])
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getPhysicsPatches enemy
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getEnvironmentPatches
(enemy, walls, wallTree, platforms, platformTree)
val enemy = EnemyPatch.withPatches (enemy, patches)
in
enemy :: enemyList
end
end
fun updateFollowState
( player
, enemy
, walls
, wallTree
, platforms
, platformTree
, projectileTree
, graph
, enemyList
) =
let
val {x, y, ...} = enemy
val size = Constants.enemySize
in
if QuadTree.hasCollisionAt (x, y, size, size, ~1, projectileTree) then
(* filter out when any projectile hits *)
enemyList
else
(* since we're not filtering out, update the enemy's state and cons enemy *)
let
val enemy = withDefaultYAxis enemy
val patches = getFollowPatches
(player, enemy, wallTree, platformTree, platforms, graph, [])
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getPhysicsPatches enemy
val enemy = EnemyPatch.withPatches (enemy, patches)
val patches = EnemyPhysics.getEnvironmentPatches
(enemy, walls, wallTree, platforms, platformTree)
val enemy = EnemyPatch.withPatches (enemy, patches)
in
enemy :: enemyList
end
end
fun updateEnemyState
( enemy
, projectiles
, projectileTree
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, enemyList
) =
let
open EnemyVariants
in
case #variant enemy of
PATROL_SLIME => getPatrollPatches (enemy, wallTree, platformTree, acc)
PATROL_SLIME =>
updatePatrolState
( enemy
, walls
, wallTree
, platforms
, platformTree
, projectileTree
, enemyList
)
| FOLLOW_SIME =>
getFollowPatches
(player, enemy, wallTree, platformTree, platforms, graph, acc)
updateFollowState
( player
, enemy
, walls
, wallTree
, platforms
, platformTree
, projectileTree
, graph
, enemyList
)
end
end

0
fcore/enemy-patch.sml → fcore/enemy/enemy-patch.sml
View File

0
fcore/enemy-variants.sml → fcore/enemy/enemy-variants.sml
View File

147
fcore/enemy/enemy.sml Normal file
View File

@@ -0,0 +1,147 @@
structure Enemy =
struct
open GameType
(* returns a vector of enemies, with new state (like position, etc.).
* Also filters any enemies from list if defeated.
* Called once per frame. *)
fun updateEnemyList
( pos
, enemies
, projectiles
, projectileTree
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, enemyList
) =
if pos < 0 then
Vector.fromList enemyList
else
let
val enemy = Vector.sub (enemies, pos)
(* call function to act on variant, either:
* 1. updating enemy and :: cons :: ing to enemyList, or
* 2. filtering enemy if projectile hit which enemy should not survive
* *)
val enemyList = EnemyBehaviour.updateEnemyState
( enemy
, projectiles
, projectileTree
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, enemyList
)
in
updateEnemyList
( pos - 1
, enemies
, projectiles
, projectileTree
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, enemyList
)
end
fun helpGenerateTree (pos, enemyVec: enemy vector, acc) =
if pos = Vector.length enemyVec then
acc
else
let
val {id, x, y, ...} = Vector.sub (enemyVec, pos)
val size = Constants.enemySize
val acc = QuadTree.insert (x, y, size, size, id, acc)
in
helpGenerateTree (pos + 1, enemyVec, acc)
end
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 *)
let
val mid = low + ((high - low) div 2)
val enemy = Vector.sub (vec, mid)
val {id = curNum, ...} = enemy
in
if curNum = findNum then enemy
else if curNum < findNum then helpFind (findNum, vec, mid + 1, high)
else helpFind (findNum, vec, low, mid - 1)
end
fun find (findNum, vec) =
helpFind (findNum, vec, 0, Vector.length vec - 1)
fun helpGetDrawVec (enemy: enemy, width, height) =
let
val {x, y, ...} = enemy
val wratio = width / Constants.worldWidthReal
val hratio = height / Constants.worldHeightReal
in
if wratio < hratio then
let
val scale = Constants.worldHeightReal * wratio
val yOffset =
if height > scale then (height - scale) / 2.0
else if height < scale then (scale - height) / 2.0
else 0.0
val x = Real32.fromInt x * wratio
val y = Real32.fromInt y * wratio + yOffset
val realSize = Constants.enemySizeReal * wratio
in
Block.lerp (x, y, realSize, realSize, width, height, 0.5, 0.5, 1.0)
end
else
let
val scale = Constants.worldWidthReal * hratio
val xOffset =
if width > scale then (width - scale) / 2.0
else if width < scale then (scale - width) / 2.0
else 0.0
val x = Real32.fromInt x * hratio + xOffset
val y = Real32.fromInt y * hratio
val realSize = Constants.enemySizeReal * hratio
in
Block.lerp (x, y, realSize, realSize, width, height, 0.5, 0.5, 1.0)
end
end
fun getDrawVecLoop (pos, enemies, width, height, acc) =
if pos = Vector.length enemies then
Vector.concat acc
else
let
val e = Vector.sub (enemies, pos)
val hd = helpGetDrawVec (e, width, height)
val acc = hd :: acc
in
getDrawVecLoop (pos + 1, enemies, width, height, acc)
end
fun getDrawVec (enemies, width, height) =
getDrawVecLoop (0, enemies, width, height, [])
end

16
fcore/game-update.sml
View File

@@ -8,6 +8,22 @@ struct
val enemyTree = Enemy.generateTree enemies
val player = Player.runPhysicsAndInput (game, input, enemyTree)
val projectiles = #projectiles player
val projectileTree = Projectile.generateTree projectiles
val enemies = Enemy.updateEnemyList
( Vector.length enemies - 1
, enemies
, projectiles
, projectileTree
, walls
, wallTree
, platforms
, platformTree
, player
, graph
, []
)
in
{ player = player
, walls = walls

8
oms.mlb
View File

@@ -24,16 +24,16 @@ fcore/platform.sml
fcore/graph.sml
fcore/path-finding.sml
fcore/enemy-variants.sml
fcore/enemy/enemy-variants.sml
fcore/game-type.sml
fcore/player-patch.sml
fcore/enemy-patch.sml
fcore/enemy/enemy-patch.sml
fcore/physics.sml
fcore/trace-jump.sml
fcore/enemy-behaviour.sml
fcore/enemy.sml
fcore/enemy/enemy-behaviour.sml
fcore/enemy/enemy.sml
fcore/player.sml
fcore/projectile.sml