chore: run fantomas

Author: AngelMunoz

samples/PlatformerSample/Constants.fs

@@ -2,22 +2,55 @@ module PlatformerSample.Constants
 
 open System.Numerics
 
+[<Literal>]
 let tileSize = 64.0f
+
+[<Literal>]
 let chunkCells = 32
-let chunkWorldSize = float32 chunkCells * tileSize  // 2048
+
+let chunkWorldSize = float32 chunkCells * tileSize // 2048
+
+[<Literal>]
 let playerWidth = 40.0f
+
+[<Literal>]
 let playerHeight = 54.0f
+
+[<Literal>]
 let gravity = 1200.0f
+
+[<Literal>]
 let moveSpeed = 300.0f
+
+[<Literal>]
 let jumpSpeed = -700.0f
+
+[<Literal>]
 let worldHeight = 12.0f
+
 let groundLevel = worldHeight * tileSize
 let groundSurface = groundLevel - tileSize
+
+[<Literal>]
 let chunkLoadRadius = 2
+
+[<Literal>]
 let chunkEvictRadius = 4
+
+[<Literal>]
 let maxOccluders = 128
+
+[<Literal>]
 let maxTorchLights = 16
+
+[<Literal>]
 let viewportWidth = 1280.0f
+
+[<Literal>]
 let viewportHeight = 720.0f
+
+[<Literal>]
 let spawnX = 200.0f
-let spawnProtectedCells = 5  // first 5 cells (0-320px) are pit-free
+
+[<Literal>]
+let spawnProtectedCells = 5 // first 5 cells (0-320px) are pit-free

samples/PlatformerSample/DayNight.fs

@@ -8,7 +8,7 @@ open PlatformerSample.Constants
 // -------------------------------------------------------------
 // Day / Night Cycle
 // -------------------------------------------------------------
