tfbscript 0.1.0__py3-none-any.whl

tfbscript/opcodes/op_print.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from typing import Any, BinaryIO, override
+
+from tfbscript.ansi import func_call, quoted_string
+from tfbscript.binary import write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("print")
+@dataclass
+class OpPrint(Opcode):
+    target: Reference = field(default_factory=Reference)
+    content: str = ""
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpPrint":
+        target = reader.readRef()
+        content = reader.read_string(reader.read_u8())
+        return cls(target=target, content=content)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call("print", str(self.target), quoted_string(self.content))
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "print",
+                },
+                {
+                    "type": "ref",
+                    "name": "target",
+                    "ref": self.target,
+                },
+                {
+                    "type": "string",
+                    "name": "content",
+                    "value": self.content,
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target.write(f)
+        write_u8(f, len(self.content))
+        f.write(self.content.encode("latin1"))

tfbscript/opcodes/op_remove.py

@@ -0,0 +1,43 @@
+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("remove")
+@dataclass
+class OpRemove(Opcode):
+    target: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpRemove":
+        return cls(target=reader.readRef())
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{self.target}.{method('remove')}{parentheses('()')};"
+
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "hasBody": False,
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "remove",
+                },
+                {
+                    "type": "ref",
+                    "ref": self.target,
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target.write(f)

tfbscript/opcodes/op_reset.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("reset")
+@dataclass
+class OpReset(Opcode):
+    target: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpReset":
+        return cls(target=reader.readRef())
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{self.target}.{method('reset')}{parentheses('()')};"
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "hasBody": True,
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "reset",
+                },
+                {
+                    "type": "ref",
+                    "ref": self.target,
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target.write(f)

tfbscript/opcodes/op_run_as_player.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import func_call
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("run as player")
+@dataclass
+class OpRunAsPlayer(Opcode):
+    actor_ref: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpRunAsPlayer":
+        return cls(actor_ref=reader.readRef())
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call("runAsPlayer", str(self.actor_ref))
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.actor_ref.write(f)

tfbscript/opcodes/op_send_message.py

@@ -0,0 +1,53 @@
+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.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("send message")
+@dataclass
+class OpSendMessage(Opcode):
+    message_ref: Reference = field(default_factory=Reference)
+    reciver_Ref: Reference = field(default_factory=Reference)
+    value: Rhs = field(default_factory=Rhs)
+    # The byte at payload+8 is the RHS record's own rec+8 field -- the same one
+    # `check message` reads as its relational operator (both opcodes hand it to
+    # FUN_0042FC60 before readRHS). Send's execute never looks at it, but it is
+    # not always zero on disk ({0: 20, 2: 636} across the corpus), so it is kept
+    # verbatim rather than assumed.
+    _rec8: int = 0
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpSendMessage":
+        message_ref = reader.readRef()
+        reciver_ref = reader.readRef()
+        rec8 = reader.read_u8()
+        value = reader.readRHS()
+        return cls(
+            message_ref=message_ref,
+            reciver_Ref=reciver_ref,
+            value=value,
+            _rec8=rec8,
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.message_ref.write(f)
+        self.reciver_Ref.write(f)
+        write_u8(f, self._rec8)
+        self.value.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call(
+            "sendMessage",
+            str(self.message_ref),
+            f"to: {self.reciver_Ref}",
+            f"value: {self.value}",
+        )

tfbscript/opcodes/op_set_behavior.py

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

tfbscript/opcodes/op_set_reference.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from typing import Any, 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("set reference")
+@dataclass
+class OpSetReference(Opcode):
+    dest_ref: Reference = field(default_factory=Reference)
+    src_ref: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpSetReference":
+        return cls(dest_ref=reader.readRef(), src_ref=reader.readRef())
+
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.dest_ref.write(f)
+        self.src_ref.write(f)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return f"{keyword('set reference')} *{self.dest_ref} = {self.src_ref};"
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "set *reference",
+                },
+                {
+                    "type": "ref",
+                    "ref": self.dest_ref,
+                },
+                {
+                    "type": "label",
+                    "content": "to",
+                },
+                {
+                    "type": "ref",
+                    "ref": self.src_ref,
+                },
+            ]
+        }

tfbscript/opcodes/op_set_value.py

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

tfbscript/opcodes/op_shutdown.py

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

