117 lines
4.0 KiB
Standard ML
117 lines
4.0 KiB
Standard ML
structure PlayerAttack =
|
|
struct
|
|
structure AttackEnemies =
|
|
MakeQuadTreeFold
|
|
(struct
|
|
type env = unit
|
|
type state = PlayerType.defeated_enemies list * EnemyMap.t
|
|
|
|
open EnemyType
|
|
|
|
fun defeatEnemy (enemyID, enemyMap, defeatedList) =
|
|
let
|
|
val defeatedList = {angle = 1} :: defeatedList
|
|
val enemyMap = EnemyMap.remove (enemyID, enemyMap)
|
|
in
|
|
(defeatedList, enemyMap)
|
|
end
|
|
|
|
fun onPlayerAttack (enemyID, enemy, enemyMap, defeatedList) =
|
|
case #variant enemy of
|
|
PATROL_SLIME => defeatEnemy (enemyID, enemyMap, defeatedList)
|
|
| FOLLOW_SLIME => defeatEnemy (enemyID, enemyMap, defeatedList)
|
|
| STRAIGHT_BAT => defeatEnemy (enemyID, enemyMap, defeatedList)
|
|
|
|
fun fold (enemyID, (), (defeatedList, enemyMap)) =
|
|
case EnemyMap.get (enemyID, enemyMap) of
|
|
SOME enemy =>
|
|
onPlayerAttack (enemyID, enemy, enemyMap, defeatedList)
|
|
| NONE => (defeatedList, enemyMap)
|
|
end)
|
|
|
|
fun attackEnemies (player: PlayerType.player, enemyMap, enemyTree) =
|
|
let
|
|
open PlayerType
|
|
val {x, y, facing, mainAttack, ...} = player
|
|
in
|
|
case mainAttack of
|
|
MAIN_ATTACKING {length, ...} =>
|
|
let
|
|
open EntityType
|
|
val height = Constants.playerSize
|
|
val x =
|
|
(case facing of
|
|
FACING_RIGHT => x + Constants.playerSize
|
|
| FACING_LEFT => x - length)
|
|
|
|
val (defeatedList, enemyMap) = AttackEnemies.foldRegion
|
|
(x, y, length, height, (), ([], enemyMap), enemyTree)
|
|
|
|
val defeatedList = Vector.fromList defeatedList
|
|
val defeatedList = Vector.concat [defeatedList, #enemies player]
|
|
|
|
val player =
|
|
PlayerPatch.withPatch (player, PlayerPatch.W_ENEMIES defeatedList)
|
|
in
|
|
(player, enemyMap)
|
|
end
|
|
| _ => (player, enemyMap)
|
|
end
|
|
|
|
structure ProjectileHitEnemy =
|
|
MakeQuadTreeFold
|
|
(struct
|
|
type env = unit
|
|
type state = EnemyType.falling_enemy list * EnemyMap.t
|
|
|
|
open EnemyType
|
|
|
|
fun onDefeated (enemyID, enemy, enemyMap, fallingList) =
|
|
let
|
|
val {x, y, variant, ...} = enemy
|
|
val fallingList = {x = x, y = y, variant = variant} :: fallingList
|
|
val enemyMap = EnemyMap.remove (enemyID, enemyMap)
|
|
in
|
|
(fallingList, enemyMap)
|
|
end
|
|
|
|
fun onProjectileAttack (enemyID, enemy, enemyMap, fallingList) =
|
|
case #variant enemy of
|
|
PATROL_SLIME => onDefeated (enemyID, enemy, enemyMap, fallingList)
|
|
| FOLLOW_SLIME => onDefeated (enemyID, enemy, enemyMap, fallingList)
|
|
| STRAIGHT_BAT => onDefeated (enemyID, enemy, enemyMap, fallingList)
|
|
|
|
fun fold (enemyID, (), (fallingList, enemyMap)) =
|
|
case EnemyMap.get (enemyID, enemyMap) of
|
|
SOME enemy =>
|
|
onProjectileAttack (enemyID, enemy, enemyMap, fallingList)
|
|
| NONE => (fallingList, enemyMap)
|
|
end)
|
|
|
|
fun helpProjectileHitEnemy (pos, projectiles, enemyTree, enemyMap, newFalling) =
|
|
if pos = Vector.length projectiles then
|
|
(newFalling, enemyMap)
|
|
else
|
|
let
|
|
val {x, y, ...}: PlayerType.player_projectile =
|
|
Vector.sub (projectiles, pos)
|
|
val size = Constants.projectileSizeInt
|
|
val (newFalling, enemyMap) = ProjectileHitEnemy.foldRegion
|
|
(x, y, size, size, (), (newFalling, enemyMap), enemyTree)
|
|
in
|
|
helpProjectileHitEnemy
|
|
(pos + 1, projectiles, enemyTree, enemyMap, newFalling)
|
|
end
|
|
|
|
fun projectileHitEnemy (projectiles, enemyMap, enemyTree, oldFalling) =
|
|
let
|
|
val (newFalling, enemyMap) = helpProjectileHitEnemy
|
|
(0, projectiles, enemyTree, enemyMap, [])
|
|
|
|
val newFalling = Vector.fromList newFalling
|
|
val allFalling = Vector.concat [newFalling, oldFalling]
|
|
in
|
|
(allFalling, enemyMap)
|
|
end
|
|
end
|