WIP: Pokemon Gen 1 Game Wrapper Expansion

pyboy/core/debug.pxi

@@ -0,0 +1,5 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+DEF DEBUG=0

pyboy/plugins/game_wrapper_pokemon_gen1/core/battle.py

@@ -0,0 +1,10 @@
+from .memory_object import MemoryObject
+from ..data.memory_addrs.battle import BattleAddress, BATTLE_ADDRESS_LOOKUP
+
+class Battle(MemoryObject):
+
+    _enum = BattleAddress
+    _lookup = BATTLE_ADDRESS_LOOKUP
+
+    def __init__(self, fields_to_track=None):
+        super().__init__(fields_to_track)

pyboy/plugins/game_wrapper_pokemon_gen1/core/game_state.py

@@ -0,0 +1,23 @@
+from ..data.memory_addrs.game_state import GameStateAddress
+
+class GameState():
+
+    def __init__(self,
+                 battle_type
+                ):
+
+        self._battle_type = battle_type
+
+    def is_in_battle(self):
+        return self._battle_type != 0
+
+    @property
+    def battle_type(self):
+        return self._battle_type
+
+    @staticmethod
+    def load_game_state(mem_manager):
+
+        battle_type = mem_manager.read_memory_address(GameStateAddress.BATTLE_TYPE)
+
+        return GameState(battle_type)

pyboy/plugins/game_wrapper_pokemon_gen1/core/mem_manager.pxd

@@ -0,0 +1,10 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+from libc.stdint cimport uint8_t
+from pyboy.pyboy cimport PyBoy
+cimport cython
+
+cdef class MemoryManager:
+    cdef PyBoy pyboy

pyboy/plugins/game_wrapper_pokemon_gen1/core/mem_manager.py