tfbscript/opcodes/op_slide_value.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+from typing import override
+
+from typing import BinaryIO
+
+from tfbscript.ansi import func_call
+from tfbscript.binary import write_u32
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("slide value")
+@dataclass
+class OpSlideValue(Opcode):
+    lhs: Reference = field(default_factory=Reference)
+    target_value: Rhs = field(default_factory=Rhs)
+    interpolation_time: Rhs = field(default_factory=Rhs)
+
+    # Plain u32s, not references: slide value's parse (FUN_00430210) reads
+    # them with FUN_00432990 -- a thunk to FUN_00432920, a raw 4-byte LE read --
+    # not with FUN_004346f0, which is what every actual reference operand goes
+    # through. Disk order is ease_out (obj+0x28) then ease_in (obj+0x24).
+    ease_out: int = 0
+    ease_in: int = 0
+    # Whatever is left when the trailer is not the expected 8 bytes. That only
+    # happens when the RHS reader took an operator tail that was not really
+    # there (see Rhs._tail_follows -- the byte test is sound but not complete),
+    # so the fields above are unreliable for those; keeping the raw bytes lets
+    # the file round-trip exactly regardless.
+    _trailing: bytes = b""
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> Opcode:
+        lhs = reader.readRef()
+        target_value = reader.readRHS()
+        interpolation_time = reader.readRHS()
+
+        # Normally exactly 8 bytes remain.
+        if reader.size_remaining() >= 8:
+            return cls(
+                lhs=lhs,
+                target_value=target_value,
+                interpolation_time=interpolation_time,
+                ease_out=reader.read_u32(),
+                ease_in=reader.read_u32(),
+            )
+
+        return cls(
+            lhs=lhs,
+            target_value=target_value,
+            interpolation_time=interpolation_time,
+            _trailing=reader.read_bytes(reader.size_remaining()),
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.lhs.write(f)
+        self.target_value.write(f)
+        self.interpolation_time.write(f)
+        if self._trailing:
+            f.write(self._trailing)
+        else:
+            write_u32(f, self.ease_out)
+            write_u32(f, self.ease_in)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return (
+            str(self.lhs)
+            + "."
+            + func_call(
+                "slide",
+                f"to {self.target_value!s}",
+                f"over {self.interpolation_time!s}",
+                f"ease in {self.ease_out!s}",
+                f"ease out {self.ease_in!s}",
+            )
+        )

tfbscript/opcodes/op_spawn_actor.py

@@ -0,0 +1,96 @@
+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.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+# TODO: RESEARCH REMAINING BYTE PURPOSE
+
+
+@opcode("spawn actor")
+@dataclass
+class OpSpawnActor(Opcode):
+    clone_ref: Reference = field(default_factory=Reference)
+    at_ref: Reference = field(default_factory=Reference)
+    facing_rhs: Rhs = field(default_factory=Rhs)
+    remaining: int | None = None
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpSpawnActor":
+        clone_ref = reader.readRef()
+        at_ref = reader.readRef()
+        facing_rhs = reader.readRHS()
+
+        if reader.size_remaining() > 0:
+            return cls(
+                clone_ref=clone_ref,
+                at_ref=at_ref,
+                facing_rhs=facing_rhs,
+                remaining=reader.read_u8(),
+            )
+        return cls(clone_ref=clone_ref, at_ref=at_ref, facing_rhs=facing_rhs)
+
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        if self.remaining is not None:
+            return f"{keyword(f'spawn actor ({self.clone_ref}, at: {self.at_ref}, facing: {self.facing_rhs}, unknown: {self.remaining})')};"
+        else:
+            return f"{keyword(f'spawn actor ({self.clone_ref}, at: {self.at_ref}, facing: {self.facing_rhs})')};"
+
+    @override
+    def editor_repr(self) -> dict[str, Any]:
+        return {
+            "fields": [
+                {
+                    "type": "op-label",
+                    "value": "clone",
+                },
+                {
+                    "type": "label",
+                    "content": "actor",
+                },
+                {
+                    "type": "ref",
+                    "name": "clone_ref",
+                    "ref": self.clone_ref,
+                },
+                {
+                    "type": "label",
+                    "content": "at",
+                },
+                {
+                    "type": "ref",
+                    "name": "at_ref",
+                    "ref": self.at_ref,
+                },
+                {
+                    "type": "label",
+                    "content": "facing",
+                },
+                {
+                    "type": "rhs",
+                    "name": "facing_rhs",
+                    "rhs": self.facing_rhs,
+                },
+                {
+                    "type": "label",
+                    "content": "degrees",
+                },
+            ]
+        }
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.clone_ref.write(f)
+        self.at_ref.write(f)
+        self.facing_rhs.write(f)
+        # The trailing byte is only there in some files; parse records its
+        # absence as None so writing can leave it out again.
+        if self.remaining is not None:
+            write_u8(f, self.remaining)

tfbscript/opcodes/op_startup.py

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

tfbscript/opcodes/op_stop_sound.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+from typing import 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("stop sound")
+@dataclass
+class OpStopSound(Opcode):
+    sound: Reference = field(default_factory=Reference)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpStopSound":
+        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('stop')}{parentheses('()')};"

tfbscript/opcodes/op_teleport_to.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 SetDirection
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+
+
+@opcode("teleport to")
+@dataclass
+class OpTeleportTo(Opcode):
+    target_ref: Reference = field(default_factory=Reference)
+    set_direction: SetDirection = field(default=SetDirection.forward)
+    facing: Rhs = field(default_factory=Rhs)
+
+    duration: Rhs = field(default_factory=Rhs)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpTeleportTo":
+        return cls(
+            target_ref=reader.readRef(),
+            set_direction=SetDirection(reader.read_u8()),
+            facing=reader.readRHS(),
+            duration=reader.readRHS(),
+        )
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call(
+            "teleportTo",
+            str(self.target_ref),
+            f"facing {self.facing}",
+            f"direction: {self.set_direction}",
+            f"over {self.duration} seconds",
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.target_ref.write(f)
+        write_u8(f, self.set_direction)
+        self.facing.write(f)
+        self.duration.write(f)