mt-lang 0.2.0 → 0.2.1

data/std/behavior_tree.mt

@@ -0,0 +1,396 @@
+import std.vec as vec
+
+public enum Status: ubyte
+    success = 0
+    failure = 1
+    running = 2
+
+public enum NodeKind: ubyte
+    sequence = 0
+    selector = 1
+    parallel_all = 2
+    parallel_any = 3
+    condition = 4
+    action = 5
+    inverter = 6
+    succeeder = 7
+    failer = 8
+    repeater = 9
+    until_success = 10
+    until_failure = 11
+
+struct RuntimeState:
+    active_child: ptr_uint
+    repeat_count: ptr_uint
+
+public struct Node[Context]:
+    kind: NodeKind
+    condition_fn: fn(context: ptr[Context]) -> bool
+    action_fn: fn(context: ptr[Context]) -> Status
+    repeat_limit: ptr_uint
+    children: vec.Vec[ptr_uint]
+
+public struct Tree[Context]:
+    nodes: vec.Vec[Node[Context]]
+    runtime: vec.Vec[RuntimeState]
+    root: ptr_uint
+    has_root: bool
+
+
+function default_condition[Context](_context: ptr[Context]) -> bool:
+    return false
+
+
+function default_action[Context](_context: ptr[Context]) -> Status:
+    return Status.failure
+
+
+function create_runtime_state() -> RuntimeState:
+    return RuntimeState(active_child = 0, repeat_count = 0)
+
+
+function child_exists[Context](tree: ref[Tree[Context]], node_id: ptr_uint) -> bool:
+    return node_id < tree.nodes.len()
+
+
+function reset_runtime_state(runtime: ptr[RuntimeState]) -> void:
+    unsafe:
+        read(runtime).active_child = 0
+        read(runtime).repeat_count = 0
+
+
+function tick_node[Context](tree: ref[Tree[Context]], node_id: ptr_uint, context: ref[Context]) -> Status:
+    let node_ptr = tree.nodes.get(node_id) else:
+        return Status.failure
+
+    let runtime_ptr = tree.runtime.get(node_id) else:
+        return Status.failure
+
+    unsafe:
+        let node = ptr[Node[Context]]<-node_ptr
+        let runtime = ptr[RuntimeState]<-runtime_ptr
+        match read(node).kind:
+            NodeKind.sequence:
+                if read(node).children.is_empty():
+                    reset_runtime_state(runtime)
+                    return Status.success
+
+                var child_index = read(runtime).active_child
+                while child_index < read(node).children.len():
+                    let child_ptr = read(node).children.get(child_index) else:
+                        reset_runtime_state(runtime)
+                        return Status.failure
+
+                    let child_status = tick_node(tree, read(child_ptr), context)
+                    match child_status:
+                        Status.success:
+                            child_index += 1
+                            continue
+                        Status.failure:
+                            reset_runtime_state(runtime)
+                            return Status.failure
+                        Status.running:
+                            read(runtime).active_child = child_index
+                            return Status.running
+
+                reset_runtime_state(runtime)
+                return Status.success
+
+            NodeKind.selector:
+                if read(node).children.is_empty():
+                    reset_runtime_state(runtime)
+                    return Status.failure
+
+                var child_index = read(runtime).active_child
+                while child_index < read(node).children.len():
+                    let child_ptr = read(node).children.get(child_index) else:
+                        reset_runtime_state(runtime)
+                        return Status.failure
+
+                    let child_status = tick_node(tree, read(child_ptr), context)
+                    match child_status:
+                        Status.success:
+                            reset_runtime_state(runtime)
+                            return Status.success
+                        Status.failure:
+                            child_index += 1
+                            continue
+                        Status.running:
+                            read(runtime).active_child = child_index
+                            return Status.running
+
+                reset_runtime_state(runtime)
+                return Status.failure
+
+            NodeKind.parallel_all:
+                if read(node).children.is_empty():
+                    return Status.failure
+
+                var saw_running = false
+                for child_ptr in read(node).children:
+                    let child_status = tick_node(tree, unsafe: read(child_ptr), context)
+                    match child_status:
+                        Status.success:
+                            pass
+                        Status.failure:
+                            return Status.failure
+                        Status.running:
+                            saw_running = true
+
+                if saw_running:
+                    return Status.running
+
+                return Status.success
+
+            NodeKind.parallel_any:
+                if read(node).children.is_empty():
+                    return Status.failure
+
+                var saw_running = false
+                for child_ptr in read(node).children:
+                    let child_status = tick_node(tree, unsafe: read(child_ptr), context)
+                    match child_status:
+                        Status.success:
+                            return Status.success
+                        Status.failure:
+                            pass
+                        Status.running:
+                            saw_running = true
+
+                if saw_running:
+                    return Status.running
+
+                return Status.failure
+
+            NodeKind.condition:
+                if read(node).condition_fn(ptr_of(context)):
+                    return Status.success
+
+                return Status.failure
+
+            NodeKind.action:
+                return read(node).action_fn(ptr_of(context))
+
+            NodeKind.inverter:
+                let child_ptr = read(node).children.first() else:
+                    return Status.failure
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                match child_status:
+                    Status.success:
+                        return Status.failure
+                    Status.failure:
+                        return Status.success
+                    Status.running:
+                        return Status.running
+
+            NodeKind.succeeder:
+                let child_ptr = read(node).children.first() else:
+                    return Status.success
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                if child_status == Status.running:
+                    return Status.running
+
+                return Status.success
+
+            NodeKind.failer:
+                let child_ptr = read(node).children.first() else:
+                    return Status.failure
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                if child_status == Status.running:
+                    return Status.running
+
+                return Status.failure
+
+            NodeKind.repeater:
+                let child_ptr = read(node).children.first() else:
+                    return Status.failure
+
+                if read(node).repeat_limit == 0:
+                    return Status.success
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                match child_status:
+                    Status.success:
+                        read(runtime).repeat_count += 1
+                        if read(runtime).repeat_count >= read(node).repeat_limit:
+                            reset_runtime_state(runtime)
+                            return Status.success
+                        return Status.running
+                    Status.failure:
+                        reset_runtime_state(runtime)
+                        return Status.failure
+                    Status.running:
+                        return Status.running
+
+            NodeKind.until_success:
+                let child_ptr = read(node).children.first() else:
+                    return Status.failure
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                match child_status:
+                    Status.success:
+                        return Status.success
+                    Status.failure:
+                        return Status.running
+                    Status.running:
+                        return Status.running
+
+            NodeKind.until_failure:
+                let child_ptr = read(node).children.first() else:
+                    return Status.failure
+
+                let child_status = tick_node(tree, read(child_ptr), context)
+                match child_status:
+                    Status.success:
+                        return Status.running
+                    Status.failure:
+                        return Status.success
+                    Status.running:
+                        return Status.running
+
+    return Status.failure
+
+
+extending Node[Context]:
+    static function create(kind: NodeKind) -> Node[Context]:
+        return Node[Context](
+            kind = kind,
+            condition_fn = default_condition[Context],
+            action_fn = default_action[Context],
+            repeat_limit = 0,
+            children = vec.Vec[ptr_uint].create()
+        )
+
+
+    public static function sequence() -> Node[Context]:
+        return Node[Context].create(NodeKind.sequence)
+
+
+    public static function selector() -> Node[Context]:
+        return Node[Context].create(NodeKind.selector)
+
+
+    public static function parallel_all() -> Node[Context]:
+        return Node[Context].create(NodeKind.parallel_all)
+
+
+    public static function parallel_any() -> Node[Context]:
+        return Node[Context].create(NodeKind.parallel_any)
+
+
+    public static function condition(check: fn(context: ptr[Context]) -> bool) -> Node[Context]:
+        var result = Node[Context].create(NodeKind.condition)
+        result.condition_fn = check
+        return result
+
+
+    public static function action(run: fn(context: ptr[Context]) -> Status) -> Node[Context]:
+        var result = Node[Context].create(NodeKind.action)
+        result.action_fn = run
+        return result
+
+
+    public static function inverter() -> Node[Context]:
+        return Node[Context].create(NodeKind.inverter)
+
+
+    public static function succeeder() -> Node[Context]:
+        return Node[Context].create(NodeKind.succeeder)
+
+
+    public static function failer() -> Node[Context]:
+        return Node[Context].create(NodeKind.failer)
+
+
+    public static function repeater(limit: ptr_uint) -> Node[Context]:
+        var result = Node[Context].create(NodeKind.repeater)
+        result.repeat_limit = limit
+        return result
+
+
+    public static function until_success() -> Node[Context]:
+        return Node[Context].create(NodeKind.until_success)
+
+
+    public static function until_failure() -> Node[Context]:
+        return Node[Context].create(NodeKind.until_failure)
+
+
+    public editable function release() -> void:
+        this.children.release()
+
+
+extending Tree[Context]:
+    public static function create() -> Tree[Context]:
+        return Tree[Context](
+            nodes = vec.Vec[Node[Context]].create(),
+            runtime = vec.Vec[RuntimeState].create(),
+            root = 0,
+            has_root = false
+        )
+
+
+    public editable function release() -> void:
+        for node_ptr in this.nodes:
+            unsafe:
+                read(node_ptr).release()
+        this.nodes.release()
+        this.runtime.release()
+        this.root = 0
+        this.has_root = false
+
+
+    public editable function reset() -> void:
+        for entry in this.runtime:
+            reset_runtime_state(unsafe: ptr[RuntimeState]<-entry)
+
+
+    public function node_count() -> ptr_uint:
+        return this.nodes.len()
+
+
+    public function root_node() -> Option[ptr_uint]:
+        if not this.has_root:
+            return Option[ptr_uint].none
+
+        return Option[ptr_uint].some(value = this.root)
+
+
+    public editable function add_node(node: Node[Context]) -> ptr_uint:
+        let node_id = this.nodes.len()
+        this.nodes.push(node)
+        this.runtime.push(create_runtime_state())
+        return node_id
+
+
+    public editable function set_root(node_id: ptr_uint) -> bool:
+        if not child_exists(ref_of(this), node_id):
+            return false
+
+        this.root = node_id
+        this.has_root = true
+        return true
+
+
+    public editable function add_child(parent_id: ptr_uint, child_id: ptr_uint) -> bool:
+        if not child_exists(ref_of(this), parent_id):
+            return false
+        if not child_exists(ref_of(this), child_id):
+            return false
+
+        let parent_ptr = this.nodes.get(parent_id) else:
+            return false
+
+        unsafe:
+            read(parent_ptr).children.push(child_id)
+        return true
+
+
+    public editable function tick(context: ref[Context]) -> Status:
+        if not this.has_root:
+            return Status.failure
+
+        return tick_node(ref_of(this), this.root, context)

