def __build_reply(self, ob):
result = ''
for reply in ob.replies:
if Helpers.is_string(reply):
result += ' ' + reply
continue
args = reply['args']
key = reply['key']
item = None
if 'item' in args.keys():
item_name = args['item']
item = self.get_room_item_by_name(item_name)
template = args['template']
if 'attacker_name' in args.keys():
if args['attacker_name'].lower() in ['thief','ranger','fighter','mage']:
key = 'player_'+key
else:
key = 'monster_'+key
if template == ReplyHelpers.TEMPLATE_ACTION:
result += ' ' + ReplyHelpers.render_action_template(key, **args)
elif template == ReplyHelpers.TEMPLATE_ROOM:
if item:
result += ' ' + ReplyHelpers.try_render_room_template(self, item, key, **args)
else:
result += ' ' + ReplyHelpers.render_room_template(key, **args)
elif template == ReplyHelpers.TEMPLATE_COMMON:
result += ' ' + ReplyHelpers.render_common_template(key, **args)
elif template == ReplyHelpers.TEMPLATE_DESCRIPTION:
result += ' ' + ReplyHelpers.render_descr_template(key, **args)
return result
def sell(self, player, item_text, amount=1):
item = player.get_item_by_name(item_text)
if item is None:
return ReplyHelpers.render_action_template('not_carrying_unknown', action=Actions.get_action_text(Actions.SELL))
item = item.one_of()
item.add(amount-1)
if not self.can_sell(item):
return ReplyHelpers.render_action_template('sell_no_item', item_prefix=item.text_prefix, item_text=item.description)
#Has item to sell
itm = player.inventory.get_item(item)
if itm is None:
return ReplyHelpers.render_action_template('not_carrying', action=Actions.get_action_text(Actions.SELL), item_prefix=item.text_prefix, item_text=item.description)
if itm.count < item.count:
return ReplyHelpers.render_action_template('not_carrying_enough', action=Actions.get_action_text(Actions.SELL), item_text=item.description_plural)
description = item.description
if item.count > 1:
description = item.description_plural
#Sell items
player.drop(item)
player.inventory.add_money(item.cost)
self.__add_item(item)
return ReplyHelpers.render_action_template('sell_item', item_text=description)
def buy(self, player, item_text, amount=1):
#Store has item to sell
item = None
for itm in self.__items:
if itm.is_match(item_text):
item = itm.one_of()
break
if item == None:
return ReplyHelpers.render_action_template('buy_no_item')
item.add(amount-1)
description = item.description
if item.count > 1:
description = item.description_plural
#Can afford items
if player.money < item.cost:
return ReplyHelpers.render_action_template('buy_no_money', item_text=description)
#Buy items
player.inventory.remove_money(item.cost)
self.__remove_item(item)
player.pickup(item)
return ReplyHelpers.render_action_template('buy_item', item_text=description)
def test__ALEXA_LOCAL_start_game(self):
request = AlexaRequest(self.app,
user_id='fred',
application_id='quest_game')
request.set_intent('StartGameIntent')
response = request.post()
print(response.data)
self.assertEqual(ReplyHelpers.render_descr_template('are_you_sure'),
response.get_output_text())
#Pass session_id to continue session
request.set_intent('AMAZON.YesIntent')
response = request.post(request.session_id)
print(response.data)
self.assertTrue(
ReplyHelpers.render_descr_template('welcome') in
response.get_output_text())
#Prompt based on starting a new game, different when you have a saved game
#self.assertTrue(ReplyHelpers.render_descr_template('no_games') in response.get_output_text())
#self.assertTrue(ReplyHelpers.render_descr_template('no_games') in response.get_reprompt_text())
#Describe Thief
request.set_intent('DescribeItemIntent')
request.set_slots([request.create_slot('ditem', 'thief')])
response = request.post(request.session_id)
print(response.get_output_text())
self.assertTrue(
ReplyHelpers.render_descr_template('descr_thief') in
response.get_output_text())
return request
def open(self, player, spell=False):
if self.is_open:
self.notify_observers_log('{} is already open'.format(self.name))
self.notify_observers_reply(
ReplyHelpers.render_room_template('already_open',
item=self.name))
self.on_open(player)
return False
if self.is_locked:
self.notify_observers_log('{} is locked'.format(self.name))
self.notify_observers_reply(
ReplyHelpers.render_room_template(
'locked_spell' if spell else 'locked', item=self.name))
return False
if spell:
if not player.current_action == Actions.CAST:
#Will only happen if there is a coding error
self.notify_observers_log(
'{} is not being cast by the player'.format(spell.name))
return False
if self.is_trapped and self.__trap.is_armed:
self.__trap.trigger(player)
self._is_open = True
self._has_been_opened = True
self.notify_observers_reply(
ReplyHelpers.render_room_template(
'open_with_spell' if spell else 'open', item=self.name))
self.on_open(player)
return True
def affect(self, source, effect, params):
'''
What happens from an effect from a spell or potion
'''
result = False
if effect == Effects.Damage:
result = self.damage(params)
if result:
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'destroyed',
source_text=source.description,
item_name=self.description))
elif effect == Effects.Repair:
result = self.repair(params)
if result:
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'repaired',
source_text=source.description,
item_name=self.description))
else:
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'no_effect',
item_text=self.name,
effect_item=source.description))
return result
def throw(self, item, target):
'''
Returns True if hit, False if miss or can't throw
TODO: May need a better return
'''
if not self.is_carrying(item):
#You're not carrying {{item_prefix}} {{item_text}} to {{action}}.
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'not_carrying',
item_prefix=item.text_prefix,
item_text=item.name,
action='throw'))
return False
if not isinstance(item, weapons.Weapon) or not item.is_throwable:
self.notify_observers_log("{} - weapon {} is not throwable".format(
self.class_name, item.name))
self.notify_observers_reply(
ReplyHelpers.render_action_template('not_throwable',
weapon_text=item.name))
return False
result = item.throw(self, target)
#Maybe give if hit?
self.drop(item.one_of())
return result
def drink(self, item):
if not isinstance(item, potions.Potion) and not isinstance(
item, items.Drink):
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'drink_cannot',
item_prefix=item.text_prefix,
item_text=item.description))
return False
if not self.is_carrying(item):
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'not_carrying',
action=Actions.get_action_text(Actions.DRINK),
item_prefix=item.text_prefix,
item_text=item.description))
return False
self.notify_observers_reply(
ReplyHelpers.render_action_template(self.get_reply_key('drink'),
item_prefix=item.text_prefix,
item_text=item.description,
attacker_name=self.name))
if item.drink(self):
self.get_rid_of_one(item)
return True
return False
def help_area(area):
try:
help_text = ReplyHelpers.render_common_template('help_{}'.format(area))
except:
help_text = ReplyHelpers.render_common_template(
'help_not_found') + ' ' + ReplyHelpers.render_common_template(
'help')
return __query(help_text)
def __check_for_bodies(self):
monster_count, monster_names = self.get_dead_monsters_list()
floor_text = self.__get_room_text()[1]
mon_results = ''
if monster_count > 1:
mon_results = ReplyHelpers.render_room_template('dead_bodies', floor_text=floor_text, monster_names=monster_names)
elif monster_count == 1:
mon_results = ReplyHelpers.render_room_template('dead_body', floor_text=floor_text, monster_names=monster_names)
return mon_results
def enter(self, player):
player._end_battle()
monster_result = self.__check_for_monster(player)
body_result = self.__check_for_bodies()
if monster_result != '':
reply_text = ReplyHelpers.render_room_template('{}_enter'.format(self.name.lower())) + ' ' + monster_result
else:
reply_text = ReplyHelpers.render_room_template('{}_enter'.format(self.name.lower())) + ' ' + body_result
return QuestGameNormalReply(self, reply_text)
def _effect(self, caster, target):
dmg = self._damage(caster)
if dmg == 0:
caster.notify_observers_reply(ReplyHelpers.render_action_template(caster.get_reply_key('cast_defend'), spell_text=self.description,
attacker_name=caster.name, defender_name=target.name, damage=dmg, hit_points=target.hit_points, mana_points=caster.mana_points))
else:
caster.notify_observers_log("{} {} hit! Damage {}".format(caster.class_name, self.class_name, dmg))
caster.notify_observers_reply(ReplyHelpers.render_action_template(caster.get_reply_key('cast_hit'), spell_text=self.description,
attacker_name=caster.name, defender_name=target.name, damage=dmg, hit_points=target.hit_points, mana_points=caster.mana_points))
target.affect(self, Effects.Damage, dmg)
def unlock(self, player, key=False, spell=False):
if not self.is_locked:
self.notify_observers_log('{} is not locked'.format(self.name))
self.notify_observers_reply(
ReplyHelpers.render_room_template('not_locked',
item=self.name))
return False
if key:
if key.id == self._key_id:
self._is_locked = False
self.notify_observers_log('{} is unlocked'.format(self.name))
return True
#Wrong key
self.notify_observers_log('Wrong key used for {}'.format(
self.name))
return False
if spell:
if spell.__class__ == spells.UnlockSpell:
self._is_locked = False
self.notify_observers_log('{} is unlocked'.format(self.name))
self.notify_observers_reply(
ReplyHelpers.render_room_template('spell_success',
action='unlocked',
target_name=self.name))
return True
#Wrong spell
self.notify_observers_log('Wrong spell used for {}'.format(
self.name))
#Picklock
if not player.current_action == Actions.PICK_LOCK:
#Logic error
self.notify_observers_log('Can'
't pick lock, player doesn'
't seem to be performing this action')
return False
#pick lock
skill_roll = GameRules.roll_skill_check(player, skills.LockPicking())
if skill_roll.total >= self.lock_resistance.value:
self._is_locked = False
self.notify_observers_reply(
ReplyHelpers.render_room_template('picklock_success',
item=self.name))
return True
#pick failed
self.notify_observers_reply(
ReplyHelpers.render_room_template('picklock_fail', item=self.name))
return False
def whats_for_sale(self):
if len(self.__items) > 0:
result = ReplyHelpers.render_room_template('sale_items')
else:
result = ReplyHelpers.render_room_template('sale_no_items')
for item in self.__items:
if self.is_unlimited(item):
result += ' {}.'.format(item.description_plural)
elif item.count > 1:
result += ' {} {}.'.format(item.count, item.description_plural)
else:
result += ' {} {}.'.format(item.text_prefix, item.description)
return result
def count_money(self, player):
carried_gold = player.inventory.get_item(items.Gold())
carried_silver = player.inventory.get_item(items.Silver())
carried_copper = player.inventory.get_item(items.Copper())
if carried_gold + carried_silver + carried_copper > 0:
result = ReplyHelpers.render_action_template('money_have')
else:
result = ReplyHelpers.render_action_template('money_none')
if carried_gold > 0:
result += ' ' + ReplyHelpers.render_action_template('money_count', type='gold', amount=carried_gold)
if carried_silver > 0:
result += ReplyHelpers.render_action_template('money_count', type='silver', amount=carried_silver)
if carried_copper > 0:
result += ReplyHelpers.render_action_template('money_count', type='copper', amount=carried_copper)
return result
def lock(self, player, key=False, spell=False):
if self.is_locked:
self.notify_observers_log('{} is already locked'.format(self.name))
self.notify_observers_reply(
ReplyHelpers.render_room_template('already_locked',
item=self.name))
return False
if self.is_open:
self.close(player)
if key:
if key.id == self._key_id:
self._is_locked = True
self.notify_observers_log('{} is locked'.format(self.name))
return True
#Wrong key
self.notify_observers_log('Wrong key used for {}'.format(
self.name))
return False
if spell:
if spell.__class__ == spells.LockSpell:
self._is_locked = True
self.notify_observers_log('{} is locked'.format(self.name))
return True
#Wrong spell
self.notify_observers_log('Wrong spell used for {}'.format(
self.name))
return False
def open(self, item):
if isinstance(item, RoomOpenableItem):
with Observer(item) as ob:
item.open(self.__player)
return self.__build_reply(ob)
else:
return ReplyHelpers.try_render_room_template(self, item, 'open_cannot')
def pull(self, player, item):
if item.name == 'loose_stone':
result = ReplyHelpers.render_room_template('cellroom_pull_stone')
if self._get_state('hidden_item_taken'):
result += ' ' + ReplyHelpers.render_room_template('cellroom_pull_stone_empty')
else:
item._has_been_opened = True
hidden_item = items.LockPick()
if player.__class__ == players.Mage:
hidden_item = items.Scroll(spells.UnlockSpell())
player.pickup(hidden_item)
self._set_state('hidden_item_taken',True)
result += ' ' + ReplyHelpers.render_room_template('cellroom_pull_stone_full',item_text=hidden_item.description)
else:
result = Room.pull(self, item)
return result
def pick_lock(self, item):
if not self.can_picklock():
self.notify_observers_reply(
ReplyHelpers.render_room_template('no_lockpick_ability'))
return False
self.remove_item(items.LockPick())
return item.unlock(self)
def test_throw_actions(self):
gm = game_manager
player = gm.create_player('thief')
gm.start_new_game('fred', player)
user = gm.get_user('fred', 'test')
user.set_room(rooms.CellRoom(player))
room = user.room
dagger = weapons.Dagger()
#Throw item you don't have
reply = room.throw(dagger, None)
self.assertTrue('not carrying' in reply)
print(reply)
#Throw at non-existent item
player.pickup(dagger)
reply = room.throw(dagger, 'chest')
self.assertTrue(
ReplyHelpers.render_action_template(
'no_such_target', item_text=dagger.description) in reply)
print(reply)
#Throw item at door
reply = room.throw(dagger, 'door')
self.assertTrue('door' in reply)
print(reply)
self.assertTrue('you throw' in reply.lower())
def describe(ditem):
if __get_query() == ReplyHelpers.QUERY_CLASS:
itm = ditem.lower()
reply_text = ''
if itm == 'mage':
reply_text = ReplyHelpers.render_descr_template('descr_mage')
elif itm == 'thief':
reply_text = ReplyHelpers.render_descr_template('descr_thief')
elif itm == 'fighter':
reply_text = ReplyHelpers.render_descr_template('descr_fighter')
elif itm == 'ranger':
reply_text = ReplyHelpers.render_descr_template('descr_ranger')
reply_text += ' ' + ReplyHelpers.render_common_template('choose_class')
return __query(reply_text, query_state=ReplyHelpers.QUERY_CLASS)
return __do_action(Actions.DESCRIBE, ditem)
def __query(text, reprompt='', query_state=None):
if query_state is None:
if __is_in_battle():
__set_query(ReplyHelpers.QUERY_BATTLE)
else:
__set_query(ReplyHelpers.QUERY_WHAT)
__set_query(query_state)
if reprompt == '':
if query_state == ReplyHelpers.QUERY_WHAT:
reprompt = ReplyHelpers.render_common_template('what_reprompt')
if query_state == ReplyHelpers.QUERY_BATTLE:
reprompt = ReplyHelpers.render_common_template('battle_reprompt')
if query_state == ReplyHelpers.QUERY_CLASS:
reprompt = ReplyHelpers.render_common_template('choose_class')
result = QuestGameReply(text, reprompt, query_state).get_alexa_reply()
return result
def cast(self, player, spell_text, target):
spell = spells.SpellStats.get_spell_by_text(spell_text)
if not spell:
return ReplyHelpers.render_action_template('spell_cannot')
with Observer(player) as ob:
if not player.can_cast_spell(spell):
return ReplyHelpers.render_action_template('spell_cannot_cast',spell_name=spell.description) + self.__build_reply(ob)
result = ''
player.cast(spell, target)
#You attacked a poor monster
if isinstance(target, players.Monster):
target.strike(player)
result += ' ' + self.__build_reply(ob)
return result
def test__ALEXA_LOCAL_character_reponse(self):
request = self.test__ALEXA_LOCAL_start_game()
request.set_intent('CharacterIntent')
request.set_slots([request.create_slot('name', 'mage')])
response = request.post(request.session_id)
print(response.data)
self.assertTrue(
ReplyHelpers.render_action_template('char_choice', char='mage') in
response.get_output_text())
def drink(self, player):
if not player.is_carrying(self):
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'not_carrying',
item_prefix=self.text_prefix,
item_text=self.description,
action='drink'))
return False
if self.count == 0:
self.notify_observers_reply(
ReplyHelpers.render_action_template('nothing_to_drink',
item_text=self.name))
return False
player.notify_observers_log("{} - drank {}".format(
player.class_name, self.class_name))
self.count -= 1
self._effect('drink', player)
return True
def lock(self, player, item):
with Observer(item) as ob:
key = item.get_key()
if player.is_carrying(key):
item.lock_with_key(player)
elif player.can_cast_spell(spells.LockSpell()):
item.lock_with_spell(spells.LockSpell(), player)
else:
return ReplyHelpers.render_room_template('nothing_to_lock_item', item=item.description)
return self.__build_reply(ob)
def choose_char(name):
if __get_query() == ReplyHelpers.QUERY_CLASS:
if name.lower() not in ['thief', 'mage', 'fighter', 'ranger']:
reply_text = ReplyHelpers.render_common_template(
'unsure') + ' ' + ReplyHelpers.render_common_template(
'choose_class')
return __query(reply_text, query_state=ReplyHelpers.QUERY_CLASS)
player = game_manager.create_player(name.lower())
reply_text = ReplyHelpers.render_common_template('chose_char',
cls=name.lower())
reply_text += ' ' + game_manager.start_new_game(
session.user.userId, player).prompt_text
return __query(reply_text)
if not game_manager.is_game_started(session.user.userId):
return launch()
reply_text = game_manager.continue_game(session.user.userId)
return __query(reply_text)
def __list_items_reply(self, items, pickup=False, player=None):
result = ''
i = 0
for item in items:
i += 1
if i == 1:
result += ' ' + ReplyHelpers.render_room_template('found_items',item=item.text_prefix + ' ' + item.description)
elif i == len(items):
result += ' and {} {}.'.format(item.text_prefix, item.description)
else:
result += ', {}'.format(item.description)
if pickup:
with Observer(player) as ob:
for item in items:
player.pickup(item)
result += self.__build_reply(ob)
if i==0:
result += ' ' + ReplyHelpers.render_room_template('found_nothing')
return result
def __search_floor(self, player):
#item = self.get_room_item_by_name('floor')
self.on_search_floor()
floor_text = self.__get_room_text()[1]
result = ReplyHelpers.render_room_template('search_item',item=floor_text)
result += ' ' + self.__list_items_reply(self._floor_items, pickup=True, player=player)
mon_results = self.__check_for_bodies()
self._set_state('floor_searched', True)
return result + ' ' + mon_results
def eat(self, item):
if not isinstance(item, items.Food):
ReplyHelpers.render_action_template('eat_cannot',
item_text=item.description)
return False
if not self.is_carrying(item):
self.notify_observers_reply(
ReplyHelpers.render_action_template(
'not_carrying',
action=Actions.get_action_text(Actions.EAT),
item_prefix=item.text_prefix,
item_text=item.description))
return False
self.notify_observers_reply(
ReplyHelpers.render_action_template('eat_food',
item_text=item.description))
if item.eat(self):
self.get_rid_of_one(item)
return True
return False
