objectionengine2 1.0.0__py3-none-any.whl

objectionengine2/beans/comment.py

@@ -0,0 +1,22 @@
+class Comment:
+    def __init__(self,
+    user_id: str = None,
+    user_name: str = 'Prosecutor',
+    text_content: str = '...',
+    evidence_path: str = None,
+    score: float = 0
+    ):
+        """
+        All arguments are optional
+        :param str user_id: An unique identifier to tell users appart
+        :param str evidence_path: Path pointing to an image to be used as evidence
+        :param str user_name: Name of the user
+        :param str text_content: Text to display
+        :param float score: Positiveness of a commentary (negative below zero, positive above zero)
+        """
+        self.user_name = user_name
+        self.user_id = user_id
+        self.text_content = text_content
+        self.score = score
+        self.evidence_path = evidence_path
+        self.effective_user_id = self.user_id or self.user_name

objectionengine2/beans/text.py

@@ -0,0 +1,9 @@
+from typing import Optional, List
+from objectionengine2.font_constants import FONT_ARRAY
+from objectionengine2.font_tools import get_font_score
+
+def is_renderable(text: str, font_array: Optional[List[dict]] = None) -> bool:
+    score = 0
+    for font in FONT_ARRAY if font_array is None else font_array:
+        score = max(score, get_font_score(font, text))
+    return score >= len(text)

objectionengine2/cache.py

@@ -0,0 +1,18 @@
+"""Per-user cache paths for downloaded Objection Engine data."""
+
+from pathlib import Path
+
+from platformdirs import user_cache_path
+
+
+def cache_path() -> Path:
+    """Return the platform's cache directory for objectionengine2."""
+    return user_cache_path("objectionengine2", appauthor=False)
+
+
+def assets_path() -> Path:
+    return cache_path() / "assets"
+
+
+def models_path() -> Path:
+    return cache_path() / "models"

objectionengine2/composers/compose_gavel_slam.py

@@ -0,0 +1,72 @@
+from objectionengine2.parse_tags import DialogueAction
+
+
+def compose_gavel_slam(
+    num_slams: int = 3,
+    delay_between_slams: float = 0.17,
+    finish_wait_time: float = 0.766,
+):
+    if num_slams <= 0:
+        return []
+
+    if num_slams == 1:
+        return [
+            DialogueAction("hidebox", 0),
+            DialogueAction("cut gavel", 0),
+            DialogueAction("gavel 0", 0),
+            DialogueAction("wait 0.3", 0),
+            DialogueAction("gavel 1", 0),
+            DialogueAction("wait 0.04", 0),
+            DialogueAction("gavel 2", 0),
+            DialogueAction("wait 0.04", 0),
+            DialogueAction("gavel 3", 0),
+            DialogueAction("sound gavel", 0),
+            DialogueAction("shake 3 0.2", 0),
+            DialogueAction(f"wait {finish_wait_time}", 0),
+        ]
+
+    commands = [
+        DialogueAction("hidebox", 0),
+        DialogueAction("cut gavel", 0),
+        DialogueAction("gavel 0", 0),
+        DialogueAction("wait 0.300", 0),
+        DialogueAction("gavel 1", 0),
+        DialogueAction("wait 0.04", 0),
+        DialogueAction("gavel 3", 0),
+        DialogueAction("sound gavel", 0),
+        DialogueAction("shake 3 0.2", 0),
+        DialogueAction(f"wait {delay_between_slams}", 0),
+    ]
+
+    # First and last slams have different duration
+    for _ in range(num_slams - 2):
+        commands.extend(
+            [
+                DialogueAction("gavel 2", 0),
+                DialogueAction("wait 0.04", 0),
+                DialogueAction("gavel 1", 0),
+                DialogueAction("wait 0.17", 0),
+                DialogueAction("gavel 3", 0),
+                DialogueAction("sound gavel", 0),
+                DialogueAction("shake 3 0.2", 0),
+                DialogueAction(f"wait {delay_between_slams}", 0),
+            ]
+        )
+
+    # Last slam
+    commands.extend(
+        [
+            DialogueAction("gavel 2", 0),
+            DialogueAction("wait 0.04", 0),
+            DialogueAction("gavel 1", 0),
+            DialogueAction("wait 0.17", 0),
+            DialogueAction("gavel 2", 0),
+            DialogueAction("wait 0.04", 0),
+            DialogueAction("gavel 3", 0),
+            DialogueAction("sound gavel", 0),
+            DialogueAction("shake 3 0.2", 0),
+            DialogueAction(f"wait {finish_wait_time}", 0),
+        ]
+    )
+
+    return commands

