mima-engine 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

mima/scripts/commands/oneway_move.py

@@ -8,11 +8,12 @@ from ...util.constants import ONEWAY_SPEED_BOOST
 
 if TYPE_CHECKING:
     from ...objects.dynamic import Dynamic
+    from ...types.player import Player
 
 
 class CommandOnewayMove(Command):
-    def __init__(self, obj: Dynamic, vx: float, vy: float):
-        super().__init__()
+    def __init__(self, obj: Dynamic, vx: float, vy: float, player: Player):
+        super().__init__([player])
 
         self.obj: Dynamic = obj
         self.vx: float = vx
@@ -27,7 +28,7 @@ class CommandOnewayMove(Command):
         self.obj.solid_vs_map = False
         self.obj.solid_vs_dyn = False
         self.obj.vx = self.obj.vy = 0.0
-        self.obj.vz = 10.0
+        self.obj.vz = 7.5
 
         self.start_px = self.obj.px
         self.start_py = self.obj.py

mima/scripts/commands/save_game.py

@@ -9,5 +9,6 @@ class CommandSaveGame(Command):
             quest.save_state()
         self.engine.game_state.save_to_disk()
         self.completed = True
+        print(f"Saved the game to {self.engine.game_state.state_name}")
 
         # print(self.engine.game_state._state["player"])

mima/states/game_state.py

@@ -2,19 +2,21 @@ import json
 import logging
 import os
 from os import PathLike
-from typing import Any, Dict, List, Optional, Union
+from pathlib import Path
+from typing import Any, Dict, Union
 
+# from typing_extensions import overload
+from ..util.constants import SAVE_FILE_NAME
 from ..util.functions import strtobool
 
 LOG = logging.getLogger(__name__)
 
 
 class GameState:
-    def __init__(self, filename: PathLike):
-        self.filename = filename
-        self._state: Dict[str, Any] = {
-            "savefile_name": os.path.split(self.filename)[-1].split(".")[0]
-        }
+    def __init__(self, save_path: PathLike, state_name: str = "autosave.json"):
+        self.state_name = state_name
+        self._save_path = save_path
+        self._state: Dict[str, Any] = {}
 
     def save_value(
         self, key: str, value: Union[int, float, bool, str, dict, list]
@@ -27,12 +29,22 @@ class GameState:
             else:
                 state[part] = value
 
+    # @overload
+    # def load_value(
+    #     self, key: str, default: str, astype: str | None
+    # ) -> str | None: ...
+
+    # @overload
+    # def load_value(
+    #     self, key: str, default: int, astype: str | None
+    # ) -> int | None: ...
+
     def load_value(
         self,
         key: str,
-        default: Optional[Union[int, float, bool, str, dict, list]] = None,
-        astype: Optional[str] = None,
-    ) -> Optional[Union[int, float, bool, str, dict, list]]:
+        default: int | float | bool | str | dict | list | None = None,
+        astype: str | None = None,
+    ) -> int | float | bool | str | dict | list | None:
         parts = key.split("__")
         state = self._state
         for idx, part in enumerate(parts):
@@ -57,11 +69,11 @@ class GameState:
         return data
 
     def load_from_disk(self, autosave: bool = False):
-        filename = self.filename
-        if autosave:
-            filename = os.path.join(
-                os.path.split(filename)[0], "autosave.json"
-            )
+        # filename = self.filename
+        # if autosave:
+        #     filename = os.path.join(self._save_path, "autosave.json")
+        # else:
+        filename = Path(self._save_path) / self.state_name
         try:
             with open(filename, "r") as fp:
                 self._state = json.load(fp)
@@ -71,32 +83,33 @@ class GameState:
             LOG.info("No saved state found or state corrupted.")
 
         if autosave:
-            self.filename = os.path.join(
-                os.path.split(filename)[0],
-                f"{self._state['savefile_name']}.json",
-            )
+            self.state_name = self.load_value("savefile_name", "")
+        # if autosave:
+        #     self.filename = os.path.join(
+        #         os.path.split(filename)[0],
+        #         f"{self._state['savefile_name']}.json",
+        #     )
 
     def save_to_disk(self, autosave: bool = False):
-        filename = self.filename
+        # filename = self.filename
         if autosave:
