tfbscript 0.1.0__py3-none-any.whl

tfbscript/opcodes/op_displace.py

@@ -0,0 +1,111 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import func_call
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import CombineMode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("displace")
+@dataclass
+class OpDisplace(Opcode):
+    target: Reference = field(default_factory=Reference)
+    combine_mode: CombineMode = field(default=CombineMode.relative)
+
+    length: Rhs = field(default_factory=Rhs)
+    heading: Rhs = field(default_factory=Rhs)
+    pitch: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpDisplace":
+        target = reader.readRef()  # the object being displaced
+        combine_mode = CombineMode(
+            reader.read_u8()
+        )  # TODO : May actually be a SetDirection
+
+        length = reader.readRHS()
+        heading = reader.readRHS()
+        pitch = reader.readRHS()
+
+        return cls(
+            target=target,
+            combine_mode=combine_mode,
+            length=length,
+            heading=heading,
+            pitch=pitch,
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target.write(f)
+        write_u8(f, self.combine_mode)
+        self.length.write(f)
+        self.heading.write(f)
+        self.pitch.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{self.target}." + func_call(
+            "displace",
+            str(self.combine_mode),
+            "length: " + str(self.length),
+            "heading: " + str(self.heading),
+            "pitch: " + str(self.pitch),
+        )
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "displace",
+                },
+                {
+                    "type": "ref",
+                    "name": "clone_ref",
+                    "ref": self.target,
+                },
+                {
+                    "type": "enum",
+                    "name": "combine_mode",
+                    "entry": self.combine_mode,
+                },
+                {
+                    "type": "label",
+                    "content": "LENGTH:",
+                },
+                {
+                    "type": "rhs",
+                    "name": "length",
+                    "rhs": self.length,
+                },
+                {
+                    "type": "label",
+                    "content": "feet HEADING:",
+                },
+                {
+                    "type": "rhs",
+                    "name": "length",
+                    "rhs": self.heading,
+                },
+                {
+                    "type": "label",
+                    "content": "degrees PITCH:",
+                },
+                {
+                    "type": "rhs",
+                    "name": "length",
+                    "rhs": self.pitch,
+                },
+                {
+                    "type": "label",
+                    "content": "degrees",
+                },
+            ]
+        }

tfbscript/opcodes/op_find_subset.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import (
+    comparison,
+    func_call,
+    variable,
+)
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import RelOp
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("find subset")
+@dataclass
+class OpFindSubset(Opcode):
+    """Filters a set by a condition; yields the subset of items that match."""
+
+    set_ref: Reference = field(default_factory=Reference)
+    rel_op: RelOp = RelOp.Eq
+    rhs: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpFindSubset":
+        set_ref = reader.readRef()
+        rel_op = RelOp(reader.read_u8())
+        rhs = reader.readRHS()
+        return cls(set_ref=set_ref, rel_op=rel_op, rhs=rhs)
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.set_ref.write(f)
+        write_u8(f, self.rel_op)
+        self.rhs.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        # Rendered as: set.filter(val <op> rhs )
+        val = variable("val")
+        lambda_src = (
+            f"{val} {comparison(self.rel_op.symbol())} {self.rhs}"
+        )
+        set_ref_str = str(self.set_ref)
+
+        return f"{set_ref_str}.{func_call('filter', lambda_src)}"

tfbscript/opcodes/op_find_variable.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import keyword
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("find variable")
+@dataclass
+class OpFindVariable(Opcode):
+    var_ref: Reference = field(default_factory=Reference)
+    owner_ref: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpFindVariable":
+        return cls(var_ref=reader.readRef(), owner_ref=reader.readRef())
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{keyword('find variable (')} {self.var_ref} in {self.owner_ref} {keyword(')')}"
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.var_ref.write(f)
+        self.owner_ref.write(f)