objectionengine2/composers/compose_verdict.py

@@ -0,0 +1,56 @@
+from objectionengine2.parse_tags import DialogueAction
+
+def compose_verdict(
+    text: str,
+    slam_group: str = "letter",
+    color: str = "white",
+    slam_delay: float = 0.0,
+    finish_wait_time: float = 2.0,
+):
+    if slam_group not in ["letter", "word"]:
+        raise ValueError(
+            f'slam_group "{slam_group}" is not valid; must be "letter" or "word"'
+        )
+    if color not in ["black", "white"]:
+        raise ValueError(f'color "{color}" is not valid; must be "black" or "white"')
+
+    output = []
+    output.append(DialogueAction(f'verdict set "{text}" {color}', 0))
+
+    slam_delay_command = f"wait {slam_delay}"
+    if slam_group == "letter":
+        for i in range(len(text)):
+            output.extend(
+                [
+                    DialogueAction(f"verdict show {i}", 0),
+                    DialogueAction("wait 0.2", 0),
+                    DialogueAction("sound guilty", 0),
+                    DialogueAction("shake 4 0.1", 0),
+                ]
+            )
+            if i != len(text) - 1:
+                output.append(DialogueAction(slam_delay_command, 0))
+
+    elif slam_group == "word":
+        for i in range(len(text)):
+            output.append(DialogueAction(f"verdict show {i}", 0))
+            if text[i].isspace():
+                output.extend(
+                    [
+                        DialogueAction("wait 0.2", 0),
+                        DialogueAction("sound guilty", 0),
+                        DialogueAction("shake 4 0.1", 0),
+                        DialogueAction(slam_delay_command, 0),
+                    ]
+                )
+        output.extend(
+            [
+                DialogueAction("wait 0.2", 0),
+                DialogueAction("sound guilty", 0),
+                DialogueAction("shake 4 0.1", 0),
+            ]
+        )
+
+    output.append(DialogueAction(f"wait {finish_wait_time}", 0))
+    output.append(DialogueAction("verdict clear", 0))
+    return output

objectionengine2/font_constants.py

@@ -0,0 +1,37 @@
+from enum import IntEnum
+from objectionengine2.loading import ASSETS_FOLDER
+
+class TextType(IntEnum):
+    DIALOGUE = 0
+    NAME = 1
+
+FONT_ARRAY = [
+        # AA-Like > Pixel > Generic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari-cyrillic/igiari-cyrillic.ttf'},
+        # AA-like, Latin, hiragana, katakana, (part of) cyrillic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/Igiari.ttf'},
+        # AA-like, Latin, hiragana, katakana, (part of) cyrillic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/Galmuri11.ttf'},
+        # Pixel, Kanji, Hiragana, Katakana
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/jackeyfont.ttf'},
+        # Arabic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/arabic-1.ttf', 'size': 12, 'offset': {TextType.NAME: (0, -5)}, 'rtl': True},
+        # Pixel-font, Hebrew
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/STANRG__.ttf'},
+        # Generic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/NotoSans-Regular.ttf'},
+        # Pixel font, Arabic
+        {'path': f'{ASSETS_FOLDER}/textbox/font/igiari/bitsy-font-with-arabic.ttf', 'size': 10, 'rtl': True},
+    ]
+
+NAMETAG_FONT_ARRAY = [
+    {'path': f'{ASSETS_FOLDER}/textbox/font/ace-name/ace-name.ttf', 'size': 8}
+] + FONT_ARRAY
+
+TEXT_COLORS = {
+    "red": (240, 112, 56),
+    "blue": (104, 192, 240),
+    "green": (0, 240, 0)
+}
+
+MAX_LINE_WIDTH = 220

objectionengine2/font_tools.py