-            filename = os.path.join(
-                os.path.split(filename)[0], "autosave.json"
-            )
-            self.save_value("savefile_name", "autosave")
+            filename = Path(self._save_path) / "autosave.json"
+            self.save_value("savefile_name", self.state_name)
             self.save_value("player__pos_x", 5.0)
             self.save_value("player__pos_y", 5.0)
             self.save_value(
                 "player__map_name", self.load_value("player__spawn_map")
             )
         else:
-            self._state["savefile_name"] = os.path.split(filename)[-1].split(
-                "."
-            )[0]
+            if self.state_name == "autosave.json":
+                self.state_name = chose_filename(self._save_path)
+                self.save_value("savefile_name", self.state_name)
+            filename = Path(self._save_path) / self.state_name
+            self._state["savefile_name"] = self.state_name
+
             # Auto save file will be removed after a successful save
             try:
-                os.remove(
-                    os.path.join(os.path.split(filename)[0], "autosave.json")
-                )
+                os.remove(Path(self._save_path) / "autosave.json")
             except FileNotFoundError:
                 pass
 
@@ -112,6 +125,17 @@ class GameState:
             del self._state[scope][k]
 
 
+def chose_filename(save_path: PathLike):
+
+    files = os.listdir(save_path)
+    game_idx = 0
+    while True:
+        savegame = f"{SAVE_FILE_NAME}_{game_idx:03d}.json"
+        if savegame not in files:
+            return savegame
+        game_idx += 1
+
+
 def convert(value, astype):
     if astype == "int":
         try:
@@ -144,17 +168,18 @@ def load_saved_games(save_path, save_file_name):
         return all_games
 
     if "autosave.json" in files:
-        all_games["autosave"] = GameState(
-            os.path.join(save_path, "autosave.json")
+        all_games["autosave.json"] = GameState(save_path)
+        all_games["autosave.json"].load_from_disk(autosave=True)
+        LOG.debug(
+            "Loading saved game from autosave.json (%s)",
+            all_games["autosave.json"].state_name,
         )
-        all_games["autosave"].load_from_disk(autosave=True)
-        LOG.debug("Loading saved game from autosave.json")
 
     game_idx = 0
     while True:
-        savegame = f"{save_file_name}{game_idx:03d}.json"
+        savegame = f"{save_file_name}_{game_idx:03d}.json"
         if savegame in files:
-            all_games[savegame] = GameState(os.path.join(save_path, savegame))
+            all_games[savegame] = GameState(save_path, savegame)
             all_games[savegame].load_from_disk()
             LOG.debug(f"Loading saved game from {savegame}")
         game_idx += 1

mima/util/constants.py

@@ -10,8 +10,8 @@ UI_HIGHT: int = 1  # TODO: remove
 # Map transition
 MOVE_MAP_DURATION: float = 1.0
 MAP_TRANSITION_DURATION_FACTOR: float = 0.75
-ONEWAY_ACTIVATION_DELAY: float = 0.175
-ONEWAY_SPEED_BOOST: float = 2.0
+ONEWAY_ACTIVATION_DELAY: float = 0.075
+ONEWAY_SPEED_BOOST: float = 2.5
 
 # Gamepad
 AXIS_DEADZONE: float = 0.25
@@ -38,7 +38,7 @@ DEFAULT_GRAPHIC_TIMER_DAMAGED: float = 0.075
 DEFAULT_GRAPHIC_TIMER_DEAD: float = 0.25
 DEFAULT_GRAPHIC_TIMER: float = 0.5
 ATTRIBUTE_TIMER: float = 0.25
-DEFAULT_KNOCK_SPEED: float = 5.0
+DEFAULT_KNOCK_SPEED: float = 6.0
 
 # Gameplay
 ABYSS_DAMAGE: int = 1
@@ -51,3 +51,5 @@ DIALOG_WIDTH: float = 14.0
 DIALOG_HEIGHT: float = 3.0
 DIALOG_CHARS_PER_LINE: int = 36
 DIALOG_N_LINES: int = 4
+
+SAVE_FILE_NAME = "savegame"

mima/util/input_defaults.py

@@ -156,3 +156,15 @@ DEFAULT_TOUCHSCREEN_MAP = {
     K.P1_B: [[0.5, 0.5], [0.75, 1.0]],
     K.P1_A: [[0.75, 0.5], [1.0, 1.0]],
 }
+
+ALT_TOUCHSCREEN_MAP = {
+    K.P1_UP: {"pos": [0.1, 0.2], "size": [0.4, 0.7]},
+    K.P1_A: {"pos": [0.83, 0.84], "size": [0.12, 0.12]},
+    K.P1_B: {"pos": [0.70, 0.84], "size": [0.12, 0.12]},
+    K.P1_X: {"pos": [0.76, 0.69], "size": [0.12, 0.12]},
+    K.P1_Y: {"pos": [0.63, 0.69], "size": [0.12, 0.12]},
+    K.P1_START: {"pos": [0.39, 0.02], "size": [0.1, 0.1]},
+    K.P1_SELECT: {"pos": [0.51, 0.02], "size": [0.1, 0.1]},
+    K.P1_L: {"pos": [0.01, 0.3], "size": [0.05, 0.4]},
+    K.P1_R: {"pos": [0.94, 0.3], "size": [0.05, 0.4]},
+}

mima/view/mima_mode.py

@@ -90,7 +90,9 @@ class MimaMode(MimaView):
     def get_camera_name(self, player: Player = Player.P1):
         return self.scenes[player].camera.name
 
-    def unload_map(self, player: Player = Player.P1, player_only: bool = False) -> None:
+    def unload_map(
+        self, player: Player = Player.P1, player_only: bool = False
+    ) -> None:
         p_obj = self.engine.memory.player[player]
         map_name = p_obj.tilemap.name
 
@@ -139,12 +141,15 @@ class MimaMode(MimaView):
     ) -> None:
         p_obj = self.engine.get_player(player)
         p_obj.stop_shining()
