objectionengine2 1.0.0__py3-none-any.whl

objectionengine2/loading.py

@@ -0,0 +1,253 @@
+from difflib import get_close_matches
+from toml import load
+from os import DirEntry, scandir
+from os.path import join
+from PIL import Image, ImageFile
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+from rich import print
+from .cache import assets_path
+
+ASSETS_FOLDER = str(assets_path())
+CHARACTERS_FOLDER = "characters"
+MUSIC_FOLDER = "music"
+
+def _print_note(note: str):
+    print('[yellow][bold]NOTE[/bold] - ' + note)
+
+def _sprite_not_found_error(
+    character_name: str,
+    sprite_name: str,
+    files_in_character_dir: list,
+):
+    error_string = f'[yellow][bold]NOTE[/bold] - Character "{character_name}" does not have "{sprite_name}"'
+    matches = get_close_matches(
+        sprite_name, [f.name for f in files_in_character_dir], cutoff=0.9
+    )
+    if len(matches) > 0:
+        error_string += f' (is the filename "{matches[0]}" misspelled?)'
+
+    error_string += "; this character will be removed from the possible characters"
+    print(error_string)
+
+
+def _sprite_corrupt_error(sprite_name: str):
+    _print_note(
+        f'Sprite "{sprite_name}" cannot be opened; this character will be removed from the possible characters'
+    )
+
+def _no_sprites_error(character_name: str):
+    _print_note(
+        f'Character "{character_name}" has no sprites; they will be removed from the possible characters'
+    )
+
+def _character_has_no_config_error(character_name: str):
+    _print_note(
+        f'Character "{character_name}" has no config.toml; they will be removed from the possible characters'
+    )
+
+def _sprite_is_usable(sprite_file: DirEntry) -> bool:
+    """
+    Confirm that all of the frames in the sprite are usable
+    """
+    try:
+        with Image.open(sprite_file.path) as img:
+            if hasattr(img, "is_animated"):
+                for frame_no in range(img.n_frames):
+                    img.seek(frame_no)
+                    img.convert("RGBA")
+            else:
+                img.convert("RGBA")
+        return True
+    except Exception:
+        return False
+
+def load_character_data(verify_sprites: bool = False) -> dict:
+    """
+    Returns information about the available characters in a dictionary.
+
+    If the optional parameter `verify_sprites` is set to `True`, all sprites
+    will be opened and checked to ensure they can be properly loaded during
+    render time.
+    Note that this is an expensive operation - using all of the DS trilogy
+    character data, it takes my computer around 7-8 seconds to run when enabled,
+    versus a fraction of a second to run when disabled!
+
+    The return value is a dictionary containing the following data:
+    - `characters` is a dictionary, where the keys
+      are character IDs (i.e. directories in the "characters" directory), and
+      the values are the contents of the character's config.toml file as a
+      dictionary. They may contain the following fields:
+      - `display_name` is the name that appears for the character in an
+        actual game.
+      - `location` is the position in the scene where the character is
+        (usually `left`, `center`, or `right`).
+      - `gender` is the character's gender, used for the speech blip
+        sound effect (usually `male` or `female`).
+      - `sprites` is a dictionary that maps different sentiment levels to
+        lists of animation names.
+        - `neutral` sprites are displayed when a comment is not especially
+          positive or negative.
+        - `positive` sprites are used when a comment is determined by the
+          sentiment analysis model to be positive (happy, excited, etc).
+        - `negative` sprites are used when a comment is determined by the
+          sentiment analysis model to be negative (sad, angry, etc).
+        - `neutral` sprites are used when a comment is not found by the
+          sentiment analysis model to be especially positive or negative.
+        - The `spoiler` sprite list contains names of animations that may imply
+          spoilers to viewers (such as an especially angry or deranged version
+          of a character). If you wish, you can use this list to determine
+          which sprites to remove from the final selection pool.
+    - `high_priority` is a list of character IDs that should be used, in order,
+      before moving to random assignment of characters to users.
+    - `omit_for_adult_mode` is a list of character IDs that should be removed
+      from the selection pool immediately if adult mode is enabled.
+    """
+    # Find all of the characters
+    characters = {}
+    folders = [f for f in scandir(join(ASSETS_FOLDER, CHARACTERS_FOLDER)) if f.is_dir()]
+    for f in folders:
+        # Allow us to skip characters by prefixing their name with
+        # an underscore
+        if f.name.startswith("_"):
+            continue
+        try:
+            with open(join(f.path, "config.toml")) as config_file:
+                characters[f.name] = load(config_file)
+        except FileNotFoundError:
+            _character_has_no_config_error(f.name)
+            continue
+
+    # Validate that all characters have the sprites they should
+    characters_to_remove = set()
+    for character_name, character_data in characters.items():
+        files_in_character_dir = [
+            f
+            for f in scandir(join(ASSETS_FOLDER, CHARACTERS_FOLDER, character_name))
+            if f.is_file()
+        ]
+
+        # First - let's confirm that all of the sprites are here.
+        raw_sprites: dict = character_data.get("sprites", {})
+
+        neutral_sprites = raw_sprites.get("neutral", [])
+        positive_sprites = raw_sprites.get("positive", [])
+        negative_sprites = raw_sprites.get("negative", [])
+        spoiler_sprites = raw_sprites.get("spoiler", [])
+
+        all_expected_sprites = []
+        all_expected_sprites.extend(s for s in neutral_sprites)
+        all_expected_sprites.extend(s for s in positive_sprites)
+        all_expected_sprites.extend(s for s in negative_sprites)
+
+        # If there are no sprites, then don't use this character
+        if len(all_expected_sprites) == 0:
+            _no_sprites_error(character_name)
+            continue
+
+        sprites_to_remove = set()
+        for sprite in all_expected_sprites:
+            sprite_prefix = f"{character_name}-{sprite}"
+            idle_sprite_filename = f"{sprite_prefix}-idle.gif"
+            talk_sprite_filename = f"{sprite_prefix}-talk.gif"
+
+            idle_sprite = next(
+                (f for f in files_in_character_dir if f.name == idle_sprite_filename),
+                None,
+            )
+            talk_sprite = next(
+                (f for f in files_in_character_dir if f.name == talk_sprite_filename),
+                None,
+            )
+
+            if idle_sprite is None:
+                _sprite_not_found_error(
+                    character_name,
+                    idle_sprite_filename,
+                    files_in_character_dir,
+                )
+                sprites_to_remove.add(character_name)
+
+            elif verify_sprites and not _sprite_is_usable(idle_sprite):
+                _sprite_corrupt_error(
+                    character_name,
+                    idle_sprite_filename,
+                )
+                sprites_to_remove.add(character_name)
+
+            if talk_sprite is None:
+                _sprite_not_found_error(
+                    character_name,
+                    talk_sprite_filename,
+                    files_in_character_dir,
+                )
+                sprites_to_remove.add(character_name)
+
+            elif verify_sprites and not _sprite_is_usable(talk_sprite):
+                _sprite_corrupt_error(
+                    character_name,
+                    talk_sprite_filename,
+                )
+                sprites_to_remove.add(character_name)
+
+        # Remove bad sprites from all lists
+        for sprite_to_remove in sprites_to_remove:
+            while sprite_to_remove in neutral_sprites:
+                neutral_sprites.remove(sprite_to_remove)
+            while sprite_to_remove in positive_sprites:
+                positive_sprites.remove(sprite_to_remove)
+            while sprite_to_remove in negative_sprites:
+                negative_sprites.remove(sprite_to_remove)
+            while sprite_to_remove in spoiler_sprites:
+                spoiler_sprites.remove(sprite_to_remove)
+
+        # If the positive or negative lists are now empty, give them
+        # the neutral sprites (and vice versa)
+        if len(neutral_sprites) == 0:
+            neutral_sprites.extend(positive_sprites)
+            neutral_sprites.extend(negative_sprites)
+        if len(positive_sprites) == 0:
+            positive_sprites.extend(neutral_sprites)
+        if len(negative_sprites) == 0:
+            negative_sprites.extend(neutral_sprites)
+
+
+    # Config file in characters folder gives high priority characters
+    try:
+        with open(join(ASSETS_FOLDER, CHARACTERS_FOLDER, "config.toml")) as config_file:
+            data = load(config_file)
+            high_priority_characters = data.get("high_priority", [])
+    except FileNotFoundError:
+        high_priority_characters = []
+
+    for character in characters_to_remove:
+        del characters[character]
+        if character in high_priority_characters:
+            high_priority_characters.remove(character)
+
+    # Characters being children is specified in their config files
+    omit_for_adult_mode = [
+        c for c, data in characters.items() if data.get("is_child", False)
+    ]
+
+    return {
+        "characters": characters,
+        "high_priority": high_priority_characters,
+        "omit_for_adult_mode": omit_for_adult_mode,
+    }
+
+
+def load_music_data() -> dict:
+    # Find all of the music packs
+    music_packs = {}
+    folders = [f for f in scandir(join(ASSETS_FOLDER, MUSIC_FOLDER)) if f.is_dir()]
+    for f in folders:
+        try:
+            with open(join(f.path, "config.toml")) as config_file:
+                music_packs[f.name] = load(config_file)
+        except FileNotFoundError:
+            print(f'ERROR - Music folder "{f.name}" has no config.toml')
+            continue
+
+    return music_packs