data/std/binary.mt

@@ -0,0 +1,314 @@
+import std.bytes as bytes
+import std.str as text
+import std.string as string
+import std.vec as vec
+
+public struct Error:
+    code: int
+    message: string.String
+
+public struct Writer:
+    buffer: vec.Vec[ubyte]
+
+public struct Reader:
+    data: span[ubyte]
+    position: ptr_uint
+
+
+function binary_error(code: int, message: str) -> Error:
+    return Error(code = code, message = string.String.from_str(message))
+
+
+function writer_append_byte(writer: ref[Writer], value: ubyte) -> void:
+    writer.buffer.push(value)
+
+
+function writer_append_span(writer: ref[Writer], data: span[ubyte]) -> void:
+    writer.buffer.append_span(data)
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending Writer:
+    public static function create() -> Writer:
+        return Writer(buffer = vec.Vec[ubyte].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Writer:
+        return Writer(buffer = vec.Vec[ubyte].with_capacity(capacity))
+
+
+    public editable function write_ubyte(value: ubyte) -> void:
+        writer_append_byte(ref_of(this), value)
+
+
+    public editable function write_ushort(value: ushort) -> void:
+        writer_append_byte(ref_of(this), ubyte<-(value & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 8) & 0xFF))
+
+
+    public editable function write_uint(value: uint) -> void:
+        writer_append_byte(ref_of(this), ubyte<-(value & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 8) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 16) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 24) & 0xFF))
+
+
+    public editable function write_ulong(value: ulong) -> void:
+        writer_append_byte(ref_of(this), ubyte<-(value & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 8) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 16) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 24) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 32) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 40) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 48) & 0xFF))
+        writer_append_byte(ref_of(this), ubyte<-((value >> 56) & 0xFF))
+
+
+    public editable function write_byte(value: byte) -> void:
+        writer_append_byte(ref_of(this), ubyte<-value)
+
+
+    public editable function write_short(value: short) -> void:
+        this.write_ushort(ushort<-value)
+
+
+    public editable function write_int(value: int) -> void:
+        this.write_uint(uint<-value)
+
+
+    public editable function write_long(value: long) -> void:
+        this.write_ulong(ulong<-value)
+
+
+    public editable function write_float(value: float) -> void:
+        let bits = unsafe: reinterpret[uint](value)
+        this.write_uint(bits)
+
+
+    public editable function write_double(value: double) -> void:
+        let bits = unsafe: reinterpret[ulong](value)
+        this.write_ulong(bits)
+
+
+    public editable function write_bool(value: bool) -> void:
+        if value:
+            writer_append_byte(ref_of(this), 1)
+        else:
+            writer_append_byte(ref_of(this), 0)
+
+
+    public editable function write_bytes(data: span[ubyte]) -> void:
+        writer_append_span(ref_of(this), data)
+
+
+    public editable function write_str(value: str) -> void:
+        this.write_uint(uint<-value.len)
+        if value.len > 0:
+            writer_append_span(ref_of(this), text.as_byte_span(value))
+
+
+    public editable function write_uint_at(position: ptr_uint, value: uint) -> void:
+        let buffer_span = this.buffer.as_span()
+        if position + 4 > buffer_span.len:
+            fatal(c"binary.write_u32_at position out of bounds")
+        unsafe:
+            read(buffer_span.data + position) = ubyte<-(value & 0xFF)
+            read(buffer_span.data + position + 1) = ubyte<-((value >> 8) & 0xFF)
+            read(buffer_span.data + position + 2) = ubyte<-((value >> 16) & 0xFF)
+            read(buffer_span.data + position + 3) = ubyte<-((value >> 24) & 0xFF)
+
+
+    public function len() -> ptr_uint:
+        return this.buffer.len()
+
+
+    public function as_span() -> span[ubyte]:
+        return this.buffer.as_span()
+
+
+    public editable function finish() -> bytes.Bytes:
+        let result = bytes.Bytes.copy(this.buffer.as_span())
+        this.buffer.release()
+        return result
+
+
+    public editable function reset() -> void:
+        this.buffer.clear()
+
+
+    public editable function release() -> void:
+        this.buffer.release()
+
+
+public function reader(data: span[ubyte]) -> Reader:
+    return Reader(data = data, position = 0)
+
+
+public function reader_from_bytes(data: bytes.Bytes) -> Reader:
+    return Reader(data = data.as_span(), position = 0)
+
+
+function reader_check_remaining(reader: ref[Reader], count: ptr_uint) -> Result[bool, Error]:
+    if reader.position > reader.data.len:
+        return Result[bool, Error].failure(error = binary_error(-1, "binary reader position overflow"))
+    if reader.data.len - reader.position < count:
+        return Result[bool, Error].failure(error = binary_error(-1, "binary reader unexpected end of buffer"))
+    return Result[bool, Error].success(value = true)
+
+
+function reader_read_byte(reader: ref[Reader]) -> Result[ubyte, Error]:
+    reader_check_remaining(reader, 1)?
+    let value = unsafe: read(reader.data.data + reader.position)
+    reader.position += 1
+    return Result[ubyte, Error].success(value = value)
+
+
+extending Reader:
+    public editable function read_ubyte() -> Result[ubyte, Error]:
+        return reader_read_byte(ref_of(this))
+
+
+    public editable function read_ushort() -> Result[ushort, Error]:
+        reader_check_remaining(ref_of(this), 2)?
+        let low = ushort<-unsafe: read(this.data.data + this.position)
+        let high = ushort<-unsafe: read(this.data.data + this.position + 1)
+        this.position += 2
+        return Result[ushort, Error].success(value = (high << 8) | low)
+
+
+    public editable function read_uint() -> Result[uint, Error]:
+        reader_check_remaining(ref_of(this), 4)?
+        var value: uint = 0
+        unsafe:
+            let b0 = uint<-read(this.data.data + this.position)
+            let b1 = uint<-read(this.data.data + this.position + 1)
+            let b2 = uint<-read(this.data.data + this.position + 2)
+            let b3 = uint<-read(this.data.data + this.position + 3)
+            value = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)
+        this.position += 4
+        return Result[uint, Error].success(value = value)
+
+
+    public editable function read_ulong() -> Result[ulong, Error]:
+        reader_check_remaining(ref_of(this), 8)?
+        var value: ulong = 0
+        unsafe:
+            let b0 = ulong<-read(this.data.data + this.position)
+            let b1 = ulong<-read(this.data.data + this.position + 1)
+            let b2 = ulong<-read(this.data.data + this.position + 2)
+            let b3 = ulong<-read(this.data.data + this.position + 3)
+            let b4 = ulong<-read(this.data.data + this.position + 4)
+            let b5 = ulong<-read(this.data.data + this.position + 5)
+            let b6 = ulong<-read(this.data.data + this.position + 6)
+            let b7 = ulong<-read(this.data.data + this.position + 7)
+            value = (
+                b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)
+                | (b4 << 32) | (b5 << 40) | (b6 << 48) | (b7 << 56)
+            )
+        this.position += 8
+        return Result[ulong, Error].success(value = value)
+
+
+    public editable function read_byte() -> Result[byte, Error]:
+        let value = this.read_ubyte()?
+        return Result[byte, Error].success(value = byte<-value)
+
+
+    public editable function read_short() -> Result[short, Error]:
+        let value = this.read_ushort()?
+        return Result[short, Error].success(value = short<-value)
+
+
+    public editable function read_int() -> Result[int, Error]:
+        let value = this.read_uint()?
+        return Result[int, Error].success(value = int<-value)
+
+
+    public editable function read_long() -> Result[long, Error]:
+        let value = this.read_ulong()?
+        return Result[long, Error].success(value = long<-value)
+
+
+    public editable function read_float() -> Result[float, Error]:
+        let value = this.read_uint()?
+        return Result[float, Error].success(value = unsafe: reinterpret[float](value))
+
+
+    public editable function read_double() -> Result[double, Error]:
+        let value = this.read_ulong()?
+        return Result[double, Error].success(value = unsafe: reinterpret[double](value))
+
+
+    public editable function read_bool() -> Result[bool, Error]:
+        let value = this.read_ubyte()?
+        if value == 0:
+            return Result[bool, Error].success(value = false)
+        if value == 1:
+            return Result[bool, Error].success(value = true)
+        return Result[bool, Error].failure(error = binary_error(-2, "binary reader invalid bool value"))
+
+
+    public editable function read_bytes(count: ptr_uint) -> Result[bytes.Bytes, Error]:
+        if count == 0:
+            return Result[bytes.Bytes, Error].success(value = bytes.Bytes.empty())
+
+        reader_check_remaining(ref_of(this), count)?
+        unsafe:
+            let result = bytes.Bytes.copy(span[ubyte](
+                data = this.data.data + this.position,
+                len = count
+            ))
+            this.position += count
+            return Result[bytes.Bytes, Error].success(value = result)
+
+
+    public editable function read_span(count: ptr_uint) -> Result[span[ubyte], Error]:
+        if count == 0:
+            let empty = unsafe: span[ubyte](data = this.data.data, len = 0)
+            return Result[span[ubyte], Error].success(value = empty)
+
+        reader_check_remaining(ref_of(this), count)?
+        unsafe:
+            let result = span[ubyte](data = this.data.data + this.position, len = count)
+            this.position += count
+            return Result[span[ubyte], Error].success(value = result)
+
+
+    public editable function read_str() -> Result[string.String, Error]:
+        let length = ptr_uint<-this.read_uint()?
+        if length == 0:
+            return Result[string.String, Error].success(value = string.String.create())
+
+        var data = this.read_bytes(length)?
+        let str_opt = text.utf8_byte_span_as_str(data.as_span())
+        match str_opt:
+            Option.none:
+                data.release()
+                return Result[string.String, Error].failure(error = binary_error(
+                    -2,
+                    "binary reader invalid UTF-8 string"
+                ))
+            Option.some as str_payload:
+                let result = string.String.from_str(str_payload.value)
+                data.release()
+                return Result[string.String, Error].success(value = result)
+
+
+    public editable function skip(count: ptr_uint) -> Result[bool, Error]:
+        reader_check_remaining(ref_of(this), count)?
+        this.position += count
+        return Result[bool, Error].success(value = true)
+
+
+    public function remaining() -> ptr_uint:
+        if this.position >= this.data.len:
+            return 0
+        return this.data.len - this.position
+
+
+    public function has_more() -> bool:
+        return this.position < this.data.len