Exemplo n.º 1
0
    def _walk(self):
        position = self.player.position
        if position is None:
            self._failure()
            return

        self.trees = find_tree(self.map, self.exhaust_db, position)
        if self.trees is None:
            self._failure()
            return

        positions = set()
        for resource in self.trees:
            for p in passable_positions_around(self.map, resource.x, resource.y, resource.z, 2):
                positions.add(p)

        if len(positions) == 0:
            # no reachable position; try again
            resource = self.trees[0]
            self.exhaust_db.set_exhausted(resource.x/8, resource.y/8)
            reactor.callLater(0.1, self._walk)
            return

        nearest = nearest_position((self.player.position.x, self.player.position.y),
                                   positions)
        position = Position(nearest[0], nearest[1])
        client = self._client
        d = PathFindWalk(self._client, self.map, position).deferred
        d.addCallbacks(self._walked, self._walk_failed)
Exemplo n.º 2
0
    def _walk(self):
        position = self.player.position
        if position is None:
            self._failure()
            return

        self.trees = find_tree(self.map, self.exhaust_db, position)
        if self.trees is None:
            self._failure()
            return

        positions = set()
        for resource in self.trees:
            for p in passable_positions_around(self.map, resource.x,
                                               resource.y, resource.z, 2):
                positions.add(p)

        if len(positions) == 0:
            # no reachable position; try again
            resource = self.trees[0]
            self.exhaust_db.set_exhausted(resource.x / 8, resource.y / 8)
            reactor.callLater(0.1, self._walk)
            return

        nearest = nearest_position(
            (self.player.position.x, self.player.position.y), positions)
        position = Position(nearest[0], nearest[1])
        client = self._client
        d = PathFindWalk(self._client, self.map, position).deferred
        d.addCallbacks(self._walked, self._walk_failed)
Exemplo n.º 3
0
    def _walk(self):
        position = self.player.position
        if position is None:
            self._failure()
            return

        self.tree = find_tree(self.map, self.exhaust_db, position)
        if self.tree is None:
            self._failure()
            return

        x, y = self.tree.x, self.tree.y
        if position.x < self.tree.x:
            x -= 1
        elif position.x > self.tree.x:
            x += 1
        if position.y < self.tree.y:
            y -= 1
        elif position.y > self.tree.y:
            y += 1

        position = Position(x, y)
        d = PathFindWalk(self._client, self.map, position).deferred
        d.addCallbacks(self._walked, self._walk_failed)
Exemplo n.º 4
0
    def _walk(self):
        position = self.player.position
        if position is None:
            self._failure()
            return

        self.tree = find_tree(self.map, self.exhaust_db, position)
        if self.tree is None:
            self._failure()
            return

        x, y = self.tree.x, self.tree.y
        if position.x < self.tree.x:
            x -= 1
        elif position.x > self.tree.x:
            x += 1
        if position.y < self.tree.y:
            y -= 1
        elif position.y > self.tree.y:
            y += 1

        position = Position(x, y)
        d = PathFindWalk(self._client, self.map, position).deferred
        d.addCallbacks(self._walked, self._walk_failed)
Exemplo n.º 5
0
def PathFindWalkRectangle(client, map, rectangle):
    assert rectangle[0] <= rectangle[2]
    assert rectangle[1] <= rectangle[3]

    wx = rectangle[2] - rectangle[0]
    wy = rectangle[3] - rectangle[1]

    player = client.world.player.position
    x, y = player.x + random.randint(-8, 8), player.y + random.randint(-8, 8)
    x += random.randint(-wx / 2, wx / 2)
    y += random.randint(-wy / 2, wy / 2)

    if x < rectangle[0]:
        x = rectangle[0]
    elif x > rectangle[2]:
        x = rectangle[2]

    if y < rectangle[1]:
        y = rectangle[1]
    elif y > rectangle[3]:
        y = rectangle[3]

    return PathFindWalk(client, map, Position(x, y))
Exemplo n.º 6
0
 def _next_walk(self):
     client = self._client
     to = Position(self.random.randint(self.min_x, self.max_x),
                   self.random.randint(self.min_y, self.max_y))
     d = PathFindWalk(client, self.map, to).deferred
     d.addCallbacks(self._walked, self._walked)
Exemplo n.º 7
0
 def _walk(self):
     self._map.flush_cache()
     d = PathFindWalk(self._client, self._map, Position(HOUSE[0], HOUSE[1])).deferred
     d.addCallbacks(self._walked, self._walk_failed)
Exemplo n.º 8
0
 def _next_walk(self):
     client = self._client
     to = Position(self.random.randint(self.min_x, self.max_x),
                   self.random.randint(self.min_y, self.max_y))
     d = PathFindWalk(client, self.map, to).deferred
     d.addCallbacks(self._walked, self._walked)