Beispiel #1
0
 def flameplayer():
     fronttiles = [coords.sum(self.position, coords.mul(self.direction, i)) for i in range(1,4)]
     for tile in fronttiles:
         if tile in [player.position for player in world.players]:
             self._suggestmessage("The dragon breaths a jet of fire towards you", 5)
             for tile in fronttiles:
                 self.cellmap.ignite(tile, forceignite=True)
             break
Beispiel #2
0
 def move(self, x, y):
     """Move if possible, update collectable levels accordingly"""
     if abs(x) + abs(y) != 1:
         return False
     self.direction = (x, y)
     if ((self.cellmap[coords.sum(self.position, (x, y))]['solid'] or
          self.cellmap[coords.sum(self.position, (x, y))]['sogginess'] == 100) and
         not GEPlayer.FREEPLAYER):
         return False
     self.position = coords.modsum(self.position, self.direction, self.cellmap.size)
     collectable = self.cellmap[self.position]['collectableitem']
     if collectable != 0:
         self.score[collectable] += collectables.value[collectable]
         self._suggestmessage("You pick up " + collectables.name[collectable], 4)
     self.cellmap[self.position]['collectableitem'] = 0
     if not GEPlayer.FREEPLAYER:
         self.score[collectables.CHOCOLATE] -= self.terraincost()
     if self.layingfuse and self.cellmap[self.position]['sogginess'] < GEPlayer.MAXFUSESOG:
         self.cellmap.placefuse(self.position)
     return True
Beispiel #3
0
    def sprite(self, player):
        isvisible = False
        tileoffset = [-1 if axis == 1 else 0 for axis in self.direction]
        for tile in [(0,0), (0,1), (1,0), (1,1)]:
            tile = coords.modsum(tile, tileoffset, self.cellmap.size)
            if coords.sum(self.position, tile) in player.visibletiles:
                isvisible = True
                break
        if isvisible:
            return self._pokedsprite(images.DragonRed[self.direction],
                                     layer=20,
                                     offset=coords.mul(tileoffset, images.TILESIZE))

        else:
            return None
Beispiel #4
0
 def scattercoins(self, radius, number):
     sqradius = radius**2
     scattered = 0
     attempts = 0
     while scattered < number and attempts < 6*number and self.score[collectables.COIN] > 0:
         attempts += 1
         tryoffset = random.randint(-radius, radius), random.randint(-radius, radius)
         if tryoffset[0]**2 + tryoffset[1]**2 > sqradius:
             continue
         trypos = coords.sum(self.position, tryoffset)
         if self.cellmap[trypos]['collectableitem'] or self.cellmap[trypos]['solid']:
             continue
         self.cellmap[trypos]['collectableitem'] = collectables.COIN
         self.score[collectables.COIN] -= 1
         scattered += 1
Beispiel #5
0
def visibletiles(position, cellmap, viewradius, xray=False):
    """Return set of tiles visible from a position"""
    visibletiles = set()
    visibletiles.add(position)

    def inviewradius(a):
        return ((a[0]-position[0])**2 + (a[1]-position[1])**2 < viewradius**2)

    for outdir in CARDINALS:
        trunkpos = position
        while inviewradius(trunkpos):
            visibletiles.add(coords.mod(trunkpos, cellmap.size))
            for perpdir in perpendiculars(outdir):
                diagdir = coords.sum(outdir, perpdir)
                branchpos = trunkpos
                while inviewradius(branchpos):
                    visibletiles.add(coords.mod(branchpos, cellmap.size))
                    if not xray and not cellmap[branchpos]['transparent']:
                        break
                    branchpos = coords.sum(branchpos, diagdir)
            if not xray and not cellmap[trunkpos]['transparent']:
                break
            trunkpos = coords.sum(trunkpos, outdir)
    return visibletiles
Beispiel #6
0
def firstmove(startpos, destpos, costs, cellmap, pfmapsize=15, maxcost=40):
    """Find the best direction to move towards the destination"""

    if (any(ax > pfmapsize for ax in coords.mindist(startpos, destpos, cellmap.size))):
        # Player is outside pathfinder area
        return False

    def mapcoord(pfcoord):
        """Get map coordinate from pathfinder one"""
        return coords.modsum(startpos, pfcoord, (-pfmapsize,)*2, cellmap.size)

    foundtarget = False
    dijkstramap = [[[0, (pfmapsize,)*2, False] for x in xrange(2*pfmapsize)] for x in xrange(2*pfmapsize)]
    import heapq
    openlist = []
    heapq.heappush(openlist, (0, (pfmapsize,)*2))
    curpos = None
    while openlist:
        curnode = heapq.heappop(openlist)
        curdist = curnode[0]
        if curdist > maxcost:
            # Give up if player is painfully unreachable.
            break
        curpos = curnode[1]
        if mapcoord(curpos) == tuple(destpos):
            foundtarget = True
            break
        if dijkstramap[curpos[0]][curpos[1]][2] == True:
            continue
        else:
            dijkstramap[curpos[0]][curpos[1]][2] = True
        for nbrpos in coords.neighbours(curpos):
            if (nbrpos[0] < 0 or nbrpos[1] < 0 or
                nbrpos[0] >= 2*pfmapsize or nbrpos[1] >= 2*pfmapsize or
                nbrpos == (pfmapsize, pfmapsize)):
                continue
            cellcost = costs(cellmap[mapcoord(nbrpos)])
            newdist = curdist+cellcost
            if ((dijkstramap[nbrpos[0]][nbrpos[1]][0] <= newdist and dijkstramap[nbrpos[0]][nbrpos[1]][0] != 0) or
                cellmap[mapcoord(nbrpos)]['solid'] or cellcost > 8):
                continue
            dijkstramap[nbrpos[0]][nbrpos[1]] = [newdist, curpos, False]
            heapq.heappush(openlist, (newdist, nbrpos))
    if not foundtarget:
        return False
    while dijkstramap[curpos[0]][curpos[1]][1] != (pfmapsize, pfmapsize):
        curpos = dijkstramap[curpos[0]][curpos[1]][1]
    return coords.sum(curpos, (-pfmapsize,)*2)