-
+[<Struct>]
 type State = {
   TimeOfDay: float32
   DayDuration: float32
@@ -21,10 +21,15 @@ let initial = {
 
 let inline update dt state =
   let hoursPerSecond = 24.0f / state.DayDuration
-  { state with TimeOfDay = (state.TimeOfDay + dt * hoursPerSecond) % 24.0f }
+
+  {
+    state with
+        TimeOfDay = (state.TimeOfDay + dt * hoursPerSecond) % 24.0f
+  }
 
 let inline lerpColor (a: Color) (b: Color) (t: float32) =
   let t = Math.Clamp(t, 0.0f, 1.0f)
+
   Color(
     byte(float32 a.R + t * (float32 b.R - float32 a.R)),
     byte(float32 a.G + t * (float32 b.G - float32 a.G)),
@@ -58,30 +63,31 @@ let getSkyColors time : Color * Color =
 
 let getAmbientColor time : Color =
   let top, bot = getSkyColors time
+
   let avg =
-    (int top.R + int top.G + int top.B + int bot.R + int bot.G + int bot.B)
-    / 6
+    (int top.R + int top.G + int top.B + int bot.R + int bot.G + int bot.B) / 6
     |> float32
+
   let intensity = MathF.Max(avg / 255.0f, 0.12f)
+
   Color(
     byte(intensity * 255.0f),
     byte(intensity * 245.0f),
     byte(intensity * 230.0f),
     255uy
   )
 
+// Sun and moon are mutually exclusive — never active simultaneously.
+// This avoids doubling directional-light uniform uploads and SDF
+// raymarch cost during dawn/dusk.
 let getSunIntensity time : float32 =
-  if time < 6.0f || time > 18.0f then 0.0f
-  elif time < 8.0f then (time - 6.0f) / 2.0f
-  elif time < 16.0f then 1.0f
-  else (18.0f - time) / 2.0f
+  if time < 5.0f || time > 19.0f then 0.0f
+  elif time < 7.0f then (time - 5.0f) / 2.0f
+  elif time < 17.0f then 1.0f
+  else (19.0f - time) / 2.0f
 
 let getMoonIntensity time : float32 =
-  if time > 6.0f && time < 18.0f then 0.0f
-  elif time < 8.0f then 1.0f - (time - 6.0f) / 2.0f
-  elif time < 16.0f then 0.0f
-  elif time < 18.0f then (time - 16.0f) / 2.0f
-  else 1.0f
+  if time >= 5.0f && time <= 19.0f then 0.0f else 1.0f
 
 let orbitalPositions (centerX: float32) (state: State) =
   let centerY = groundLevel - 200.0f

samples/PlatformerSample/Physics.fs

@@ -9,23 +9,28 @@ open PlatformerSample.Types
 // Player Bounds & Collision
 // -------------------------------------------------------------
 
-let playerBounds(pos: Vector2) =
+let inline playerBounds(pos: Vector2) =
   Rectangle(pos.X, pos.Y, playerWidth, playerHeight)
 
 let inline checkCollision (a: Rectangle) (b: Rectangle) =
-  a.X < b.X + b.Width && a.X + a.Width > b.X && a.Y < b.Y + b.Height && a.Y + a.Height > b.Y
+  a.X < b.X + b.Width
+  && a.X + a.Width > b.X
+  && a.Y < b.Y + b.Height
+  && a.Y + a.Height > b.Y
 
 let resolvePlatformCollision
   (prevPos: Vector2)
   (newPos: Vector2)
   (velocity: Vector2)
-  (platforms: Rectangle[])
+  (platforms: ResizeArray<Rectangle>)
   : struct (Vector2 * Vector2 * bool) =
   let mutable pos = newPos
   let mutable vel = velocity
   let mutable grounded = false
 
-  for pb in platforms do
+  for i = 0 to platforms.Count - 1 do
+    let pb = platforms[i]
+
     if checkCollision (playerBounds pos) pb then
       let prevFeetY = prevPos.Y + playerHeight
       let currFeetY = pos.Y + playerHeight
@@ -54,7 +59,10 @@ let resolvePlatformCollision
 
 let getAnimationState (velocity: Vector2) (isGrounded: bool) =
   if not isGrounded then
-    if velocity.Y > 0.0f then AnimationState.Fall else AnimationState.Jump
+    if velocity.Y > 0.0f then
+      AnimationState.Fall
+    else
+      AnimationState.Jump
   elif abs velocity.X > 1.0f then
     AnimationState.Walk
   else

samples/PlatformerSample/Program.fs

@@ -19,7 +19,7 @@ open PlatformerSample.WorldGen
 let inline r (x: int) (y: int) (w: int) (h: int) =
   Rectangle(float32 x, float32 y, float32 w, float32 h)
 
-let loadAssets (ctx: GameContext) : SpriteAssets =
+let loadAssets(ctx: GameContext) : SpriteAssets =
   let assets = GameContext.getService<IAssets> ctx
 
   let playerTex =
@@ -36,29 +36,50 @@ let loadAssets (ctx: GameContext) : SpriteAssets =
   let jumpSound = assets.Sound("assets/sfx_jump.ogg")
 
   // White 1x1 texture for particles (black would multiply to zero)
-  let particleImg = Raylib.GenImageColor(1, 1, Color(255uy, 255uy, 255uy, 255uy))
+  let particleImg =
+    Raylib.GenImageColor(1, 1, Color(255uy, 255uy, 255uy, 255uy))
+
   let particleTex = Raylib.LoadTextureFromImage(particleImg)
   Raylib.UnloadImage(particleImg)
 
   let playerSheet =
-    SpriteSheet.fromFrames
-      playerTex
-      (Vector2(64.0f, 64.0f))
-      [|
-        struct ("idle", { Frames = [| r 645 0 128 128 |]; FrameDuration = 1.0f; Loop = false })
-        struct ("walk", { Frames = [| r 0 129 128 128; r 129 129 128 128 |]; FrameDuration = 0.1f; Loop = true })
-        struct ("jump", { Frames = [| r 774 0 128 128 |]; FrameDuration = 1.0f; Loop = false })
-        struct ("fall", { Frames = [| r 774 0 128 128 |]; FrameDuration = 1.0f; Loop = false })
-      |]
+    SpriteSheet.fromFrames playerTex (Vector2(64.0f, 64.0f)) [|
+      struct ("idle",
+              {
+                Frames = [| r 645 0 128 128 |]
+                FrameDuration = 1.0f
+                Loop = false
+              })
+      struct ("walk",
+              {
+                Frames = [| r 0 129 128 128; r 129 129 128 128 |]
+                FrameDuration = 0.1f
+                Loop = true
+              })
+      struct ("jump",
+              {
+                Frames = [| r 774 0 128 128 |]
+                FrameDuration = 1.0f
+                Loop = false
+              })
+      struct ("fall",
+              {
+                Frames = [| r 774 0 128 128 |]
+                FrameDuration = 1.0f
+                Loop = false
+              })
+    |]
 
   // torch_on_a (65,1105) and torch_on_b (130,1105) — 64x64 each
   let torchSheet =
-    SpriteSheet.fromFrames
-      tileTex
-      (Vector2(32.0f, 32.0f))
-      [|
-        struct ("lit", { Frames = [| r 65 1105 64 64; r 130 1105 64 64 |]; FrameDuration = 0.15f; Loop = true })
-      |]
+    SpriteSheet.fromFrames tileTex (Vector2(32.0f, 32.0f)) [|
+      struct ("lit",
+              {
+                Frames = [| r 65 1105 64 64; r 130 1105 64 64 |]
+                FrameDuration = 0.15f
+                Loop = true
+              })
+    |]
 
   {
     PlayerSheet = playerSheet
@@ -73,7 +94,7 @@ let loadAssets (ctx: GameContext) : SpriteAssets =
 // Init
 // -------------------------------------------------------------
 
-let init (ctx: GameContext) =
+let init(ctx: GameContext) =
   let assets = loadAssets ctx
 
   let inputMap =
@@ -97,14 +118,22 @@ let init (ctx: GameContext) =
   // Pre-load spawn chunks
   let spawnChunkX = 0
   let spawnChunkY = 0
+
   for x in spawnChunkX - chunkLoadRadius .. spawnChunkX + chunkLoadRadius do
     for y in spawnChunkY - chunkLoadRadius .. spawnChunkY + chunkLoadRadius do
       if x >= 0 then
-        model.Chunks[struct(x, y)] <- generateChunk x y seed
+        model.Chunks[struct (x, y)] <- generateChunk x y seed
 
   model.PlayerPosition <- Vector2(spawnX, spawnY)
-  model.CameraPos <- Vector2(spawnX, spawnY)
+
+  model.Camera <-
+    Camera2D.create
+      (Vector2(spawnX, spawnY))
+      1.0f
+      (Vector2(viewportWidth, viewportHeight))
+
   model.Seed <- seed
+
   model.Lighting <-
     new LightContext2D(softness = 0.05f, maxShadowDistance = 2000.0f)