tfbscript/opcodes/op_for_each.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import keyword
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import SetDirection
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode(
+    "for each",
+    "Loops over a set in the order of set_direction, stores the current element in [^each]",
+)
+@dataclass
+class OpForEach(Opcode):
+    set_ref: Reference = field(default_factory=Reference)
+    set_direction: SetDirection = field(default=SetDirection.forward)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpForEach":
+        return cls(
+            set_ref=reader.readRef(),
+            set_direction=SetDirection(reader.read_u8()),
+        )
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{keyword('for each [~each] in ')} {self.set_ref} {keyword('')}"
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.set_ref.write(f)
+        write_u8(f, self.set_direction)
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "for each",
+                },
+                {
+                    "type": "label",
+                    "content": "in",
+                },
+                {
+                    "type": "ref",
+                    "name": "set_ref",
+                    "ref": self.set_ref,
+                },
+                {
+                    "type": "label",
+                    "content": "moving",
+                },
+                {
+                    "type": "enum",
+                    "name": "set_direction",
+                    "entry": self.set_direction,
+                },
+            ]
+        }

tfbscript/opcodes/op_if_else.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import flow_control, keyword
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+
+
+@opcode("if/else")
+@dataclass
+class OpIfElse(Opcode):
+    # No payload of its own. The first child is the condition opcode; the
+    # condition's own children are the "then" branch, and any remaining
+    # children of the if/else are the "else" branch.
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpIfElse":
+        return cls()
+
+    @override
+    def print_tree(self, indent: int = 0, chained: bool = False) -> None:
+        if not self.children:
+            return
+
+        pad = "    " * indent
+        condition = self.children[0]
+
+        keyword_str = "} else if (" if chained else "if ("
+
+        print(
+            f"{pad}{keyword(keyword_str)} {condition.source_line(inline=True)} {keyword(') {')}"
+        )
+
+        context = self.context
+        if context is not None:
+            context.open_opcodes.append(self)
+        try:
+            if context is not None:
+                context.open_opcodes.append(condition)
+            try:
+                for then_child in condition.children:
+                    then_child.print_tree(indent + 1)
+            finally:
+                if context is not None:
+                    context.open_opcodes.pop()
+
+            print(
+                f"{'    ' * (indent + 1)}{keyword('flow ')}{flow_control(self.flags.flow_control_str())}"
+            )
+
+            else_children = self.children[1:]
+
+            # None
+            if not else_children:
+                print(pad + keyword("}"))
+            # ELSE IF
+            elif len(else_children) == 1 and isinstance(else_children[0], OpIfElse):
+                fist_child = else_children[0]
+                fist_child.print_tree(indent, chained=True)  # type: ignore
+            # ELSE
+            else:
+                print(pad + keyword("} else {"))
+                for else_child in else_children:
+                    else_child.print_tree(indent + 1)
+
+                print(
+                    f"{'    ' * (indent + 1)}{keyword('flow ')}{flow_control(self.flags.flow_control_str())}"
+                )
+
+                print(pad + keyword("}"))
+        finally:
+            if context is not None:
+                context.open_opcodes.pop()
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        # The row is the condition itself; its body is the "true" branch and
+        # the remaining children are the "else" branch.
+        if not self.children:
+            return {"fields": [{"type": "op-label", "value": "if/else"}]}
+
+        condition = self.children[0]
+        else_children = self.children[1:]
+
+        groups: list[dict[str, Any]] = [
+            {
+                "label": "true",
+                "children": condition.children,
+                "scope": [condition],
+            }
+        ]
+
+        if else_children:
+            groups.append({"label": "else", "children": else_children})
+
+        return {
+            "row": condition,
+            "groups": groups,
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        # If/Else has no payload
+        pass

tfbscript/opcodes/op_inc_value.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import operator
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("inc value")
+@dataclass
+class OpIncValue(Opcode):
+    lhs: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpIncValue":
+        return cls(lhs=reader.readRef())
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{self.lhs} {operator('++')};"
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "hasBody": False,
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "increment value",
+                },
+                {
+                    "type": "ref",
+                    "name": "lhs",
+                    "ref": self.lhs,
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.lhs.write(f)

tfbscript/opcodes/op_loop_value.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import keyword
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.rhs import Rhs
+
+
+@opcode("loop value", "Loops X amount of times, stores the current index in [^each]")
+@dataclass
+class OpLoopValue(Opcode):
+    loop_amount: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpLoopValue":
+        return cls(
+            loop_amount=reader.readRHS(),
+        )
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{keyword('loop value (')} {self.loop_amount} {keyword(')')}"
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.loop_amount.write(f)

tfbscript/opcodes/op_move_from.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import func_call
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import AnimationMapping
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("move from")
+@dataclass
+class OpMoveFrom(Opcode):
+    target_ref: Reference = field(default_factory=Reference)
+    with_anim: AnimationMapping = field(default=AnimationMapping.ambient)
+    until_beyond: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpMoveFrom":
+        return cls(
+            target_ref=reader.readRef(),
+            with_anim=AnimationMapping(reader.read_u8()),
+            until_beyond=reader.readRHS(),
+        )
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        base = func_call(
+            "moveFrom",
+            str(self.target_ref),
+            f"animation: {self.with_anim}",
+            f"until_beyond: {self.until_beyond}",
+            add_semicolon=not self.children,
+        )
+
+        if self.children:
+            return f"when {base} is done, do:"
+        return base
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target_ref.write(f)
+        write_u8(f, self.with_anim)
+        self.until_beyond.write(f)

tfbscript/opcodes/op_move_to.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import func_call
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import AnimationMapping, SetDirection
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("move to")
+@dataclass
+class OpMoveTo(Opcode):
+    target_ref: Reference = field(default_factory=Reference)
+    set_direction: SetDirection = field(default=SetDirection.forward)
+    with_anim: AnimationMapping = field(default=AnimationMapping.ambient)
+    until_within: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpMoveTo":
+        return cls(
+            target_ref=reader.readRef(),
+            set_direction=SetDirection(reader.read_u8()),
+            with_anim=AnimationMapping(reader.read_u8()),
+            until_within=reader.readRHS(),
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target_ref.write(f)
+        write_u8(f, self.set_direction)
+        write_u8(f, self.with_anim)
+        self.until_within.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        base = func_call(
+            "moveTo",
+            str(self.target_ref),
+            f"set_dir: {self.set_direction}",
+            f"animation: {self.with_anim}",
+            f"until_within: {self.until_within}",
+            add_semicolon=not self.children,
+        )
+
+        if self.children:
+            return f"when {base} is done, do:"
+        return base
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "hasBody": True,
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "move to",
+                },
+                {
+                    "type": "ref",
+                    "name": "target_ref",
+                    "ref": self.target_ref,
+                },
+                {
+                    "type": "op-label",
+                    "value": "set direction: ",
+                },
+                {
+                    "type": "enum",
+                    "name": "set_direction",
+                    "entry": self.set_direction,
+                },
+                {
+                    "type": "op-label",
+                    "value": "with animation: ",
+                },
+                {
+                    "type": "enum",
+                    "name": "with_anim",
+                    "entry": self.with_anim,
+                },
+                {
+                    "type": "op-label",
+                    "value": "until within: ",
+                },
+                {
+                    "type": "rhs",
+                    "name": "until_within",
+                    "rhs": self.until_within,
+                },
+                {
+                    "type": "op-label",
+                    "value": "ft",
+                },
+            ],
+        }

