mima-engine 0.1.5__py3-none-any.whl → 0.2.1__py3-none-any.whl

mima/scripts/commands/move_map.py

@@ -1,27 +1,27 @@
+from typing import List, Optional
+
 from ...maps.transition_map import TransitionMap
 from ...objects.dynamic import Dynamic
-from ...util.constants import (
-    HEIGHT,
-    MOVE_MAP_DURATION,
-    TILE_HEIGHT,
-    TILE_WIDTH,
-    WIDTH,
-)
+from ...types.player import Player
+from ...util.constants import HEIGHT, MOVE_MAP_DURATION, WIDTH
 from ..command import Command
 
 
 class CommandMoveMap(Command):
     def __init__(
         self,
+        *,
         new_map_name: str,
         obj: Dynamic,
         target_px: float,
         target_py: float,
         vx: float,
         vy: float,
+        players: Optional[List[Player]] = None,
     ):
         super().__init__()
 
+        self.players = [obj.is_player()]
         self.src_map = self.engine.scene.tilemap
         self.dst_map = self.engine.assets.get_map(new_map_name)
         self.obj: Dynamic = obj
@@ -129,7 +129,7 @@ class CommandMoveMap(Command):
         )
 
     def _get_offset_x(self, px: float) -> float:
-        visible_tiles = WIDTH / TILE_WIDTH
+        visible_tiles = WIDTH / self.engine.rtc.tile_width
         offset = px - visible_tiles / 2.0
 
         if offset < 0:
@@ -140,7 +140,7 @@ class CommandMoveMap(Command):
         return offset
 
     def _get_offset_y(self, py: float) -> float:
-        visible_tiles = HEIGHT / TILE_HEIGHT - 1
+        visible_tiles = HEIGHT / self.engine.rtc.tile_width - 1
         offset = py - visible_tiles / 2.0
 
         if offset < 0:

mima/scripts/commands/parallel.py

@@ -1,4 +1,6 @@
-from typing import List
+from typing import List, Optional
+
+from ...types.player import Player
 from ..command import Command
 
 
@@ -7,7 +9,12 @@ class CommandParallel(Command):
     ANY_COMPLETED: int = 1
     FIRST_COMPLETED: int = 2
 
-    def __init__(self, cmds: List[Command], completed_when: int = ALL_COMPLETED):
+    def __init__(
+        self,
+        cmds: List[Command],
+        completed_when: int = ALL_COMPLETED,
+        players: Optional[List[Player]] = None,
+    ):
         super().__init__()
         self._cmds: List[Command] = cmds
         self._completed_when: int = completed_when
@@ -28,7 +35,8 @@ class CommandParallel(Command):
             self._check_for_first()
         else:
             raise ValueError(
-                f"Unknown value {self._completed_when} for " "attribute _completed_when"
+                f"Unknown value {self._completed_when} for "
+                "attribute _completed_when"
             )
 
     def finalize(self):
@@ -51,3 +59,8 @@ class CommandParallel(Command):
 
     def _check_for_first(self):
         self.completed = self._cmds[0].completed
+
+    def set_players(self, players: List[Player]):
+        self.players = players
+        for cmd in self._cmds:
+            cmd.set_players(players)

mima/scripts/commands/present_item.py

@@ -14,14 +14,13 @@ class CommandPresentItem(Command):
     def __init__(self, item_name: str, dynamic: Optional[Dynamic] = None):
         super().__init__()
 
-        if dynamic is None:
-            dynamic = self.engine.player
-
-        self._dynamic: Dynamic = dynamic
+        self._dynamic: Optional[Dynamic] = dynamic
         self._item_name: str = item_name
         self._item_sprite: Optional[Projectile] = None
 
     def start(self):
+        if self._dynamic is None:
+            self._dynamic = self.engine.get_player(self.players[0])
         item = self.engine.get_item(self._item_name)
         self._item_sprite = Projectile(
             self._dynamic.px,
@@ -30,6 +29,7 @@ class CommandPresentItem(Command):
             0,
             3600,
             self._dynamic.alignment,
+            self._dynamic.tilemap,
         )
         self._item_sprite.layer = 2
         self._item_sprite.sprite.name = item.sprite_name
@@ -42,7 +42,9 @@ class CommandPresentItem(Command):
         self._item_sprite.one_hit = False
         self._item_sprite.damage = 0
 
-        self.engine.scene.add_projectile(self._item_sprite)
+        self.engine.get_view().add_projectile(
+            self._item_sprite, self._dynamic.tilemap.name
+        )
         self._dynamic.lock_graphic_state(GraphicState.CELEBRATING)
         self.completed = True
 

