mt-lang 0.3.2 → 0.3.4

data/std/graph.mt

@@ -1,6 +1,10 @@
 import std.vec as vec
 import std.deque as deque
 import std.mem.heap as heap
+import std.binary_heap as heap_mod
+
+const INF: float = 3.4028235e38
+const NIL_NODE: ptr_uint = ~(ptr_uint<-0)
 
 public struct Edge:
     from: ptr_uint
@@ -20,6 +24,27 @@ public struct DenseGraph[T]:
     is_directed: bool
 
 
+public struct HeapEntry:
+    node: ptr_uint
+    dist: float
+
+extending HeapEntry:
+    public static function order(a: const_ptr[HeapEntry], b: const_ptr[HeapEntry]) -> int:
+        let da = unsafe: read(a).dist
+        let db = unsafe: read(b).dist
+        if da < db:
+            return 1
+        else if da > db:
+            return -1
+        else:
+            return 0
+
+
+public struct ShortestPaths:
+    dist: vec.Vec[float]
+    prev: vec.Vec[ptr_uint]
+
+
 extending Graph[T]:
     public static function create() -> Graph[T]:
         return Graph[T](
@@ -233,6 +258,15 @@ extending Graph[T]:
         var targets = vec.Vec[ptr_uint].with_capacity(m)
         var weights = vec.Vec[float].with_capacity(m)
 
+        if n == 0:
+            return DenseGraph[T](
+                nodes = vec.Vec[T].create(),
+                offsets = offsets,
+                targets = targets,
+                weights = weights,
+                is_directed = this.is_directed
+            )
+
         var counts = heap.must_alloc[ptr_uint](n)
         var pos = heap.must_alloc[ptr_uint](n)
         var i: ptr_uint = 0
@@ -514,8 +548,211 @@ extending DenseGraph[T]:
         return order
 
 
+    public function dijkstra(source: ptr_uint) -> ShortestPaths:
+        var dist = vec.Vec[float].with_capacity(this.node_count())
+        var prev = vec.Vec[ptr_uint].with_capacity(this.node_count())
+        let n = this.node_count()
+
+        var i: ptr_uint = 0
+        while i < n:
+            dist.push(INF)
+            prev.push(NIL_NODE)
+            i += 1
+
+        if n == 0 or source >= n:
+            return ShortestPaths(dist = dist, prev = prev)
+
+        let src_dist_ptr = dist.get(source) else:
+            return ShortestPaths(dist = dist, prev = prev)
+        unsafe:
+            read(src_dist_ptr) = 0.0
+
+        var pq = heap_mod.BinaryHeap[HeapEntry].create()
+        pq.push(HeapEntry(node = source, dist = 0.0))
+
+        while not pq.is_empty():
+            let entry = pq.pop() else:
+                break
+            let u = entry.node
+            let d = entry.dist
+
+            let cur_dist_ptr = dist.get(u) else:
+                break
+            if d > unsafe: read(cur_dist_ptr):
+                continue
+
+            let start_ptr = this.offsets.get(u) else:
+                break
+            let end_ptr = this.offsets.get(u + 1) else:
+                break
+            let start = unsafe: read(start_ptr)
+            let end = unsafe: read(end_ptr)
+            var j = start
+            while j < end:
+                let t_ptr = this.targets.get(j) else:
+                    break
+                let w_ptr = this.weights.get(j) else:
+                    break
+                let v = unsafe: read(t_ptr)
+                let weight = unsafe: read(w_ptr)
+                let new_dist = d + weight
+
+                let v_dist_ptr = dist.get(v) else:
+                    continue
+                if new_dist < unsafe: read(v_dist_ptr):
+                    unsafe:
+                        read(v_dist_ptr) = new_dist
+                    let v_prev_ptr = prev.get(v) else:
+                        continue
+                    unsafe:
+                        read(v_prev_ptr) = u
+                    pq.push(HeapEntry(node = v, dist = new_dist))
+                j += 1
+
+        pq.release()
+        return ShortestPaths(dist = dist, prev = prev)
+
+
+    public function astar(source: ptr_uint, target: ptr_uint, heuristic: fn(node: ptr_uint) -> float) -> vec.Vec[ptr_uint]:
+        var path = vec.Vec[ptr_uint].create()
+        let n = this.node_count()
+        if n == 0 or source >= n or target >= n:
+            return path
+
+        var g_score = heap.must_alloc[float](n)
+        var came_from = heap.must_alloc[ptr_uint](n)
+        var i: ptr_uint = 0
+        while i < n:
+            unsafe:
+                g_score[i] = INF
+                came_from[i] = NIL_NODE
+            i += 1
+        unsafe:
+            g_score[source] = 0.0
+
+        var pq = heap_mod.BinaryHeap[HeapEntry].create()
+        pq.push(HeapEntry(node = source, dist = heuristic(source)))
+
+        while not pq.is_empty():
+            let entry = pq.pop() else:
+                break
+            let u = entry.node
+
+            if u == target:
+                var cur = target
+                while cur != source:
+                    path.push(cur)
+                    unsafe:
+                        cur = came_from[cur]
+                path.push(source)
+                var li: ptr_uint = 0
+                var lj = path.len()
+                if lj > 0:
+                    lj -= 1
+                while li < lj:
+                    let a_ptr = path.get(li) else:
+                        break
+                    let b_ptr = path.get(lj) else:
+                        break
+                    let tmp = unsafe: read(a_ptr)
+                    unsafe:
+                        read(a_ptr) = unsafe: read(b_ptr)
+                        read(b_ptr) = tmp
+                    li += 1
+                    lj -= 1
+                break
+
+            let cur_g = unsafe: g_score[u]
+
+            let start_ptr = this.offsets.get(u) else:
+                break
+            let end_ptr = this.offsets.get(u + 1) else:
+                break
+            let start = unsafe: read(start_ptr)
+            let end = unsafe: read(end_ptr)
+            var j = start
+            while j < end:
+                let t_ptr = this.targets.get(j) else:
+                    break
+                let w_ptr = this.weights.get(j) else:
+                    break
+                let v = unsafe: read(t_ptr)
+                let weight = unsafe: read(w_ptr)
+                let tentative_g = cur_g + weight
+
+                if tentative_g < unsafe: g_score[v]:
+                    unsafe:
+                        g_score[v] = tentative_g
+                        came_from[v] = u
+                    pq.push(HeapEntry(node = v, dist = tentative_g + heuristic(v)))
+                j += 1
+
+        pq.release()
+        heap.release(g_score)
+        heap.release(came_from)
+        return path
+
+
     public editable function release():
         this.nodes.release()
         this.offsets.release()
         this.targets.release()
         this.weights.release()
+
+
+extending ShortestPaths:
+    public function distance_to(node: ptr_uint) -> float:
+        let d_ptr = this.dist.get(node) else:
+            return INF
+        return unsafe: read(d_ptr)
+
+
+    public function has_path_to(node: ptr_uint) -> bool:
+        let d_ptr = this.dist.get(node) else:
+            return false
+        return unsafe: read(d_ptr) < INF
+
+
+    public function path_to(target: ptr_uint) -> vec.Vec[ptr_uint]:
+        var path = vec.Vec[ptr_uint].create()
+        if target >= this.dist.len():
+            return path
+
+        let d_ptr = this.dist.get(target) else:
+            return path
+        if unsafe: read(d_ptr) >= INF:
+            return path
+
+        var cur = target
+        path.push(cur)
+        let nil = NIL_NODE
+        while cur != nil:
+            let p_ptr = this.prev.get(cur) else:
+                break
+            cur = unsafe: read(p_ptr)
+            if cur == nil:
+                break
+            path.push(cur)
+
+        var i: ptr_uint = 0
+        var j = path.len()
+        if j > 0:
+            j -= 1
+        while i < j:
+            let a_ptr = path.get(i) else:
+                break
+            let b_ptr = path.get(j) else:
+                break
+            let tmp = unsafe: read(a_ptr)
+            unsafe:
+                read(a_ptr) = unsafe: read(b_ptr)
+                read(b_ptr) = tmp
+            i += 1
+            j -= 1
+
+        return path
+
+
+    public editable function release():
+        this.dist.release()
+        this.prev.release()

data/std/htn.mt

@@ -0,0 +1,254 @@
+## Hierarchical Task Network (HTN) planner.
+##
+## Total-order forward decomposition. Define a domain of operators
+## (primitive tasks) and methods (compound task decompositions),
+## then plan from a root task with an initial world state.
+##
+##   import std.htn as htn
+##   var planner = htn.HtnPlanner[World, Context].create()
+##   planner.add_operator(...)
+##   planner.add_method(...)
+##   var result = planner.plan(ref_of(ctx), world, "root_task")
+##   match result.plan:
+##       Option.some as p: execute(p.value)
+##       Option.none: handle failure
+
+import std.vec as vec
+
+
+public enum HtnStatus: ubyte
+    success = 0
+    failure = 1
+    max_depth = 2
+    max_iterations = 3
+
+
+public struct HtnOperator[World, Context]:
+    name: str
+    precondition: fn(context: ptr[Context], world: World) -> bool
+    effect: fn(context: ptr[Context], world: World) -> World
+
+
+public struct HtnMethod[World, Context]:
+    name: str
+    task: str
+    precondition: fn(context: ptr[Context], world: World) -> bool
+    subtasks: vec.Vec[str]
+
+
+public struct HtnDomain[World, Context]:
+    operators: vec.Vec[HtnOperator[World, Context]]
+    methods: vec.Vec[HtnMethod[World, Context]]
+
+
+public struct HtnPlanStep:
+    task_name: str
+
+
+public struct HtnPlan[World]:
+    steps: vec.Vec[HtnPlanStep]
+    final_world: World
+
+
+public struct HtnResult[World]:
+    status: HtnStatus
+    plan: Option[HtnPlan[World]]
+    iterations: ptr_uint
+    depth: ptr_uint
+
+
+public struct HtnPlanner[World, Context]:
+    domain: HtnDomain[World, Context]
+    max_depth: ptr_uint
+    max_iterations: ptr_uint
+
+
+# ── planner entry point ──
+
+function plan_task[World, Context](
+    planner: ref[HtnPlanner[World, Context]],
+    context: ptr[Context],
+    world: World,
+    task: str,
+    depth: ptr_uint,
+    iterations: ptr[ptr_uint],
+    reason: ptr[HtnStatus]
+) -> Option[HtnPlan[World]]:
+    unsafe:
+        read(iterations) += 1
+    if depth >= planner.max_depth:
+        unsafe:
+            if read(reason) != HtnStatus.max_iterations:
+                read(reason) = HtnStatus.max_depth
+        return Option[HtnPlan[World]].none
+    if unsafe: read(iterations) >= planner.max_iterations:
+        unsafe:
+            read(reason) = HtnStatus.max_iterations
+        return Option[HtnPlan[World]].none
+
+    # Try operators (primitive tasks)
+    for entry in planner.domain.operators:
+        unsafe:
+            let op = read(entry)
+            if op.name == task:
+                if op.precondition(context, world):
+                    var steps = vec.Vec[HtnPlanStep].create()
+                    steps.push(HtnPlanStep(task_name = task))
+                    let result_world = op.effect(context, world)
+                    return Option[HtnPlan[World]].some(value =
+                        HtnPlan[World](steps = steps, final_world = result_world)
+                    )
+
+    # Try methods (compound task decompositions)
+    for entry in planner.domain.methods:
+        unsafe:
+            let method = read(entry)
+            if method.task == task and method.precondition(context, world):
+                var current_world = world
+                var all_steps = vec.Vec[HtnPlanStep].create()
+                var success = true
+
+                for subtask_name_ptr in method.subtasks:
+                    let subtask_name = unsafe: read(subtask_name_ptr)
+                    let sub_plan = plan_task(planner, context, current_world, subtask_name, depth + 1, iterations, reason)
+                    match sub_plan:
+                        Option.none:
+                            success = false
+                            break
+                        Option.some as sub_payload:
+                            for step_ptr in sub_payload.value.steps:
+                                unsafe:
+                                    all_steps.push(read(step_ptr))
+                            current_world = sub_payload.value.final_world
+                            sub_payload.value.steps.release()
+
+                if success:
+                    return Option[HtnPlan[World]].some(value =
+                        HtnPlan[World](steps = all_steps, final_world = current_world)
+                    )
+
+                all_steps.release()
+
+    return Option[HtnPlan[World]].none
+
+
+# ── public types: extensions ──
+
+extending HtnOperator[World, Context]:
+    public static function create(
+        name: str,
+        precondition: fn(context: ptr[Context], world: World) -> bool,
+        effect: fn(context: ptr[Context], world: World) -> World
+    ) -> HtnOperator[World, Context]:
+        return HtnOperator[World, Context](
+            name = name,
+            precondition = precondition,
+            effect = effect
+        )
+
+
+extending HtnMethod[World, Context]:
+    public static function create(
+        name: str,
+        task: str,
+        precondition: fn(context: ptr[Context], world: World) -> bool
+    ) -> HtnMethod[World, Context]:
+        return HtnMethod[World, Context](
+            name = name,
+            task = task,
+            precondition = precondition,
+            subtasks = vec.Vec[str].create()
+        )
+
+
+    public editable function add_subtask(task_name: str) -> void:
+        this.subtasks.push(task_name)
+
+
+extending HtnPlan[World]:
+    public editable function release() -> void:
+        this.steps.release()
+
+
+    public function step_count() -> ptr_uint:
+        return this.steps.len()
+
+
+    public function step(index: ptr_uint) -> ptr[HtnPlanStep]?:
+        return this.steps.get(index)
+
+
+extending HtnResult[World]:
+    public editable function release() -> void:
+        match this.plan:
+            Option.none:
+                pass
+            Option.some as payload:
+                payload.value.release()
+        this.plan = Option[HtnPlan[World]].none
+
+
+    public function has_plan() -> bool:
+        match this.plan:
+            Option.none:
+                return false
+            Option.some:
+                return true
+
+
+extending HtnPlanner[World, Context]:
+    public static function create() -> HtnPlanner[World, Context]:
+        return HtnPlanner[World, Context](
+            domain = HtnDomain[World, Context](
+                operators = vec.Vec[HtnOperator[World, Context]].create(),
+                methods = vec.Vec[HtnMethod[World, Context]].create()
+            ),
+            max_depth = 32,
+            max_iterations = 4096
+        )
+
+
+    public editable function release() -> void:
+        this.domain.operators.release()
+        for entry in this.domain.methods:
+            unsafe:
+                read(entry).subtasks.release()
+        this.domain.methods.release()
+
+
+    public editable function add_operator(op: HtnOperator[World, Context]) -> void:
+        this.domain.operators.push(op)
+
+
+    public editable function add_method(method: HtnMethod[World, Context]) -> void:
+        this.domain.methods.push(method)
+
+
+    public editable function set_max_depth(limit: ptr_uint) -> void:
+        this.max_depth = limit
+
+
+    public editable function set_max_iterations(limit: ptr_uint) -> void:
+        this.max_iterations = limit
+
+
+    public editable function plan(context: ptr[Context], world: World, root_task: str) -> HtnResult[World]:
+        var iterations: ptr_uint = 0
+        var reason: HtnStatus = HtnStatus.failure
+        let res = plan_task(ref_of(this), context, world, root_task, 0, ptr_of(iterations), ptr_of(reason))
+
+        match res:
+            Option.none:
+                return HtnResult[World](
+                    status = reason,
+                    plan = Option[HtnPlan[World]].none,
+                    iterations = iterations,
+                    depth = 0
+                )
+            Option.some as payload:
+                return HtnResult[World](
+                    status = HtnStatus.success,
+                    plan = Option[HtnPlan[World]].some(value = payload.value),
+                    iterations = iterations,
+                    depth = 0
+                )

data/std/input.mt

@@ -0,0 +1,132 @@
+## Input action mapping — decouple logical actions from physical inputs.
+##
+## Define actions, bind keyboard/mouse/gamepad inputs, and
+## query the map each frame using your platform's input API.
+##
+##   import std.input as inp
+##   const ACTION_JUMP: ptr_uint = 0
+##   var map = inp.InputMap.create()
+##   map.bind_key(ACTION_JUMP, KEY_SPACE)
+##   map.bind_gamepad(ACTION_JUMP, 0, GAMEPAD_BUTTON_A)
+##   ...
+##   if map.check_digital(ACTION_JUMP, key_down, mouse_down, gamepad_down):
+##       do_jump()
+
+import std.vec as vec
+
+
+public enum InputKind: ubyte
+    key = 0
+    mouse_button = 1
+    gamepad_button = 2
+
+
+public struct InputBinding:
+    kind: InputKind
+    code: int
+    device_id: int
+
+
+public struct InputAction:
+    name: str
+    bindings: vec.Vec[InputBinding]
+
+
+public struct InputMap:
+    actions: vec.Vec[InputAction]
+
+
+# ── public API ──
+
+extending InputMap:
+    public static function create() -> InputMap:
+        return InputMap(actions = vec.Vec[InputAction].create())
+
+
+    public editable function add_action(name: str) -> ptr_uint:
+        let id = this.actions.len()
+        var action = InputAction(name = name, bindings = vec.Vec[InputBinding].create())
+        this.actions.push(action)
+        return id
+
+
+    public editable function bind_key(action_id: ptr_uint, keycode: int) -> void:
+        let action_ptr = this.actions.get(action_id) else:
+            return
+        unsafe:
+            read(action_ptr).bindings.push(
+                InputBinding(kind = InputKind.key, code = keycode, device_id = 0)
+            )
+
+
+    public editable function bind_mouse(action_id: ptr_uint, button: int) -> void:
+        let action_ptr = this.actions.get(action_id) else:
+            return
+        unsafe:
+            read(action_ptr).bindings.push(
+                InputBinding(kind = InputKind.mouse_button, code = button, device_id = 0)
+            )
+
+
+    public editable function bind_gamepad(action_id: ptr_uint, gamepad_id: int, button: int) -> void:
+        let action_ptr = this.actions.get(action_id) else:
+            return
+        unsafe:
+            read(action_ptr).bindings.push(
+                InputBinding(kind = InputKind.gamepad_button, code = button, device_id = gamepad_id)
+            )
+
+
+    public function action_count() -> ptr_uint:
+        return this.actions.len()
+
+
+    public function action_name(action_id: ptr_uint) -> str:
+        let action_ptr = this.actions.get(action_id) else:
+            return ""
+        unsafe:
+            return read(action_ptr).name
+
+
+    public function check_digital(
+        action_id: ptr_uint,
+        key_down: fn(code: int) -> bool,
+        mouse_down: fn(button: int) -> bool,
+        gamepad_down: fn(device: int, button: int) -> bool
+    ) -> bool:
+        let action_ptr = this.actions.get(action_id) else:
+            return false
+        unsafe:
+            let action = read(action_ptr)
+            for entry in action.bindings:
+                let binding = read(entry)
+                if binding.kind == InputKind.key and key_down(binding.code):
+                    return true
+                if binding.kind == InputKind.mouse_button and mouse_down(binding.code):
+                    return true
+                if binding.kind == InputKind.gamepad_button and gamepad_down(binding.device_id, binding.code):
+                    return true
+        return false
+
+
+    public function binding_count(action_id: ptr_uint) -> ptr_uint:
+        let action_ptr = this.actions.get(action_id) else:
+            return 0
+        unsafe:
+            return read(action_ptr).bindings.len()
+
+
+    public function binding_at(action_id: ptr_uint, index: ptr_uint) -> Option[InputBinding]:
+        let action_ptr = this.actions.get(action_id) else:
+            return Option[InputBinding].none
+        unsafe:
+            let b_ptr = read(action_ptr).bindings.get(index) else:
+                return Option[InputBinding].none
+            return Option[InputBinding].some(value = read(b_ptr))
+
+
+    public editable function release() -> void:
+        for entry in this.actions:
+            unsafe:
+                read(entry).bindings.release()
+        this.actions.release()