@@ -0,0 +1,205 @@
+from enum import Enum
+from ..data.memory_addrs.base import MemoryAddress, MemoryAddressType
+
+STRING_TERMINATOR = 80
+ASCII_DELTA = 63
+
+MAX_STRING_LENGTH = 16
+
+class MemoryManager():
+
+    def __init__(self, pyboy):
+        self.pyboy = pyboy
+
+    @staticmethod
+    def _byte_to_bitfield(n, reverse : bool):
+        # Force bit extension to 10 chars; 2 for '0x' and 8 for the bits
+        bitlist = [1 if digit=='1' else 0 for digit in format(n, '#010b')[2:]]
+
+        if reverse:
+            bitlist.reverse()
+
+        return bitlist
+
+    @staticmethod
+    def _bitfield_to_byte(bitlist, reverse : bool):
+
+        if reverse: 
+            bitlist.reverse()
+
+        bit_str = ''.join([str(i) for i in bitlist])
+
+        return int(bit_str, 2)
+
+    @staticmethod
+    def get_character_index(character):
+        if character == ' ':
+            return 0x7F
+        if character == '?':
+            return 0xE6
+        if character == '!':
+            return 0xE7
+        if character == 'é':
+            return 0xBA
+
+        index = ord(character)
+        if index > 47 and index < 58:
+            # number
+            return index + 197
+        return index + ASCII_DELTA
+
+    def get_
+
+    def _read_byte(self, addr):
+        return self.pyboy.get_memory_value(addr)
+
+    def _write_byte(self, value, addr):
+        return self.pyboy.set_memory_value(addr, value)
+
+    def read_address_from_memory(self, addr, num_bytes=1):
+        p_addr = 0
+        for i in range(num_bytes):
+            p_addr += self._read_byte(addr+i) << i*8
+        return p_addr
+
+    def read_hex_from_memory(self, addr, num_bytes=1):
+        bytes = []
+        for i in range(num_bytes):
+            bytes.append(self._read_byte(addr + i))
+        # Do not believe there is ever a case where we would 
+        # need to read this in little endian for Pokemon gen 1
+        return int.from_bytes(bytes, byteorder='big')
+
+    def write_hex_to_memory(self, value, addr, num_bytes=1):
+        bytes = value.to_bytes(2, byteorder='big')
+        assert len(bytes) == num_bytes*2
+        for i, byte in enumerate(bytes):
+            self._write_byte(addr + i, byte)
+
+    def read_bcd_from_memory(self, addr, num_bytes=1):
+        byte_str = ""
+        for i in range(num_bytes):
+            byte_str += "%x"%self._read_byte(addr+i)
+        return int(byte_str)
+
+    def write_bcd_to_memory(self, value, addr, num_bytes=1):
+        val_str = str(value)
+        assert len(val_str) <= num_bytes*2
+
+        padded_val = val_str.zfill(num_bytes*2)
+        for i in range(num_bytes):
+            sub_val = int(padded_val[i*2:(i*2)+2], 16)
+            self._write_byte(sub_val, addr+i)
+
+    def read_bitfield_from_memory(self, addr, num_bytes=1, reverse=False):
+        bits = []
+        for i in range(num_bytes):
+            bits.extend(MemoryManager._byte_to_bitfield(self._read_byte(addr+i), reverse))
+        return bits
+
+    def write_bitlist_to_memory(self, value, addr, num_bytes=1, reverse=False):
+
+        # TODO: This check might be too restrictive
+        assert len(value) % 8 == 0
+        # TODO: Maybe don't need this check if we trust users to make value fit
+        assert len(value)/8 == num_bytes
+
+        for i in range(num_bytes):
+            bit_list_start = i*8
+            sub_bit_list = value[bit_list_start:bit_list_start+8]
+            byte_val = MemoryManager._bitfield_to_byte(sub_bit_list, reverse)
+            self._write_byte(byte_val, addr+i)
+
+    def read_text_from_memory(self, address, num_bytes):
+        """
+        Retrieves a string from a given address.
+
+        Args:
+            address (int): Address from where to retrieve text from.
+            cap (int): Maximum expected length of string (default: 16).
+        """
+        # Make sure string to write not too large
+        assert num_bytes <= MAX_STRING_LENGTH
+        text = ''
+        for i in range(num_bytes):
+            value = self._read_byte(address + i)
+            if value == STRING_TERMINATOR:
+                break
+            text += chr(value - ASCII_DELTA)
+        return text
+
+    def write_text_to_memory(self, text, address, num_bytes=1):
+        """Sets text at address.
+
+        Will always add a string terminator (80) at the end.
+        """
+
+        terminated_text = text + '\0'
+        # TODO: Check that this isn't an off-by-one issue
+        assert len(terminated_text) <= num_bytes
+
+        i = 0
+        for i, chr in enumerate(text):
+            self.pyboy.set_memory_value(address + i, MemoryManager.get_character_index(chr))
+
+    def read_memory_address(self, mem_addr):
+        if isinstance(mem_addr, Enum):
+            mem_addr = mem_addr.value
+        if mem_addr.memory_type == MemoryAddressType.HEX:
+            mem_func = self.read_hex_from_memory
+        elif mem_addr.memory_type == MemoryAddressType.ADDRESS:
+            mem_func = self.read_address_from_memory
+        elif mem_addr.memory_type == MemoryAddressType.BCD:
+            mem_func = self.read_bcd_from_memory
+        elif mem_addr.memory_type == MemoryAddressType.BITFIELD:
+            mem_func = self.read_bitfield_from_memory
+        elif mem_addr.memory_type == MemoryAddressType.TEXT:
+            mem_func = self.read_text_from_memory
+        else:
+            raise ValueError(f"{mem_addr.memory_type} is not a valid memory type")
+
+        return mem_func(mem_addr.address, mem_addr.num_bytes)
+
+    def write_memory_address(self, mem_addr):
+        if isinstance(mem_addr, Enum):
+            mem_addr = mem_addr.value
+        if mem_addr.memory_type == MemoryAddressType.HEX:
+            mem_func = self.write_hex_to_memory
+        elif mem_addr.memory_type == MemoryAddressType.ADDRESS:
+            #mem_func = self.write_add
+            pass
+        elif mem_addr.memory_type == MemoryAddressType.BCD:
+            mem_func = self.write_bcd_to_memory
+        elif mem_addr.memory_type == MemoryAddressType.BITFIELD:
+            mem_func = self.write_bitlist_to_memory
+        elif mem_addr.memory_type == MemoryAddressType.TEXT:
+            mem_func = self.write_text_to_memory
+        else:
+            raise ValueError(f"{mem_addr.memory_type} is not a valid memory type")
+
+        return mem_func(mem_addr.address, mem_addr.num_bytes)
+
+    def _load_rombank(self, rombank_selected):
+        self.pyboy.set_memory_value(0x2000, rombank_selected)
+
+    def read_from_rom(self, address, num_bytes=1):
+        rombank = int(address / 0x4000)
+        address_in_rom = address % 0x4000
+
+        # PyBoy treats the switchable ROM bank as being at address
+        # 0x4000 to 0x8000 (0x0000 to 0x4000 is always ROM bank 0),
+        # append 04x4000
+
+        address_in_rom += 0x4000
+
+        # Switch in correct ROM bank
+        self._load_rombank(rombank)
+
+        rom_values = []
+
+        for i in range(num_bytes):
+            rom_values.append(self.pyboy.get_memory_value(address_in_rom+i))
+
+        return rom_values
+
+

