def generate_map(self):
"""Generates a map."""
#load map
self.db("ATTACH ':memory:' AS map")
#...
self.world = World(self)
self.world._init(self.db)
#setup view
self.view.center(((self.world.max_x - self.world.min_x) / 2.0),
((self.world.max_y - self.world.min_y) / 2.0))
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 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 test_world_end(self): w = World(self.session) w.end()
def _load_raw_world(cls, map_file):
WorldObject.reset()
world = World(session=None)
world.inited = True
world.load_raw_map(SavegameAccessor(map_file, True), preview=True)
return world
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'
"""
