def collide(self, Object):
results = false
Position = None
X = self.x
Y = self.y
if (Position != None):
X = Position.x
Y = Position.y
#Figure out what tiles we need to check against
selectionX = Math.floor((Object.x - X) / self._tileSize)
selectionY = Math.floor((Object.y - Y) / self._tileSize)
selectionWidth = selectionX + (Math.ceil(
Object.width / self._tileSize)) + 1
selectionHeight = selectionY + Math.ceil(
Object.height / self._tileSize) + 1
#Then bound these coordinates by the map edges
if (selectionX < 0):
selectionX = 0
if (selectionY < 0):
selectionY = 0
if (selectionWidth > self.widthInTiles):
selectionWidth = self.widthInTiles
if (selectionHeight > self.heightInTiles):
selectionHeight = self.heightInTiles
#Then loop through this selection of tiles and call FlxObject.separate() accordingly
rowStart = selectionY * self.widthInTiles
row = selectionY
overlapFound = false
deltaX = X - self.last.x
deltaY = Y - self.last.y
#print "selection====="
#print selectionX,selectionY,selectionWidth,selectionHeight
while (row <= selectionHeight):
column = selectionX
while (column <= selectionWidth):
overlapFound = false
#print "at="+str(int(rowStart+column))
tile = self._tileObjects[self._data[int(rowStart + column)]]
#print "row,column",row,column,tile.allowCollisions
#print "data="+str(self._data[int(rowStart+column)])
if (tile.allowCollisions):
tile.x = X + column * self._tileSize
tile.y = Y + row * self._tileSize
tile.last.x = tile.x - deltaX
tile.last.y = tile.y - deltaY
#print "==========="
#print tile.x,tile.y,self._tileSize
#print Object.x,Object.y,Object.width,Object.height
mycollide.collide(Object, tile)
#raw_input()
column += 1
rowStart += self.widthInTiles
row += 1
return results
def overlapsWithCallback(self,Object,Callback=None,FlipCallbackParams=false,Position=None):
results = false;
X = self.x;
Y = self.y;
if(Position != None):
X = Position.x;
Y = Position.y;
#Figure out what tiles we need to check against
selectionX = Math.floor((Object.x - X)/self._tileSize)
selectionY = Math.floor((Object.y - Y)/self._tileSize)
selectionWidth = selectionX + (Math.ceil(Object.width/self._tileSize)) + 1;
selectionHeight = selectionY + Math.ceil(Object.height/self._tileSize) + 1;
#Then bound these coordinates by the map edges
if(selectionX < 0):
selectionX = 0;
if(selectionY < 0):
selectionY = 0;
if(selectionWidth > self.widthInTiles):
selectionWidth = self.widthInTiles;
if(selectionHeight > self.heightInTiles):
selectionHeight = self.heightInTiles;
#Then loop through this selection of tiles and call FlxObject.separate() accordingly
rowStart = selectionY*self.widthInTiles;
row = selectionY;
overlapFound=false;
deltaX = X - self.last.x;
deltaY = Y - self.last.y;
while(row < selectionHeight):
column = selectionX;
while(column < selectionWidth):
#print "row,column",row,column
overlapFound = false;
tile = self._tileObjects[self._data[int(rowStart+column)]];
if(tile.allowCollisions):
tile.x = X+column*self._tileSize;
tile.y = Y+row*self._tileSize;
tile.last.x = tile.x - deltaX;
tile.last.y = tile.y - deltaY;
if(Callback != None):
if(FlipCallbackParams):
overlapFound = Callback(Object,tile);
else:
overlapFound = Callback(tile,Object);
else:
overlapFound = (Object.x + Object.width > tile.x) and (Object.x < tile.x + tile.width) and (Object.y + Object.height > tile.y) and (Object.y < tile.y + tile.height);
if(overlapFound):
if((tile.callback != None) and ((tile.filter == None) or (Object is tile.filter))):
tile.mapIndex = rowStart+column;
tile.callback(tile,Object);
results = true;
elif((tile.callback != None) and ((tile.filter == None) or (Object is tile.filter))):
tile.mapIndex = rowStart+column;
tile.callback(tile,Object);
column+=1;
rowStart += self.widthInTiles;
row+=1;
return results;
def __init__(self, MapData, TileGraphic, CollisionIndex=1, DrawIndex=1):
#image = pyglet.resource.image("data/logo.png")
FlxCore.__init__(self)
self.CollideIndex = CollisionIndex
self.DrawIndex = 1
self._ci = CollisionIndex
self.widthInTiles = 0
self.heightInTiles = 0
self._data = FlxArray()
#c;
#cols:Array;
rows = open(MapData).read().split("\n")
rows.reverse()
rows = rows[2:]
self.heightInTiles = len(rows)
for r in range(self.heightInTiles):
cols = rows[r].split(",")
if (len(cols) <= 1):
self.heightInTiles -= 1
continue
if (self.widthInTiles == 0):
self.widthInTiles = len(cols)
for c in range(self.widthInTiles):
self._data.append(int(cols[c]))
self._pixels = TileGraphic
self._rects = FlxArray()
self._p = FlxPoint()
self._tileSize = self._pixels.height
self.width = self.widthInTiles * self._tileSize
self.height = self.heightInTiles * self._tileSize
self.numTiles = self.widthInTiles * self.heightInTiles
for i in range(self.numTiles):
if (self._data[i] >= DrawIndex):
self._rects.append(
FlxRect(self._tileSize * self._data[i], 0, self._tileSize,
self._tileSize))
else:
self._rects.append(None)
#self._block = FlxBlock(0,0,self._tileSize,self._tileSize,None);
self._screenRows = int(Math.ceil(FlxG.height / self._tileSize) + 1)
if (self._screenRows > self.heightInTiles):
self._screenRows = self.heightInTiles
self._screenCols = int(Math.ceil(FlxG.width / self._tileSize) + 1)
if (self._screenCols > self.widthInTiles):
self._screenCols = self.widthInTiles
self._tileObjects = range(self._pixels.width / self._pixels.height)
i = 0
while (i < self._pixels.width / self._pixels.height):
collide = FlxCore.NONE
if (i >= self.CollideIndex):
collide = self.allowCollisions
self._tileObjects[i] = FlxTile(self, i, self._tileSize,
self._tileSize,
(i >= self.DrawIndex), collide)
i += 1
def collide(self,Object):
results = false;
Position=None
X = self.x;
Y = self.y;
if(Position != None):
X = Position.x;
Y = Position.y;
#Figure out what tiles we need to check against
selectionX = Math.floor((Object.x - X)/self._tileSize)
selectionY = Math.floor((Object.y - Y)/self._tileSize)
selectionWidth = selectionX + (Math.ceil(Object.width/self._tileSize)) + 1;
selectionHeight = selectionY + Math.ceil(Object.height/self._tileSize) + 1;
#Then bound these coordinates by the map edges
if(selectionX < 0):
selectionX = 0;
if(selectionY < 0):
selectionY = 0;
if(selectionWidth > self.widthInTiles):
selectionWidth = self.widthInTiles;
if(selectionHeight > self.heightInTiles):
selectionHeight = self.heightInTiles;
#Then loop through this selection of tiles and call FlxObject.separate() accordingly
rowStart = selectionY*self.widthInTiles;
row = selectionY;
overlapFound=false;
deltaX = X - self.last.x;
deltaY = Y - self.last.y;
#print "selection====="
#print selectionX,selectionY,selectionWidth,selectionHeight
while(row <= selectionHeight):
column = selectionX;
while(column <=selectionWidth):
overlapFound = false;
#print "at="+str(int(rowStart+column))
tile = self._tileObjects[self._data[int(rowStart+column)]];
#print "row,column",row,column,tile.allowCollisions
#print "data="+str(self._data[int(rowStart+column)])
if(tile.allowCollisions):
tile.x = X+column*self._tileSize;
tile.y = Y+row*self._tileSize;
tile.last.x = tile.x - deltaX;
tile.last.y = tile.y - deltaY;
#print "==========="
#print tile.x,tile.y,self._tileSize
#print Object.x,Object.y,Object.width,Object.height
mycollide.collide(Object,tile)
#raw_input()
column+=1;
rowStart += self.widthInTiles;
row+=1;
return results;
def __init__(self,MapData, TileGraphic, CollisionIndex=1, DrawIndex=1):
#image = pyglet.resource.image("data/logo.png")
FlxCore.__init__(self);
self.CollideIndex = CollisionIndex;self.DrawIndex = 1;
self._ci = CollisionIndex;
self.widthInTiles = 0;
self.heightInTiles = 0;
self._data = FlxArray();
#c;
#cols:Array;
rows = open(MapData).read().split("\n");
rows.reverse()
rows=rows[2:]
self.heightInTiles = len(rows);
for r in range(self.heightInTiles):
cols = rows[r].split(",");
if(len(cols) <= 1):
self.heightInTiles-=1;
continue;
if(self.widthInTiles == 0):
self.widthInTiles = len(cols);
for c in range(self.widthInTiles):
self._data.append(int(cols[c]));
self._pixels = TileGraphic
self._rects = FlxArray();
self._p = FlxPoint();
self._tileSize =self._pixels.height;
self.width = self.widthInTiles*self._tileSize;
self.height = self.heightInTiles*self._tileSize;
self.numTiles = self.widthInTiles*self.heightInTiles;
for i in range(self.numTiles):
if(self._data[i] >= DrawIndex):
self._rects.append(FlxRect(self._tileSize*self._data[i],0,self._tileSize,self._tileSize));
else:
self._rects.append(None);
#self._block = FlxBlock(0,0,self._tileSize,self._tileSize,None);
self._screenRows =int( Math.ceil(FlxG.height/self._tileSize)+1);
if(self._screenRows > self.heightInTiles):
self._screenRows = self.heightInTiles;
self._screenCols = int(Math.ceil(FlxG.width/self._tileSize)+1);
if(self._screenCols > self.widthInTiles):
self._screenCols = self.widthInTiles;
self._tileObjects = range(self._pixels.width/self._pixels.height)
i=0
while(i < self._pixels.width/self._pixels.height):
collide=FlxCore.NONE
if(i>= self.CollideIndex):
collide=self.allowCollisions
self._tileObjects[i] =FlxTile(self,i,self._tileSize,self._tileSize,(i >= self.DrawIndex),collide)
i+=1;
def old_collide(self,Spr):
#print "map collide"#Spr.velocity.x
ix =int(Math.floor((Spr.x - self.x)/self._tileSize))
iy =int(Math.floor((Spr.y - self.y)/self._tileSize))
for r in [iy-1,iy,iy+1]:
if((r < 0) or (r >= self.heightInTiles)):
continue;
for c in [ix-1,ix,ix+1]:
if((c < 0) or (c >= self.widthInTiles)):
continue;
at=(r)*self.widthInTiles+c
#print "at=",at
if( self._data[at] >= self._ci):
self._block.x = self.x+c*self._tileSize;
self._block.y = self.y+r*self._tileSize;
self._block.collide(Spr);
#print at,self._block.x,self._block.y
return
#old
ix =int(Math.floor((Spr.x - self.x)/self._tileSize))
iy =int(Math.floor((Spr.y - self.y)/self._tileSize))
iw =int( Math.ceil(float(Spr.width)/self._tileSize)+1)
ih =int(Math.ceil(float(Spr.height)/self._tileSize)+1)
print "map collide",ih,iw
print Spr.width,self._tileSize,Spr.x,Spr.y
for r in range( ih):
if((r < 0) or (r >= self.heightInTiles)):
continue;
for c in range(iw):
if((c < 0) or (c >= self.widthInTiles)):
continue;
at=(iy+r)*self.widthInTiles+ix+c
print "at=",at,
if(at<len(self._data) and self._data[at] >= self._ci):
self._block.x = self.x+(ix+c)*self._tileSize;
self._block.y = self.y+(iy+r)*self._tileSize;
self._block.collide(Spr);
def old_collide(self, Spr):
#print "map collide"#Spr.velocity.x
ix = int(Math.floor((Spr.x - self.x) / self._tileSize))
iy = int(Math.floor((Spr.y - self.y) / self._tileSize))
for r in [iy - 1, iy, iy + 1]:
if ((r < 0) or (r >= self.heightInTiles)):
continue
for c in [ix - 1, ix, ix + 1]:
if ((c < 0) or (c >= self.widthInTiles)):
continue
at = (r) * self.widthInTiles + c
#print "at=",at
if (self._data[at] >= self._ci):
self._block.x = self.x + c * self._tileSize
self._block.y = self.y + r * self._tileSize
self._block.collide(Spr)
#print at,self._block.x,self._block.y
return
#old
ix = int(Math.floor((Spr.x - self.x) / self._tileSize))
iy = int(Math.floor((Spr.y - self.y) / self._tileSize))
iw = int(Math.ceil(float(Spr.width) / self._tileSize) + 1)
ih = int(Math.ceil(float(Spr.height) / self._tileSize) + 1)
print "map collide", ih, iw
print Spr.width, self._tileSize, Spr.x, Spr.y
for r in range(ih):
if ((r < 0) or (r >= self.heightInTiles)):
continue
for c in range(iw):
if ((c < 0) or (c >= self.widthInTiles)):
continue
at = (iy + r) * self.widthInTiles + ix + c
print "at=", at,
if (at < len(self._data) and self._data[at] >= self._ci):
self._block.x = self.x + (ix + c) * self._tileSize
self._block.y = self.y + (iy + r) * self._tileSize
self._block.collide(Spr)
def overlapsWithCallback(self,
Object,
Callback=None,
FlipCallbackParams=false,
Position=None):
results = false
X = self.x
Y = self.y
if (Position != None):
X = Position.x
Y = Position.y
#Figure out what tiles we need to check against
selectionX = Math.floor((Object.x - X) / self._tileSize)
selectionY = Math.floor((Object.y - Y) / self._tileSize)
selectionWidth = selectionX + (Math.ceil(
Object.width / self._tileSize)) + 1
selectionHeight = selectionY + Math.ceil(
Object.height / self._tileSize) + 1
#Then bound these coordinates by the map edges
if (selectionX < 0):
selectionX = 0
if (selectionY < 0):
selectionY = 0
if (selectionWidth > self.widthInTiles):
selectionWidth = self.widthInTiles
if (selectionHeight > self.heightInTiles):
selectionHeight = self.heightInTiles
#Then loop through this selection of tiles and call FlxObject.separate() accordingly
rowStart = selectionY * self.widthInTiles
row = selectionY
overlapFound = false
deltaX = X - self.last.x
deltaY = Y - self.last.y
while (row < selectionHeight):
column = selectionX
while (column < selectionWidth):
#print "row,column",row,column
overlapFound = false
tile = self._tileObjects[self._data[int(rowStart + column)]]
if (tile.allowCollisions):
tile.x = X + column * self._tileSize
tile.y = Y + row * self._tileSize
tile.last.x = tile.x - deltaX
tile.last.y = tile.y - deltaY
if (Callback != None):
if (FlipCallbackParams):
overlapFound = Callback(Object, tile)
else:
overlapFound = Callback(tile, Object)
else:
overlapFound = (Object.x + Object.width > tile.x) and (
Object.x < tile.x + tile.width) and (
Object.y + Object.height >
tile.y) and (Object.y < tile.y + tile.height)
if (overlapFound):
if ((tile.callback != None)
and ((tile.filter == None) or
(Object is tile.filter))):
tile.mapIndex = rowStart + column
tile.callback(tile, Object)
results = true
elif ((tile.callback != None)
and ((tile.filter == None) or (Object is tile.filter))):
tile.mapIndex = rowStart + column
tile.callback(tile, Object)
column += 1
rowStart += self.widthInTiles
row += 1
return results
