def _use_skill(self, skill):
assert self._target_locked == bool(self._targets)
log.msg("train skill", SKILL_NAMES[skill])
if skill == SKILL_MUSICIANSHIP:
instrument = self._find_instrument()
if instrument is not None:
self._client.send(p.Use(instrument.serial))
self._success()
else:
self._client.send(p.Use(SERIAL_PLAYER | self._world.player.serial))
self._failure(NoSuchEntity('No instrument'))
return
elif skill == SKILL_HERDING:
crook = self._find_crook()
if crook is not None:
self._client.send(p.Use(crook.serial))
else:
self._client.send(p.Use(SERIAL_PLAYER | self._world.player.serial))
self._target_mutex.put_target()
self._failure(NoSuchEntity('No crook'))
return
else:
self._client.send(p.UseSkill(skill))
if len(self._targets) == 0:
self._success()
def target_ok(self):
client = self._client
client.send(p.Use(self.crook.serial))
self.engine = SendTarget(client, Target(serial=self.target.serial))
d = self.engine.deferred
d.addCallbacks(self._target_sent, self._target_failed)
def run(client):
gate = client.world.find_reachable_item(lambda x: x.item_id == ITEM_GATE)
if gate is None:
return defer.fail('No nearby gate found')
print gate
client.send(p.Use(gate.serial))
def _got_skill(self, result):
target = tailoring_target(result.value)
if target is None:
self._failure(NoTailoringTarget())
return
client = self._client
client.send(p.Use(self.tool.serial))
d = MenuResponse(client, target).deferred
d.addCallbacks(self._success, self._success)
def _next(self):
door = find_door_at(self._client.world, self.x, self.y)
if door is None:
self._success()
return
self.__tries -= 1
if self.__tries <= 0:
self._failure()
return
self._client.send(p.Use(door.serial))
reactor.callLater(0.5, self._next)
def __init__(self, client, skills, round_robin=False):
Engine.__init__(self, client)
self._world = client.world
self._skills = list(skills)
self._use = None
self.call_id = None
self.round_robin = round_robin
# refresh backpack contents, in case we need a target
if self._world.backpack() is not None:
client.send(p.Use(self._world.backpack().serial))
self.__deferred_skills = deferred_skills(client)
self.__deferred_skills.addCallbacks(self._got_skills, self._failed_skills)
def __init__(self, client):
Engine.__init__(self, client)
tool = client.world.find_item_in(
client.world.backpack(),
lambda x: x.item_id in ITEMS_CARPENTRY_TOOLS)
if tool is None:
print("No tool")
self._failure()
return
client.send(p.Use(tool.serial))
d = MenuResponse(client, ('Other', 'board: 1 Logs')).deferred
d.addCallbacks(self._responded, self._failure)
def __init__(self, client, container):
Engine.__init__(self, client)
self._serial = container.serial
self._open = False
if container.is_bank(client.world.player):
self._client.send(p.TalkUnicode(text='Bank!', keyword=0x02))
else:
if not self._client.world.is_empty(container):
# we know its contents, it seems already open
self._success()
return
client.send(p.Use(self._serial))
self.call_id = reactor.callLater(3, self._timeout)
def _found_tool(self, tool):
client.send(p.Use(tool.serial))
d = MenuResponse(client, target).deferred
d.addCallbacks(self._success, self._success)
def open_door(self, player_serial):
self._client.send(p.Use(self.door))
log.msg("Opened door for " + str(player_serial))
def _do(self):
client = self._client
client.send(p.Use(self.item))
self.engine = SendTarget(client, self.target)
self.engine.deferred.addCallbacks(self._target_sent,
self._target_failed)