pyboy/plugins/game_wrapper_pokemon_gen1/core/memory_object.py

@@ -0,0 +1,21 @@
+class MemoryObject():
+
+    _enum = {}
+    _lookup = {}
+
+    def __init__(self, fields_to_track):
+        if fields_to_track is None:
+            fields_to_track = [e for e in self._enum]
+        self._fields_to_track = fields_to_track
+        self._data = {}
+
+    def _load_field_from_memory(self, mem_manager, field_enum):
+        self.data[field_enum] = mem_manager.read_memory_address(self._lookup[field_enum])
+
+    def load_from_memory(self, mem_manager):
+        for field_enum in self._fields_to_track:
+            self._load_field_from_memory(mem_manager, field_enum)
+
+    def get_value(self, k):
+        return self._data.get(k)
+

pyboy/plugins/game_wrapper_pokemon_gen1/core/move.py

@@ -0,0 +1,19 @@
+from ..data.constants.moves import MoveId
+
+class Move():
+
+    NONEXISTENT_MOVE_STR = "---"
+
+    def __init__(self, move_id):
+        pass
+
+    # We can cheat with just using the enum name as the move name
+    # since there is no move that has any special characters in it
+    @classmethod
+    def get_name_from_id(cls, move_id, camel_case=False):
+        if move_id == 0:
+            return cls.NONEXISTENT_MOVE_STR
+        move_name = MoveId(move_id).name.replace('_', ' ')
+        if camel_case:
+            return move_name.title()
+        return move_name

pyboy/plugins/game_wrapper_pokemon_gen1/core/player.py

@@ -0,0 +1,71 @@
+from ..data.memory_addrs.player import PlayerAddress, PLAYER_ADDRESS_LOOKUP
+from ..data.constants.pokemon import PokemonId
+from ..data.constants.misc import Badge
+from .memory_object import MemoryObject
+
+class Player(MemoryObject):
+
+    _enum = PlayerAddress
+    _lookup = PLAYER_ADDRESS_LOOKUP
+
+    def __init__(self, fields_to_track):
+        super().__init__(fields_to_track)
+
+    '''
+    Getters and setters
+    '''
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, n):
+        # Name truncated to 8 characters
+        self._name = n[:8]
+
+    @property
+    def money(self):
+        return self._money
+
+    @money.setter
+    def money(self, m):
+        # Max money game can store is 999999
+        self._money = min(m, 999999)
+
+    @property
+    def num_pokemon_in_party(self):
+        return len(self._pokemon_in_party)
+
+    @property
+    def num_badges(self):
+        return sum(self._badges)
+
+    '''
+    Badge functionality
+    '''
+    def has_badge(self, badge : Badge):
+        return self._badges[badge.value] == 1
+
+    def give_badge(self, badge : Badge):
+        self._badges[badge.value] = 1
+
+    def remove_badge(self, badge : Badge):
+        self._badges[badge.value] = 0
+
+    @staticmethod
+    def load_player(mem_manager, fields_to_track=None):
+        player = Player(mem_manager, fields_to_track)
+        player.load_from_memory(mem_manager)
+        return player
+
+    # def save_player(self, mem_manager):
+
+    #     mem_manager.write_memory_address(self._name, PlayerAddress.NAME)
+    #     mem_manager.write_memory_address(self.num_pokemon_in_party, PlayerAddress.NUM_POKEMON_IN_PARTY)
+    #     # TODO: Figure out the loading and unloading of Pokemon in party, as that should be in tandem with
+    #     # Pokemon class so that data does not get out of sync
+    #     mem_manager.write_memory_address(self._badges, PlayerAddress.BADGES)
+    #     mem_manager.write_memory_address(self._money, PlayerAddress.MONEY)
+
+
+