Exemplo n.º 1
0
 def tryDigHallwayBetween( self, alpha, beta):
     from pathfind import Pathfinder, infinity
     import math
     tx, ty = beta.floorpoint()
     ox, oy = alpha.floorpoint()
     assert self.data[oy][ox] == '.'
     assert self.data[ty][tx] == '.'
     costs = {
         '!': infinity,
         '*': infinity,
         '.': 1,
         '#': 100,
         '-': 10,
         ':': infinity,
         '+': infinity,
         'X': infinity,
         '=': infinity,
         'C': infinity,
         '[': infinity,
     }
     def cost( (x, y) ):
         if self.data[y][x] != '-':
             if not alpha.contains( x, y) and not beta.contains( x, y):
                 return infinity
         return costs[ self.data[y][x] ]
     pf = Pathfinder(cost = cost,
                     goal = lambda (x,y) : beta.contains(x, y) and self.data[y][x] == '.',
                     heuristic = lambda (x,y) : math.sqrt( (x-tx)*(x-tx) + (y-tx)*(y-tx) ),
                     neighbours = lambda (x,y) : [ (x+dx,y+dy) for (dx,dy) in ((0,1),(0,-1),(1,0),(-1,0)) if x+dx >= 0 and y+dy >= 0 and x+dx < self.width and y+dy < self.height ],
                     limit = self.hallwayLimit,
                     delay = self.delay
     )
     pf.addOrigin( (ox,oy) )
     path = pf.seek()
     if not path:
         return False
     protect = []
     for x, y in path:
         self.data[y][x] = {
             '#': '+',
             '-': ':',
             '.': '.',
             '=': ':',
             '[': ':',
         }[ self.data[y][x] ]
         if self.data[y][x] != '.':
             protect.append( (x,y) )
     for x, y in protect:
         for dx, dy in ((1,0),(-1,0),(0,1),(0,-1),(1,1),(1,-1),(-1,1),(-1,-1)):
             try:
                 t = self.data[y+dy][x+dx]
             except IndexError:
                 continue
             if t == '#':
                 self.data[y+dy][x+dx] = '['
             if t == '-':
                 self.data[y+dy][x+dx] = '='
     return True
Exemplo n.º 2
0
 def getClearTileAround(self, origin, goal = lambda tile: not tile.impassable and not tile.mobile):
     from pathfind import Pathfinder, infinity
     import math
     pf = Pathfinder(cost = lambda tile : 1,
                     goal = goal,
                     heuristic = lambda tile : 0,
     )
     pf.addOrigin( origin )
     path = pf.seek()
     return path[-1]
Exemplo n.º 3
0
def seekGoal(mob, target, radius, openDoors = False):
    from pathfind import Pathfinder, infinity
    import math
    pf = Pathfinder(cost = lambda tile : infinity if tile.cannotEnterBecause( mob ) and not target(tile) and not (openDoors and tile.name == "closed door") else 1,
                    goal = target,
                    heuristic = lambda tile : 0,
                    limit = radius,
    )
    pf.addOrigin( mob.tile )
    path = pf.seek()
    return path
Exemplo n.º 4
0
def seekMob(mob, target, radius):
    from pathfind import Pathfinder, infinity
    import math
    pf = Pathfinder(cost = lambda tile : infinity if tile.cannotEnterBecause( mob ) and not tile.mobile == target  else 1,
                    goal = lambda tile : tile.mobile == target,
                    heuristic = lambda tile : max( abs( tile.x - target.tile.x ), abs( tile.y - target.tile.y ) ),
                    tiebreaker = lambda tile : (tile.x - target.tile.x)**2 + (tile.y - target.tile.y)**2,
                    limit = radius,
    )
    pf.addOrigin( mob.tile )
    path = pf.seek()
    return path