smrpgpatchbuilder 7.1.1__tar.gz → 7.1.5__tar.gz

{smrpgpatchbuilder-7.1.1/src/smrpgpatchbuilder.egg-info → smrpgpatchbuilder-7.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smrpgpatchbuilder
-Version: 7.1.1
+Version: 7.1.5
 Summary: Patchable base class support for some SMRPG concepts similar to their definitions in Lazy Shell
 Author-email: pidgezero_one <s.kischak@gmail.com>
 License-Expression: MIT

{smrpgpatchbuilder-7.1.1 → smrpgpatchbuilder-7.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "smrpgpatchbuilder"
-version = "7.1.1"
+version = "7.1.5"
 authors = [
   { name="pidgezero_one", email="s.kischak@gmail.com" },
 ]

{smrpgpatchbuilder-7.1.1 → smrpgpatchbuilder-7.1.5}/src/smrpgpatchbuilder/datatypes/dialogs/formatter.py

@@ -110,6 +110,42 @@ def _build_control_token_list() -> list[str]:
 _CONTROL_TOKENS = _build_control_token_list()
 
 
+def _byte_glyph_width(byte: int, widths: tuple[int, ...] = VANILLA_DIALOG_FONT_WIDTHS) -> int:
+    """Rendered width (raw + 1px spacing) of a single compressed dialog byte.
+
+    The game renders the *compressed* byte stream, so a character's on-screen
+    width is that of its glyph byte -- e.g. ':' is stored as 0x8E and drawn with
+    glyph 0x8E's width, not ASCII 0x3A's. Bytes below 0x20 are control codes and
+    have no width (mirrors Lazy Shell's ``l >= 0x20 && l <= 0x9F`` guard).
+    """
+    if 0x20 <= byte <= 0x20 + len(widths) - 1:
+        return widths[byte - 0x20] + 1
+    return 0
+
+
+def _build_glyph_tokens() -> list[tuple[str, int]]:
+    """Compression-table substrings that render as one drawable glyph, paired
+    with that glyph's byte value.
+
+    These are the source-string spellings (curly quotes, ``♥``, ``♪``, bullets,
+    and remapped punctuation like ``:`` ``~`` ``×``) whose glyph byte differs
+    from their unicode codepoint. Sorted longest-first so greedy matching picks
+    e.g. the single ``••`` glyph (0x2B) over two ``•`` (0x2A). Control/variable
+    entries (byte < 0x20, or multi-byte like ``[0x7000]``) are excluded -- those
+    are handled as control/variable tokens elsewhere. Width is computed at
+    tokenize time so a caller-supplied ``widths`` table is honored.
+    """
+    glyphs = []
+    for key, val in COMPRESSION_TABLE:
+        if len(val) == 1 and 0x20 <= val[0] <= 0x9F:
+            glyphs.append((key, val[0]))
+    glyphs.sort(key=lambda kv: -len(kv[0]))
+    return glyphs
+
+
+_GLYPH_TOKENS = _build_glyph_tokens()
+
+
 def _tokenize(text: str, widths: tuple[int, ...] = VANILLA_DIALOG_FONT_WIDTHS) -> list[Token]:
     """Parse a dialog string into a sequence of tokens."""
     tokens = []
@@ -165,6 +201,20 @@ def _tokenize(text: str, widths: tuple[int, ...] = VANILLA_DIALOG_FONT_WIDTHS) -
         if matched:
             continue
 
+        # 2c. Match a compression-table glyph substring (curly quotes, ♥, ♪,
+        # bullets, remapped punctuation like ':' -> 0x8E). These render as one
+        # glyph whose width comes from the *byte*, not the unicode codepoint,
+        # so measuring ord(char) would give the wrong width (often 0).
+        glyph_matched = False
+        for sub, byte in _GLYPH_TOKENS:
+            if text[cursor:cursor + len(sub)] == sub:
+                tokens.append(Token(text=sub, width_px=_byte_glyph_width(byte, widths)))
+                cursor += len(sub)
+                glyph_matched = True
+                break
+        if glyph_matched:
+            continue
+
         # 3. Literal character
         ch = text[cursor]
         if ch == " ":

{smrpgpatchbuilder-7.1.1 → smrpgpatchbuilder-7.1.5}/src/smrpgpatchbuilder/datatypes/items/classes.py

@@ -488,7 +488,7 @@ class Item:
             + (self.target_all << 4)
             + (self.koed_target_only << 5)
             + (self.one_side_only << 6)
-            + (not (self.can_target_self) << 7)
+            + ((not self.can_target_self) << 7)
         )
         data += ByteField(target).as_bytes()
 

{smrpgpatchbuilder-7.1.1 → smrpgpatchbuilder-7.1.5/src/smrpgpatchbuilder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smrpgpatchbuilder
-Version: 7.1.1
+Version: 7.1.5
 Summary: Patchable base class support for some SMRPG concepts similar to their definitions in Lazy Shell
 Author-email: pidgezero_one <s.kischak@gmail.com>
 License-Expression: MIT

{smrpgpatchbuilder-7.1.1 → smrpgpatchbuilder-7.1.5}/src/tests/dialogs/test_formatter.py

@@ -271,3 +271,75 @@ class TestCalculateTextWidth:
     def test_variable_token(self):
         # [0x7000] should be 16px
         assert calculate_text_width("[0x7000]") == 16
+
+
+class TestSpecialCharWidths:
+    """Width must come from the *compressed glyph byte*, not the unicode
+    codepoint. The game renders the compressed byte stream, so e.g. ':' is
+    drawn with glyph 0x8E, and a heart with glyph 0x24 -- see COMPRESSION_TABLE.
+    Before the fix these all measured 0px (out-of-range unicode) or the wrong
+    ascii slot."""
+
+    def test_curly_quotes(self):
+        # left/right double quotes -> bytes 0x22 / 0x23 (raw 6 -> 7)
+        assert calculate_text_width("“") == 7
+        assert calculate_text_width("”") == 7
+
+    def test_curly_apostrophes(self):
+        # left/right single quotes -> bytes 0x26 / 0x27 (raw 4 -> 5)
+        assert calculate_text_width("‘") == 5
+        assert calculate_text_width("’") == 5
+
+    def test_heart_and_note(self):
+        # heart -> 0x24 (raw 8 -> 9), eighth note -> 0x25 (raw 8 -> 9)
+        assert calculate_text_width("♥") == 9
+        assert calculate_text_width("♪") == 9
+
+    def test_bullets_greedy(self):
+        # single bullet -> 0x2A (raw 6 -> 7); double bullet -> 0x2B (raw 8 -> 9)
+        # Greedy longest-match must pick the single 0x2B glyph, not two 0x2A.
+        assert calculate_text_width("•") == 7
+        assert calculate_text_width("••") == 9
+
+    def test_remapped_punctuation(self):
+        # ':' stored as 0x8E (raw 7 -> 8), NOT ascii 0x3A (raw 8 -> 9)
+        assert calculate_text_width(":") == 8
+        assert calculate_text_width(";") == 8   # 0x8F raw 7 -> 8
+        assert calculate_text_width("<") == 9   # 0x90 raw 8 -> 9
+        assert calculate_text_width(">") == 9   # 0x91 raw 8 -> 9
+        assert calculate_text_width("#") == 10  # 0x93 raw 9 -> 10
+        assert calculate_text_width("&") == 9   # 0x9C raw 8 -> 9
+
+    def test_tilde(self):
+        # '~' stored as 0x3A (raw 8 -> 9), NOT ascii 0x7E
+        assert calculate_text_width("~") == 9
+
+    def test_multiplication_sign(self):
+        # multiplication sign -> 0x95 (raw 9 -> 10); unicode is out-of-range (was 0)
+        assert calculate_text_width("×") == 10
+
+    def test_middle_dots_greedy(self):
+        # three middle dots -> single glyph 0x92 (raw 9 -> 10)
+        assert calculate_text_width("···") == 10
+
+    def test_tokenizes_special_into_word(self):
+        # A special glyph is part of its surrounding word (not a break), so the
+        # whole word's width is counted for wrap decisions.
+        tokens = _tokenize("a♥b")
+        assert [t.text for t in tokens] == ["a", "♥", "b"]
+        assert tokens[1].width_px == 9
+
+
+class TestSpecialCharWrapping:
+    """Regression: special chars measured as 0px let lines overflow, so the
+    game wrapped a word on its own right before the formatter's \\n."""
+
+    def test_line_with_specials_does_not_overflow(self):
+        # start_x = 17, wrap boundary = 240 -> a completed line's content width
+        # must stay below 240 - 17 = 223px.
+        raw = ("The “Super” Star ♥ gives you power ♪ "
+               "for a while okay friend")
+        formatted = format_dialog(raw)
+        for line in formatted.split("\n"):
+            assert calculate_text_width(line) < 223, (
+                repr(line), calculate_text_width(line))