fcore/game-update.sml

structure GameUpdate =
struct
  fun update (game, input) =
    let
      val
        { player
        , walls
        , wallTree
        , platforms
        , platformTree
        , enemies
        , graph
        , fallingEnemies
        } = game

      val enemyTree = Enemy.generateTree enemies
      val player = Player.runPhysicsAndInput (game, input, enemyTree)

      val projectiles = #projectiles player
      val projectileTree = Projectile.generateTree projectiles

      (* update state of falling enemies and possibly filter *)
      val fallingEnemies = FallingEnemies.updateList
        (Vector.length fallingEnemies - 1, fallingEnemies, player, [])

      val (enemies, fallingEnemies) = Enemy.updateEnemyList
        ( Vector.length enemies - 1
        , enemies
        , projectiles
        , projectileTree
        , walls
        , wallTree
        , platforms
        , platformTree
        , player
        , graph
        , []
        , fallingEnemies
        )

      val fallingEnemies = Vector.fromList fallingEnemies
    in
      { player = player
      , walls = walls
      , wallTree = wallTree
      , platforms = platforms
      , platformTree = platformTree
      , enemies = enemies
      , graph = graph
      , fallingEnemies = fallingEnemies
      }
    end
end
add GameType.game_type which stores player and wall types, add GameUpdate.update function which takes a game type and returns a new game type, and refactor player/wall files, and gl-draw file, in light of these changes 2024-12-15 09:10:19 +00:00			`structure GameUpdate =`
			`struct`
			`fun update (game, input) =`
			`let`
add falling_enemies type to game (these enemies can be picked up and thrown), and thread fallingEnemies through enemy.sml to set up scaffolding for them 2025-02-08 09:20:10 +00:00			`val`
			`{ player`
			`, walls`
			`, wallTree`
			`, platforms`
			`, platformTree`
			`, enemies`
			`, graph`
			`, fallingEnemies`
			`} = game`
restore player-enemy collisions (this time in fcore/game-update.sml) 2024-12-24 19:00:11 +00:00
remove enemyTree (quad tree holding enemies) from game type as this is not static geometry and, since enemies are moving every frame, this should also be regenerated on every frame 2025-01-11 22:06:08 +00:00			`val enemyTree = Enemy.generateTree enemies`
rip out player-enemy.sml and let player react to enemy collisions independently of enemy reaction to player 2025-02-06 17:37:48 +00:00			`val player = Player.runPhysicsAndInput (game, input, enemyTree)`
remove enemyTree (quad tree holding enemies) from game type as this is not static geometry and, since enemies are moving every frame, this should also be regenerated on every frame 2025-01-11 22:06:08 +00:00
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.) 2025-02-08 01:05:39 +00:00			`val projectiles = #projectiles player`
			`val projectileTree = Projectile.generateTree projectiles`

update state of falling enemies per loop 2025-02-08 09:49:32 +00:00			`(* update state of falling enemies and possibly filter *)`
			`val fallingEnemies = FallingEnemies.updateList`
code functionality to filter out falling enemy from list if falling enemy is colliding with player 2025-02-08 11:05:58 +00:00			`(Vector.length fallingEnemies - 1, fallingEnemies, player, [])`
update state of falling enemies per loop 2025-02-08 09:49:32 +00:00
			`val (enemies, fallingEnemies) = Enemy.updateEnemyList`
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.) 2025-02-08 01:05:39 +00:00			`( Vector.length enemies - 1`
			`, enemies`
			`, projectiles`
			`, projectileTree`
			`, walls`
			`, wallTree`
			`, platforms`
			`, platformTree`
			`, player`
			`, graph`
			`, []`
update state of falling enemies per loop 2025-02-08 09:49:32 +00:00			`, fallingEnemies`
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.) 2025-02-08 01:05:39 +00:00			`)`
add falling_enemies type to game (these enemies can be picked up and thrown), and thread fallingEnemies through enemy.sml to set up scaffolding for them 2025-02-08 09:20:10 +00:00
update state of falling enemies per loop 2025-02-08 09:49:32 +00:00			`val fallingEnemies = Vector.fromList fallingEnemies`
add GameType.game_type which stores player and wall types, add GameUpdate.update function which takes a game type and returns a new game type, and refactor player/wall files, and gl-draw file, in light of these changes 2024-12-15 09:10:19 +00:00			`in`
add platform vector and platform quadtree to game type 2024-12-17 21:42:06 +00:00			`{ player = player`
			`, walls = walls`
			`, wallTree = wallTree`
			`, platforms = platforms`
			`, platformTree = platformTree`
begin coding enemy 2024-12-19 03:08:26 +00:00			`, enemies = enemies`
precompute graph to be used for dijkstra's algorithm, resulting in CPU usage that never exceed 7/home/humza/Downloads/sml/oh-my-stars/fcore/path-finding.sml with 5 enemies and eliminating lag 2025-01-31 04:32:53 +00:00			`, graph = graph`
add falling_enemies type to game (these enemies can be picked up and thrown), and thread fallingEnemies through enemy.sml to set up scaffolding for them 2025-02-08 09:20:10 +00:00			`, fallingEnemies = fallingEnemies`
add platform vector and platform quadtree to game type 2024-12-17 21:42:06 +00:00			`}`
add GameType.game_type which stores player and wall types, add GameUpdate.update function which takes a game type and returns a new game type, and refactor player/wall files, and gl-draw file, in light of these changes 2024-12-15 09:10:19 +00:00			`end`
			`end`