Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
8.5 kB · 249 lines
Swift
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250// PMove.swift — Swift port of lib/pmove.mjs. Pure player movement: the same// math the web arena runs for client prediction and the server runs for// authority, so the feel carries over 1:1.//// Coordinate convention (WORLD coords): +X right, +Y up, +Z forward; the// player faces along yaw. yaw 0 → facing +Z; +yaw rotates clockwise looking// down. pitch in degrees, clamped ±89.
import Foundation
// Buttons bitmask (matches the JS usercmd wire format).struct BTN { static let jump: Int = 1 << 0 static let crouch: Int = 1 << 1 static let shoot: Int = 1 << 2 static let dash: Int = 1 << 3}
// Movement tuning — mirrors DEFAULT_CFG / ARENA_CFG merged with ARENA_PHYSICS.struct MoveConfig { var runSpeed: Double = 10 var walkSpeed: Double = 5 var jumpVelocity: Double = 8 var gravity: Double = 50 var groundY: Double = -1.5 var eyeHeight: Double = 2.0 var crouchEyeHeight: Double = 1.2 var crouchLerp: Double = 0.25 var groundBounds: (xMin: Double, xMax: Double, zMin: Double, zMax: Double)? = (xMin: -14, xMax: 14, zMin: -14, zMax: 14) var deathFloorY: Double? = -30 var deathFloorClearance: Double = 0.3 var simHz: Double = 120 var hVelDecay: Double = 0.9 // 🏃 Quake-style physics (ARENA_PHYSICS). When airAccel is set, the legacy // hVelDecay lerp is replaced by Q3 friction + ground/air accelerate. var airAccel: Double? = 70 var groundAccel: Double? = 80 var airCapSpeed: Double = 1.5 var groundFriction: Double = 10 var obstacles: [Obstacle] = ArenaWorld.obstacles var playerRadius: Double = 0.4}
// Player state — value type; pmove returns a mutated copy (functional like JS).struct PlayerState { var x: Double = 0 var y: Double // eye position in world Y var z: Double = 0 var vx: Double = 0 var vz: Double = 0 var vy: Double = 0 // world-up velocity var yaw: Double = 0 // degrees var pitch: Double = 0 // degrees, clamped ±89 var crouchT: Double = 0 var onGround: Bool = true var frozen: Bool = false var alive: Bool = true
init(x: Double = 0, z: Double = 0, yaw: Double = 0, pitch: Double = 0, cfg: MoveConfig = MoveConfig()) { self.x = x self.z = z self.y = cfg.groundY + cfg.eyeHeight self.yaw = yaw self.pitch = pitch }}
// One usercmd: movement intent + look angles for a single sim step.struct UserCmd { var fwd: Int = 0 // -1 | 0 | 1 var right: Int = 0 // -1 | 0 | 1 var yaw: Double? // nil = keep current var pitch: Double? var buttons: Int = 0 var dt: Double // seconds}
@inline(__always) private func clamp(_ v: Double, _ lo: Double, _ hi: Double) -> Double { v < lo ? lo : (v > hi ? hi : v)}
// Apply one usercmd to a state. Pure: returns a new state.func pmove(_ state: PlayerState, _ cmd: UserCmd, _ cfg: MoveConfig) -> PlayerState { var s = state let dt = clamp(cmd.dt, 0, 0.25) // cap dt so a pause doesn't teleport
// --- Look --- if let y = cmd.yaw { s.yaw = y } if let p = cmd.pitch { s.pitch = clamp(p, -89, 89) }
let crouching = (cmd.buttons & BTN.crouch) != 0 let jumping = (cmd.buttons & BTN.jump) != 0
// --- Horizontal intent rotated into world space by yaw --- let speed = crouching ? cfg.walkSpeed : cfg.runSpeed var ix = Double(cmd.right) var iz = Double(cmd.fwd) let ilen = (ix * ix + iz * iz).squareRoot() if ilen > 1 { ix /= ilen; iz /= ilen }
let yr = s.yaw * .pi / 180 let sy = sin(yr), cy = cos(yr) let wx = (ix * cy + iz * sy) * speed let wz = (-ix * sy + iz * cy) * speed
// --- Jump: edge-trigger before friction (Q3 bunny-hop land trick) --- if !s.frozen && jumping && s.onGround { s.vy = cfg.jumpVelocity s.onGround = false }
if let airAccel = cfg.airAccel { // 🏃 Q3: ground friction + ground/air accelerate. let wishLen = (wx * wx + wz * wz).squareRoot() let wishSpeed = wishLen let wdx = wishLen > 1e-6 ? wx / wishLen : 0 let wdz = wishLen > 1e-6 ? wz / wishLen : 0
if s.onGround && !s.frozen { qFriction(&s, cfg, dt) }
if wishLen > 1e-6 && !s.frozen { if s.onGround { qAccel(&s, wdx, wdz, wishSpeed, cfg.groundAccel ?? 80, dt) } else { let cap = cfg.airCapSpeed let airWish = min(wishSpeed, cap) qAccel(&s, wdx, wdz, airWish, airAccel, dt) } } } else { let decay = pow(cfg.hVelDecay, dt * cfg.simHz) s.vx = s.vx * decay + wx * (1 - decay) s.vz = s.vz * decay + wz * (1 - decay) }
s.x += s.vx * dt s.z += s.vz * dt
if !cfg.obstacles.isEmpty { resolveObstacles(&s, cfg) }
// --- Crouch lerp --- let crouchTarget: Double = (!s.frozen && crouching) ? 1 : 0 s.crouchT += (crouchTarget - s.crouchT) * cfg.crouchLerp if s.crouchT < 0.0005 && crouchTarget == 0 { s.crouchT = 0 } if s.crouchT > 0.9995 && crouchTarget == 1 { s.crouchT = 1 } let effEye = cfg.eyeHeight + (cfg.crouchEyeHeight - cfg.eyeHeight) * s.crouchT
// --- Vertical integration --- if !s.onGround || s.frozen { s.vy -= cfg.gravity * dt s.y += s.vy * dt }
// --- Ground clamp: only over the solid ground rectangle --- var onSolid = true if let b = cfg.groundBounds { onSolid = s.x >= b.xMin && s.x <= b.xMax && s.z >= b.zMin && s.z <= b.zMax }
let floorY = cfg.groundY + effEye if onSolid && !s.frozen { if s.y <= floorY { s.y = floorY if s.vy < 0 { s.vy = 0 } s.onGround = true } else if s.onGround { s.y = floorY } } else { s.onGround = false }
// --- Death floor clamp (lava pit) --- if s.frozen, let deathY = cfg.deathFloorY { let lavaY = deathY + cfg.deathFloorClearance if s.y <= lavaY { s.y = lavaY; s.vy = 0 } }
return s}
// --- Quake physics helpers ---
private func qFriction(_ s: inout PlayerState, _ cfg: MoveConfig, _ dt: Double) { let speed = (s.vx * s.vx + s.vz * s.vz).squareRoot() if speed < 1e-4 { s.vx = 0; s.vz = 0; return } let stop = max(speed, cfg.runSpeed * 0.5) let drop = stop * cfg.groundFriction * dt let k = max(0, speed - drop) / speed s.vx *= k s.vz *= k}
private func qAccel(_ s: inout PlayerState, _ wdx: Double, _ wdz: Double, _ wishSpeed: Double, _ accel: Double, _ dt: Double) { let cur = s.vx * wdx + s.vz * wdz let addspeed = wishSpeed - cur if addspeed <= 0 { return } var mag = accel * dt * wishSpeed if mag > addspeed { mag = addspeed } s.vx += wdx * mag s.vz += wdz * mag}
// Horizontal collision against static obstacles, checked against the player's// vertical column [feetY, eyeY]. Pure horizontal push-out + velocity clip.func resolveObstacles(_ s: inout PlayerState, _ cfg: MoveConfig) { let r = cfg.playerRadius let eyeY = s.y let feetY = s.y - cfg.eyeHeight for o in cfg.obstacles { if let yMax = o.yMax, feetY > yMax { continue } if let yMin = o.yMin, eyeY < yMin { continue } switch o.kind { case .cylinder: let dx = s.x - o.x let dz = s.z - o.z let d = (dx * dx + dz * dz).squareRoot() let minD = o.r + r if d >= minD { continue } if d < 1e-4 { s.x += minD; continue } let nx = dx / d, nz = dz / d let push = minD - d s.x += nx * push s.z += nz * push let vd = s.vx * nx + s.vz * nz if vd < 0 { s.vx -= vd * nx; s.vz -= vd * nz } case .box: let cx = (o.xMin + o.xMax) * 0.5 let cz = (o.zMin + o.zMax) * 0.5 let hx = (o.xMax - o.xMin) * 0.5 + r let hz = (o.zMax - o.zMin) * 0.5 + r let dx = s.x - cx let dz = s.z - cz let ox = hx - abs(dx) let oz = hz - abs(dz) if ox <= 0 || oz <= 0 { continue } if ox < oz { s.x += dx >= 0 ? ox : -ox if (dx >= 0 && s.vx < 0) || (dx < 0 && s.vx > 0) { s.vx = 0 } } else { s.z += dz >= 0 ? oz : -oz if (dz >= 0 && s.vz < 0) || (dz < 0 && s.vz > 0) { s.vz = 0 } } } }}