def load(self, savegame, players, is_ai_test, is_map):
# keep a reference on the savegame, so we can cleanup in `end`
self.savegame = savegame
self.started_from_map = is_map
if is_ai_test:
# enable trader, pirate and natural resources in AI tests.
options = StartGameOptions.create_ai_test(savegame, players)
else:
# disable the above in usual game tests for simplicity.
options = StartGameOptions.create_game_test(savegame, players)
options.is_map = is_map
super(SPTestSession, self).load(options)
def load(self, savegame, players, is_ai_test, is_map): # keep a reference on the savegame, so we can cleanup in `end` self.savegame = savegame self.started_from_map = is_map if is_ai_test: # enable trader, pirate and natural resources in AI tests. options = StartGameOptions.create_ai_test(savegame, players) else: # disable the above in usual game tests for simplicity. options = StartGameOptions.create_game_test(savegame, players) options.is_map = is_map super(SPTestSession, self).load(options)
def prepare_multiplayer(game, trader_enabled=True, pirate_enabled=True, natural_resource_multiplier=1):
"""Starts a multiplayer game server
TODO: actual game data parameter passing
"""
_modules.gui.show_loading_screen()
global preloading
preload_game_join(preloading)
# remove cursor while loading
horizons.globals.fife.cursor.set(fife_module.CURSOR_NONE)
horizons.globals.fife.engine.pump()
horizons.globals.fife.set_cursor_image('default')
# destruct old session (right now, without waiting for gc)
if _modules.session is not None and _modules.session.is_alive:
_modules.session.end()
# start new session
from horizons.mpsession import MPSession
# get random seed for game
uuid = game.uuid
random = sum([ int(uuid[i : i + 2], 16) for i in range(0, len(uuid), 2) ])
_modules.session = MPSession(horizons.globals.db, NetworkInterface(), rng_seed=random)
# NOTE: this data passing is only temporary, maybe use a player class/struct
if game.is_savegame:
map_file = SavegameManager.get_multiplayersave_map(game.map_name)
else:
map_file = SavegameManager.get_map(game.map_name)
options = StartGameOptions.create_start_multiplayer(map_file, game.get_player_list(), not game.is_savegame)
_modules.session.load(options)
def _start_map(
map_name,
ai_players=0,
is_scenario=False,
pirate_enabled=True,
trader_enabled=True,
force_player_id=None,
is_map=False,
):
"""Start a map specified by user
@param map_name: name of map or path to map
@return: bool, whether loading succeeded"""
if is_scenario:
savegames = SavegameManager.get_available_scenarios(locales=True)
else:
savegames = SavegameManager.get_maps()
map_file = _find_matching_map(map_name, savegames)
if not map_file:
return False
options = StartGameOptions.create_start_singleplayer(
map_file, is_scenario, ai_players, trader_enabled, pirate_enabled, force_player_id, is_map
)
start_singleplayer(options)
return True
def test_save_load_ticket_1421(gui):
"""
Boatbuilder crashes when saving/loading while a ship is being produced.
"""
# Select boat builder
gui.cursor_click(64, 10, 'left')
# Select trade ships tab
gui.trigger('tab_base', '1')
# Build huker
gui.trigger('boatbuilder_showcase', 'ok_0')
# Select war ships tab
gui.trigger('tab_base', '2')
# Build frigate
gui.trigger('boatbuilder_showcase', 'ok_0')
fd, filename = tempfile.mkstemp()
os.close(fd)
assert gui.session.save(savegamename=filename)
options = StartGameOptions.create_load_game(filename, None)
horizons.main.start_singleplayer(options)
def prepare_multiplayer(game, trader_enabled=True, pirate_enabled=True, natural_resource_multiplier=1):
"""Starts a multiplayer game server
TODO: actual game data parameter passing
"""
_modules.gui.show_loading_screen()
preloader.wait_for_finish()
# remove cursor while loading
horizons.globals.fife.cursor.set(fife_module.CURSOR_NONE)
horizons.globals.fife.engine.pump()
horizons.globals.fife.set_cursor_image('default')
# destruct old session (right now, without waiting for gc)
if _modules.session is not None and _modules.session.is_alive:
_modules.session.end()
# start new session
from horizons.mpsession import MPSession
# get random seed for game
uuid = game.uuid
random = sum([int(uuid[i : i + 2], 16) for i in range(0, len(uuid), 2)])
_modules.session = MPSession(horizons.globals.db, NetworkInterface(), rng_seed=random)
# NOTE: this data passing is only temporary, maybe use a player class/struct
if game.is_savegame:
map_file = SavegameManager.get_multiplayersave_map(game.map_name)
else:
map_file = SavegameManager.get_map(game.map_name)
options = StartGameOptions.create_start_multiplayer(map_file, game.get_player_list(), not game.is_savegame)
_modules.session.load(options)
def start_single(self):
""" Starts a single player horizons. """
assert self.current is self.widgets['singleplayermenu']
playername = self.current.playerdata.get_player_name()
if not playername:
self.show_popup(_("Invalid player name"),
_("You entered an invalid playername."))
return
playercolor = self.current.playerdata.get_player_color()
self._save_player_name()
if self.current.collectData('random'):
map_file = self._get_random_map_file()
else:
assert self.active_right_side.collectData('maplist') != -1
map_file = self._get_selected_map()
is_scenario = bool(self.current.collectData('scenario'))
if not is_scenario:
ai_players = int(self.current.aidata.get_ai_players())
horizons.globals.fife.set_uh_setting("AIPlayers", ai_players)
horizons.globals.fife.save_settings()
self.show_loading_screen()
if is_scenario:
try:
options = StartGameOptions.create_start_scenario(map_file)
options.set_human_data(playername, playercolor)
horizons.main.start_singleplayer(options)
except InvalidScenarioFileFormat as e:
self._show_invalid_scenario_file_popup(e)
self._select_single(show='scenario')
else: # free play/random map
options = StartGameOptions.create_start_map(map_file)
options.set_human_data(playername, playercolor)
options.ai_players = ai_players
options.trader_enabled = self.widgets['game_settings'].findChild(
name='free_trader').marked
options.pirate_enabled = self.widgets['game_settings'].findChild(
name='pirates').marked
options.disasters_enabled = self.widgets[
'game_settings'].findChild(name='disasters').marked
options.natural_resource_multiplier = self._get_natural_resource_multiplier(
)
horizons.main.start_singleplayer(options)
ExtScheduler().rem_all_classinst_calls(self)
def load_game(self): saved_game = self.show_select_savegame(mode='load') if saved_game is None: return False # user aborted dialog options = StartGameOptions(saved_game) horizons.main.start_singleplayer(options) return True
def act(self, player_name, player_color): map_file = self._get_selected_map() try: options = StartGameOptions.create_start_scenario(map_file) options.set_human_data(player_name, player_color) horizons.main.start_singleplayer(options) except InvalidScenarioFileFormat as e: self._show_invalid_scenario_file_popup(e)
def act(self, player_name, player_color):
map_file = self._get_selected_map()
try:
options = StartGameOptions.create_start_scenario(map_file)
options.set_human_data(player_name, player_color)
horizons.main.start_singleplayer(options)
except InvalidScenarioFileFormat as e:
self._show_invalid_scenario_file_popup(e)
def start_single(self):
""" Starts a single player horizons. """
assert self.current is self.widgets['singleplayermenu']
playername = self.current.playerdata.get_player_name()
if not playername:
self.show_popup(_("Invalid player name"), _("You entered an invalid playername."))
return
playercolor = self.current.playerdata.get_player_color()
self._save_player_name()
if self.current.collectData('random'):
map_file = self._get_random_map_file()
else:
assert self.active_right_side.collectData('maplist') != -1
map_file = self._get_selected_map()
is_scenario = bool(self.current.collectData('scenario'))
if not is_scenario:
ai_players = int(self.current.aidata.get_ai_players())
horizons.globals.fife.set_uh_setting("AIPlayers", ai_players)
horizons.globals.fife.save_settings()
self.mainmenu.show_loading_screen()
if is_scenario:
try:
options = StartGameOptions.create_start_scenario(map_file)
options.set_human_data(playername, playercolor)
horizons.main.start_singleplayer(options)
except InvalidScenarioFileFormat as e:
self._show_invalid_scenario_file_popup(e)
self._select_single(show='scenario')
else: # free play/random map
options = StartGameOptions.create_start_map(map_file)
options.set_human_data(playername, playercolor)
options.ai_players = ai_players
options.trader_enabled = self.widgets['game_settings'].findChild(name='free_trader').marked
options.pirate_enabled = self.widgets['game_settings'].findChild(name='pirates').marked
options.disasters_enabled = self.widgets['game_settings'].findChild(name='disasters').marked
options.natural_resource_multiplier = self._get_natural_resource_multiplier()
horizons.main.start_singleplayer(options)
ExtScheduler().rem_all_classinst_calls(self)
def act(self): for size in self.sizes: option_name = 'size_%d' % size if self._gui.findChild(name=option_name).marked: self._windows.close() # the empty list is interpreted as the empty list of random map island strings options = StartGameOptions.create_editor_load([]) options.map_padding = size // 2 horizons.main.start_singleplayer(options) return
def act(self, player_name, player_color):
map_file = self._get_selected_map()
options = StartGameOptions.create_start_map(map_file)
options.set_human_data(player_name, player_color)
options.ai_players = self._aidata.get_ai_players()
options.trader_enabled = self._game_settings.free_trader
options.pirate_enabled = self._game_settings.pirates
options.disasters_enabled = self._game_settings.disasters
options.natural_resource_multiplier = self._game_settings.natural_resource_multiplier
horizons.main.start_singleplayer(options)
def act(self):
for size in self.sizes:
option_name = 'size_{:d}'.format(size)
if self._gui.findChild(name=option_name).marked:
self._windows.close()
# the empty list is interpreted as the empty list of random map island strings
options = StartGameOptions.create_editor_load([])
options.map_padding = size // 2
horizons.main.start_singleplayer(options)
return
def act(self, player_name, player_color): map_file = self._get_selected_map() options = StartGameOptions.create_start_map(map_file) options.set_human_data(player_name, player_color) options.ai_players = self._aidata.get_ai_players() options.trader_enabled = self._game_settings.free_trader options.pirate_enabled = self._game_settings.pirates options.disasters_enabled = self._game_settings.disasters options.natural_resource_multiplier = self._game_settings.natural_resource_multiplier horizons.main.start_singleplayer(options)
def act(self): for size in self.sizes: option_name = 'size_%d' % size if self._gui.findChild(name=option_name).marked: self.parent.hide() self.parent.parent.show_loading_screen() # the empty list is interpreted as the empty list of random map island strings options = StartGameOptions.create_editor_load([]) options.map_padding = size // 2 session = horizons.main.start_singleplayer(options) session.world_editor = WorldEditor(session.world) return
def _load_cmd_map(savegame, ai_players, force_player_id=None): """Load a map specified by user. @param savegame: either the displayname of a savegame or a path to a savegame @return: bool, whether loading succeeded""" # first check for partial or exact matches in the normal savegame list savegames = SavegameManager.get_saves() map_file = _find_map(savegame, savegames) if not map_file: return False options = StartGameOptions.create_load_game(map_file, force_player_id) start_singleplayer(options) return True
def _load_game(self):
if self._in_editor_mode:
editor_start_menu = EditorStartMenu(self._windows)
self._windows.show(editor_start_menu)
else:
window = SelectSavegameDialog('load', self._windows)
saved_game = self._windows.show(window)
if saved_game is None:
return
options = StartGameOptions(saved_game)
horizons.main.start_singleplayer(options)
return True
def _edit_map(map_file): """ Start editing the specified map file. @param map_file: path to the map file or a list of random island strings @return: bool, whether loading succeeded """ if not map_file: return False options = StartGameOptions.create_editor_load(map_file) start_singleplayer(options) return True
def _load_cmd_map(savegame, ai_players, force_player_id=None): """Load a map specified by user. @param savegame: either the displayname of a savegame or a path to a savegame @return: bool, whether loading succeeded""" # first check for partial or exact matches in the normal savegame list savegames = SavegameManager.get_saves() map_file = _find_matching_map(savegame, savegames) if not map_file: return False options = StartGameOptions.create_load_game(map_file, force_player_id) start_singleplayer(options) return True
def _edit_map(map_file): """ Start editing the specified map file. @param map_file: path to the map file or a list of random island strings @return: bool, whether loading succeeded """ if not map_file: return False options = StartGameOptions.create_editor_load(map_file) start_singleplayer(options) return True
def act(self, player_name, player_color): self.end() self._mainmenu.show_loading_screen() map_file = generate_random_map(*self._get_map_parameters()) options = StartGameOptions.create_start_map(map_file) options.set_human_data(player_name, player_color) options.ai_players = self._aidata.get_ai_players() options.trader_enabled = self._game_settings.free_trader options.pirate_enabled = self._game_settings.pirates options.disasters_enabled = self._game_settings.disasters options.natural_resource_multiplier = self._game_settings.natural_resource_multiplier horizons.main.start_singleplayer(options)
def saveload(gui): """Save and load the game (gui test version). Use like this: # For gui tests saveload(gui) """ fd, filename = tempfile.mkstemp() os.close(fd) assert gui.session.save(savegamename=filename) options = StartGameOptions.create_load_game(filename, None) # This hands out a new session, but `gui.session` is a property. horizons.main.start_singleplayer(options) # Restore some properties that were changed for tests: # Set game speed to maximum, and disable autoscroll. gui.setup()
def _edit_map(map_file): """ Start editing the specified map file. @param map_file: path to the map file or a list of random island strings @return: bool, whether loading succeeded """ if not map_file: return False options = StartGameOptions.create_editor_load(map_file) start_singleplayer(options) from horizons.editor.worldeditor import WorldEditor _modules.session.world_editor = WorldEditor(_modules.session.world) return True
def _edit_map(map_file):
"""
Start editing the specified map file.
@param map_file: path to the map file or a list of random island strings
@return: bool, whether loading succeeded
"""
if not map_file:
return False
options = StartGameOptions.create_editor_load(map_file)
start_singleplayer(options)
from horizons.editor.worldeditor import WorldEditor
_modules.session.world_editor = WorldEditor(_modules.session.world)
return True
def _start_map(map_name, ai_players=0, is_scenario=False,
pirate_enabled=True, trader_enabled=True, force_player_id=None, is_map=False):
"""Start a map specified by user
@param map_name: name of map or path to map
@return: bool, whether loading succeeded"""
if is_scenario:
map_file = _find_scenario(map_name, SavegameManager.get_available_scenarios(locales=True))
else:
map_file = _find_map(map_name, SavegameManager.get_maps())
if not map_file:
return False
options = StartGameOptions.create_start_singleplayer(map_file, is_scenario,
ai_players, trader_enabled, pirate_enabled, force_player_id, is_map)
start_singleplayer(options)
return True
def _load_last_quicksave(session=None, force_player_id=None):
"""Load last quicksave
@param session: value of session
@return: bool, whether loading succeeded"""
save_files = SavegameManager.get_quicksaves()[0]
if _modules.session is not None:
if not save_files:
_modules.session.ingame_gui.open_popup(_("No quicksaves found"),
_("You need to quicksave before you can quickload."))
return False
else:
if not save_files:
print "Error: No quicksave found."
return False
save = max(save_files)
options = StartGameOptions.create_load_game(save, force_player_id)
start_singleplayer(options)
return True
def _load_last_quicksave(session=None, force_player_id=None):
"""Load last quicksave
@param session: value of session
@return: bool, whether loading succeeded"""
save_files = SavegameManager.get_quicksaves()[0]
if _modules.session is not None:
if not save_files:
_modules.session.ingame_gui.open_popup(T("No quicksaves found"),
T("You need to quicksave before you can quickload."))
return False
else:
if not save_files:
print("Error: No quicksave found.")
return False
save = max(save_files)
options = StartGameOptions.create_load_game(save, force_player_id)
start_singleplayer(options)
return True
def _load_last_quicksave(session=None, force_player_id=None):
"""Load last quicksave
@param session: value of session
@return: bool, whether loading succeded"""
save_files = SavegameManager.get_quicksaves()[0]
if session is not None:
if not save_files:
session.gui.show_popup(
_("No quicksaves found"),
_("You need to quicksave before you can quickload."))
return False
else:
session.ingame_gui.on_escape() # close widgets that might be open
else:
if not save_files:
print "Error: No quicksave found."
return False
save = max(save_files)
_modules.gui.show_loading_screen()
options = StartGameOptions.create_load_game(save, force_player_id)
start_singleplayer(options)
return True
def _start_random_map(ai_players, seed=None, force_player_id=None): options = StartGameOptions.create_start_random_map(ai_players, seed, force_player_id) start_singleplayer(options) return True
def _start_random_map(ai_players, seed=None, force_player_id=None): options = StartGameOptions.create_start_random_map(ai_players, seed, force_player_id) start_singleplayer(options) return True
