def test_randomize_ram(): pyboy = PyBoy(default_rom, window_type="dummy", randomize=False) # RAM banks should all be 0 by default assert not any([pyboy.get_memory_value(x) for x in range(0x8000, 0xA000)]), "VRAM not zeroed" assert not any([pyboy.get_memory_value(x) for x in range(0xC000, 0xE000) ]), "Internal RAM 0 not zeroed" assert not any([pyboy.get_memory_value(x) for x in range(0xFE00, 0xFEA0)]), "OAM not zeroed" assert not any([pyboy.get_memory_value(x) for x in range(0xFEA0, 0xFF00) ]), "Non-IO internal RAM 0 not zeroed" assert not any([pyboy.get_memory_value(x) for x in range(0xFF4C, 0xFF80) ]), "Non-IO internal RAM 1 not zeroed" assert not any([pyboy.get_memory_value(x) for x in range(0xFF80, 0xFFFF) ]), "Internal RAM 1 not zeroed" pyboy.stop(save=False) pyboy = PyBoy(default_rom, window_type="dummy", randomize=True) # RAM banks should have at least one nonzero value now assert any([pyboy.get_memory_value(x) for x in range(0x8000, 0xA000)]), "VRAM not randomized" assert any([pyboy.get_memory_value(x) for x in range(0xC000, 0xE000) ]), "Internal RAM 0 not randomized" assert any([pyboy.get_memory_value(x) for x in range(0xFE00, 0xFEA0)]), "OAM not randomized" assert any([pyboy.get_memory_value(x) for x in range(0xFEA0, 0xFF00) ]), "Non-IO internal RAM 0 not randomized" assert any([pyboy.get_memory_value(x) for x in range(0xFF4C, 0xFF80) ]), "Non-IO internal RAM 1 not randomized" assert any([pyboy.get_memory_value(x) for x in range(0xFF80, 0xFFFF) ]), "Internal RAM 1 not randomized" pyboy.stop(save=False)
def test_mooneye(clean, rom): global saved_state # Has to be in here. Otherwise all test workers will import this file, and cause an error. mooneye_dir = "mooneye" if not os.path.isdir(mooneye_dir): print( urllib.request.urlopen( "https://pyboy.dk/mirror/LICENSE.mooneye.txt").read()) mooneye_data = io.BytesIO( urllib.request.urlopen( "https://pyboy.dk/mirror/mooneye.zip").read()) with ZipFile(mooneye_data) as _zip: _zip.extractall(mooneye_dir) if saved_state is None: # HACK: We load any rom and load it until the last frame in the boot rom. # Then we save it, so we won't need to redo it. pyboy = PyBoy(default_rom, window_type="dummy") pyboy.set_emulation_speed(0) saved_state = io.BytesIO() for _ in range(59): pyboy.tick() pyboy.save_state(saved_state) pyboy.stop(save=False) pyboy = PyBoy(rom, window_type="headless") pyboy.set_emulation_speed(0) saved_state.seek(0) if clean: for _ in range(59): pyboy.tick() else: pyboy.load_state(saved_state) for _ in range(180 if "div_write" in rom else 40): pyboy.tick() png_path = Path(f"test_results/{rom}.png") image = pyboy.botsupport_manager().screen().screen_image() if OVERWRITE_PNGS: png_path.parents[0].mkdir(parents=True, exist_ok=True) image.save(png_path) else: old_image = PIL.Image.open(png_path) if "acceptance" in rom: # The registers are too volatile to depend on. We crop the top out, and only match the assertions. diff = PIL.ImageChops.difference(image.crop((0, 72, 160, 144)), old_image.crop((0, 72, 160, 144))) else: diff = PIL.ImageChops.difference(image, old_image) if diff.getbbox() and not os.environ.get("TEST_CI"): image.show() old_image.show() diff.show() assert not diff.getbbox(), f"Images are different! {rom}" pyboy.stop(save=False)
def __init__(self, filename, max_steps, visualize=False): self.pyboy = PyBoy(filename, window_type="headless" if not visualize else "SDL2", window_scale=3, debug=visualize, game_wrapper=True) assert self.pyboy.cartridge_title() == "SUPER MARIOLAN" self.pyboy.set_emulation_speed(0) self.mario = self.pyboy.game_wrapper() self.mario_lives = None self.mario_size = 0 self.fitness_score = 0 self.previous_fitness_score = 0 self.previous_direction = 0 self._level_progress_max = 0 self.observation_space = (16, 20) self.action_space = [4] self.max_steps = max_steps self.pair_actions = {"5": 13, "3": 11, "4": 12, "0": 0} self.action_jump = [ WindowEvent.PRESS_BUTTON_A, WindowEvent.RELEASE_BUTTON_A ] self.action_direction = [ WindowEvent.PRESS_ARROW_LEFT, WindowEvent.PRESS_ARROW_RIGHT, 0 ]
def test_start_level(self): pyboy = PyBoy(supermarioland_rom, window_type="dummy", game_wrapper=True) pyboy.set_emulation_speed(0) starting_level = (2, 1) env = pyboy.openai_gym(observation_type="minimal", action_type="toggle", world_level=starting_level) if env is None: raise Exception( "'env' is None. Did you remember to install 'gym'?") observation = env.reset() print(env.game_wrapper.world, starting_level) assert env.game_wrapper.world == starting_level env.game_wrapper.set_lives_left(0) env.step(4) # PRESS LEFT for _ in range(200): env.step(0) assert env.game_wrapper.time_left == 399 assert env.game_wrapper.world == starting_level
def test_tiles(): pyboy = PyBoy(tetris_rom, window_type='headless', disable_input=True) pyboy.set_emulation_speed(0) tile = pyboy.get_window_tile_map().get_tile(0, 0) image = tile.image() assert isinstance(image, PIL.Image.Image) ndarray = tile.image_ndarray() assert isinstance(ndarray, np.ndarray) assert ndarray.shape == (8, 8, 4) assert ndarray.dtype == np.uint8 data = tile.image_data() assert data.shape == (8, 8) for identifier in range(384): t = pyboy.get_tile(identifier) assert t.identifier == identifier if identifier > 0xFF: assert t.index[1] == identifier - botsupport.constants.LOW_TILEDATA_NTILES else: assert t.index[1] == identifier with pytest.raises(Exception): pyboy.get_tile(-1) with pytest.raises(Exception): pyboy.get_tile(385) pyboy.stop(save=False)
def run_rom(rom): pyboy = PyBoy(rom, window_type="dummy") pyboy.set_emulation_speed(0) t = time.time() result = "" while not pyboy.tick(): b = pyboy._serial() if b != "": result += b t = time.time() if pyboy._is_cpu_stuck(): break for _ in range(10): pyboy.tick() pyboy.stop(save=False) result += pyboy._serial( ) # Getting the absolute last. Some times the tests says "Failed X tests". if result == "": n = 0 while True: char = pyboy.get_memory_value(0xA004 + n) if char != 0: result += chr(char) n += 1 if n > 250: break return result
def main(): # Automatically bump to '-OO' optimizations if __debug__: os.execl(sys.executable, sys.executable, '-OO', *sys.argv) bootrom = "ROMs/DMG_ROM.bin" romdir = "ROMs/" scale = 3 # Verify directories if bootrom is not None and not os.path.exists(bootrom): print("Boot-ROM not found. Please copy the Boot-ROM to '%s'. Using replacement in the meanwhile..." % bootrom) bootrom = None if not os.path.exists(romdir) and len(sys.argv) < 2: print("ROM folder not found. Please copy the Game-ROM to '%s'".format(romdir)) exit() try: # Check if the ROM is given through argv if len(sys.argv) > 2: # First arg is SDL2/PyGame filename = sys.argv[2] else: filename = getROM(romdir) # Start PyBoy and run loop pyboy = PyBoy(sys.argv[1] if len(sys.argv) > 1 else None, scale, filename, bootrom) while not pyboy.tick(): pass pyboy.stop() except KeyboardInterrupt: print("Interrupted by keyboard") except Exception: traceback.print_exc()
def run_rom(rom): # logger.info(rom) pyboy = PyBoy(rom, window_type="dummy", window_scale=1, bootrom_file="ROMs/DMG_ROM.bin", disable_input=True) # pyboy = PyBoy("ROMs/DMG_ROM.bin", window_type="SDL2", window_scale=1, bootrom_file=rom, disable_input=True) pyboy.disable_title() pyboy.set_emulation_speed(0) serial_output = "" t = time.time() result = None while not pyboy.tick(): b = pyboy.get_serial() if b != "": serial_output += b t = time.time() if "Passed" in serial_output: result = ("Passed") break elif "Failed" in serial_output: result = (serial_output) break if time.time() - t > timeout: result = ("Timeout:\n" + serial_output) break pyboy.stop(save=False) return result
def run_rom(args): rom, frame_limit = args pyboy = PyBoy(rom, window_type="dummy", window_scale=1, bootrom_file=utils.boot_rom, disable_input=True) pyboy.set_emulation_speed(0) serial_output = "" t = time.time() result = None frame_count = 0 while not pyboy.tick(): b = pyboy._serial() if b != "": serial_output += b t = time.time() if "Passed" in serial_output: result = ("Passed") break elif "Failed" in serial_output: result = (serial_output) break if frame_limit == -1 and time.time() - t > timeout: result = ("Timeout:\n" + serial_output) break elif frame_count == frame_limit: result = ("Frame limit reached:\n" + serial_output) break frame_count += 1 pyboy.stop(save=False) return result
def replay(ROM, replay, verify=True): pyboy = PyBoy(ROM, disable_input=True) pyboy.set_emulation_speed(0) with open(replay, 'rb') as f: recorded_input = json.loads(zlib.decompress(f.read()).decode('ascii')) # Filters out the blacklisted events recorded_input = list( map( lambda event_tuple: ( event_tuple[0], list(filter(lambda x: x not in event_filter, event_tuple[1])), # event_tuple[2] ), recorded_input)) frame_count = 0 next_event = recorded_input.pop(0) while recorded_input != []: if next_event[0] == frame_count: for e in next_event[1]: pyboy.send_input(e) # if verify: # assert verify_screen_image_np(pyboy, base64.b64decode(next_event[2].encode('utf8'))) next_event = recorded_input.pop(0) frame_count += 1 pyboy.tick() pyboy.stop(save=False)
async def on_message(message): if message.author != client.user: if message.content.startswith(config.prefix): text = message.content[config.prefix_len:] if text.startswith("run"): game.gb = PyBoy("data/PokemonRouge.gb") game.bot_supp = game.gb.botsupport_manager() game.gb.set_emulation_speed(4) game.channel = message.channel game.pause = False await message.channel.send("Starting: " + game.gb.cartridge_title()) elif text.startswith("stop"): game.gb.stop() game.channel = None game.bot_supp = None game.gb = None game.pause = True elif text.startswith("pause"): game.gb.send_input(WindowEvent.PAUSE) game.pause = True elif text.startswith("unpause"): game.gb.send_input(WindowEvent.PAUSE) game.pause = False elif text.startswith("name"): await message.channel.send("Running: " + game.gb.cartridge_title()) elif text in input_list.keys() and message.channel == game.channel: game.gb.send_input(input_list[text])
def test_rom(rom): logger.info(rom) pyboy = PyBoy("dummy", 1, rom, "ROMs/DMG_ROM.bin") # pyboy = PyBoy("SDL2", 1, rom, "ROMs/DMG_ROM.bin") pyboy.disableTitle() pyboy.setEmulationSpeed(False) serial_output = "" t = time.time() result = None while not pyboy.tick(): b = pyboy.getSerial() if b != "": serial_output += b # print b, t = time.time() if "Passed" in serial_output: result = ("Passed") break elif "Failed" in serial_output: result = (serial_output) break if time.time() - t > timeout: result = ("Timeout:\n" + serial_output) break print(serial_output) pyboy.stop(save=False) return result
def test_dmg_acid(): # Has to be in here. Otherwise all test workers will import the file, and cause an error. dmg_acid_file = "dmg_acid2.gb" if not os.path.isfile(dmg_acid_file): print( urllib.request.urlopen( "https://pyboy.dk/mirror/LICENSE.dmg-acid2.txt").read()) dmg_acid_data = urllib.request.urlopen( "https://pyboy.dk/mirror/dmg-acid2.gb").read() with open(dmg_acid_file, "wb") as rom_file: rom_file.write(dmg_acid_data) pyboy = PyBoy(dmg_acid_file, window_type="headless") pyboy.set_emulation_speed(0) for _ in range(59): pyboy.tick() for _ in range(25): pyboy.tick() png_path = Path(f"test_results/{dmg_acid_file}.png") image = pyboy.botsupport_manager().screen().screen_image() if OVERWRITE_PNGS: png_path.parents[0].mkdir(parents=True, exist_ok=True) image.save(png_path) else: old_image = PIL.Image.open(png_path) diff = PIL.ImageChops.difference(image, old_image) if diff.getbbox() and not os.environ.get("TEST_CI"): image.show() old_image.show() diff.show() assert not diff.getbbox(), f"Images are different! {dmg_acid_file}" pyboy.stop(save=False)
def test_tilemap_position_list(): pyboy = PyBoy(supermarioland_rom, window_type="headless") for _ in range(100): pyboy.tick() # Start the game pyboy.send_input(WindowEvent.PRESS_BUTTON_START) pyboy.tick() pyboy.send_input(WindowEvent.RELEASE_BUTTON_START) # Move right for 100 frame pyboy.send_input(WindowEvent.PRESS_ARROW_RIGHT) for _ in range(100): pyboy.tick() # Get screen positions, and verify the values positions = pyboy.botsupport_manager().screen().tilemap_position_list() for y in range(1, 16): assert positions[y][0] == 0 # HUD for y in range(16, 144): assert positions[y][0] == 49 # Actual screen position # Progress another 10 frames to see and increase in SCX for _ in range(10): pyboy.tick() # Get screen positions, and verify the values positions = pyboy.botsupport_manager().screen().tilemap_position_list() for y in range(1, 16): assert positions[y][0] == 0 # HUD for y in range(16, 144): assert positions[y][0] == 59 # Actual screen position pyboy.stop(save=False)
def pyboy(): pyboy = PyBoy(tetris_rom, window_type="headless", disable_input=True, game_wrapper=True) pyboy.set_emulation_speed(0) return pyboy
def main(): argv = parser.parse_args() log_level(argv.log_level) logger.info( """ The Game Boy controls are as follows: | Keyboard key | GameBoy equivalant | | --- | --- | | Up | Up | | Down | Down | | Left | Left | | Right | Right | | A | A | | S | B | | Return | Start | | Backspace | Select | The other controls for the emulator: | Keyboard key | Emulator function | | --- | --- | | Escape | Quit | | D | Debug | | Space | Unlimited FPS | | Z | Save state | | X | Load state | | I | Toggle screen recording | | O | Save screenshot | | , | Rewind backwards | | . | Rewind forward | See "pyboy --help" for how to enable rewind and other awesome features! """ ) # Start PyBoy and run loop pyboy = PyBoy(argv.ROM, **vars(argv)) if argv.loadstate is not None: if argv.loadstate == INTERNAL_LOADSTATE: # Guess filepath from ROM path state_path = argv.ROM + ".state" else: # Use filepath given state_path = argv.loadstate valid_file_path(state_path) with open(state_path, "rb") as f: pyboy.load_state(f) while not pyboy.tick(): pass pyboy.stop() if argv.profiling: print("\n".join(profiling_printer(pyboy._cpu_hitrate())))
def test_misc(): pyboy = PyBoy(any_rom, window_type="dummy", bootrom_file=boot_rom, disable_input=True, hide_window=True) pyboy.tick() pyboy.stop(save=False)
def eval_network(epoch, child_index, child_model): pyboy = PyBoy('SuperMarioLand.gb', game_wrapper=True) #, window_type="headless") pyboy.set_emulation_speed(3) mario = pyboy.game_wrapper() mario.start_game() # start off with just one life each mario.set_lives_left(0) run = 0 scores = [] fitness_scores = [] level_progress = [] time_left = [] # prev_action = np.asarray([1,0]) # do_action(prev_action, pyboy) while run < run_per_child: # do some things action = get_action(pyboy, mario, child_model) action = action.detach().numpy() action = np.where(action < np.max(action), 0, action) action = np.where(action == np.max(action), 1, action) action = action.astype(int) action = action.reshape((2, )) # do_action_multiple(prev_action,action,pyboy) do_action(action, pyboy) # prev_action = action # Game over: if mario.game_over() or mario.score == max_score: scores.append(mario.score) #fitness_scores.append(mario.fitness) fitness_scores.append( fitness_calc(mario.score, mario.level_progress, mario.time_left)) level_progress.append(mario.level_progress) time_left.append(mario.time_left) if run == run_per_child - 1: pyboy.stop() else: mario.reset_game() run += 1 child_fitness = np.average(fitness_scores) logger.info("-" * 20) logger.info("Iteration %s - child %s" % (epoch, child_index)) logger.info("Score: %s, Level Progress: %s, Time Left %s" % (scores, level_progress, time_left)) logger.info("Fitness: %s" % child_fitness) #logger.info("Output weight:") #weights = {} #for i, j in zip(feature_names, child_model.output.weight.data.tolist()[0]): # weights[i] = np.round(j, 3) #logger.info(weights) return child_fitness
def test_disable_title(): # Simply tests, that no exception is generated pyboy = PyBoy(any_rom, window_type="dummy", disable_input=True, hide_window=True) pyboy.disable_title() pyboy.tick() pyboy.stop(save=False)
def test_all_argv(): pyboy = PyBoy(any_rom, window_type="dummy", bootrom_file=utils.boot_rom, disable_input=True, hide_window=True) pyboy.tick() pyboy.send_input(windowevent.QUIT) pyboy.stop(save=False)
def loadCartridge(filePath, quiet=True, emSpd=1): pyboy = PyBoy(filePath, window_type="headless" if quiet else "SDL2", window_scale=3, debug=not quiet, game_wrapper=True) pyboy.set_emulation_speed(emSpd) pyboy.cartridge_title() == "SUPER MARIOLAN" return pyboy
def test_screen_buffer_and_image(): for window, dims, cformat, boot_logo_hash_predigested in [ # These are different because the underlying format is different. We'll test the actual image afterwards. ("SDL2", (160, 144), 'RGBA', b'=\xff\xf9z 6\xf0\xe9\xcb\x05J`PM5\xd4rX+\x1b~z\xef1\xe0\x82\xc4t\x06\x82\x12C' ), ("headless", (160, 144), 'RGBA', b'=\xff\xf9z 6\xf0\xe9\xcb\x05J`PM5\xd4rX+\x1b~z\xef1\xe0\x82\xc4t\x06\x82\x12C' ), ("OpenGL", (144, 160), 'RGB', b's\xd1R\x88\xe0a\x14\xd0\xd2\xecOk\xe8b\xae.\x0e\x1e\xb6R\xc2\xe9:\xa2\x0f\xae\xa2\x89M\xbf\xd8|' ) ]: pyboy = PyBoy(any_rom, window_type=window, window_scale=1, bootrom_file=boot_rom, disable_input=True, hide_window=True) pyboy.set_emulation_speed(0) for n in range(275): # Iterate to boot logo pyboy.tick() assert pyboy.get_raw_screen_buffer_dims() == dims assert pyboy.get_raw_screen_buffer_format() == cformat boot_logo_hash = hashlib.sha256() boot_logo_hash.update(pyboy.get_raw_screen_buffer()) assert boot_logo_hash.digest() == boot_logo_hash_predigested assert isinstance(pyboy.get_raw_screen_buffer(), bytes) # The output of `get_screen_image` is supposed to be homogeneous, which means a shared hash between versions. boot_logo_png_hash_predigested = ( b'\xf4b,(\xbe\xaa\xf8\xec\x06\x9fJ-\x84\xd3I\x16\xb8' b'\xe3\xd0\xd5\xae\x80\x01\x1e\x96\xba!1\xeb\xd1\xce_') boot_logo_png_hash = hashlib.sha256() image = pyboy.get_screen_image() assert isinstance(image, PIL.Image.Image) image_data = io.BytesIO() image.save(image_data, format='BMP') boot_logo_png_hash.update(image_data.getvalue()) assert boot_logo_png_hash.digest() == boot_logo_png_hash_predigested # get_screen_ndarray numpy_hash = hashlib.sha256() numpy_array = np.ascontiguousarray(pyboy.get_screen_ndarray()) assert isinstance(pyboy.get_screen_ndarray(), np.ndarray) assert numpy_array.shape == (144, 160, 3) numpy_hash.update(numpy_array.tobytes()) assert numpy_hash.digest() == ( b'\r\t\x87\x131\xe8\x06\x82\xcaO=\n\x1e\xa2K$' b'\xd6\x8e\x91R( H7\xd8a*B+\xc7\x1f\x19') pyboy.stop(save=False)
def eval_genome(genome, config): global max_fitness pyboy = PyBoy('SuperMarioLand.gb', game_wrapper=True) #, window_type="headless") pyboy.set_emulation_speed(0) mario = pyboy.game_wrapper() mario.start_game() # start off with just one life each mario.set_lives_left(0) run = 0 scores = [] fitness_scores = [] level_progress = [] time_left = [] # create NN from neat model = neat.nn.FeedForwardNetwork.create(genome, config) child_fitness = 0 while run < run_per_child: # do some things action = get_action_neat(pyboy, mario, model) action = np.asarray([np.mean(val) for val in action]) action = np.where(action < np.max(action), 0, action) action = np.where(action == np.max(action), 1, action) action = action.astype(int) action = action.reshape((2, )) do_action(action, pyboy) # Game over: if mario.game_over() or mario.score == max_score: scores.append(mario.score) fitness_scores.append( fitness_calc(mario.score, mario.level_progress, mario.time_left)) level_progress.append(mario.level_progress) time_left.append(mario.time_left) if run == run_per_child - 1: pyboy.stop() else: mario.reset_game() run += 1 child_fitness = np.average(fitness_scores) #logger.info("-" * 20) #logger.info("Iteration %s - child %s" % (epoch, child_index)) #logger.info("Score: %s, Level Progress: %s, Time Left %s" % (scores, level_progress, time_left)) #logger.info("Fitness: %s" % child_fitness) return child_fitness
def __init__(self, args): self.locations = [] self.events = [ 'D5F3', 'D60D', 'D700', 'D70B', 'D70C', 'D70D', 'D70E', 'D710', 'D714', 'D72E', 'D751', 'D755', 'D75E', 'D773', 'D77C', 'D782', 'D790', 'D792', 'D79A', 'D7B3', 'D7D4', 'D7D8', 'D7E0', 'D7EE', 'D803', 'D85F' ] self.towns_visited = 0 self.event_tot = 0 self.badges = 0 self.owned_pokemon = 0 self.position = {} self.actions_since_moved = 0 self.pyboy = PyBoy( args.rom, window_type= "headless", # For unattended use, for example machine learning ) self.pyboy.disable_title() self.transform = transforms.Compose( [transforms.Resize(64), transforms.ToTensor()]) self.args = args self.action_space = 6 self.pyboy.set_emulation_speed(0) self.buffered_state = io.BytesIO() if args.save_state != "": self.pyboy.load_state(open(args.save_state, 'rb')) self.pyboy.save_state(self.buffered_state) else: for n in tqdm( range(4000)): # Move ahead the desired number of frames. self.pyboy.tick() if 1298 == n: self.pyboy.send_input(windowevent.PRESS_BUTTON_START) elif n == 1320: self.pyboy.send_input(windowevent.RELEASE_BUTTON_START) elif n > 1320 and n % 2 == 0: self.pyboy.send_input(windowevent.PRESS_BUTTON_A) elif n > 1320 and n % 2 != 0: self.pyboy.send_input(windowevent.RELEASE_BUTTON_A) self.pyboy.save_state(open('start_game.state', 'wb')) self.pyboy.save_state(self.buffered_state) self.position['x'] = self.pyboy.get_memory_value(0xd361) self.position['y'] = self.pyboy.get_memory_value(0xd362) self.pyboy.send_input(SCREEN_RECORDING_TOGGLE) self.pyboy.tick() frame = self.transform(self.pyboy.get_screen_image()) self.state_size = frame.size(-1) * frame.size(-2) * frame.size(-3)
def pokemon(): pyboy = PyBoy( 'roms/Pokemon-VersionBleue(France).gb', window_type="headless", # "SDL2" if hidden window_scale=3, debug=False, game_wrapper=True) pyboy.set_emulation_speed(0) # while not pyboy.tick(): # pass return pyboy
def get_set_override(): pyboy = PyBoy(default_rom, window_type="dummy") pyboy.tick() assert pyboy.get_memory_value(0xFF40) == 0x91 assert pyboy.set_memory_value(0xFF40) == 0x12 assert pyboy.get_memory_value(0xFF40) == 0x12 assert pyboy.get_memory_value(0x0002) == 0xFE assert pyboy.override_memory_value(0x0002) == 0x12 assert pyboy.get_memory_value(0x0002) == 0x12 pyboy.stop(save=False)
def setup_pyboy(self): # load rom through PyBoy dir_path = os.path.dirname(os.path.realpath(__file__)) rom_dir = os.path.join(dir_path, 'roms') self.pyboy = PyBoy(os.path.join(rom_dir, 'Pokemon.gb')) # set up PyBoy screen support self.bot_sup = self.pyboy.botsupport_manager() self.scrn = self.bot_sup.screen() # minimize PyBoy window pyboy_handle = ctypes.windll.user32.FindWindowW(None, "PyBoy") ctypes.windll.user32.ShowWindow(pyboy_handle, 6)
def __init__(self, rom_path, name, host, port, savestate, password): self.pyboy = PyBoy(rom_path) if savestate: file_like_object = open(savestate, "rb") self.pyboy.load_state(file_like_object) self.host = host self.port = port self.currMap = -1 self.x = 0 self.y = 0 self.rivalMap = -1 self.rivalX = 0 self.rivalY = 0 self.rivalFacing = 0 self.rivalSpriteNum = 15 self.prevmoFlags = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] self.rivalSprite = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] self.sprite = [] #initial dex self.pokedex = pokedexOwned([ self.pyboy.get_memory_value(t) for t in range(POKEDEX_RANGE_START, POKEDEX_RANGE_END + 1) ]) #list of wild pokemon locked out by opp self.lockedOutWilds = [] #initial badges self.badges = badgesOwned(self.pyboy.get_memory_value(BADGES_ACQUIRED)) #game options self.gameOptions = None #connect to server and send nickname self.Connect((self.host, self.port)) connection.Send({"action": "nickname", "nickname": name}) #reaaal basic passwording here connection.Send({ "action": "verifyPasswordCheckCapacity", "password": password })
def _abstractStart(self, gameROM, bootROM) -> None: """Start the PyBoy emulator. Parameters ---------- gameROM: str File path to the game ROM to use. bootROM: str File path to the boot ROM to use. """ self._pyboy = PyBoy(gameROM, default_ram_file=bootROM, window_type="headless") self._pyboy.set_emulation_speed(False)
def test_mario_basics(): pyboy = PyBoy(supermarioland_rom, window_type="dummy", game_wrapper=True) pyboy.set_emulation_speed(0) assert pyboy.cartridge_title() == "SUPER MARIOLAN" mario = pyboy.game_wrapper() mario.start_game(world_level=(1, 1)) assert mario.score == 0 assert mario.lives_left == 2 assert mario.time_left == 400 assert mario.world == (1, 1) assert mario.fitness == 0 # A built-in fitness score for AI development pyboy.stop()