objectionengine2/make_movie.py

@@ -0,0 +1,133 @@
+from objectionengine2.ace_attorney_scene import (
+    AceAttorneyDirector,
+    DialogueBoxBuilder,
+)
+
+from objectionengine2.beans.comment import Comment
+from objectionengine2.parse_tags import DialoguePage
+
+from rich import print
+from rich.live import Live
+from rich.table import Table
+from rich.progress import (
+    Progress,
+    TextColumn,
+    BarColumn,
+    MofNCompleteColumn,
+    TaskProgressColumn,
+    TimeElapsedColumn,
+)
+
+from objectionengine2.utils import ensure_assets_are_available
+
+def render_comment_list(
+    comment_list: list["Comment"],
+    output_filename: str = "output.mp4",
+    music_code: str = "pwr",
+    resolution_scale: int = 1,
+    assigned_characters: dict = None,
+    adult_mode: bool = False,
+    avoid_spoiler_sprites: bool = False,
+):
+    ensure_assets_are_available()
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        process_comments_task = progress.add_task(
+            "Processing comments...", start=True, total=len(comment_list), visible=False
+        )
+        complete_pages_task = progress.add_task(
+            "Rendering video...", total=0, start=False, visible=False
+        )
+        composite_audio_task = progress.add_task(
+            "Rendering audio...", total=0, start=False, visible=False
+        )
+        composite_task = progress.add_task(
+            "Compositing...", total=0, start=False, visible=False
+        )
+
+        def on_characters_cast(cast: dict):
+            try:
+                cast_table = Table("User ID", "Character ID", title="Cast")
+                for username, character in cast.items():
+                    cast_table.add_row(username, character)
+                print(cast_table)
+            except:
+                pass
+
+        def on_comment_processed(
+            comment_index: int, num_comments: int, comment: Comment
+        ):
+            progress.update(
+                process_comments_task,
+                completed=comment_index + 1,
+                total=num_comments,
+                refresh=True,
+                visible=True,
+            )
+
+        def on_page_completed(
+            page_index,
+            num_pages: int,
+            page: DialoguePage,
+            time_to_render: float,
+            time_onscreen: float,
+        ):
+            print(
+                f'"{page.get_raw_text():30.30s}"\t\tRender {time_to_render:3.2f} sec\t\tVisible {time_onscreen:3.2f} sec\t\t{time_to_render / time_onscreen:3.2f} SPS'
+            )
+            progress.start_task(complete_pages_task)
+            progress.update(
+                complete_pages_task,
+                completed=page_index + 1,
+                total=num_pages,
+                refresh=True,
+                visible=True,
+            )
+
+        def on_all_pages_completed():
+            pass
+
+        def on_audio_composite_progress(audio_index: int, num_audios: int, audio: dict):
+            progress.start_task(composite_audio_task)
+            progress.update(
+                composite_audio_task,
+                completed=audio_index + 1,
+                total=num_audios,
+                refresh=True,
+                visible=True,
+            )
+
+        def on_ffmpeg_started():
+            progress.start_task(composite_task)
+            progress.update(
+                composite_task, completed=0, total=1, refresh=True, visible=True
+            )
+
+        def on_ffmpeg_finished():
+            progress.update(composite_task, completed=1, refresh=True)
+
+        callbacks = {
+            "on_characters_cast": on_characters_cast,
+            "on_comment_processed": on_comment_processed,
+            "on_page_completed": on_page_completed,
+            "on_all_pages_completed": on_all_pages_completed,
+            "on_audio_composite_progress": on_audio_composite_progress,
+            "on_ffmpeg_started": on_ffmpeg_started,
+            "on_ffmpeg_finished": on_ffmpeg_finished,
+        }
+
+        builder = DialogueBoxBuilder(callbacks=callbacks)
+        builder.render(
+            comment_list,
+            output_filename=output_filename,
+            music_code=music_code.lower(),
+            assigned_characters=assigned_characters,
+            adult_mode=adult_mode,
+            avoid_spoiler_sprites=avoid_spoiler_sprites,
+            resolution_scale=resolution_scale
+        )

