tfbscript 0.1.0__py3-none-any.whl

tfbscript/opcodes/op_turn_to.py

@@ -0,0 +1,33 @@
+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.rhs import Rhs
+
+
+@opcode(
+    "turn to",
+    "Turns to either an actor reference or an angle while playing an animation.",
+)
+@dataclass
+class OpTurnTo(Opcode):
+    rhs: Rhs = field(default_factory=Rhs)  # angle or actor reference
+    animation: AnimationMapping = field(default=AnimationMapping.ambient)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpTurnTo":
+        return cls(rhs=reader.readRHS(), animation=AnimationMapping(reader.read_u8()))
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call("turnTo", str(self.rhs), f"animation: {self.animation}")
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.rhs.write(f)
+        write_u8(f, self.animation)

tfbscript/opcodes/op_use_camera.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, field
+from typing import BinaryIO, override
+
+from tfbscript.ansi import func_call
+from tfbscript.binary import write_f32, write_u8
+from tfbscript.opcodes.base import Opcode, opcode
+from tfbscript.opcodes.enums import CamTransitionInMode, CamTransitionOutMode
+from tfbscript.payload import PayloadReader
+from tfbscript.reference import Reference
+
+
+@opcode("use camera")
+@dataclass
+class OpUseCamera(Opcode):
+    camera_ref: Reference = field(default_factory=Reference)
+
+    trans_in_mode: CamTransitionInMode = field(default=CamTransitionInMode.fade_in)
+    trans_in_duration: float = field(default=0.0)
+
+    trans_out_mode: CamTransitionOutMode = field(
+        default=CamTransitionOutMode.no_transition
+    )
+    trans_out_duration: float | None = field(default=None)
+
+    @classmethod
+    @override
+    def parse_payload(cls, reader: PayloadReader) -> "OpUseCamera":
+        camera_ref = reader.readRef()
+
+        trans_in_mode = CamTransitionInMode(reader.read_u8())
+        trans_in_duration = reader.read_f32()
+
+        trans_out_mode = CamTransitionOutMode(reader.read_u8())
+
+        trans_out_duration = None
+        if trans_out_mode != CamTransitionOutMode.no_transition:
+            trans_out_duration = reader.read_f32()
+
+        return cls(
+            camera_ref=camera_ref,
+            trans_in_mode=trans_in_mode,
+            trans_in_duration=trans_in_duration,
+            trans_out_mode=trans_out_mode,
+            trans_out_duration=trans_out_duration,
+        )
+
+    @override
+    def write_payload(self, f: BinaryIO) -> None:
+        self.camera_ref.write(f)
+        write_u8(f, self.trans_in_mode)
+        write_f32(f, self.trans_in_duration)
+
+        write_u8(f, self.trans_out_mode)
+        if self.trans_out_mode != CamTransitionOutMode.no_transition:
+            assert self.trans_out_duration is not None # Should never assert
+            write_f32(f, self.trans_out_duration)
+
+    @override
+    def source_line(self, inline: bool = False) -> str:
+        return func_call(
+            "useCamera",
+            str(self.camera_ref),
+            f"trans_in: {self.trans_in_mode} for {self.trans_in_duration}sec",
+            f"trans_out: {self.trans_out_mode} for {self.trans_out_duration}sec"
+            if self.trans_out_mode != CamTransitionOutMode.no_transition
+            else f"trans_out: {self.trans_out_mode}",
+        )
+

tfbscript/payload.py

@@ -0,0 +1,40 @@
+"""Reader for opcode payloads, with access to the script's reference tables."""
+
+from typing import TYPE_CHECKING
+
+from tfbscript.binary import BinaryReader
+from tfbscript.reference import Reference
+from tfbscript.rhs import Rhs
+from tfbscript.string_table import StringTable
+
+if TYPE_CHECKING:
+    from tfbscript.opcodes.base import ParserContext
+
+
+class PayloadReader(BinaryReader):
+    """A BinaryReader over one opcode payload.
+
+    Also carries the script's global/local reference tables so payload parsers
+    can read References and RHS operands without threading the tables through.
+    """
+
+    def __init__(
+        self,
+        data: bytes,
+        global_refs: StringTable,
+        local_refs: StringTable,
+        little_endian: bool = True,
+        context: "ParserContext | None" = None,
+    ):
+        super().__init__(data, little_endian)
+        self.global_refs = global_refs
+        self.local_refs = local_refs
+        self.context = context
+
+    def readRef(self) -> Reference:
+        """Read a 4-byte TFB-Script variable reference."""
+        return Reference.read(self, self.global_refs, self.local_refs, self.context)
+
+    def readRHS(self) -> Rhs:
+        """Read a 5-11 byte TFB-Script RHS operand."""
+        return Rhs.read(self, self.global_refs, self.local_refs, self.context)