def _wear(self, index):
item = self.being.inventory.could_wear()[index]
self.being.inventory.wear(item)
self.controller.turn_done(self.being)
logger.msg_info("{You} are now wearing {}.".format(item, **self.being.words_dict))
return True
def _remove_using(self, index):
item = self.being.inventory.wearing[index]
self.being.inventory.take_off(item)
self.controller.turn_done(self.being)
logger.msg_info("{You} took off {}.".format(item, **self.being.words_dict))
return True
def zap(self, being, wand, direction):
if wand.charges < 1:
logger.msg_info('{You} cannot zap a wand without charges.'.format(**being.words_dict))
return False
wand.item.charges -= 1
tile = self.game.level.tile_for(being)
spell = wand.spell
first = True
# if its ray we now know it.
if not wand.item.known and wand.kind.bounce:
wand.item.known = True
# if we have a ray or a beam
if wand.kind.ray_dice:
length = wand.kind.ray_dice.roll()
while length > 0:
tiles = self.game.level.get_ray(tile, direction, length+1, all_types=wand.item.can_tunnel)
if first:
tiles = tiles[1:]
length -= len(tiles)
self.events['wand_zapped'].emit(spell.view(), [t.idx for t in tiles], direction)
for t in tiles:
logger.ddebug('A {} passes through {}.'.format(wand.item.zap, t))
other = tile.being
if spell.damage and t.being:
if self.player_can_see(t):
logger.msg_warn("The {zap} hits {you}.".format(zap=wand.item.zap, **t.being.words_dict))
else:
logger.ddebug("The (unseen) {zap} hits {you}.".format(zap=wand.item.zap, **t.being.words_dict))
if self.combat_arena.spell_attack(tile, t, spell):
wand.item.known = True
if spell.method and spell.handle(self.game, t):
wand.item.known = True
logger.msg_warn('The wand {} {}.'.format(spell.verb.she, t.being))
self.handle_spell(spell, t, other, tile.being)
# if the wand does not bounce or the tiletype does not bouce then stop
if not (tiles[-1].tiletype.bounce and wand.kind.bounce):
break
direction = direction.bounce(tiles[-1].tiletype.bounce)
tile = self.game.level.adjacent_tile(tiles[-1], direction)
first = False
elif spell.method and spell.handle(self.game, tile):
wand.item.known = True
self.handle_spell(spell, tile, being)
if not being.is_dead:
self.turn_done(being)
return True
def drop_item(self, being):
if not being.inventory:
return False
tile = self.game.level.tile_for(being)
item = being.inventory.pop()
tile.inventory.append(item)
self.events['tile_inventory_changed'].emit(tile.idx, tile.inventory.view())
logger.msg_info("{You} {drop} {item}".format(item=item, **being.words_dict))
self.turn_done(being)
return True
def _attack(self, attack, attacker, attackee):
if attack.means.condition:
success, msg = self.on_set_condition(attack, attacker, attackee)
else:
method = getattr(self, 'on_' + attack.means.name)
success, msg = method(attack, attacker, attackee)
if success:
logger.msg_warn(msg.strip())
else:
logger.msg_info(msg.strip())
def pickup_item(self, being):
tile = self.game.level.tile_for(being)
try:
item = tile.inventory.pop()
except IndexError:
logger.msg_impossible("There is nothing for {you} to pickup".format(subject.being.words_dict))
return False
being.inventory.append(item)
self.events['tile_inventory_changed'].emit(tile.idx, tile.inventory.view())
logger.msg_info("{You} {pick} up {item}".format(item=item, **being.words_dict))
self.turn_done(being)
return True
def _on_create_monster(self, species):
game = self.controller.game
try:
being = game.create_being_by(self.being, species.strip())
except AttrReaderError:
logger.msg_impossible("No such spieces {} exists.".format(repr(species)))
return False
if not being:
logger.msg_impossible("Could not create spieces {}.".format(species))
else:
logger.msg_info("Created spieces {}.".format(species))
tile = game.level.tile_for(being)
self.controller.events['being_became_visible'].emit(tile.view(game.player))
return being is not None
def _on_create_item(self, item_name):
game = self.controller.game
try:
item = game.create_item_by(self.being, item_name.strip())
except AttrReaderError:
logger.msg_impossible("No such item {} exists.".format(repr(item_name)))
return False
if not item:
logger.msg_impossible("Could not create item {}.".format(item_name))
else:
logger.msg_info("Created item {}.".format(item))
tile = game.level.tile_for(self.being)
self.controller.events['tile_inventory_changed'].emit(tile.idx, tile.inventory.view())
return item is not None
def close(self, being, target):
name = target.tiletype.kind
if target.closable:
ok = self.game.level.close_door(target)
if ok:
logger.msg_info('{You} {close} {}'.format(name, **being.words_dict))
self.events['tile_changed'].emit(target.view(self.game.player))
else:
logger.msg_info('{You} {do} not {close} {}'.format(name, **being.words_dict))
self.turn_done(being)
return True
else:
logger.msg_impossible("{You} cannot close a {}.".format(name, **being.words_dict))
return False
def move(self, subject, target):
if not target:
logger.msg_impossible("There is no tile for {you} to move there.".format(**subject.being.words_dict))
return False
elif target.being:
logger.msg_impossible("{You} cannot move into a square with a monster!".format(**subject.being.words_dict))
return False
elif not target.tiletype.is_open:
logger.msg_impossible("{You} cannot move through {tiletype}.".format(tiletype=target.tiletype, **subject.being.words_dict))
return False
being = subject.being
self.game.level.move_being(subject, target)
target_seen = self.player_can_see(target)
subject_seen = self.player_can_see(subject)
# if we are the player we always know about it
if being.is_player:
if not target.inventory:
logger.debug('{You} {move} to {}.'.format(target, **being.words_dict))
else:
logger.msg_info('{You_are} standing on {}.'.format(target.inventory, **being.words_dict))
self.events['being_moved'].emit(subject.idx, target.idx, being.guid, being.direction)
# else if a monster just walked out of the dark
elif target_seen and not subject_seen:
logger.ddebug('{} came out of the dark onto {}.'.format(being.words.You, target))
self.events['being_became_visible'].emit(subject.idx, being.view())
self.events['being_moved'].emit(subject.idx, target.idx, being.guid, being.direction)
being.has_been_seen = True
# else if a monster just walked into the dark
elif subject_seen and not target_seen:
logger.ddebug('{} went into the dark onto {}.'.format(being.words.You, target))
self.events['being_moved'].emit(subject.idx, target.idx, being.guid, being.direction)
self.events['being_became_invisible'].emit(being.guid)
# else if we watched the monster move
elif subject_seen and target_seen:
logger.ddebug('The player watched {} move onto {}.'.format(target.being, target))
self.events['being_moved'].emit(subject.idx, target.idx, being.guid, being.direction)
else:
logger.ddebug('{} moved to {}, but the player did not see it.'.format(target.being.words.You, target))
self.turn_done(target.being)
return True
def spell_attack(self, subject, target, spell):
attackee = target.being
attacker = subject.being
if attacker:
logger.ddebug('{} casting {} on {}.'.format(attacker.words.You_are, spell, attackee.words.your_self))
else:
logger.ddebug('{} is cast upon {}.'.format(str(spell).capitalize(), attackee.words.your_self))
if [c for c in attackee.conditions if c.spell_resistance == spell.name]:
logger.msg_info('{} resits the {} spell.'.format(attackee.words.You, spell.name))
self.controller.events['being_spell_resistance'].emit(target.idx, attackee.guid, spell.view())
else:
damage = spell.damage.roll()
logger.msg_debug("The {} spell does {} damage on {}".format(spell.name, damage, attackee))
self.controller.events['being_spell_damage'].emit(target.idx, attackee.guid, spell.view())
self._take_damage(attackee, attacker, damage)
return True
def kick(self, source, target, direction):
#FIXME do bad stuff to legs when we dont succeed
self.events['being_kicked'].emit(source.idx, target.idx, source.being.guid, direction)
being = source.being
if target.breakable:
# chance to break the door
if random() > .5: #FIXME
door = str(target)
self.game.level.break_door(target)
logger.msg_info("{You} {kick} {door} down!".format(door=target.tiletyp, **being.words_dict))
self.events['tile_changed'].emit(target.view(self.game.player))
# else we just hit the door
else:
logger.msg_info("Wham! Wham!")
# else it was not a closed door
else:
if target.tiletype.is_open:
logger.msg_info('{You} {kick} at empty space.'.format(**subject.being.words_dict))
else:
if subject.being.is_player:
logger.msg_info('Ouch! That hurts.')
def open(self, being, target):
name = target.tiletype.kind
if target.openable:
ok = self.game.level.open_door(target)
if ok:
logger.msg_info('{You} {open} {}'.format(name, **being.words_dict))
self.events['tile_changed'].emit(target.view(self.game.player))
else:
if being.is_player:
logger.msg_info("The {} does not open.".format(name))
else:
logger.msg_info("{You} cannot open the {}.".format(name, **being.words_dict))
self.turn_done(being)
return True
else:
logger.msg_impossible("{You} cannot open a {}.".format(name, **being.words_dict))
return False
def on_spell_confusion(self, spell, tile, being, attacker):
if being.is_player:
logger.msg_info("Huh, what? Where am I?")
else:
logger.msg_info("{You} {look} confused.".format(**being.words_dict))
def on_spell_healing(self, spell, tile, being, attacker):
verb = 'feel' if being.is_player else 'looks'
logger.msg_info('{You} {} better'.format(verb, **being.words_dict))
def on_spell_confusor(self, spell, tile, being, attacker):
logger.msg_info('{Your} hands begin to glow red.'.format(**being.words_dict))
def examine_tile(self):
tile = self.controller.game.level.tile_for(self.being)
thing = tile.ontop(nobeing=True)
logger.msg_info("{You} are standing on {}.".format(thing.description, **self.being.words_dict))
return False
def on_spell_locking(self, spell, tile, being, attacker):
logger.msg_info(spell.msg)
self.events['tile_changed'].emit(tile.view(self.game.player))