tfbscript/opcodes/op_play_animation.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import func_call, method, parentheses
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import AnimationMapping
+from tfbscript.payload import PayloadReader
+
+
+@opcode("play animation")
+@dataclass
+class OpPlayAnimation(Opcode):
+    animation: AnimationMapping = field(default=AnimationMapping.ambient)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpPlayAnimation":
+        return cls(animation=AnimationMapping(reader.read_u8()))
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        if self.children:
+            return f"when {method('playAnimation')}{parentheses('(')}{self.animation!s}{parentheses(')')} is done playing, do:"
+        return func_call("playAnimation", str(self.animation))
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "hasBody": False,
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "play animation",
+                },
+                {
+                    "type": "enum",
+                    "name": "animation",
+                    "entry": self.animation,
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        write_u8(f, self.animation)

tfbscript/opcodes/op_play_sound.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import method, parentheses
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("play sound")
+@dataclass
+class OpPlaySound(Opcode):
+    sound: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpPlaySound":
+        return cls(sound=reader.readRef())
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.sound.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{self.sound}.{method('play')}{parentheses('()')};"
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "play sound",
+                },
+                {
+                    "type": "ref",
+                    "name": "sound",
+                    "ref": self.sound,
+                },
+            ]
+        }

tfbscript/opcodes/op_prescript.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Any, BinaryIO, override
+
+from tfbscript.opcodes.block import BlockOpcode
+
+
+@dataclass
+class OpPrescript(BlockOpcode):
+    @override
+    def block_name(self) -> str:
+        return "PRESCRIPT"
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        pass # Prescript has no payload
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "block-label",
+                    "value": "PRESCRIPT",
+                },
+            ]
+        }