+        p_obj.on_exit_map()
 
         if map_name not in self.players_on_map:
             # Map not loaded
             self.prepare_object_lists(map_name, player, p_obj)
 
-            self._loader.populate_dynamics(self.maps[player], self.dynamics[map_name])
+            self._loader.populate_dynamics(
+                self.maps[player], self.dynamics[map_name]
+            )
 
             for quest in self.engine.memory.quests:
                 quest.populate_dynamics(self.dynamics[map_name], map_name)
@@ -161,6 +166,7 @@ class MimaMode(MimaView):
         p_obj.tilemap = self.maps[player]
         p_obj.px = px
         p_obj.py = py
+        p_obj.on_enter_map()
         self.engine.memory.last_spawn_px[player] = px
         self.engine.memory.last_spawn_py[player] = py
 
@@ -185,7 +191,9 @@ class MimaMode(MimaView):
                     chunks_per_row,
                 )
                 if self.engine.draw_chunk_info:
-                    self.add_effect(DynamicDebugBox(obj, n_frames=-1), map_name)
+                    self.add_effect(
+                        DynamicDebugBox(obj, n_frames=-1), map_name
+                    )
 
     def handle_user_input(self):
         for player, scene in self.scenes.items():
@@ -215,7 +223,9 @@ class MimaMode(MimaView):
                             else:
                                 msg += f"object {obj.name} ({obj.dyn_id})"
                         else:
-                            msg = "Trying to interact with a quest that is None"
+                            msg = (
+                                "Trying to interact with a quest that is None"
+                            )
 
                         LOG.exception(msg)
                         raise
@@ -290,7 +300,9 @@ class MimaMode(MimaView):
                         tilemap.width + self.chunk_size // 2,
                         self.chunk_size,
                     ):
