mt-lang 0.3.2 → 0.3.4

data/std/noise.mt

@@ -0,0 +1,201 @@
+## Coherent noise generation — Perlin noise and fractal variants.
+##
+## Seed-based deterministic noise for procedural generation:
+## terrain, textures, fog, animation, and more.
+##
+##   import std.noise as ns
+##   var noise = ns.Noise.create(42)
+##   let h = noise.fbm2d(x * 0.01, y * 0.01)
+
+
+public struct Noise:
+    perm: array[ubyte, 512]
+    octaves: int
+    lacunarity: float
+    gain: float
+    frequency: float
+
+
+# ── fade / interpolation ──
+
+function fade(t: float) -> float:
+    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0)
+
+
+function lerp(a: float, b: float, t: float) -> float:
+    return a + t * (b - a)
+
+
+# ── gradient functions ──
+
+function grad2d(hash: int, x: float, y: float) -> float:
+    let h = hash & 3
+    let u = if h == 0 or h == 1: x else: y
+    let v = if h == 0 or h == 3: y else: x
+    return (if (h & 1) == 0: u else: -u) + (if (h & 2) == 0: v else: -v)
+
+
+function grad3d(hash: int, x: float, y: float, z: float) -> float:
+    let h = hash & 15
+    let u = if h < 8: x else: y
+    let v = if h < 4: y else: if h == 12 or h == 14: x else: z
+    let mu = if (h & 1) == 0: u else: -u
+    let mv = if (h & 2) == 0: v else: -v
+    return mu + mv
+
+
+# ── internal noise functions ──
+
+function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
+    let ix = int<-(x)
+    let iy = int<-(y)
+    let X = ix & 255
+    let Y = iy & 255
+    let xf = x - float<-(ix - (ix & ~255))
+    let yf = y - float<-(iy - (iy & ~255))
+
+    let u = fade(if xf < 0.0: xf + 1.0 else: xf)
+    let v = fade(if yf < 0.0: yf + 1.0 else: yf)
+
+    let A = int<-(perm[X]) + Y
+    let B = int<-(perm[X + 1]) + Y
+    let aa = int<-(perm[A])
+    let ab = int<-(perm[A + 1])
+    let ba = int<-(perm[B])
+    let bb = int<-(perm[B + 1])
+
+    let x1 = lerp(grad2d(aa, xf, yf), grad2d(ba, xf - 1.0, yf), u)
+    let x2 = lerp(grad2d(ab, xf, yf - 1.0), grad2d(bb, xf - 1.0, yf - 1.0), u)
+
+    return lerp(x1, x2, v)
+
+
+function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) -> float:
+    let ix = int<-(x)
+    let iy = int<-(y)
+    let iz = int<-(z)
+    let X = ix & 255
+    let Y = iy & 255
+    let Z = iz & 255
+    let xf = x - float<-(ix - (ix & ~255))
+    let yf = y - float<-(iy - (iy & ~255))
+    let zf = z - float<-(iz - (iz & ~255))
+
+    let u = fade(if xf < 0.0: xf + 1.0 else: xf)
+    let v = fade(if yf < 0.0: yf + 1.0 else: yf)
+    let w = fade(if zf < 0.0: zf + 1.0 else: zf)
+
+    let A = int<-(perm[X]) + Y
+    let AA = int<-(perm[A]) + Z
+    let AB = int<-(perm[A + 1]) + Z
+    let B = int<-(perm[X + 1]) + Y
+    let BA = int<-(perm[B]) + Z
+    let BB = int<-(perm[B + 1]) + Z
+
+    let x1 = lerp(grad3d(int<-(perm[AA]), xf, yf, zf), grad3d(int<-(perm[BA]), xf - 1.0, yf, zf), u)
+    let x2 = lerp(grad3d(int<-(perm[AB]), xf, yf - 1.0, zf), grad3d(int<-(perm[BB]), xf - 1.0, yf - 1.0, zf), u)
+    let y1 = lerp(x1, x2, v)
+
+    let x3 = lerp(grad3d(int<-(perm[AA + 1]), xf, yf, zf - 1.0), grad3d(int<-(perm[BA + 1]), xf - 1.0, yf, zf - 1.0), u)
+    let x4 = lerp(grad3d(int<-(perm[AB + 1]), xf, yf - 1.0, zf - 1.0), grad3d(int<-(perm[BB + 1]), xf - 1.0, yf - 1.0, zf - 1.0), u)
+    let y2 = lerp(x3, x4, v)
+
+    return lerp(y1, y2, w)
+
+
+# ── float floor for negative numbers ──
+
+function floor_f(x: float) -> int:
+    let i = int<-(x)
+    if x < 0.0 and float<-(i) != x:
+        return i - 1
+    return i
+
+
+# ── public API ──
+
+extending Noise:
+    public static function create(seed: ulong) -> Noise:
+        var n = Noise(
+            perm = zero[array[ubyte, 512]],
+            octaves = 6,
+            lacunarity = 2.0,
+            gain = 0.5,
+            frequency = 1.0
+        )
+
+        var i: int = 0
+        while i < 256:
+            n.perm[i] = ubyte<-i
+            i += 1
+
+        var state: ulong = seed
+        var j: int = 255
+        while j > 0:
+            state = state * 6364136223846793005 + 1442695040888963407
+            let r = int<-(state % ulong<-(j + 1))
+            let tmp = n.perm[j]
+            n.perm[j] = n.perm[r]
+            n.perm[r] = tmp
+            j -= 1
+
+        i = 0
+        while i < 256:
+            n.perm[i + 256] = n.perm[i]
+            i += 1
+
+        return n
+
+
+    public function perlin2d(x: float, y: float) -> float:
+        return perlin2d_impl(this.perm, x, y)
+
+
+    public function perlin3d(x: float, y: float, z: float) -> float:
+        return perlin3d_impl(this.perm, x, y, z)
+
+
+    public function fbm2d(x: float, y: float) -> float:
+        var value: float = 0.0
+        var freq: float = this.frequency
+        var amp: float = 1.0
+        var max_val: float = 0.0
+        var i: int = 0
+        while i < this.octaves:
+            value = value + amp * perlin2d_impl(this.perm, x * freq, y * freq)
+            max_val = max_val + amp
+            amp = amp * this.gain
+            freq = freq * this.lacunarity
+            i += 1
+        return value / max_val
+
+
+    public function fbm3d(x: float, y: float, z: float) -> float:
+        var value: float = 0.0
+        var freq: float = this.frequency
+        var amp: float = 1.0
+        var max_val: float = 0.0
+        var i: int = 0
+        while i < this.octaves:
+            value = value + amp * perlin3d_impl(this.perm, x * freq, y * freq, z * freq)
+            max_val = max_val + amp
+            amp = amp * this.gain
+            freq = freq * this.lacunarity
+            i += 1
+        return value / max_val
+
+
+    public editable function set_octaves(n: int) -> void:
+        this.octaves = n
+
+
+    public editable function set_lacunarity(v: float) -> void:
+        this.lacunarity = v
+
+
+    public editable function set_gain(v: float) -> void:
+        this.gain = v
+
+
+    public editable function set_frequency(v: float) -> void:
+        this.frequency = v