Beispiel #7
0
def getAllPairwiseDistances( coords ):
    """Use the law of cosines to get the distances bweteen all atoms:    
    d_{ij}^2 = x_i^2 + y_j^2 - 2\dot(x_i, x_j)    
    Returns a matrix D of squared-distances D_ij.
    """
    
    origin = coords.sum(axis=0)/float(coords.shape[0])       
    # print 'origin', origin
    coords = coords - origin
    # The incoming coords, X, are an N x 3 matrix.  
    transpose_coords = numpy.transpose(coords)    # X^T
    outer = numpy.dot(coords, transpose_coords)   # X(X^T)
                
    squaredDistances = numpy.zeros( outer.shape )

    dotprodrows = numpy.dot( coords**2, numpy.ones( transpose_coords.shape ) )   # M_ij = x_i*x_i
    dotprodcols = numpy.transpose(dotprodrows)      # M_ij = x_j*x_j
    squaredDistances = dotprodrows + dotprodcols - outer
    # print 'squaredDistances', squaredDistances
    return squaredDistances
Beispiel #8
0
def getAllPairwiseDistances(coords):
    """Use the law of cosines to get the distances bweteen all atoms:    
    d_{ij}^2 = x_i^2 + y_j^2 - 2\dot(x_i, x_j)    
    Returns a matrix D of squared-distances D_ij.
    """

    origin = coords.sum(axis=0) / float(coords.shape[0])
    # print 'origin', origin
    coords = coords - origin
    # The incoming coords, X, are an N x 3 matrix.
    transpose_coords = numpy.transpose(coords)  # X^T
    outer = numpy.dot(coords, transpose_coords)  # X(X^T)

    squaredDistances = numpy.zeros(outer.shape)

    dotprodrows = numpy.dot(coords**2, numpy.ones(
        transpose_coords.shape))  # M_ij = x_i*x_i
    dotprodcols = numpy.transpose(dotprodrows)  # M_ij = x_j*x_j
    squaredDistances = dotprodrows + dotprodcols - outer
    # print 'squaredDistances', squaredDistances
    return squaredDistances
Beispiel #9
0
    def rendervisible(self, geplayer, extrasprites=[]):
        sprites = []
        sprites += extrasprites

        for gemgo in self.gemgos:
            sprite = gemgo.sprite(geplayer)
            if sprite is not None:
                sprites.append(sprite)

        visibleranges = ([],[])
        for axis in [0, 1]:
            if 2*geplayer.visibility + 5 >= self.cellmap.size[axis]:
                visibleranges[axis].append((0, self.cellmap.size[axis]))
            else:
                rmin = (geplayer.position[axis] - geplayer.visibility - 2) % self.cellmap.size[axis]
                rmax = (geplayer.position[axis] + geplayer.visibility + 2) % self.cellmap.size[axis]
                if rmin < rmax:
                    visibleranges[axis].append((rmin, rmax))
                else:
                    visibleranges[axis].append((rmin, self.cellmap.size[axis]))
                    visibleranges[axis].append((0, rmax))

        surface = geplayer.surface
        for rx in visibleranges[0]:
            for ry in visibleranges[1]:
                surface.set_clip(
                    rx[0]*TILESIZE, ry[0]*TILESIZE,
                    (rx[1]-rx[0])*TILESIZE, (ry[1]-ry[0])*TILESIZE)
                regionsprites = sprites
                for ix in range(rx[0]-1, rx[1]+1):
                    for iy in range(ry[0]-1, ry[1]+1):
                        regionsprites += self.cellmap.sprites((ix, iy))
                        if coords.mod((ix, iy), self.cellmap.size) not in geplayer.visibletiles:
                            sprites.append((images.NonVisible, coords.sum(coords.mul((ix, iy), TILESIZE), (-4,-4)), 100))
                regionsprites.sort(key=lambda x: x[2])
                for sprite in regionsprites:
                    surface.blit(*sprite[:2])
Beispiel #10
0
 def subtuple(a, b):
     return coords.sum(a, coords.mul(b, -1))