@@ -0,0 +1,98 @@
+from .font_constants import FONT_ARRAY
+from PIL import ImageFont
+from typing import List, Dict, Union
+from textwrap import wrap
+import spacy
+
+nlp = spacy.blank("xx")
+nlp.add_pipe('sentencizer')
+
+
+def split_sentences(text: str) -> list[str]:
+    """Split dialogue without requiring Polyglot language data."""
+    sentences = [span.text.strip() for span in nlp(text).sents]
+    return [sentence for sentence in sentences if sentence] or [text]
+
+try:
+    from fontTools.ttLib import TTFont
+except:
+    from fonttools.ttLib import TTFont
+
+def get_text_width(text, font_size = 15, font = None):
+    if font is None:
+        font = get_best_font(text, FONT_ARRAY)
+    font_path = font['path']
+    font_obj = ImageFont.truetype(font_path, font_size)
+    return font_obj.getlength(text)
+
+def get_font_score(font, text):
+    font_path = font['path']
+    font = TTFont(font_path)
+
+    # We check all chars for presence on the font
+    valid_chars = 0
+    for char in text:
+        # We check if the char is in any table of the font
+        for table in font['cmap'].tables:
+            if ord(char) in table.cmap:
+                valid_chars += 1
+                break
+    return valid_chars
+
+def get_best_font(text, font_array):
+    best_font = font_array[-1]
+    best_font_points = 0
+    text = text.replace('\n', '').replace('\r', '').replace('\t', '').replace('\u200B', '')
+    for font in font_array:
+        pts = get_font_score(font, text)
+        if pts > best_font_points:
+            best_font_points = pts
+            best_font = font
+        if best_font_points >= len(text):
+            return font
+    print(f'WARNING. NO OPTIMAL FONT FOUND, font: {best_font}, font score: {best_font_points}/{len(text)}, text \"{text}\"\n')
+    return best_font
+
+
+def fit_words_within_width(words: Union[list[str], str], font: ImageFont.FreeTypeFont, insert_space: bool):
+    new_text = ""
+    space = " " if insert_space else ""
+    for word in words:
+        last_sentence = new_text.split("\n")[-1] + word + space
+        if font.getlength(text=last_sentence) >= 240:
+            if new_text.split("\n")[-1] != "":
+                new_text += "\n"
+            new_text += fit_words_within_width(word, font, False) + space
+        else:
+            new_text += word + space
+
+    return new_text
+
+def split_str_into_newlines(text: str, font_path, font_size):
+    font = ImageFont.truetype(font_path, font_size)
+    words = text.split(" ")
+    return fit_words_within_width(words, font, True)
+
+
+def split_with_joined_sentences(text: str):
+    """
+    """
+    tokens = nlp(text)
+    sentences = [sent.text.strip() for sent in tokens.sents]
+    joined_sentences = []
+    i = 0
+    while i < len(sentences):
+        sentence = sentences[i]
+        if len(sentence) > 85: # Long sentences should be wrapped to multiple shorter lines
+            text_chunks = [chunk for chunk in wrap(sentence, 85)]
+            joined_sentences = [*joined_sentences, *text_chunks]
+            i += 1
+        else:
+            if i + 1 < len(sentences) and len(f"{sentence} {sentences[i+1]}") <= 85: # Maybe we can join two different sentences
+                joined_sentences.append(sentence + " " + sentences[i+1])
+                i += 2
+            else:
+                joined_sentences.append(sentence)
+                i += 1
+
+    return joined_sentences

objectionengine2/gavel_slam.py