data/std/pool.mt

@@ -0,0 +1,82 @@
+## Object pool — fixed-capacity reusable object storage.
+##
+## Pre-allocate objects once, then acquire/release without
+## allocation churn. O(1) acquire and release via free stack.
+##
+##   import std.pool as pool
+##   var p = pool.Pool[Bullet].create(64)
+##   let id = p.acquire() else: /* pool exhausted */
+##   let bullet = p.get(id)   # ptr to object
+##   p.release(id)
+
+import std.vec as vec
+import std.mem.heap as heap
+
+
+public struct Pool[T]:
+    objects: ptr[T]
+    free_stack: vec.Vec[ptr_uint]
+    capacity: ptr_uint
+
+
+# ── public API ──
+
+extending Pool[T]:
+    public static function create(capacity: ptr_uint) -> Pool[T]:
+        var p = Pool[T](
+            objects = heap.must_alloc[T](capacity),
+            free_stack = vec.Vec[ptr_uint].with_capacity(capacity),
+            capacity = capacity
+        )
+
+        # Push all indices onto the free stack in reverse order so
+        # acquire() returns them in ascending order (0 first).
+        var i = capacity
+        while i > 0:
+            i -= 1
+            p.free_stack.push(i)
+
+        return p
+
+
+    public editable function acquire() -> Option[ptr_uint]:
+        let idx = this.free_stack.pop() else:
+            return Option[ptr_uint].none
+        return Option[ptr_uint].some(value = idx)
+
+
+    public function get(index: ptr_uint) -> ptr[T]?:
+        if index >= this.capacity:
+            return null
+        unsafe:
+            return this.objects + index
+
+
+    public editable function release_object(index: ptr_uint) -> void:
+        if index >= this.capacity:
+            return
+
+        # Check for double-release by scanning free stack.
+        # Skip this check for simplicity — caller must not double-release.
+        this.free_stack.push(index)
+
+
+    public function available() -> ptr_uint:
+        return this.free_stack.len()
+
+
+    public function count() -> ptr_uint:
+        return this.capacity - this.free_stack.len()
+
+
+    public editable function clear() -> void:
+        this.free_stack.clear()
+        var i = this.capacity
+        while i > 0:
+            i -= 1
+            this.free_stack.push(i)
+
+
+    public editable function release() -> void:
+        this.free_stack.release()
+        heap.release(this.objects)

