def __move(self, being, name):
direc = direction_by_name[name]
controller = self.controller
subject = controller.game.level.tile_for(being)
#FIXME this should go to controller
if being.has_condition('confused'):
tiles = [t for t in controller.game.level.adjacent_tiles(subject) if t.tiletype.is_open]
if not tiles:
return False
target = choice(tiles)
else:
target = controller.game.level.adjacent_tile(subject, direc)
# FIXME
# if we cannot move
#if not self.being.can_move():
if False:
logger.msg_impossible('{You} cannot move!'.format(**subject.being.words_dict))
return False
# if there is a monster and we can fight
elif target.being and being.species.attacks:
return controller.attack(subject, target, direc)
# else try to move to the square
else:
ok = controller.move(subject, target)
return ok
def remove_using(self):
wearing = self.being.inventory.wearing
if not wearing:
logger.msg_impossible("You have nothing you can take off or stop using.")
return False
self.events['remove_usable_requested'].emit([i.view() for i in wearing], self._remove_using)
return False
def wear_item(self):
items = self.being.inventory.could_wear()
if not items:
logger.msg_impossible("{You} have nothing you can wear or use.".format(**self.being.words_dict))
return False
question = 'Wear or wield what item?'
self.events['usable_requested'].emit(question, [(i.view()) for i in items], self._wear)
return False
def zap_wand(self):
items = self.being.inventory.by_klass_name('wand')
if not items:
logger.msg_impossible("{You} have nothing to zap.".format(**self.being.words_dict))
return False
question = 'Zap what wand?'
self.events['usable_requested'].emit(question, [(i.view()) for i in items], self._zap)
return False
def quaff_potion(self):
items = self.being.inventory.by_klass_name('potion')
if not items:
logger.msg_impossible("{You} have nothing you can quaff.".format(**self.being.words_dict))
return False
question = 'Quaff what potion?'
self.events['usable_requested'].emit(question, [(i.view()) for i in items], self._quaff)
return False
def read_scroll(self):
items = self.being.inventory.by_klass_name('scroll')
if not items:
logger.msg_impossible("{You} have nothing you can read.".format(**self.being.words_dict))
return False
question = 'Read what scroll?'
self.events['usable_requested'].emit(question, [(i.view()) for i in items], self._read)
return False
def _zap(self, index):
wand = self.being.inventory.by_klass_name('wand')[index]
if wand.charges < 1:
logger.msg_impossible("The wand has no charges.")
return False
if wand.kind.directional:
question = 'What direction?'
self.events['item_direction_requested'].emit(question, index, self._zap_direction)
return False
else:
return self.controller.zap(self.being, wand, None)
def attack(self, subject, target, direc):
if not target:
logger.msg_impossible('{You} {try} to attack nothing.'.format(**being.words_dict))
return False
elif not target.being:
logger.msg_impossible('{You} {try} to attack empty space.'.format(**being.words_dict))
return False
self.events['being_meleed'].emit(subject.idx, target.idx, subject.being.guid, direc.abr)
self.combat_arena.attack(subject.being, target.being)
self.turn_done(subject.being)
return True
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_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 _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 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 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 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 drop_item(self):
if not self.being.inventory:
logger.msg_impossible('{You} have no items in your inventory!'.format(**self.being.words_dict))
return False
ok = self.controller.drop_item(self.being)
return ok
def move_down(self):
if not self.being.can_move:
logger.msg_impossible('{You} cannot move!'.format(**self.being.words_dict))
return False
return self.controller.move_down(self.being)