@@ -0,0 +1,80 @@
+from objectionengine2.loading import ASSETS_FOLDER, _print_note
+from objectionengine2.MovieKit import ImageObject, SceneObject
+from os.path import join, exists
+
+GAVEL_SLAM_PATH = join(ASSETS_FOLDER, "gavel_slam")
+
+"""
+https://www.youtube.com/watch?v=XBR35H_ya4g as reference
+Single slam at 9:53
+0 - 9 frames   (0.300s)
+1 - 1 frame    (0.033s)
+2 - 1 frame    (0.033s)
+3 - 23 frames  (0.766s)
+
+# Triple slam at 11:07
+0 - 9 frames   (0.300s)
+1 - 1 frame    (0.033s)
+3 - 5 frames   (0.166s)
+2 - 1 frame    (0.033s)
+1 - 5 frames   (0.166s)
+3 - 5 frames   (0.166s)
+2 - 1 frame    (0.033s)
+1 - 5 frames   (0.166s)
+2 - 1 frame    (0.033s)
+3 - 23 frames  (0.766s)
+
+NOTE: using 0.033 for to indicate 1 frame didn't seem to work (it would simply
+skip the frame) - instead, I rounded up fo 0.04.
+"""
+
+class GavelSlamObject(SceneObject):
+    def __init__(self, parent: SceneObject = None, name: str = "", pos: tuple[int, int, int] = (0, 0, 0)):
+        super().__init__(parent, name, pos)
+        if not exists(GAVEL_SLAM_PATH):
+            _print_note(
+                f"Gavel slam assets not found at {GAVEL_SLAM_PATH}"
+            )
+            return
+
+        self.bg_img = ImageObject(
+            parent=self,
+            name="Gavel Slam BG",
+            pos=(0, 0, 11),
+            filepath=join(GAVEL_SLAM_PATH, "gavel_slam_bg.png"),
+        )
+
+        self.block_img = ImageObject(
+            parent=self,
+            name="Gavel Slam Block",
+            pos=(0, 0, 11),
+            filepath=join(GAVEL_SLAM_PATH, "gavel_slam_block.png"),
+        )
+
+        self.gavel_frames = [
+            ImageObject(
+                parent=self,
+                name="Gavel Frame 1",
+                pos=(0, 0, 11),
+                filepath=join(GAVEL_SLAM_PATH, "gavel_slam_gavel_1.png"),
+            ),
+            ImageObject(
+                parent=self,
+                name="Gavel Frame 2",
+                pos=(0, 0, 11),
+                filepath=join(GAVEL_SLAM_PATH, "gavel_slam_gavel_2.png"),
+            ),
+            ImageObject(
+                parent=self,
+                name="Gavel Frame 3",
+                pos=(0, 0, 11),
+                filepath=join(GAVEL_SLAM_PATH, "gavel_slam_gavel_3.png"),
+            ),
+        ]
+        self.set_gavel_frame(0)
+
+    def set_gavel_frame(self, frame: int = 0):
+        for f in self.gavel_frames: f.hide()
+        if frame <= 0 or frame > len(self.gavel_frames):
+            return
+        self.gavel_frames[frame - 1].show()

objectionengine2/judge_verdict.py