objectionengine2/math_helpers.py

@@ -0,0 +1,22 @@
+from math import cos, pi
+
+def lerp(a: float, b: float, t: float) -> float:
+    return (1.0 - t) * a + b * t
+
+def inv_lerp(a: float, b: float, v: float) -> float:
+    return (v - a) / (b - a)
+
+def remap(a_in: float, b_in: float, a_out: float, b_out: float, v: float, func: callable = None):
+    t = inv_lerp(a_in, b_in, v)
+    if func is not None:
+        t = func(t)
+    return lerp(a_out, b_out, t)
+
+def ease_in_out_sine(x: int):
+    return -(cos(pi * x) - 1.0) / 2.0
+
+def ease_in_out_quint(x: int):
+    return (16 * x ** 5) if x < 0.5 else 1 - ((-2 * x + 2) ** 5) / 2
+
+def ease_in_out_cubic(x: int):
+    return 4 * x * x * x if x < 0.5 else 1 - ((-2 * x + 2) ** 3) / 2

objectionengine2/parse_tags.py

@@ -0,0 +1,213 @@
+from dataclasses import dataclass, field
+from re import compile
+from copy import deepcopy
+from objectionengine2.font_tools import get_best_font, split_str_into_newlines, split_with_joined_sentences, get_text_width
+from .font_constants import FONT_ARRAY
+
+@dataclass
+class DialogueTag:
+    name: str = ""
+    start: int = 0
+    end: int = 0
+
+    def range(self):
+        return range(self.start, self.end)
+
+class BaseDialogueItem:
+    completed: bool = False
+
+    def __repr__(self) -> str:
+        return f"BaseDialogueItem()"
+
+class DialogueAction(BaseDialogueItem):
+    name: str = ""
+    index: int = -1
+
+    def __init__(self, name: str, index: str):
+        self.name = name
+        self.index = index
+
+    def __repr__(self) -> str:
+        return f"DialogueAction(\'{self.name}\', {self.index})"
+
+class DialogueTextLineBreak(BaseDialogueItem):
+    def __repr__(self) -> str:
+        return f"DialogueTextLineBreak()"
+
+class DialogueTextChunk(BaseDialogueItem):
+    text: str = ""
+    tags: list[str] = field(default_factory=list)
+    position: int = 0
+
+    def __init__(self, text: str, tags: list[str]):
+        self.text = text
+        self.tags = tags
+
+    def __len__(self) -> int:
+        return len(self.text)
+
+    def __repr__(self) -> str:
+        return f"DialogueTextChunk(\'{self.text}\', {self.tags}, {self.position})"
+
+class DialoguePage:
+    commands: list[BaseDialogueItem]
+    current_item: int
+
+    def __init__(self, commands: list[BaseDialogueItem]):
+        self.commands = commands
+
+    def __repr__(self) -> str:
+        return f"DialoguePage({self.commands})"
+
+    def get_current_item(self):
+        for command in self.commands:
+            if (command is not None) and (not command.completed):
+                return command
+        return None
+
+    def __len__(self) -> int:
+        lens = []
+        for command in self.commands:
+            if isinstance(command, DialogueTextChunk):
+                lens.append(len(command))
+        return sum(lens)
+
+    def get_raw_text(self) -> str:
+        texts = []
+        for command in self.commands:
+            if isinstance(command, DialogueTextChunk):
+                texts.append(command.text)
+        return ''.join(texts)
+
+    def get_visible_text(self, visible_chars: int = 10) -> 'DialoguePage':
+        """
+        Iterate through each line, and within each line, its chunks.
+        Count the characters and keep adding to a variable.
+        Once the variable hits visible_chars, stop counting.
+        The chunks we read should be added to a list, and the chunk we're reading right now
+        should be cut off to its correct length before being added.
+        """
+        read_everything = True
+        chars_remaining = visible_chars
+        new_lines = []
+        for line in self.commands:
+            new_line = []
+            for chunk in line:
+                if chars_remaining >= len(chunk):
+                    new_line.append(deepcopy(chunk))
+                    chars_remaining -= len(chunk)
+                elif chars_remaining > 0:
+                    partial_copy = deepcopy(chunk)
+                    partial_copy.text = partial_copy.text[:chars_remaining]
+                    new_line.append(partial_copy)
+                    chars_remaining = 0
+                    break
+                else:
+                    break
+            new_lines.append(new_line)
+            if chars_remaining <= 0:
+                break
+
+        d = DialoguePage(new_lines)
+        # print("output from get_visible_text", d)
+        return d
+
+    def condense_chunks(self) -> 'DialoguePage':
+        chunks = []
+        current_string = ""
+        current_tags = None
+        for chunk in self.commands:
+            if isinstance(chunk, DialogueTextChunk) and (current_tags is None or chunk.tags == current_tags):
+                current_string += chunk.text
+                if current_tags is None:
+                    current_tags = chunk.tags.copy()
+            elif isinstance(chunk, DialogueTextChunk):
+                chunks.append(DialogueTextChunk(current_string, current_tags))
+                current_string = chunk.text
+                current_tags = chunk.tags.copy()
+            elif isinstance(chunk, DialogueAction):
+                if len(current_string) > 0:
+                    chunks.append(DialogueTextChunk(current_string, current_tags))
+                chunks.append(chunk)
+                current_string = ""
+                current_tags = None
+            elif isinstance(chunk, DialogueTextLineBreak):
+                if len(current_string) > 0:
+                    chunks.append(DialogueTextChunk(current_string, current_tags))
+                chunks.append(chunk)
+                current_string = ""
+                current_tags = None
+        if len(current_string) > 0:
+            chunks.append(DialogueTextChunk(current_string, current_tags))
+
+        d = DialoguePage(chunks)
+        # print("condensed chunks:", d)
+        return d
+
+@dataclass
+class DialogueTextContent:
+    cleaned_lines: str
+    tags: list[DialogueTag]
+    actions: list[DialogueAction]
+
+    def get_text_chunks(self) -> list[DialoguePage]:
+        pages = []
+        current_position = 0
+        for box_text in split_with_joined_sentences(self.cleaned_lines):
+            splitter_font_path = get_best_font(box_text, FONT_ARRAY)['path']
+            wrapped_box_lines = split_str_into_newlines(box_text, splitter_font_path, 15).split('\n')
+            chunks: list[list[DialogueTextChunk]] = []
+
+            for line in wrapped_box_lines:
+                for char in line:
+                    # print(f"Processing char {char} at position {current_position}")
+                    # First, process actions
+                    for action in [a for a in self.actions if a.index == current_position]:
+                        # print(f"Action {action} takes place at this position, so insert it")
+                        chunks.append(action)
+
+                    this_char_tags: list[str] = []
+                    for tag in self.tags:
+                        if current_position in tag.range():
+                            this_char_tags.append(tag.name)
+                    chunks.append(DialogueTextChunk(char, this_char_tags))
+                    current_position += 1
+
+                chunks.append(DialogueTextLineBreak())
+            new_page = DialoguePage(chunks).condense_chunks()
+            pages.append(new_page)
+
+        return pages
+
+__tag_matcher = compile(r"\[(.*?)\]")
+def parse_line(text: str) -> DialoguePage:
+    current_line_width = 0.0
+
+    page_content: list[BaseDialogueItem] = []
+
+    remaining_text = text
+    while len(remaining_text) > 0:
+        re_match = __tag_matcher.match(remaining_text)
+        if re_match is not None:
+            # Tag found at beginning of string, let's get it
+            match_content = re_match.group(1)
+
+            if match_content == "br":
+                page_content.append(DialogueTextLineBreak())
+            else:
+                page_content.append(DialogueAction(match_content, 0))
+            remaining_text = remaining_text[len(re_match.group(0)):]
+        else:
+            char = remaining_text[0]
+            page_content.append(DialogueTextChunk(char, []))
+
+            # Uncomment for auto line breaking (but its stinky)
+            # char_width = get_text_width(char, font=get_best_font(char, FONT_ARRAY))
+            # current_line_width += char_width
+            # if current_line_width > MAX_WIDTH:
+            #     page_content.append(DialogueTextLineBreak())
+            #     current_line_width = 0.0
+
+            remaining_text = remaining_text[1:]
+
+    return page_content