data/std/signal.mt

@@ -0,0 +1,66 @@
+## Signal — fixed-capacity observer / publish-subscribe.
+##
+## Connect callbacks to signals and fire typed payloads.
+## Up to 16 subscribers per signal, stack-allocated.
+##
+##   import std.signal as sig
+##   var on_damage = sig.Signal[int].create()
+##   on_damage.connect(handle_damage)
+##   on_damage.fire(25)
+
+public struct Signal[Payload]:
+    slots: array[fn(payload: Payload) -> void, 16]
+    count: ptr_uint
+
+
+# ── public API ──
+
+extending Signal[Payload]:
+    public static function create() -> Signal[Payload]:
+        var s = Signal[Payload](
+            slots = zero[array[fn(payload: Payload) -> void, 16]],
+            count = 0
+        )
+        return s
+
+
+    public editable function connect(callback: fn(payload: Payload) -> void) -> void:
+        if this.count >= 16:
+            return
+
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                if this.slots[i] == callback:
+                    return
+            i += 1
+
+        unsafe:
+            this.slots[this.count] = callback
+        this.count = this.count + 1
+
+
+    public editable function disconnect(callback: fn(payload: Payload) -> void) -> void:
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                if this.slots[i] == callback:
+                    # swap-remove with last
+                    this.count = this.count - 1
+                    if i < this.count:
+                        this.slots[i] = this.slots[this.count]
+                    return
+            i += 1
+
+
+    public function fire(payload: Payload) -> void:
+        var i: ptr_uint = 0
+        while i < this.count:
+            unsafe:
+                let cb = this.slots[i]
+                cb(payload)
+            i += 1
+
+
+    public function count() -> ptr_uint:
+        return this.count

data/std/steering.mt