-                        chidx = _chunk_index(px, py, self.chunk_size, chunks_per_row)
+                        chidx = _chunk_index(
+                            px, py, self.chunk_size, chunks_per_row
+                        )
                         # collision_lists[map_name][chidx] = []
                         self.add_effect(
                             StaticDebugBox(
@@ -333,7 +345,9 @@ class MimaMode(MimaView):
         # return collision_lists
 
     def _determine_target(self, obj, players) -> Dynamic:
-        players = [p for p in players if not self.engine.get_player(p).occupied]
+        players = [
+            p for p in players if not self.engine.get_player(p).occupied
+        ]
         if not players:
             return None
         dists = [
@@ -354,7 +368,10 @@ class MimaMode(MimaView):
         return target  # , skip
 
     def _update_velocity_z(self, obj: Dynamic, elapsed_time: float) -> None:
-        obj.vz -= obj.attributes.gravity_vz * elapsed_time
+        if obj.pz > 0.0:
+            obj.vz -= obj.attributes.gravity_vz * elapsed_time
+        # else:
+        # obj.vz = 0.0
 
     def _update_position_z(self, obj: Dynamic, elapsed_time: float) -> None:
         if obj.gravity:
@@ -364,11 +381,16 @@ class MimaMode(MimaView):
                 obj.vz = 0.0
 
     def handle_collisions(self, elapsed_time: float) -> None:
-        screen_width = self.engine.backend.render_width // self.engine.rtc.tile_width
-        screen_height = self.engine.backend.render_height // self.engine.rtc.tile_height
+        screen_width = (
+            self.engine.backend.render_width // self.engine.rtc.tile_width
+        )
+        screen_height = (
+            self.engine.backend.render_height // self.engine.rtc.tile_height
+        )
         max_dist = screen_width + screen_height
 
         for map_name, players in self.players_on_map.items():
+            # print(f"Collisions for {map_name}: {self.colliders[map_name]}")
             for obj in self.colliders[map_name]:
                 if obj.occupied:
                     continue
@@ -407,13 +429,19 @@ class MimaMode(MimaView):
                             self.engine.memory.quests,
                         ]
                         if self._probe_p2p_collision(obj, other):
-                            new2_px, new2_py = check_object_to_object_collision(*args)
+                            new2_px, new2_py = (
+                                check_object_to_object_collision(*args)
+                            )
 
                             if new2_px == new_px and new2_py == new_py:
                                 # No change = no collision
-                                self.engine.trigger_player_collision(True, obj.player)
+                                self.engine.trigger_player_collision(
+                                    True, obj.player
+                                )
                         else:
-                            new_px, new_py = check_object_to_object_collision(*args)
+                            new_px, new_py = check_object_to_object_collision(
+                                *args
+                            )
                 obj.px = new_px
                 obj.py = new_py
 
@@ -435,17 +463,23 @@ class MimaMode(MimaView):
             vx, vy = vx * 0.707, vy * 0.707
 
         obj.real_vx = (
-            vx if vx == obj.real_vx else calculate(obj, vx, obj.real_vx, elapsed_time)
+            vx
+            if vx == obj.real_vx
+            else calculate(obj, vx, obj.real_vx, elapsed_time)
         )
         obj.real_vy = (
-            vy if vy == obj.real_vy else calculate(obj, vy, obj.real_vy, elapsed_time)
+            vy
+            if vy == obj.real_vy
+            else calculate(obj, vy, obj.real_vy, elapsed_time)
         )
 
         new_px = (
-            obj.px + obj.real_vx * obj.speed * obj.attributes.speed_mod * elapsed_time
+            obj.px
+            + obj.real_vx * obj.speed * obj.attributes.speed_mod * elapsed_time
         )
         new_py = (
-            obj.py + obj.real_vy * obj.speed * obj.attributes.speed_mod * elapsed_time
+            obj.py
+            + obj.real_vy * obj.speed * obj.attributes.speed_mod * elapsed_time
         )
 
         return new_px, new_py
@@ -475,7 +509,9 @@ class MimaMode(MimaView):
         for map_name in self.players_on_map:
             for effect in self.effects[map_name]:
                 effect.update(elapsed_time)
-                effect.px, effect.py = self.update_position(effect, elapsed_time)
+                effect.px, effect.py = self.update_position(
+                    effect, elapsed_time
+                )
 
     def update_scenes(self, elapsed_time: float) -> None:
         for player, scene in self.scenes.items():
@@ -494,12 +530,17 @@ class MimaMode(MimaView):
 
     def add_dynamic(self, dynamic: Dynamic, map_name: str):
         self.dynamics[map_name].append(dynamic)
-        if map_name in self.collision_targets and not dynamic.moves_on_collision:
+        if (
+            map_name in self.collision_targets
+            and not dynamic.moves_on_collision
+        ):
             dynamic.chunks = add_to_collision_chunk(
                 self.collision_targets[map_name],
                 dynamic,
                 self.chunk_size,
-                _chunks_per_row(self.chunk_size, self.engine.get_map(map_name).width),
+                _chunks_per_row(
+                    self.chunk_size, self.engine.get_map(map_name).width
+                ),
             )
 
     def add_projectile(self, projectile: Projectile, map_name: str):

mima/view/mima_scene.py

@@ -39,8 +39,10 @@ class MimaScene(MimaView):
         self._camera_name: str = (
             camera_name if camera_name is not None else f"C_{player.name}"
         )
+        self._controls_camera_name: str = f"{self._camera_name}_CONTROLS"
 
         self.camera: Camera
+        self.controls_camera: Camera
         self._dialog_px: float
         self._dialog_py: float
         self._dialog_width: float = DIALOG_WIDTH
@@ -85,6 +87,9 @@ class MimaScene(MimaView):
             self._dialog_py = height - 4
 
         self.camera = Camera(self._camera_name, width, height)
+        # self.controls_camera = Camera(
+        #     self._controls_camera_name, width, height
+        # )
         if position == Position.CENTER:
             # print(f"Camera setup finished: {width}, {height}")
             return
@@ -181,6 +186,7 @@ class MimaScene(MimaView):
             self.skip_draw_ui = False
             return
         self._current_window.draw_ui()
+        self._current_window.draw_controls()
 
     def draw_camera_border(self):
         self.camera.draw_borders()

mima/view/mima_window.py

@@ -6,6 +6,8 @@ from ..types.direction import Direction
 from ..types.keys import Key as K
 from ..types.player import Player
 from ..types.window import Window
+from ..util.colors import TRANS_CYAN, TRANS_LIGHT_RED
+from ..util.constants import BIG_FONT_HEIGHT, BIG_FONT_WIDTH
 from ..util.functions import wrap_text
 from .mima_view import MimaView
 
@@ -92,6 +94,16 @@ class MimaWindow(MimaView):
                     obj.draw_self(
                         self.camera.ox, self.camera.oy, self.camera.name
                     )
+                    if self.engine.draw_dyn_ids:
+                        self.engine.backend.draw_small_text(
+                            f"{obj.dyn_id}",
+                            (obj.px - self.camera.ox)
+                            * self.engine.rtc.tile_width,
+                            (obj.py - self.camera.oy) * obj.sprite.height
+                            + obj.sprite.height,
+                            self.engine.rtc.color_red,
+                            self.camera.name,
+                        )
 
     def draw_effect_layers(
         self, effects: List[Dynamic], layers: List[int]
@@ -116,6 +128,85 @@ class MimaWindow(MimaView):
     def draw_ui(self) -> None:
         pass
 
+    def draw_controls(self) -> None:
+        if not self.engine.show_touch_controls:
+            return
+
+        state = self.engine.keys.get_touch_state()
+        if not state:
+            return
+
+        data_move = state[K.UP]
+        if data_move["active"]:
+            radius = self.engine.rtc.tile_width
+            self.engine.backend.draw_circle(
+                int(data_move["rsx"] * self.camera.pwidth),
+                int(data_move["rsy"] * self.camera.pheight),
+                radius,
+                TRANS_LIGHT_RED,
+                self.camera.name,
+                draw_to_ui=True,
+            )
+            self.engine.backend.fill_circle(
+                int(data_move["rpx"] * self.camera.pwidth),
+                int(data_move["rpy"] * self.camera.pheight),
+                radius,
+                TRANS_LIGHT_RED,
+                self.camera.name,
+                draw_to_ui=True,
+            )
+
+        for idx in range(4, 12):
+            key = K(idx)
+            data = state.get(key, {})
+            if not data:
+                continue
+            # print(data_a)
+
+            ppx = int(data["rpx"] * self.camera.pwidth)
+            ppy = int(data["rpy"] * self.camera.pheight)
+            pwidth = int(data["rwidth"] * self.camera.pwidth)
+            pheight = int(data["rheight"] * self.camera.pheight)
+            if data["active"]:
+                self.engine.backend.fill_rect(
+                    ppx,
+                    ppy,
+                    pwidth,
+                    pheight,
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+            else:
+                self.engine.backend.draw_rect(
+                    ppx,
+                    ppy,
+                    pwidth,
+                    pheight,
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+                text = key.name
+                text_width = len(text) * BIG_FONT_WIDTH
+                self.engine.backend.draw_big_text(
+                    text,
+                    int(ppx + pwidth / 2 - text_width / 2),
+                    int(ppy + pheight / 2 - BIG_FONT_HEIGHT / 2),
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+
+        # self.engine.backend.fill_circle(
+        #     int(data_a["px"] * self.camera.pwidth),
+        #     int(data_a["py"] * self.camera.pheight),
+        #     int(data_a["width"] * self.camera.pwidth / 2),
+        #     color,
+        #     self.camera.name,
+        #     draw_to_ui=True,
+        # )
+
     def set_camera(self, camera: Camera):
         self.camera = camera
 

{mima_engine-0.2.3.dist-info → mima_engine-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mima-engine
-Version: 0.2.3
+Version: 0.2.5
 Summary: A game engine based on pygame.
 Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
 Classifier: Programming Language :: Python :: 3