def execute(self, session):
# Open a dialog window in the current scene.
open_dialog(session, self._dialog_chain_queue, self._avatar,
self._menu)
self._dialog_chain_queue = list()
self._avatar = None
self._menu = None
def host_game(self):
# check if server is already hosting a game
if self.game.server.listening:
self.game.pop_state(self)
open_dialog(local_session,
[T.translate('multiplayer_already_hosting')])
# not hosting, so start the process
elif not self.game.isclient:
# Configure this game to host
self.game.ishost = True
self.game.server.server.listen()
self.game.server.listening = True
# Enable the game, so we can connect to self
self.game.client.enable_join_multiplayer = True
self.game.client.client.listen()
self.game.client.listening = True
# connect to self
while not self.game.client.client.registered:
self.game.client.client.autodiscover(autoregister=False)
for game in self.game.client.client.discovered_servers:
self.game.client.client.register(game)
# close this menu
self.game.pop_state(self)
# inform player that hosting is ready
open_dialog(local_session,
[T.translate('multiplayer_hosting_ready')])
def choose_target(menu_item):
# open menu to choose target of technique
technique = menu_item.game_object
if technique.next_use > 0:
params = {"move": technique.name, "name": self.monster.name}
tools.open_dialog(local_session, [T.format('combat_recharging', params)])
return
combat_state = self.client.get_state_by_name("CombatState")
state = self.client.push_state("CombatTargetMenuState", player=combat_state.players[0],
user=self.monster, action=technique)
state.on_menu_selection = partial(enqueue_technique, technique)
def enqueue_item(item, menu_item):
target = menu_item.game_object
# is the item valid to use?
if not item.validate(target):
msg = T.format('cannot_use_item_monster', {'name': item.name})
tools.open_dialog(local_session, [msg])
return
# enqueue the item
combat_state = self.client.get_state_by_name("CombatState")
# TODO: don't hardcode to player0
combat_state.enqueue_action(combat_state.players[0], item, target)
# close all the open menus
self.client.pop_state() # close target chooser
self.client.pop_state() # close the monster action menu
def save(self):
logger.info("Saving!")
try:
save_data = save.get_save_data(local_session, )
save.save(
save_data,
self.selected_index + 1,
)
save.slot_number = self.selected_index
except Exception as e:
raise
logger.error("Unable to save game!!")
logger.error(e)
open_dialog(local_session, [T.translate('save_failure')])
else:
open_dialog(local_session, [T.translate('save_success')])
def swap_it(menuitem):
monster = menuitem.game_object
if monster in self.client.get_state_by_name('CombatState').active_monsters:
tools.open_dialog(local_session, [T.format('combat_isactive', {"name": monster.name})])
return
elif monster.current_hp < 1:
tools.open_dialog(local_session, [T.format('combat_fainted', {"name": monster.name})])
return
combat_state = self.client.get_state_by_name("CombatState")
swap = Technique("swap")
swap.combat_state = combat_state
player = local_session.player
target = monster
combat_state.enqueue_action(player, swap, target)
self.client.pop_state() # close technique menu
self.client.pop_state() # close the monster action menu
def on_menu_selection(self, menu_item):
""" Called when player has selected something from the inventory
Currently, opens a new menu depending on the state context
:param menu_item:
:return:
"""
item = menu_item.game_object
state = self.determine_state_called_from()
if not any(menu_item.game_object.validate(m) for m in local_session.player.monsters):
msg = T.format('item_no_available_target', {'name': item.name})
tools.open_dialog(local_session, [msg])
elif state not in item.usable_in:
msg = T.format('item_cannot_use_here', {'name': item.name})
tools.open_dialog(local_session, [msg])
else:
self.open_confirm_use_menu(item)
def add(menuitem):
monster = menuitem.game_object
if monster.current_hp == 0:
tools.open_dialog(local_session, [T.format("combat_fainted", parameters={"name": monster.name})])
elif monster in self.active_monsters:
tools.open_dialog(local_session, [T.format("combat_isactive", parameters={"name": monster.name})])
msg = T.translate("combat_replacement_is_fainted")
tools.open_dialog(local_session, [msg])
else:
self.add_monster_into_play(player, monster)
self.client.pop_state()
def open_dialog(self, pages, avatar):
logger.info("Opening chain dialog window")
open_dialog(self.session, pages, avatar)
def open_dialog(self, initial_text, avatar):
logger.info("Opening dialog window")
open_dialog(self.session, [initial_text], avatar)
def not_implemented_dialog():
open_dialog(local_session, [T.translate('not_implemented')])
def open_monster_stats():
open_dialog(local_session, [T.translate('not_implemented')])