@@ -0,0 +1,132 @@
+## Steering behaviors — Craig Reynolds' autonomous motion.
+##
+## Pure-function steering forces for autonomous agents.
+## Seek, flee, arrive, pursuit, evade, wander, and flocking
+## (separation, alignment, cohesion). All return steering
+## force vectors to be accumulated and applied by the caller.
+##
+##   import std.steering as steer
+##   var force = steer.Steer.seek(pos, vel, target, max_speed)
+##   force = force + steer.Steer.separation(pos, neighbors, r, max_speed)
+
+import std.linear_algebra as la
+import std.math as math
+
+
+# ── internal helpers ──
+
+function set_magnitude(v: vec2, magnitude: float) -> vec2:
+    let len = v.length()
+    if len <= 0.0:
+        return v
+    return v * (magnitude / len)
+
+
+function limit_force(steering: vec2, max_force: float) -> vec2:
+    let mag = steering.length()
+    if mag > max_force:
+        return steering * (max_force / mag)
+    return steering
+
+
+# ── public API ──
+
+extending vec2:
+    public static function seek(position: vec2, velocity: vec2, target: vec2, max_speed: float) -> vec2:
+        let desired = target - position
+        let desired_vel = set_magnitude(desired, max_speed)
+        return desired_vel - velocity
+
+
+    public static function flee(position: vec2, velocity: vec2, threat: vec2, max_speed: float) -> vec2:
+        let desired = position - threat
+        let desired_vel = set_magnitude(desired, max_speed)
+        return desired_vel - velocity
+
+
+    public static function arrive(position: vec2, velocity: vec2, target: vec2, max_speed: float, slowing_distance: float) -> vec2:
+        let offset = target - position
+        let distance = offset.length()
+        if distance < 0.001:
+            return zero[vec2]
+        let speed = if distance < slowing_distance: max_speed * distance / slowing_distance else: max_speed
+        let desired_vel = offset * (speed / distance)
+        return desired_vel - velocity
+
+
+    public static function pursuit(position: vec2, velocity: vec2, target_pos: vec2, target_vel: vec2, max_speed: float) -> vec2:
+        let offset = target_pos - position
+        let distance = offset.length()
+        let my_speed = velocity.length()
+        var look_ahead: float = distance / (max_speed + 0.001)
+        if my_speed > 0.001:
+            look_ahead = distance / my_speed
+        let future = target_pos + target_vel * look_ahead
+        return vec2.seek(position, velocity, future, max_speed)
+
+
+    public static function evade(position: vec2, velocity: vec2, threat_pos: vec2, threat_vel: vec2, max_speed: float) -> vec2:
+        let offset = threat_pos - position
+        let distance = offset.length()
+        let my_speed = velocity.length()
+        var look_ahead: float = distance / (max_speed + 0.001)
+        if my_speed > 0.001:
+            look_ahead = distance / my_speed
+        let future = threat_pos + threat_vel * look_ahead
+        return vec2.flee(position, velocity, future, max_speed)
+
+
+    public static function wander(velocity: vec2, wander_angle: float, wander_distance: float, wander_radius: float) -> vec2:
+        if velocity.length() < 0.001:
+            return zero[vec2]
+        let forward = set_magnitude(velocity, 1.0)
+        let circle_center = forward * wander_distance
+        let wx = circle_center.x + wander_radius * float<-(math.cos(double<-(wander_angle)))
+        let wy = circle_center.y + wander_radius * float<-(math.sin(double<-(wander_angle)))
+        let displacement = vec2(x = wx, y = wy)
+        return displacement
+
+
+    public static function separation(position: vec2, neighbors: span[vec2], desired_separation: float) -> vec2:
+        var steer: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for n in neighbors:
+            let d = position - n
+            let distance = d.length()
+            if distance > 0.0 and distance < desired_separation:
+                let repulsion = d * (1.0 / distance)
+                steer = steer + repulsion
+                count += 1
+        if count > 0:
+            steer = steer / float<-(count)
+        return steer
+
+
+    public static function alignment(velocity: vec2, neighbor_velocities: span[vec2]) -> vec2:
+        var sum: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for nv in neighbor_velocities:
+            sum = sum + nv
+            count += 1
+        if count > 0:
+            let avg = sum / float<-(count)
+            return avg - velocity
+        return zero[vec2]
+
+
+    public static function cohesion(position: vec2, neighbor_positions: span[vec2], radius: float) -> vec2:
+        var sum: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for np in neighbor_positions:
+            let d = position - np
+            if d.length() < radius:
+                sum = sum + np
+                count += 1
+        if count > 0:
+            let center = sum / float<-(count)
+            return center - position
+        return zero[vec2]
+
+
+    public static function limit(steering: vec2, max_force: float) -> vec2:
+        return limit_force(steering, max_force)

data/std/timer.mt

@@ -0,0 +1,81 @@
+## Timer — countdown and repeating timers.
+##
+## Accumulate delta time and fire when duration is reached.
+## Supports one-shot (auto-stop) and repeating (auto-reset).
+##
+##   import std.timer as time
+##   var cooldown = time.Timer.create(0.5, false)
+##   var regen = time.Timer.create(1.0, true)
+##   ...
+##   if cooldown.step(dt): do_ability()
+##   if regen.step(dt): heal(1)
+
+
+public struct Timer:
+    duration: float
+    elapsed: float
+    active: bool
+    repeating: bool
+
+
+# ── public API ──
+
+extending Timer:
+    public static function create(duration: float, repeating: bool) -> Timer:
+        return Timer(
+            duration = duration,
+            elapsed = 0.0,
+            active = true,
+            repeating = repeating
+        )
+
+
+    public editable function step(dt: float) -> bool:
+        if not this.active:
+            return false
+        this.elapsed = this.elapsed + dt
+        if this.elapsed >= this.duration:
+            if this.repeating:
+                this.elapsed = this.elapsed - this.duration
+            else:
+                this.elapsed = this.duration
+                this.active = false
+            return true
+        return false
+
+
+    public function progress() -> float:
+        if this.duration <= 0.0:
+            return 1.0
+        let p = this.elapsed / this.duration
+        if p > 1.0: return 1.0
+        return p
+
+
+    public function time_left() -> float:
+        let t = this.duration - this.elapsed
+        if t < 0.0: return 0.0
+        return t
+
+
+    public editable function reset() -> void:
+        this.elapsed = 0.0
+        this.active = true
+
+
+    public editable function restart(duration: float) -> void:
+        this.duration = duration
+        this.elapsed = 0.0
+        this.active = true
+
+
+    public editable function stop() -> void:
+        this.active = false
+
+
+    public editable function pause() -> void:
+        this.active = false
+
+
+    public editable function resume() -> void:
+        this.active = true