mima/scripts/commands/screen_fade.py

@@ -1,8 +1,8 @@
 from typing import Optional
 
 from ...objects.effects.colorize_screen import ColorizeScreen
+from ...util.colors import BLACK, Color
 from ..command import Command
-from ...util.colors import BLACK,Color
 
 
 class CommandScreenFade(Command):
@@ -11,12 +11,13 @@ class CommandScreenFade(Command):
         duration: float = 0.5,
         color: Optional[Color] = None,
         fadein: bool = False,
+        map_name: Optional[str] = None,
     ):
         super().__init__()
 
         self.duration: float = duration
         if color is None:
-            color = self.engine.rtc.colors["gb_dark"]
+            color = self.engine.rtc.color_black
 
         self.color: Color = color
         self.fadein: bool = fadein
@@ -30,16 +31,34 @@ class CommandScreenFade(Command):
             self._end = 0
             self._iter = -self._iter
 
-        # self._alpha = chain([i for i in range(self._start, self._end, self._iter)])
+        self._map_name = map_name
 
-        self._effect = ColorizeScreen()
+        self._effect: Optional[ColorizeScreen] = None
         # self.duration -= 0.1
-        self._effect.alpha = self._start
 
     def start(self):
-        self.engine.scene.add_effect(self._effect)
-        self.engine.player.vx = 0
-        self.engine.player.vy = 0
+
+        self._effect = ColorizeScreen(
+            cameras=[
+                self.engine.get_view().get_camera_name(p) for p in self.players
+            ]
+        )
+        self._effect.alpha = self._start
+        if self._map_name is None:
+            map_names = list(
+                set(
+                    [
+                        self.engine.get_player(p).tilemap.name
+                        for p in self.players
+                    ]
+                )
+            )
+            for map_name in map_names:
+                self.engine.get_view().add_effect(self._effect, map_name)
+        else:
+            self.engine.get_view().add_effect(self._effect, self._map_name)
+        for p in self.players:
+            self.engine.get_player(p).halt()
 
     def update(self, elapsed_time: float):
         self.time_so_far += elapsed_time
@@ -51,10 +70,9 @@ class CommandScreenFade(Command):
             alpha = 255 - alpha
 
         self._effect.alpha = min(255, max(0, alpha))
-        # print(self, self._effect.alpha)
 
-        self.engine.player.vx = 0
-        self.engine.player.vy = 0
+        for p in self.players:
+            self.engine.get_player(p).halt()
 
         if self.time_so_far >= self.duration:
             self._effect.alpha = self._end
@@ -62,4 +80,4 @@ class CommandScreenFade(Command):
 
     def finalize(self):
         self.completed = True
-        self._effect.kill()
+        self._effect.kill()

mima/scripts/commands/serial.py

@@ -1,25 +1,35 @@
-from typing import List, Union
 import logging
+from typing import List, Optional, Union
+
+from ...types.player import Player
 from ..command import Command
 
 LOG = logging.getLogger(__name__)
 
+
 class CommandSerial(Command):
     START_AND_UPDATE: int = 0
     START_WITHOUT_UPDATE: int = 1
 
-    def __init__(self, cmds: List[Command], update_when: Union[int, List[int]] = START_AND_UPDATE):
-        super().__init__()
+    def __init__(
+        self,
+        cmds: List[Command],
+        update_when: Union[int, List[int]] = START_AND_UPDATE,
+        players: Optional[List[Player]] = None,
+    ):
+        super().__init__(players)
         self._cmds: List[Command] = cmds
+
         self._current: int = 0
         self._update_when: List[int]
-
         if not isinstance(update_when, list):
-            self._update_when = [update_when for _ in range(len(self._cmds)-1)]
+            self._update_when = [
+                update_when for _ in range(len(self._cmds) - 1)
+            ]
         else:
             self._update_when = update_when
 