objectionengine2/renderer.py

@@ -0,0 +1 @@
+from .make_movie import render_comment_list

objectionengine2/tag_macros.py

@@ -0,0 +1,25 @@
+from .ace_attorney_scene import get_sprite_tag
+B_M = "<startblip male/>"
+B_F = "<startblip female/>"
+B_ST = "<stopblip/>"
+
+SPR_PHX_NORMAL_T = B_M + get_sprite_tag('left', 'phoenix', 'normal-talk')
+SPR_PHX_NORMAL_I = B_ST + get_sprite_tag('left', 'phoenix', 'normal-idle')
+SPR_PHX_SWEAT_T = B_M + get_sprite_tag('left', 'phoenix', 'sweating-talk')
+SPR_PHX_SWEAT_I = B_ST + get_sprite_tag('left', 'phoenix', 'sweating-idle')
+
+SPR_EDW_NORMAL_T = B_M + get_sprite_tag('right', 'edgeworth', 'normal-talk')
+SPR_EDW_NORMAL_I = B_ST + get_sprite_tag('right', 'edgeworth', 'normal-idle')
+
+SLAM_PHX = B_ST + "<deskslam phoenix/><wait 0.8/>"
+SLAM_EDW = B_ST + "<deskslam edgeworth/><wait 0.8/>"
+
+OBJ_PHX = B_ST + "<bubble objection phoenix/><wait 0.8/>"
+OBJ_EDW = B_ST + "<bubble objection edgeworth/><wait 0.8/>"
+HDI_PHX = B_ST + "<bubble holdit phoenix/><wait 0.8/>"
+
+END_BOX = "<showarrow/><wait 2/><hidearrow/><sound pichoop/><wait 0.3/>"
+
+SHAKE = "<shake 3 0.3/>"
+S_DRAMAPOUND = f"<sound dramapound/><flash 0.15/>{SHAKE}"
+S_SMACK = f"<sound smack/><flash 0.15/>{SHAKE}"