@@ -0,0 +1,179 @@
+from objectionengine2.loading import ASSETS_FOLDER, _print_note
+from objectionengine2.math_helpers import lerp
+from .MovieKit import SceneObject
+from PIL import Image, ImageDraw, ImageFont
+from os.path import exists
+
+VERDICT_FONT_SIZE = 70
+VERDICT_FONT_START_SIZE_RATIO = 8 / 3
+VERDICT_STROKE_WIDTH_RATIO = 1 / 14
+VERDICT_STROKE_WIDTH = int(VERDICT_FONT_SIZE * VERDICT_STROKE_WIDTH_RATIO)
+
+VERDICT_MAX_WIDTH = 230
+VERDICT_SLAM_SPEED = 8.0
+
+VERDICT_COLORS = {
+    "black": {"fill": (0, 0, 0), "stroke": (255, 255, 255)},
+    "white": {"fill": (255, 255, 255), "stroke": (0, 0, 0)},
+}
+
+VERDICT_FONT_PATH = f"{ASSETS_FOLDER}/verdict/DFMinchoStd-W12.otf"
+
+
+class JudgeVerdictTextObject(SceneObject):
+    def __init__(self, parent: SceneObject = None, name: str = ""):
+        super().__init__(parent, name, (0, 0, 10))
+        self.font = None
+
+        # If the verdict font isn't available, then don't crash, but don't
+        # render anything
+        if not exists(VERDICT_FONT_PATH):
+            _print_note(
+                f"Verdict font not found at {VERDICT_FONT_PATH}, so verdict text will not be rendered"
+            )
+            return
+
+        self.font = ImageFont.truetype(VERDICT_FONT_PATH, VERDICT_FONT_SIZE)
+        self._text = ""
+        self.clear()
+
+    def get_text_bbox(self, text):
+        if self.font is None:
+            return (0, 0)
+
+        bb = self.font.getbbox(text)
+        x1, y1, x2, y2 = bb
+
+        padding = VERDICT_STROKE_WIDTH
+        x1 -= padding
+        y1 -= padding
+        x2 += padding
+        y2 += padding
+        h = y2 - y1
+        w = x2 - x1
+
+        return (w, h)
+
+    def clear(self):
+        if self.font is None:
+            return
+
+        self.set_text("")
+
+    def set_text(self, text: str, text_color: str = None):
+        if self.font is None:
+            return
+
+        self._text = text
+
+        w, h = self.get_text_bbox(self._text)
+
+        x_squish = min(1.0, VERDICT_MAX_WIDTH / w)
+        chars = []
+        for i, c in enumerate(self._text):
+            next_char = "" if i == len(self._text) - 1 else self._text[i + 1]
+            next_char_width = self.font.getlength(next_char)
+            char_width = self.font.getlength(c + next_char) - next_char_width
+
+            # For each character, make an image and store it along with the character
+            # it holds and its getlength value
+            char_img = Image.new("RGBA", self.get_text_bbox(c), (255, 0, 255, 0))
+            char_img_ctx = ImageDraw.Draw(char_img)
+
+            if text_color not in VERDICT_COLORS:
+                text_color = "black"
+            args = {
+                "xy": (VERDICT_STROKE_WIDTH, VERDICT_STROKE_WIDTH),
+                "text": c,
+                "fill": VERDICT_COLORS[text_color]["fill"],
+                "stroke_width": VERDICT_STROKE_WIDTH,
+                "stroke_fill": VERDICT_COLORS[text_color]["stroke"],
+                "font": self.font,
+                "anchor": "lt",
+            }
+            char_img_ctx.text(**args)
+
+            # Squish character on X axis if the whole string will be too wide
+            char_img = char_img.resize(
+                (int(char_img.width * x_squish), char_img.height)
+            )
+            true_char_width = int(char_width * x_squish)
+
+            # Get bounding box stuff!
+            # From https://github.com/python-pillow/Pillow/issues/3921#issuecomment-533085656
+            bottom_1 = self.font.getsize(self._text[i])[1]
+            right, bottom_2 = self.font.getsize(self._text[: i + 1])
+            bottom = bottom_1 if bottom_1 < bottom_2 else bottom_2
+            width, height = self.font.getmask(c).size
+            top = bottom - height
+            left = right - width
+
+            rect = (left, top, right, bottom)
+
+            chars.append(
+                {
+                    "img": char_img,
+                    "char": c,
+                    "width": true_char_width,
+                    "rect": rect,
+                    "scale": VERDICT_FONT_START_SIZE_RATIO,
+                    "visible": False,
+                }
+            )
+
+        width_sum = sum([i["width"] for i in chars])
+        self._characters = {"chars": chars, "width_sum": width_sum, "height": h}
+
+    def show_index(self, index: int):
+        if self.font is None:
+            return
+
+        self._characters["chars"][index]["visible"] = True
+
+    def update(self, delta):
+        if self.font is None:
+            return
+
+        for character in self._characters["chars"]:
+            if not character["visible"]:
+                continue
+            character["scale"] = max(
+                1.0, character["scale"] - delta * VERDICT_SLAM_SPEED
+            )
+
+    def render(self, img: Image.Image, ctx: ImageDraw.ImageDraw):
+        if self.font is None:
+            return
+
+        width_so_far = -int(self._characters["width_sum"] / 2) - VERDICT_STROKE_WIDTH
+        for character in self._characters["chars"]:
+            if not character["visible"]:
+                continue
+            char_img: Image.Image = character["img"]
+            char_width = character["width"]
+
+            x = width_so_far
+            y = (
+                character["rect"][1]
+                - int(self._characters["height"] / 2)
+                - VERDICT_STROKE_WIDTH
+            )
+            w = char_img.width
+            h = char_img.height
+
+            scale = character["scale"]
+            scaled_w = int(char_img.width * scale)
+            scaled_h = int(char_img.height * scale)
+
+            # https://math.stackexchange.com/a/3055687
+            scaled_x = x + int(w / 2) - int(scaled_w / 2)
+            scaled_y = y + int(h / 2) - int(scaled_h / 2)
+            scaled_char_img = char_img.resize(
+                (scaled_w, scaled_h), resample=Image.Resampling.NEAREST
+            )
+
+            img.alpha_composite(
+                scaled_char_img,
+                (scaled_x + int(img.width / 2), scaled_y + int(img.height / 2)),
+            )
+            width_so_far += char_width