-        if len(self._update_when) < len(self._cmds):
+        if len(self._update_when) + 1 < len(self._cmds):
             LOG.warning(
                 "Unsufficient information for 'update_when' of serial command:"
                 f"cmds={self._cmds}, update_when={self._update_when}. Using "
@@ -31,16 +41,29 @@ class CommandSerial(Command):
 
     def update(self, delta_time):
         if not self._cmds[self._current].completed:
+            # Not completed -> Update current command
             self._cmds[self._current].update(delta_time)
         else:
+            # Current command completed -> progress to next
             self._current += 1
             if self._current == len(self._cmds):
+                # Reached end? -> Finish serial command
                 self.completed = True
             else:
+                # End not reached -> call start of next command
                 self._cmds[self._current].start()
-                if self._update_when[self._current-1] == self.START_AND_UPDATE:
+                if (
+                    self._update_when[self._current - 1]
+                    == self.START_AND_UPDATE
+                ):
+                    # Start the command already with update
                     self._cmds[self._current].update(delta_time)
 
     def finalize(self):
         for cmd in self._cmds:
             cmd.finalize()
+
+    def set_players(self, players: List[Player]):
+        self.players = players
+        for cmd in self._cmds:
+            cmd.set_players(players)

mima/scripts/commands/set_spawn_map.py

@@ -8,7 +8,10 @@ class CommandSetSavePosition(Command):
         self._py = py
 
     def start(self):
-        self.engine.player_state.save_map = self._map_name
-        self.engine.player_state.save_px = self._px
-        self.engine.player_state.save_py = self._py
+
+        self.engine.memory.player_state[self.players[0]].save_map = (
+            self._map_name
+        )
+        self.engine.memory.player_state[self.players[0]].save_px = self._px
+        self.engine.memory.player_state[self.players[0]].save_py = self._py
         self.completed = True

mima/scripts/commands/show_choices.py

@@ -1,6 +1,8 @@
 from typing import List
+
 from ...scripts.command import Command
 from ...types.keys import Key as K
+from ...types.player import Player
 
 
 class CommandShowChoices(Command):
@@ -20,13 +22,13 @@ class CommandShowChoices(Command):
         self._cursor_pos: int = 0
 
     def update(self, elapsed_time: float):
-        if self.engine.keys.new_key_release(K.UP):
+        if self.engine.keys.new_key_release(K.UP, self.players[0]):
             self._cursor_pos = (self._cursor_pos - 1) % len(self._options)
-        elif self.engine.keys.new_key_release(K.DOWN):
+        elif self.engine.keys.new_key_release(K.DOWN, self.players[0]):
             self._cursor_pos = (self._cursor_pos + 1) % len(self._options)
-        elif self.engine.keys.new_key_press(K.A):
+        elif self.engine.keys.new_key_press(K.A, self.players[0]):
             self.completed = True
-        elif self.engine.keys.new_key_release(K.B):
+        elif self.engine.keys.new_key_release(K.B, self.players[0]):
             self._cursor_pos = self._default_option
             self.completed = True
 
@@ -36,8 +38,15 @@ class CommandShowChoices(Command):
                 lines.append(f"> {opt}")
             else:
                 lines.append(f"  {opt}")
-
-        self.engine.scene.show_dialog(lines)
+        # for p in self.players:
+        self.engine.get_view().show_dialog(lines, self.players[0])
 
     def finalize(self):
-        self.engine.script.add_command(self._replies[self._cursor_pos])
+        self.engine.script.add_command(
+            self._replies[self._cursor_pos], players=self.players
+        )
+
+    def set_players(self, players: List[Player]):
+        for cmd in self._replies:
+            cmd.set_players(players)
+        self.players = players

mima/scripts/commands/show_dialog.py

@@ -1,11 +1,118 @@
-from typing import List
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
 from ...scripts.command import Command
+from ...util.constants import DIALOG_CHARS_PER_LINE, DIALOG_N_LINES
+from ...util.functions import wrap_text
+
+if TYPE_CHECKING:
+    from ...types.player import Player
 
 
 class CommandShowDialog(Command):
-    def __init__(self, lines: List[str]):
+    def __init__(
+        self,
+        lines: List[str],
+        *,
+        no_auto_wrap: bool = False,
+        chars_per_line: int = DIALOG_CHARS_PER_LINE,
+        n_lines: int = DIALOG_N_LINES,
+    ):
         super().__init__()
+
         self.lines: List[str] = lines
+        self._current_lines: List[str] = []
+        self._no_auto_wrap: bool = no_auto_wrap
+        self._chars_per_line: int = chars_per_line
+        self._n_lines: int = n_lines
+        self._row: int = 0
+        self._char: int = 0
+        self._first_row: int = 0
+        self._last_row: int = self._n_lines
+
+        self._timer_reset = 0.01
+        self._timer = self._timer_reset
+        self._auto_scroll: bool = True
+        self._progress: bool = False
+        self._lines_changed: bool = True
 
     def start(self):
-        self.engine.scene.show_dialog(self.lines)
+        if not self._no_auto_wrap:
+            one_liner = ""
+            for line in self.lines:
+                one_liner += f"{line.strip()} "
+
+            self.lines = wrap_text(one_liner, self._chars_per_line)
+        self._current_lines = [self.lines[0][0]]
+        self._char += 1
+        for p in self.players:
+            self.engine.get_view().show_dialog(self._current_lines, p)
+
+    def update(self, elapsed_time: float):
+        if self._auto_scroll:
+            self._timer -= elapsed_time
+            if self._timer <= 0.0:
+                self._timer += self._timer_reset
+
+                self._current_lines = []
+                for r in range(self._first_row, self._last_row):
+                    if r < self._row:
+                        self._current_lines.append(self.lines[r])
+                        continue
+
+                    line = ""
+
+                    for c in range(self._char + 1):
+                        if c + 1 >= self._char or c + 1 >= len(self.lines[r]):
+                            break
+                        line += self.lines[r][c]
+
+                    self._current_lines.append(line)
+
+                    if r + 1 >= self._row:
+                        break
+
+                self._char += 1
+                if self._char >= self._chars_per_line or self._char >= len(
+                    self.lines[r]
+                ):
+                    self._char = 0
+                    self._row += 1
+
+                if self._row >= self._n_lines + self._first_row:
+                    self._first_row += 1
+                    self._last_row += 1
+                if self._row >= len(self.lines):
+                    self._auto_scroll = False
+
+                # print(f"'{self._current_lines}'")
+                for p in self.players:
+                    self.engine.get_view().show_dialog(self._current_lines, p)
+        else:
+            if self._lines_changed:
+                self._current_lines = []
+                for r in range(self._first_row, self._last_row):
+                    if r >= len(self.lines):
+                        break
+                    self._current_lines.append(self.lines[r])
+                for p in self.players:
+                    self.engine.get_view().show_dialog(self._current_lines, p)
+                self._lines_changed = False
+
+            if self._progress:
+                self._first_row += self._n_lines
+                self._last_row += self._n_lines
+                self._progress = False
+                self._lines_changed = True
+
+    def can_complete(self, force: bool = False) -> bool:
+        if force:
+            return True
+        if self._auto_scroll:
+            self._auto_scroll = False
+        elif self._last_row >= len(self.lines):
+            return True
+        else:
+            self._progress = True
+        return False

mima/scripts/script_processor.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Dict, List, Optional
 
+from ..types.player import Player
 from .command import Command
 
 if TYPE_CHECKING:
@@ -12,29 +13,49 @@ class ScriptProcessor:
     engine: MimaEngine
 
     def __init__(self):
-        self.commands: List[Command] = []
-        self.user_control_enabled: bool = True
+        self.commands: Dict[Player : List[Command]] = {}
 
-    def add_command(self, cmd: Command):
-        self.commands.append(cmd)
+    def add_command(
+        self, cmd: Command, *, players: Optional[List[Player]] = None
+    ):
+        if players is not None and players:
+            cmd.set_players(players)
+
+        for p in cmd.players:
+            self.commands.setdefault(p, []).append(cmd)
+        # self.commands.append(cmd)
 
     def process_command(self, elapsed_time: float):
-        self.user_control_enabled = len(self.commands) == 0
-        if self.commands:
-            if not self.commands[0].completed:
-                if not self.commands[0].started:
-                    self.commands[0].start()
-                    self.commands[0].started = True
+        # for p in Player:
+        #     self.engine.trigger_script(False, p)
+        #     for cmd in self.commands:
+        #         if p in cmd.players or Player.P0 in cmd.players:
+        #             self.engine.trigger_script(True, p)
+        #             break
+        for p in self.commands:
+            if self.commands[p]:
+                self.engine.trigger_script(True, p)
+                if not self.commands[p][0].completed:
+                    if not self.commands[p][0].started:
+                        self.commands[p][0].start()
+                        self.commands[p][0].started = True
+                    else:
+                        self.commands[p][0].update(elapsed_time)
                 else:
-                    self.commands[0].update(elapsed_time)
+                    self.commands[p][0].finalize()
+                    self.commands[p].pop(0)
+                    self.engine.trigger_script(False, p)
             else:
-                self.commands[0].finalize()
-                self.commands.pop(0)
+                self.engine.trigger_script(False, p)
 
-    def complete_command(self, force: bool = False):
-        if self.commands:
-            if self.commands[0].uninterruptible and not force:
-                return False
-            else:
-                self.commands[0].completed = True
+    def complete_command(self, player: Player, force: bool = False):
+        if self.commands[player]:
+            # for cmd in self.commands:
+            #     if player in cmd.players or Player.P0 in cmd.players:
+
+            if self.commands[player][0].can_complete(force):
+                self.commands[player][0].completed = True
                 return True
+            else:
+                return False
+        return True

mima/states/game_state.py

@@ -82,6 +82,7 @@ class GameState:
             filename = os.path.join(
                 os.path.split(filename)[0], "autosave.json"
             )
+            self.save_value("savefile_name", "autosave")
             self.save_value("player__pos_x", 5.0)
             self.save_value("player__pos_y", 5.0)
             self.save_value(
@@ -131,6 +132,7 @@ def convert(value, astype):
 
 
 def load_saved_games(save_path, save_file_name):
+    os.makedirs(save_path, exist_ok=True)
     all_games = {}
     if not os.path.isdir(save_path):
         LOG.warning(f"Save folder does not exist: {save_path}")

mima/states/memory.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List
+
+from ..types.player import Player
+
+if TYPE_CHECKING:
+    from ..objects.creature import Creature
+    from ..usables.item import Item
+    from .quest import Quest
+
+
+class Memory:
+    def __init__(self):
+        self.player: Dict[Player, Creature] = {}
+        self.items: Dict[str, Any] = {}
+        self.quests: List[Quest] = []
+        self.teleport_active: Dict[Player, bool] = {p: False for p in Player}
+        self.dialog_active: Dict[Player, bool] = {p: False for p in Player}
+        self.script_active: Dict[Player, bool] = {p: False for p in Player}
+        self.player_collision_active: Dict[Player, bool] = {
+            p: False for p in Player
+        }
+        self.bag: Dict[Player, List[Item]] = {p: [] for p in Player}
+        self.map_name: Dict[Player, str] = {}
+
+        self.last_spawn_px: Dict[Player, float] = {p: 0.0 for p in Player}
+        self.last_spawn_py: Dict[Player, float] = {p: 0.0 for p in Player}

mima/states/quest.py

@@ -8,6 +8,7 @@ if TYPE_CHECKING:
     from ..engine.mima_engine import MimaEngine
     from ..objects.dynamic import Dynamic
     from ..types.nature import Nature
+    from ..types.player import Player
 
 
 class Quest:
@@ -21,9 +22,7 @@ class Quest:
         self.completed: bool = False
         self.state: int = 0
 
-    def on_interaction(
-        self, dynamics: List[Dynamic], target: Dynamic, nature: Nature
-    ):
+    def on_interaction(self, target: Dynamic, nature: Nature, player: Player):
         return False
 
     def populate_dynamics(self, dynamics: List[Dynamic], map_name: str):

mima/types/keys.py

@@ -14,3 +14,51 @@ class Key(Enum):
     L = 9
     START = 10
     SELECT = 11
+    P1_UP = 12
+    P1_DOWN = 13
+    P1_LEFT = 14
+    P1_RIGHT = 15
+    P1_A = 16
+    P1_B = 17
+    P1_X = 18
+    P1_Y = 19
+    P1_R = 20
+    P1_L = 21
+    P1_START = 22
+    P1_SELECT = 23
+    P2_UP = 24
+    P2_DOWN = 25
+    P2_LEFT = 26
+    P2_RIGHT = 27
+    P2_A = 28
+    P2_B = 29
+    P2_X = 30
+    P2_Y = 31
+    P2_R = 32
+    P2_L = 33
+    P2_START = 34
+    P2_SELECT = 35
+    P3_UP = 36
+    P3_DOWN = 37
+    P3_LEFT = 38
+    P3_RIGHT = 39
+    P3_A = 40
+    P3_B = 41
+    P3_X = 42
+    P3_Y = 43
+    P3_R = 44
+    P3_L = 45
+    P3_START = 46
+    P3_SELECT = 47
+    P4_UP = 48
+    P4_DOWN = 49
+    P4_LEFT = 50
+    P4_RIGHT = 51
+    P4_A = 52
+    P4_B = 53
+    P4_X = 54
+    P4_Y = 55
+    P4_R = 56
+    P4_L = 57
+    P4_START = 58
+    P4_SELECT = 59

mima/types/mode.py

@@ -3,13 +3,7 @@ from enum import Enum
 
 class Mode(Enum):
     LOADING = 0
-    TITLE = 1
-    SELECT_GAME = 2
-    LOCAL_MAP = 3
-    WORLD_MAP = 4
-    INVENTORY = 5
-    SHOP = 6
-    GAME_OVER = 7
-    TITLE_SETTINGS = 8
-    CONTROLS = 9
-    COMBAT = 10
+    MENU = 1
+    SESSION = 2
+    COMBAT = 3
+    INVENTORY = 4