def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev == 0: # not a regular savegame, usually a map self.final_path = self.original_path elif rev == VERSION.SAVEGAMEREVISION: # the current version self.final_path = self.original_path else: # upgrade self.using_temp = True handle, self.final_path = tempfile.mkstemp(prefix='uh-savegame.' + os.path.basename(os.path.splitext(self.original_path)[0]) + '.', suffix='.sqlite') os.close(handle) shutil.copyfile(self.original_path, self.final_path) db = DbReader(self.final_path) if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) db.close()
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev == 0: # not a regular savegame, usually a map self.final_path = self.original_path elif rev == VERSION.SAVEGAMEREVISION: # the current version self.final_path = self.original_path else: # upgrade self.using_temp = True handle, self.final_path = tempfile.mkstemp(prefix='uh-savegame.' + os.path.basename(os.path.splitext(self.original_path)[0]) + '.', suffix='.sqlite') os.close(handle) shutil.copyfile(self.original_path, self.final_path) db = DbReader(self.final_path) db('BEGIN TRANSACTION') if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) if rev < 53: self._upgrade_to_rev53(db) if rev < 54: self._upgrade_to_rev54(db) if rev < 55: self._upgrade_to_rev55(db) if rev < 56: self._upgrade_to_rev56(db) if rev < 57: self._upgrade_to_rev57(db) if rev < 58: self._upgrade_to_rev58(db) if rev < 59: self._upgrade_to_rev59(db) if rev < 60: self._upgrade_to_rev60(db) if rev < 61: self._upgrade_to_rev61(db) if rev < 62: self._upgrade_to_rev62(db) if rev < 63: self._upgrade_to_rev63(db) if rev < 64: self._upgrade_to_rev64(db) if rev < 65: self._upgrade_to_rev65(db) if rev < 66: self._upgrade_to_rev66(db) if rev < 67: self._upgrade_to_rev67(db) db('COMMIT') db.close()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) map_file = None try: map_file = map_files[gui.collectData(savegamelist)] except IndexError: # this was a click in the savegame list, but not on an element # it happens when the savegame list is empty return savegame_info = SavegameManager.get_metadata(map_file) details_label = pychan.widgets.Label(min_size=(140, 0), max_size=(140, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info["timestamp"] == -1: details_label.text += _("Unknown savedate\n") else: details_label.text += _("Saved at %s\n") % time.strftime( "%H:%M, %A, %B %d", time.localtime(savegame_info["timestamp"]) ) counter = savegame_info["savecounter"] # N_ takes care of plural forms for different languages details_label.text += N_("Saved %(counter)d time\n", "Saved %(counter)d times\n", counter) % { "counter": counter } details_label.stylize("book_t") from horizons.constants import VERSION try: if savegame_info["savegamerev"] == VERSION.SAVEGAMEREVISION: details_label.text += _("Savegame ver. %d") % (savegame_info["savegamerev"]) else: details_label.text += _("WARNING: Incompatible ver. %(ver)d!\nNeed ver. %(need)d!") % { "ver": savegame_info["savegamerev"], "need": VERSION.SAVEGAMEREVISION, } except KeyError: details_label.text += _("INCOMPATIBLE VERSION\n") box.addChild(details_label) """ if savegame_info['screenshot']: fd, filename = tempfile.mkstemp() os.fdopen(fd, "w").write(savegame_info['screenshot']) box.addChild( pychan.widgets.Icon(image=filename) ) """ gui.adaptLayout()
def load(self, savegame, players, is_scenario=False, campaign={}): """Loads a map. @param savegame: path to the savegame database. @param players: iterable of dictionaries containing id, name, color and local @param is_scenario: Bool whether the loaded map is a scenario or not """ if is_scenario: # savegame is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler(self, savegame) savegame = os.path.join(SavegameManager.maps_dir, \ self.scenario_eventhandler.get_map_file()) self.campaign = campaign self.log.debug("Session: Loading from %s", savegame) savegame_db = SavegameAccessor(savegame) # Initialize new dbreader try: # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = SavegameManager.get_metadata(savegame)['savecounter'] except KeyError: self.savecounter = 0 self.world = World(self) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db) self.view.load(savegame_db) # load view if not self.is_game_loaded(): # NOTE: this must be sorted before iteration, cause there is no defined order for # iterating a dict, and it must happen in the same order for mp games. for i in sorted(players): self.world.setup_player(i['id'], i['name'], i['color'], i['local']) center = self.world.init_new_world() self.view.center(center[0], center[1]) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load(savegame_db) # load the manager (there might me old scheduled ticks). self.ingame_gui.load(savegame_db) # load the old gui positions and stuff for instance_id in savegame_db("SELECT id FROM selected WHERE `group` IS NULL"): # Set old selected instance obj = WorldObject.get_object_by_id(instance_id[0]) self.selected_instances.add(obj) obj.select() for group in xrange(len(self.selection_groups)): # load user defined unit groups for instance_id in savegame_db("SELECT id FROM selected WHERE `group` = ?", group): self.selection_groups[group].add(WorldObject.get_object_by_id(instance_id[0])) # cursor has to be inited last, else player interacts with a not inited world with it. self.cursor = SelectionTool(self) self.cursor.apply_select() # Set cursor correctly, menus might need to be opened. assert hasattr(self.world, "player"), 'Error: there is no human player' """
def tmp_show_details(): """Fetches details of selected savegame and displays it""" box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) map_file = None try: map_file = map_files[gui.collectData(savegamelist)] except IndexError: # this was a click in the savegame list, but not on an element # it happens when the savegame list is empty return savegame_info = SavegameManager.get_metadata(map_file) details_label = pychan.widgets.Label(min_size=(140, 0), max_size=(140, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += _("Unknown savedate\n") else: details_label.text += _("Saved at %s\n") % \ time.strftime(_("%H:%M, %A, %B %d"), time.localtime(savegame_info['timestamp'])) counter = savegame_info['savecounter'] # N_ takes care of plural forms for different languages details_label.text += N_("Saved %(counter)d time\n", \ "Saved %(counter)d times\n", \ counter) % {'counter':counter} details_label.stylize('book_t') from horizons.constants import VERSION try: if savegame_info['savegamerev'] == VERSION.SAVEGAMEREVISION: details_label.text += _("Savegame ver. %d") % ( savegame_info['savegamerev'] ) else: details_label.text += _("WARNING: Incompatible ver. %(ver)d!\nNeed ver. %(need)d!") \ % {'ver' : savegame_info['savegamerev'], 'need' : VERSION.SAVEGAMEREVISION} except KeyError: details_label.text += _("INCOMPATIBLE VERSION\n") box.addChild( details_label ) """ if savegame_info['screenshot']: fd, filename = tempfile.mkstemp() os.fdopen(fd, "w").write(savegame_info['screenshot']) box.addChild( pychan.widgets.Icon(image=filename) ) """ gui.adaptLayout()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) savegame_info = SavegameManager.get_metadata(map_files[gui.collectData(savegamelist)]) details_label = pychan.widgets.Label(min_size=(140, 0), max_size=(140, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += _("Unknown savedate\n") else: details_label.text += _("Saved at %s\n") % \ time.strftime(_("%H:%M, %A, %B %d"), time.localtime(savegame_info['timestamp'])) counter = savegame_info['savecounter'] # N_ takes care of plural forms for different languages details_label.text += N_("Saved %(counter)d time\n", \ "Saved %(counter)d times\n", \ counter) % {'counter':counter} details_label.stylize('book_t') from horizons.constants import VERSION try: if savegame_info['savegamerev'] == VERSION.SAVEGAMEREVISION: details_label.text += _("Savegame ver. %d") % ( savegame_info['savegamerev'] ) else: details_label.text += _("WARNING: Incompatible ver. %(ver)d!\nNeed ver. %(need)d!") \ % {'ver' : savegame_info['savegamerev'], 'need' : VERSION.SAVEGAMEREVISION} except KeyError: details_label.text += _("INCOMPATIBLE VERSION\n") box.addChild( details_label ) """ if savegame_info['screenshot']: fd, filename = tempfile.mkstemp() os.fdopen(fd, "w").write(savegame_info['screenshot']) box.addChild( pychan.widgets.Icon(image=filename) ) """ gui.adaptLayout()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) savegame_info = SavegameManager.get_metadata(map_files[gui.collectData(savegamelist)]) details_label = pychan.widgets.Label(min_size=(140, 0), max_size=(140, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += _("Unknown savedate\n") else: details_label.text += _("Saved at %s\n") % \ time.strftime(_("%H:%M, %A, %B %d"), time.localtime(savegame_info['timestamp'])) if savegame_info['savecounter'] == 1: details_label.text += _("Saved 1 time\n") else: details_label.text += _("Saved %d times\n") % savegame_info['savecounter'] details_label.stylize('book_t') from horizons.constants import VERSION try: if savegame_info['savegamerev'] == VERSION.SAVEGAMEREVISION: details_label.text += _("Savegame ver. %d") % ( savegame_info['savegamerev'] ) else: details_label.text += _("WARNING: Incompatible ver. %(ver)d!\nNeed ver. %(need)d!") \ % {'ver' : savegame_info['savegamerev'], 'need' : VERSION.SAVEGAMEREVISION} except KeyError: details_label.text += _("INCOMPATIBLE VERSION\n") box.addChild( details_label ) """ if savegame_info['screenshot']: fd, filename = tempfile.mkstemp() os.fdopen(fd, "w").write(savegame_info['screenshot']) box.addChild( pychan.widgets.Icon(image=filename) ) """ gui.adaptLayout()
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev < VERSION.SAVEGAMEREVISION: if not SavegameUpgrader.can_upgrade(rev): raise SavegameTooOld(revision=rev) self.log.warning('Discovered old savegame file, auto-upgrading: {} -> {}' .format(rev, VERSION.SAVEGAMEREVISION)) db = DbReader(self.final_path) db('BEGIN TRANSACTION') # placeholder for future upgrade calls if rev < 77: self._upgrade_to_rev77(db) db('COMMIT') db.close()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) savegame_info = SavegameManager.get_metadata(map_files[gui.collectData(savegamelist)]) details_label = pychan.widgets.Label(min_size=(140, 0), max_size=(140, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += "Unknown savedate\n" else: details_label.text += "Saved at %s\n" % \ time.strftime("%H:%M, %A, %B %d", time.localtime(savegame_info['timestamp'])) details_label.text += "Saved %d time%s\n" % (savegame_info['savecounter'], \ 's' if savegame_info['savecounter'] > 1 else '') from horizons.constants import VERSION try: if savegame_info['savegamerev'] == VERSION.SAVEGAMEREVISION: details_label.text += u"Savegame ver. %d" % ( savegame_info['savegamerev'] ) else: details_label.text += u"WARNING: Incompatible ver. %d!\nNeed ver. %d!" \ % (savegame_info['savegamerev'], VERSION.SAVEGAMEREVISION) except KeyError: details_label.text += u"INCOMPATIBlE VERSION\n" box.addChild( details_label ) """ if savegame_info['screenshot']: fd, filename = tempfile.mkstemp() os.fdopen(fd, "w").write(savegame_info['screenshot']) box.addChild( pychan.widgets.Icon(image=filename) ) """ gui.adaptLayout()
def load(self, savegame, players, trader_enabled, pirate_enabled, natural_resource_multiplier, is_scenario=False, campaign=None, force_player_id=None, disasters_enabled=True, is_multiplayer=False): """Loads a map. Key method for starting a game. @param savegame: path to the savegame database. @param players: iterable of dictionaries containing id, name, color, local, ai, and difficulty @param is_scenario: Bool whether the loaded map is a scenario or not @param force_player_id: the worldid of the selected human player or default if None (debug option) """ """ TUTORIAL: Here you see how the vital game elements (and some random things that are also required) are initialised. """ if is_scenario: # savegame is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler(self, savegame) # scenario maps can be normal maps or scenario maps: map_filename = self.scenario_eventhandler.get_map_file() savegame = os.path.join(SavegameManager.scenario_maps_dir, map_filename) if not os.path.exists(savegame): savegame = os.path.join(SavegameManager.maps_dir, map_filename) self.campaign = {} if not campaign else campaign self.log.debug("Session: Loading from %s", savegame) savegame_db = SavegameAccessor(savegame) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = savegame_data.get('savecounter', 0) if savegame_data.get('rng_state', None): rng_state_list = json.loads( savegame_data['rng_state'] ) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple( rec_list_to_tuple(i) for i in x ) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate( rng_state_tuple ) self.world = World(self) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db, force_player_id, disasters_enabled=disasters_enabled) self.view.load(savegame_db) # load view if not self.is_game_loaded(): # NOTE: this must be sorted before iteration, cause there is no defined order for # iterating a dict, and it must happen in the same order for mp games. for i in sorted(players, lambda p1, p2: cmp(p1['id'], p2['id'])): self.world.setup_player(i['id'], i['name'], i['color'], i['clientid'] if is_multiplayer else None, i['local'], i['ai'], i['difficulty']) self.world.set_forced_player(force_player_id) center = self.world.init_new_world(trader_enabled, pirate_enabled, natural_resource_multiplier) self.view.center(center[0], center[1]) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load(savegame_db) # load the manager (there might me old scheduled ticks). self.world.init_fish_indexer() # now the fish should exist if self.is_game_loaded(): LastActivePlayerSettlementManager().load(savegame_db) # before ingamegui self.ingame_gui.load(savegame_db) # load the old gui positions and stuff for instance_id in savegame_db("SELECT id FROM selected WHERE `group` IS NULL"): # Set old selected instance obj = WorldObject.get_object_by_id(instance_id[0]) self.selected_instances.add(obj) obj.get_component(SelectableComponent).select() for group in xrange(len(self.selection_groups)): # load user defined unit groups for instance_id in savegame_db("SELECT id FROM selected WHERE `group` = ?", group): self.selection_groups[group].add(WorldObject.get_object_by_id(instance_id[0])) # cursor has to be inited last, else player interacts with a not inited world with it. self.current_cursor = 'default' self.cursor = SelectionTool(self) # Set cursor correctly, menus might need to be opened. # Open menus later; they may need unit data not yet inited self.cursor.apply_select() Scheduler().before_ticking() savegame_db.close() assert hasattr(self.world, "player"), 'Error: there is no human player' """
def tmp_show_details(): """Fetches details of selected savegame and displays it""" gui.findChild(name="screenshot").image = None box = gui.findChild(name="savegamedetails_box") old_label = box.findChild(name="savegamedetails_lbl") if old_label is not None: box.removeChild(old_label) map_file = None map_file_index = gui.collectData(savegamelist) if map_file_index == -1: return try: map_file = map_files[map_file_index] except IndexError: # this was a click in the savegame list, but not on an element # it happens when the savegame list is empty return savegame_info = SavegameManager.get_metadata(map_file) # screenshot (len can be 0 if save failed in a weird way) if 'screenshot' in savegame_info and \ savegame_info['screenshot'] is not None and \ len(savegame_info['screenshot']) > 0: # try to find a writeable location, that is accessible via relative paths # (required by fife) fd, filename = tempfile.mkstemp() try: path_rel = os.path.relpath(filename) except ValueError: # the relative path sometimes doesn't exist on win os.close(fd) os.unlink(filename) # try again in the current dir, it's often writable fd, filename = tempfile.mkstemp(dir=os.curdir) try: path_rel = os.path.relpath(filename) except ValueError: fd, filename = None, None if fd: with os.fdopen(fd, "w") as f: f.write(savegame_info['screenshot']) # fife only supports relative paths gui.findChild(name="screenshot").image = path_rel os.unlink(filename) # savegamedetails details_label = pychan.widgets.Label(min_size=(290, 0), max_size=(290, 290), wrap_text=True) details_label.name = "savegamedetails_lbl" details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += _("Unknown savedate") else: #xgettext:python-format details_label.text += _("Saved at {time}").format( time=time.strftime("%c", time.localtime(savegame_info['timestamp'])).decode('utf-8')) details_label.text += u'\n' counter = savegame_info['savecounter'] # N_ takes care of plural forms for different languages #xgettext:python-format details_label.text += N_("Saved {amount} time", "Saved {amount} times", counter).format(amount=counter) details_label.text += u'\n' details_label.stylize('book_t') from horizons.constants import VERSION try: #xgettext:python-format details_label.text += _("Savegame version {version}").format( version=savegame_info['savegamerev']) if savegame_info['savegamerev'] != VERSION.SAVEGAMEREVISION: #xgettext:python-format details_label.text += u" " + _("(potentially incompatible)") except KeyError: # this should only happen for very old savegames, so having this unfriendly # error is ok (savegame is quite certainly fully unusable). details_label.text += _("Incompatible version") box.addChild( details_label ) gui.adaptLayout()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" gui.findChild(name="screenshot").image = None map_file = None map_file_index = gui.collectData(savegamelist) savegame_details_box = gui.findChild(name="savegame_details") savegame_details_parent = savegame_details_box.parent if map_file_index == -1: if (Fife.getVersion() >= (0, 4, 0)): savegame_details_parent.hideChild(savegame_details_box) else: if savegame_details_box not in savegame_details_parent.hidden_children: savegame_details_parent.hideChild(savegame_details_box) return else: savegame_details_parent.showChild(savegame_details_box) try: map_file = map_files[map_file_index] except IndexError: # this was a click in the savegame list, but not on an element # it happens when the savegame list is empty return savegame_info = SavegameManager.get_metadata(map_file) if savegame_info.get('screenshot'): # try to find a writable location, that is accessible via relative paths # (required by fife) fd, filename = tempfile.mkstemp() try: path_rel = os.path.relpath(filename) except ValueError: # the relative path sometimes doesn't exist on win os.close(fd) os.unlink(filename) # try again in the current dir, it's often writable fd, filename = tempfile.mkstemp(dir=os.curdir) try: path_rel = os.path.relpath(filename) except ValueError: fd, filename = None, None if fd: with os.fdopen(fd, "w") as f: f.write(savegame_info['screenshot']) # fife only supports relative paths gui.findChild(name="screenshot").image = path_rel os.unlink(filename) # savegamedetails details_label = gui.findChild(name="savegamedetails_lbl") details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += T("Unknown savedate") else: savetime = time.strftime( "%c", time.localtime(savegame_info['timestamp'])) details_label.text += T("Saved at {time}").format( time=savetime.decode('utf-8')) details_label.text += u'\n' counter = savegame_info['savecounter'] # NT takes care of plural forms for different languages details_label.text += NT("Saved {amount} time", "Saved {amount} times", counter).format(amount=counter) details_label.text += u'\n' from horizons.constants import VERSION try: details_label.text += T("Savegame version {version}").format( version=savegame_info['savegamerev']) if savegame_info['savegamerev'] != VERSION.SAVEGAMEREVISION: if not SavegameUpgrader.can_upgrade( savegame_info['savegamerev']): details_label.text += u" " + T( "(probably incompatible)") except KeyError: # this should only happen for very old savegames, so having this unfriendly # error is ok (savegame is quite certainly fully unusable). details_label.text += u" " + T("Incompatible version") gui.adaptLayout()
def load(self, options): """Loads a map. Key method for starting a game.""" """ TUTORIAL: Here you see how the vital game elements (and some random things that are also required) are initialized. """ if options.is_scenario: # game_identifier is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler(self, options.game_identifier) # scenario maps can be normal maps or scenario maps: map_filename = self.scenario_eventhandler.get_map_file() options.game_identifier = os.path.join(SavegameManager.scenario_maps_dir, map_filename) if not os.path.exists(options.game_identifier): options.game_identifier = os.path.join(SavegameManager.maps_dir, map_filename) options.is_map = True self.log.debug("Session: Loading from %s", options.game_identifier) savegame_db = SavegameAccessor(options.game_identifier, options.is_map, options) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame_db.db_path) self.view.resize_layers(savegame_db) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = savegame_data.get('savecounter', 0) if savegame_data.get('rng_state', None): rng_state_list = json.loads(savegame_data['rng_state']) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple(rec_list_to_tuple(i) for i in x) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate(rng_state_tuple) LoadingProgress.broadcast(self, 'session_create_world') self.world = World(self) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db, options.force_player_id, disasters_enabled=options.disasters_enabled) self.view.load(savegame_db, self.world) # load view if not self.is_game_loaded(): options.init_new_world(self) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load(savegame_db) # load the manager (there might be old scheduled ticks). LoadingProgress.broadcast(self, "session_index_fish") self.world.init_fish_indexer() # now the fish should exist # load the old gui positions and stuff # Do this before loading selections, they need the minimap setup LoadingProgress.broadcast(self, "session_load_gui") self.ingame_gui = self._ingame_gui_class(self) self.ingame_gui.load(savegame_db) Scheduler().before_ticking() savegame_db.close() assert hasattr(self.world, "player"), 'Error: there is no human player' LoadingProgress.broadcast(self, "session_finish") """
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata["savegamerev"] if rev == 0: # not a regular savegame, usually a map self.final_path = self.original_path elif rev == VERSION.SAVEGAMEREVISION: # the current version self.final_path = self.original_path else: # upgrade self.log.warning("Discovered old savegame file, auto-upgrading: %s -> %s" % (rev, VERSION.SAVEGAMEREVISION)) self.using_temp = True handle, self.final_path = tempfile.mkstemp( prefix="uh-savegame." + os.path.basename(os.path.splitext(self.original_path)[0]) + ".", suffix=".sqlite", ) os.close(handle) shutil.copyfile(self.original_path, self.final_path) db = DbReader(self.final_path) db("BEGIN TRANSACTION") if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) if rev < 53: self._upgrade_to_rev53(db) if rev < 54: self._upgrade_to_rev54(db) if rev < 55: self._upgrade_to_rev55(db) if rev < 56: self._upgrade_to_rev56(db) if rev < 57: self._upgrade_to_rev57(db) if rev < 58: self._upgrade_to_rev58(db) if rev < 59: self._upgrade_to_rev59(db) if rev < 60: self._upgrade_to_rev60(db) if rev < 61: self._upgrade_to_rev61(db) if rev < 62: self._upgrade_to_rev62(db) if rev < 63: self._upgrade_to_rev63(db) if rev < 64: self._upgrade_to_rev64(db) if rev < 65: self._upgrade_to_rev65(db) if rev < 66: self._upgrade_to_rev66(db) if rev < 67: self._upgrade_to_rev67(db) if rev < 68: self._upgrade_to_rev68(db) if rev < 69: self._upgrade_to_rev69(db) if rev < 70: self._upgrade_to_rev70(db) if rev < 71: self._upgrade_to_rev71(db) if rev < 72: self._upgrade_to_rev72(db) if 70 < rev < 73: self._upgrade_to_rev73(db) db("COMMIT") db.close()
def load(self, options): """Loads a map. Key method for starting a game.""" """ TUTORIAL: Here you see how the vital game elements (and some random things that are also required) are initialised. """ if options.is_scenario: # game_identifier is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler(self, options.game_identifier) # scenario maps can be normal maps or scenario maps: map_filename = self.scenario_eventhandler.get_map_file() options.game_identifier = os.path.join(SavegameManager.scenario_maps_dir, map_filename) if not os.path.exists(options.game_identifier): options.game_identifier = os.path.join(SavegameManager.maps_dir, map_filename) options.is_map = True self.log.debug("Session: Loading from %s", options.game_identifier) savegame_db = SavegameAccessor(options.game_identifier, options.is_map) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame_db.db_path) self.view.resize_layers(savegame_db) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = savegame_data.get('savecounter', 0) if savegame_data.get('rng_state', None): rng_state_list = json.loads(savegame_data['rng_state']) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple(rec_list_to_tuple(i) for i in x) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate(rng_state_tuple) self.world = World(self) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db, options.force_player_id, disasters_enabled=options.disasters_enabled) self.view.load(savegame_db) # load view if not self.is_game_loaded(): options.init_new_world(self) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load(savegame_db) # load the manager (there might me old scheduled ticks). self.world.init_fish_indexer() # now the fish should exist if self.is_game_loaded(): LastActivePlayerSettlementManager().load(savegame_db) # before ingamegui self.ingame_gui.load(savegame_db) # load the old gui positions and stuff for instance_id in savegame_db("SELECT id FROM selected WHERE `group` IS NULL"): # Set old selected instance obj = WorldObject.get_object_by_id(instance_id[0]) self.selected_instances.add(obj) obj.get_component(SelectableComponent).select() for group in xrange(len(self.selection_groups)): # load user defined unit groups for instance_id in savegame_db("SELECT id FROM selected WHERE `group` = ?", group): self.selection_groups[group].add(WorldObject.get_object_by_id(instance_id[0])) # cursor has to be inited last, else player interacts with a not inited world with it. self.current_cursor = 'default' self.cursor = SelectionTool(self) # Set cursor correctly, menus might need to be opened. # Open menus later; they may need unit data not yet inited self.cursor.apply_select() Scheduler().before_ticking() savegame_db.close() assert hasattr(self.world, "player"), 'Error: there is no human player' """
def load(self, options): """Loads a map. Key method for starting a game.""" """ TUTORIAL: Here you see how the vital game elements (and some random things that are also required) are initialised. """ if options.is_scenario: # game_identifier is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler( self, options.game_identifier) # scenario maps can be normal maps or scenario maps: map_filename = self.scenario_eventhandler.get_map_file() options.game_identifier = os.path.join( SavegameManager.scenario_maps_dir, map_filename) if not os.path.exists(options.game_identifier): options.game_identifier = os.path.join( SavegameManager.maps_dir, map_filename) options.is_map = True self.log.debug("Session: Loading from %s", options.game_identifier) savegame_db = SavegameAccessor( options.game_identifier, options.is_map) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame_db.db_path) self.view.resize_layers(savegame_db) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = savegame_data.get('savecounter', 0) if savegame_data.get('rng_state', None): rng_state_list = json.loads(savegame_data['rng_state']) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple(rec_list_to_tuple(i) for i in x) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate(rng_state_tuple) self.world = World( self ) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db, options.force_player_id, disasters_enabled=options.disasters_enabled) self.view.load(savegame_db) # load view if not self.is_game_loaded(): options.init_new_world(self) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load( savegame_db ) # load the manager (there might me old scheduled ticks). self.world.init_fish_indexer() # now the fish should exist if self.is_game_loaded(): LastActivePlayerSettlementManager().load( savegame_db) # before ingamegui self.ingame_gui.load( savegame_db) # load the old gui positions and stuff for instance_id in savegame_db( "SELECT id FROM selected WHERE `group` IS NULL" ): # Set old selected instance obj = WorldObject.get_object_by_id(instance_id[0]) self.selected_instances.add(obj) obj.get_component(SelectableComponent).select() for group in xrange(len( self.selection_groups)): # load user defined unit groups for instance_id in savegame_db( "SELECT id FROM selected WHERE `group` = ?", group): self.selection_groups[group].add( WorldObject.get_object_by_id(instance_id[0])) # cursor has to be inited last, else player interacts with a not inited world with it. self.current_cursor = 'default' self.cursor = SelectionTool(self) # Set cursor correctly, menus might need to be opened. # Open menus later; they may need unit data not yet inited self.cursor.apply_select() Scheduler().before_ticking() savegame_db.close() assert hasattr(self.world, "player"), 'Error: there is no human player' """
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev == 0: # not a regular savegame, usually a map self.final_path = self.original_path elif rev == VERSION.SAVEGAMEREVISION: # the current version self.final_path = self.original_path else: # upgrade self.using_temp = True handle, self.final_path = tempfile.mkstemp( prefix='uh-savegame.' + os.path.basename(os.path.splitext(self.original_path)[0]) + '.', suffix='.sqlite') os.close(handle) shutil.copyfile(self.original_path, self.final_path) db = DbReader(self.final_path) db('BEGIN TRANSACTION') if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) if rev < 53: self._upgrade_to_rev53(db) if rev < 54: self._upgrade_to_rev54(db) if rev < 55: self._upgrade_to_rev55(db) if rev < 56: self._upgrade_to_rev56(db) if rev < 57: self._upgrade_to_rev57(db) if rev < 58: self._upgrade_to_rev58(db) if rev < 59: self._upgrade_to_rev59(db) if rev < 60: self._upgrade_to_rev60(db) if rev < 61: self._upgrade_to_rev61(db) if rev < 62: self._upgrade_to_rev62(db) if rev < 63: self._upgrade_to_rev63(db) if rev < 64: self._upgrade_to_rev64(db) if rev < 65: self._upgrade_to_rev65(db) if rev < 66: self._upgrade_to_rev66(db) if rev < 67: self._upgrade_to_rev67(db) if rev < 68: self._upgrade_to_rev68(db) if rev < 69: self._upgrade_to_rev69(db) if rev < 70: self._upgrade_to_rev70(db) db('COMMIT') db.close()
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev < VERSION.SAVEGAMEREVISION: if not SavegameUpgrader.can_upgrade(rev): raise SavegameTooOld(revision=rev) self.log.warning('Discovered old savegame file, auto-upgrading: %s -> %s' % \ (rev, VERSION.SAVEGAMEREVISION)) db = DbReader(self.final_path) db('BEGIN TRANSACTION') if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) if rev < 53: self._upgrade_to_rev53(db) if rev < 54: self._upgrade_to_rev54(db) if rev < 55: self._upgrade_to_rev55(db) if rev < 56: self._upgrade_to_rev56(db) if rev < 57: self._upgrade_to_rev57(db) if rev < 58: self._upgrade_to_rev58(db) if rev < 59: self._upgrade_to_rev59(db) if rev < 60: self._upgrade_to_rev60(db) if rev < 61: self._upgrade_to_rev61(db) if rev < 62: self._upgrade_to_rev62(db) if rev < 63: self._upgrade_to_rev63(db) if rev < 64: self._upgrade_to_rev64(db) if rev < 65: self._upgrade_to_rev65(db) if rev < 66: self._upgrade_to_rev66(db) if rev < 67: self._upgrade_to_rev67(db) if rev < 68: self._upgrade_to_rev68(db) if rev < 69: self._upgrade_to_rev69(db) if rev < 70: self._upgrade_to_rev70(db) if rev < 71: self._upgrade_to_rev71(db) if rev < 72: self._upgrade_to_rev72(db) if 70 < rev < 73: self._upgrade_to_rev73(db) if rev < 74: self._upgrade_to_rev74(db) if rev < 75: self._upgrade_to_rev75(db) if rev < 76: self._upgrade_to_rev76(db) db('COMMIT') db.close()
def tmp_show_details(): """Fetches details of selected savegame and displays it""" gui.findChild(name="screenshot").image = None map_file = None map_file_index = gui.collectData(savegamelist) savegame_details_box = gui.findChild(name="savegame_details") savegame_details_parent = savegame_details_box.parent if map_file_index == -1: if savegame_details_box not in savegame_details_parent.hidden_children: savegame_details_parent.hideChild(savegame_details_box) return else: savegame_details_parent.showChild(savegame_details_box) try: map_file = map_files[map_file_index] except IndexError: # this was a click in the savegame list, but not on an element # it happens when the savegame list is empty return savegame_info = SavegameManager.get_metadata(map_file) if savegame_info.get('screenshot'): # try to find a writable location, that is accessible via relative paths # (required by fife) fd, filename = tempfile.mkstemp() try: path_rel = os.path.relpath(filename) except ValueError: # the relative path sometimes doesn't exist on win os.close(fd) os.unlink(filename) # try again in the current dir, it's often writable fd, filename = tempfile.mkstemp(dir=os.curdir) try: path_rel = os.path.relpath(filename) except ValueError: fd, filename = None, None if fd: with os.fdopen(fd, "w") as f: f.write(savegame_info['screenshot']) # fife only supports relative paths gui.findChild(name="screenshot").image = path_rel os.unlink(filename) # savegamedetails details_label = gui.findChild(name="savegamedetails_lbl") details_label.text = u"" if savegame_info['timestamp'] == -1: details_label.text += _("Unknown savedate") else: savetime = time.strftime("%c", time.localtime(savegame_info['timestamp'])) #xgettext:python-format details_label.text += _("Saved at {time}").format(time=savetime.decode('utf-8')) details_label.text += u'\n' counter = savegame_info['savecounter'] # N_ takes care of plural forms for different languages #xgettext:python-format details_label.text += N_("Saved {amount} time", "Saved {amount} times", counter).format(amount=counter) details_label.text += u'\n' from horizons.constants import VERSION try: #xgettext:python-format details_label.text += _("Savegame version {version}").format( version=savegame_info['savegamerev']) if savegame_info['savegamerev'] != VERSION.SAVEGAMEREVISION: if not SavegameUpgrader.can_upgrade(savegame_info['savegamerev']): details_label.text += u" " + _("(probably incompatible)") except KeyError: # this should only happen for very old savegames, so having this unfriendly # error is ok (savegame is quite certainly fully unusable). details_label.text += u" " + _("Incompatible version") gui.adaptLayout()
def _upgrade(self): # fix import loop from horizons.savegamemanager import SavegameManager metadata = SavegameManager.get_metadata(self.original_path) rev = metadata['savegamerev'] if rev < VERSION.SAVEGAMEREVISION : if not SavegameUpgrader.can_upgrade(rev): raise SavegameTooOld(revision=rev) self.log.warning('Discovered old savegame file, auto-upgrading: %s -> %s' % \ (rev, VERSION.SAVEGAMEREVISION)) db = DbReader(self.final_path) db('BEGIN TRANSACTION') if rev < 49: self._upgrade_to_rev49(db) if rev < 50: self._upgrade_to_rev50(db) if rev < 51: self._upgrade_to_rev51(db) if rev < 52: self._upgrade_to_rev52(db) if rev < 53: self._upgrade_to_rev53(db) if rev < 54: self._upgrade_to_rev54(db) if rev < 55: self._upgrade_to_rev55(db) if rev < 56: self._upgrade_to_rev56(db) if rev < 57: self._upgrade_to_rev57(db) if rev < 58: self._upgrade_to_rev58(db) if rev < 59: self._upgrade_to_rev59(db) if rev < 60: self._upgrade_to_rev60(db) if rev < 61: self._upgrade_to_rev61(db) if rev < 62: self._upgrade_to_rev62(db) if rev < 63: self._upgrade_to_rev63(db) if rev < 64: self._upgrade_to_rev64(db) if rev < 65: self._upgrade_to_rev65(db) if rev < 66: self._upgrade_to_rev66(db) if rev < 67: self._upgrade_to_rev67(db) if rev < 68: self._upgrade_to_rev68(db) if rev < 69: self._upgrade_to_rev69(db) if rev < 70: self._upgrade_to_rev70(db) if rev < 71: self._upgrade_to_rev71(db) if rev < 72: self._upgrade_to_rev72(db) if 70 < rev < 73: self._upgrade_to_rev73(db) if rev < 74: self._upgrade_to_rev74(db) if rev < 75: self._upgrade_to_rev75(db) db('COMMIT') db.close()
def load(self, options): """Loads a map. Key method for starting a game.""" """ TUTORIAL: Here you see how the vital game elements (and some random things that are also required) are initialized. """ if options.is_scenario: # game_identifier is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler( self, options.game_identifier) # scenario maps can be normal maps or scenario maps: map_filename = self.scenario_eventhandler.get_map_file() options.game_identifier = os.path.join( SavegameManager.scenario_maps_dir, map_filename) if not os.path.exists(options.game_identifier): options.game_identifier = os.path.join( SavegameManager.maps_dir, map_filename) options.is_map = True self.log.debug("Session: Loading from %s", options.game_identifier) savegame_db = SavegameAccessor(options.game_identifier, options.is_map, options) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame_db.db_path) self.view.resize_layers(savegame_db) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = savegame_data.get('savecounter', 0) if savegame_data.get('rng_state', None): rng_state_list = json.loads(savegame_data['rng_state']) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple(rec_list_to_tuple(i) for i in x) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate(rng_state_tuple) LoadingProgress.broadcast(self, 'session_create_world') self.world = World( self ) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db, options.force_player_id, disasters_enabled=options.disasters_enabled) self.view.load(savegame_db, self.world) # load view if not self.is_game_loaded(): options.init_new_world(self) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load( savegame_db ) # load the manager (there might be old scheduled ticks). LoadingProgress.broadcast(self, "session_index_fish") self.world.init_fish_indexer() # now the fish should exist # load the old gui positions and stuff # Do this before loading selections, they need the minimap setup LoadingProgress.broadcast(self, "session_load_gui") self.ingame_gui = self._ingame_gui_class(self) self.ingame_gui.load(savegame_db) Scheduler().before_ticking() savegame_db.close() assert hasattr(self.world, "player"), 'Error: there is no human player' LoadingProgress.broadcast(self, "session_finish") """
def load(self, savegame, players, is_scenario=False, campaign=None): """Loads a map. @param savegame: path to the savegame database. @param players: iterable of dictionaries containing id, name, color, local, ai, and difficulty @param is_scenario: Bool whether the loaded map is a scenario or not """ if is_scenario: # savegame is a yaml file, that contains reference to actual map file self.scenario_eventhandler = ScenarioEventHandler(self, savegame) savegame = os.path.join(SavegameManager.maps_dir, \ self.scenario_eventhandler.get_map_file()) self.campaign = {} if not campaign else campaign self.log.debug("Session: Loading from %s", savegame) savegame_db = SavegameAccessor(savegame) # Initialize new dbreader savegame_data = SavegameManager.get_metadata(savegame) # load how often the game has been saved (used to know the difference between # a loaded and a new game) self.savecounter = 0 if not 'savecounter' in savegame_data else savegame_data['savecounter'] if savegame_data.get('rng_state', None): rng_state_list = json.loads( savegame_data['rng_state'] ) # json treats tuples as lists, but we need tuples here, so convert back def rec_list_to_tuple(x): if isinstance(x, list): return tuple( rec_list_to_tuple(i) for i in x ) else: return x rng_state_tuple = rec_list_to_tuple(rng_state_list) # changing the rng is safe for mp, as all players have to have the same map self.random.setstate( rng_state_tuple ) self.world = World(self) # Load horizons.world module (check horizons/world/__init__.py) self.world._init(savegame_db) self.view.load(savegame_db) # load view if not self.is_game_loaded(): # NOTE: this must be sorted before iteration, cause there is no defined order for # iterating a dict, and it must happen in the same order for mp games. for i in sorted(players, lambda p1, p2: cmp(p1['id'], p2['id'])): self.world.setup_player(i['id'], i['name'], i['color'], i['local'], i['ai'], i['difficulty']) center = self.world.init_new_world() self.view.center(center[0], center[1]) else: # try to load scenario data self.scenario_eventhandler.load(savegame_db) self.manager.load(savegame_db) # load the manager (there might me old scheduled ticks). self.world.init_fish_indexer() # now the fish should exist self.ingame_gui.load(savegame_db) # load the old gui positions and stuff for instance_id in savegame_db("SELECT id FROM selected WHERE `group` IS NULL"): # Set old selected instance obj = WorldObject.get_object_by_id(instance_id[0]) self.selected_instances.add(obj) obj.select() for group in xrange(len(self.selection_groups)): # load user defined unit groups for instance_id in savegame_db("SELECT id FROM selected WHERE `group` = ?", group): self.selection_groups[group].add(WorldObject.get_object_by_id(instance_id[0])) # cursor has to be inited last, else player interacts with a not inited world with it. self.cursor = SelectionTool(self) # Set cursor correctly, menus might need to be opened. # Open menus later, they may need unit data not yet inited self.cursor.apply_select() assert hasattr(self.world, "player"), 'Error: there is no human player' """