Ejemplo n.º 1
0
    def update(self):
        FlxCore.update(self)
        for i in range(len(self._children)):

            if ((self._children[i] != None) and self._children[i].exists
                    and self._children[i].active):
                self._children[i].update()
Ejemplo n.º 2
0
 def __init__(self,X,Y,Width,Height,TileGraphic,Empties=0):
     FlxCore.__init__(self);
     self._tileSize=0;
     self.x = X;
     self.y = Y;
     self.width = Width;
     self.height = Height;
     if(TileGraphic == None):
         print "block None graphic"
         return;
     self._pixels = TileGraphic
     self._rects = FlxArray();
     self._p = FlxPoint();
     self._tileSize = self._pixels.height;
     self.widthInTiles = math.ceil(self.width/self._tileSize);
     self.heightInTiles = math.ceil(self.height/self._tileSize);
     self.width = self.widthInTiles*self._tileSize;
     self.height = self.heightInTiles*self._tileSize;
     self.numTiles = self.widthInTiles*self.heightInTiles;
     self.numGraphics = self._pixels.get_width()/self._tileSize;
     for i in range( numTiles):
         if(math.random()*(numGraphics+Empties) > Empties):
             self._rects.append(Rect(self._tileSize*Math.floor(Math.random()*self.numGraphics),0,self._tileSize,self._tileSize));
         else:
             self._rects.append(None);
Ejemplo n.º 3
0
 def __init__(self,X, Y, Width, Height, Sprites=None, Delay=-1, MinVelocityX=-100, MaxVelocityX=100, MinVelocityY=-100, MaxVelocityY=100, MinRotation=-360, MaxRotation=360, Gravity=500, Drag=0, Graphics=None, Quantity=0, Multiple=false, Parent=None):
     FlxCore.__init__(self);
     
     self.visible = false;
     self.x = X;
     self.y = Y;
     self.width = Width;
     self.height = Height;
     
     self.minVelocity =  FlxPoint(MinVelocityX,MinVelocityY);
     self.maxVelocity =  FlxPoint(MaxVelocityX,MaxVelocityY);
     self._minRotation = MinRotation;
     self._maxRotation = MaxRotation;
     self._gravity = Gravity;
     self._drag = Drag;
     self._delay = Delay;
     self._timer=0
     self._particle = 0;
     if(Graphics != None):
         self._sprites =  FlxArray();
         for  i in range(Quantity):
             if(Multiple):
                 (self._sprites.add( FlxSprite(Graphics,0,0,true))).randomFrame();
             else:
                 self._sprites.add( FlxSprite(Graphics));
         for  i in range(len(self._sprites)):
             if(Parent == None):
                 FlxG.state.add(self._sprites[i]);
             else:
                 Parent.add(self._sprites[i]);
     else:
         self._sprites = Sprites;
     self.kill();
     if(self._delay > 0):
         self.reset();
Ejemplo n.º 4
0
    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
Ejemplo n.º 5
0
 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;
Ejemplo n.º 6
0
    def __init__(self,
                 X,
                 Y,
                 Width,
                 Height,
                 Sprites=None,
                 Delay=-1,
                 MinVelocityX=-100,
                 MaxVelocityX=100,
                 MinVelocityY=-100,
                 MaxVelocityY=100,
                 MinRotation=-360,
                 MaxRotation=360,
                 Gravity=500,
                 Drag=0,
                 Graphics=None,
                 Quantity=0,
                 Multiple=false,
                 Parent=None):
        FlxCore.__init__(self)

        self.visible = false
        self.x = X
        self.y = Y
        self.width = Width
        self.height = Height

        self.minVelocity = FlxPoint(MinVelocityX, MinVelocityY)
        self.maxVelocity = FlxPoint(MaxVelocityX, MaxVelocityY)
        self._minRotation = MinRotation
        self._maxRotation = MaxRotation
        self._gravity = Gravity
        self._drag = Drag
        self._delay = Delay
        self._timer = 0
        self._particle = 0
        if (Graphics != None):
            self._sprites = FlxArray()
            for i in range(Quantity):
                if (Multiple):
                    (self._sprites.add(FlxSprite(Graphics, 0, 0,
                                                 true))).randomFrame()
                else:
                    self._sprites.add(FlxSprite(Graphics))
            for i in range(len(self._sprites)):
                if (Parent == None):
                    FlxG.state.add(self._sprites[i])
                else:
                    Parent.add(self._sprites[i])
        else:
            self._sprites = Sprites
        self.kill()
        if (self._delay > 0):
            self.reset()
Ejemplo n.º 7
0
 def render(self):
     FlxCore.render(self);
     self.getScreenXY(self._p);
     opx = self._p.x;
     for i in range( len(self._rects)):
         if(self._rects[i] != None):
             FlxG.buffer.blit(self._pixels,_rects[i],self._p,None,None,true);
         self._p.x += self._tileSize;
         if(self._p.x >= opx + self.width):
             self._p.x = opx;
             self._p.y += self._tileSize;
Ejemplo n.º 8
0
 def __init__(self, Tilemap, Index, Width, Height, Visible,
              AllowCollisions):
     FlxCore.__init__(self)  #,0, 0, Width, Height);
     # # /**
     # # * This function is called whenever an object hits a tile of this type.
     # # * This function should take the form <code>myFunction(Tile:FlxTile,Object:FlxObject):void</code>.
     # # * Defaults to null, set through <code>FlxTilemap.setTileProperties()</code>.
     # # */
     # self.callback=None;
     # # /**
     # # * Each tile can store its own filter class for their callback functions.
     # # * That is, the callback will only be triggered if an object with a class
     # # * type matching the filter touched it.
     # # * Defaults to null, set through <code>FlxTilemap.setTileProperties()</code>.
     # # */
     # self.filter=None;
     # # /**
     # # * A reference to the tilemap this tile object belongs to.
     # # */
     # public var tilemap:FlxTilemap;
     # /**
     # * The index of this tile type in the core map data.
     # * For example, if your map only has 16 kinds of tiles in it,
     # * this number is usually between 0 and 15.
     # */
     # public var index:uint;
     # /**
     # * The current map index of this tile object at this moment.
     # * You can think of tile objects as moving around the tilemap helping with collisions.
     # * This value is only reliable and useful if used from the callback function.
     # */
     # public var mapIndex:uint;
     self.immovable = true
     self.moves = false
     self.callback = None
     self.filter = None
     self.width = Width
     self.height = Height
     self.tilemap = Tilemap
     self.index = Index
     self.visible = Visible
     self.allowCollisions = AllowCollisions
     self.velocity = FlxPoint()
     self.mapIndex = 0
Ejemplo n.º 9
0
 def render(self):
     #NOTE: While this will only draw the tiles that are actually on screen, it will ALWAYS draw one screen's worth of tiles
     FlxCore.render(self)
     self.getScreenXY(self._p)
     #print self._p.x,self._p.y
     #self.position=(self._p.x,self._p.y)
     #raw_input()
     tx = Math.floor(-self._p.x / self._tileSize)
     ty = Math.floor(-self._p.y / self._tileSize)
     if (tx < 0):
         tx = 0
     if (tx > self.widthInTiles - self._screenCols):
         tx = self.widthInTiles - self._screenCols
     if (ty < 0):
         ty = 0
     if (ty > self.heightInTiles - self._screenRows):
         ty = self.heightInTiles - self._screenRows
     ri = int(ty * self.widthInTiles + tx)
     self._p.x += tx * self._tileSize
     self._p.y += ty * self._tileSize
     opx = self._p.x
     for r in range(self._screenRows):
         cri = ri
         for c in range(self._screenCols):
             #print self._rects[cri]
             #raw_input()
             if (self._rects[cri] != None):
                 im = self._pixels.get_region(
                     self._rects[cri].x, self._rects[cri].y,
                     self._rects[cri].width, self._rects[cri].height
                 )  #.x,self._rects[cri].y, self._rects[cri].width,self._rects[cri].height)
                 #tmp=Sprite(im)
                 #tmp.position=(self._p.x,self._p.y)
                 #print r,c,"tile",self._p.x,self._p.y
                 #self.add(tmp)
                 r = FlxRect(self._p.x, self._p.y, self._rects[cri].width,
                             self._rects[cri].height)
                 im.blit(self._p.x, self._p.y)
             cri += 1
             self._p.x += self._tileSize
         ri += self.widthInTiles
         self._p.x = opx
         self._p.y += self._tileSize
Ejemplo n.º 10
0
 def __init__(self,Tilemap, Index, Width, Height, Visible, AllowCollisions):
     FlxCore.__init__(self)#,0, 0, Width, Height);
      # # /**
      # # * This function is called whenever an object hits a tile of this type.
      # # * This function should take the form <code>myFunction(Tile:FlxTile,Object:FlxObject):void</code>.
      # # * Defaults to null, set through <code>FlxTilemap.setTileProperties()</code>.
      # # */
     # self.callback=None;
     # # /**
      # # * Each tile can store its own filter class for their callback functions.
      # # * That is, the callback will only be triggered if an object with a class
      # # * type matching the filter touched it.
      # # * Defaults to null, set through <code>FlxTilemap.setTileProperties()</code>.
      # # */
     # self.filter=None;
     # # /**
      # # * A reference to the tilemap this tile object belongs to.
      # # */
     # public var tilemap:FlxTilemap;
     # /**
      # * The index of this tile type in the core map data.
      # * For example, if your map only has 16 kinds of tiles in it,
      # * this number is usually between 0 and 15.
      # */
     # public var index:uint;
     # /**
      # * The current map index of this tile object at this moment.
      # * You can think of tile objects as moving around the tilemap helping with collisions.
      # * This value is only reliable and useful if used from the callback function.
      # */
     # public var mapIndex:uint;
     self.immovable = true;
     self.moves = false;
     self.callback = None;
     self.filter = None;
     self.width=Width
     self.height=Height
     self.tilemap = Tilemap;
     self.index = Index;
     self.visible = Visible;
     self.allowCollisions = AllowCollisions;
     self.velocity = FlxPoint();
     self.mapIndex = 0;
Ejemplo n.º 11
0
 def update(self):
     self.last.x=self.x
     self.last.y=self.y
     #print "last",self,self.last.x,self.last.y
     FlxCore.update(self);
     
     if(not self.active): 
         return;
     
     #animation
     if((self._curAnim != None) and (self._curAnim.delay > 0) and (self._curAnim.looped or not self.finished)):
         self._frameTimer += FlxG.elapsed;
         #print self._frameTimer,self._curAnim.delay,FlxG.elapsed
         #raw_input()
         if(self._frameTimer > self._curAnim.delay):
             self._frameTimer -= self._curAnim.delay;
             if(self._curFrame == len(self._curAnim.frames)-1):
                 if(self._curAnim.looped):
                     self._curFrame = 0;
                 self.finished = true;
             else:
                 self._curFrame+=1;
             self.calcFrame();
             #print "curframe",self._curFrame
     
     #motion + physics
     self.angularVelocity = FlxG.computeVelocity(self.angularVelocity,self.angularAacceleration,self.angularDrag,self.maxAngular)
     self.angle += (self.angularVelocity)*FlxG.elapsed;
     self.thrustComponents=FlxPoint();
     if(self.thrust != 0):
         self.thrustComponents = FlxG.rotatePoint(-self.thrust,0,0,0,self.angle);
         maxComponents = FlxG.rotatePoint(-maxself.thrust,0,0,0,self.angle);
         maxself.velocity.x = Math.abs(maxComponents.x);
         maxself.velocity.y = Math.abs(maxComponents.y);
     else:
         self.thrustComponents = self._pZero;
     self.velocity.x = FlxG.computeVelocity(self.velocity.x,self.acceleration.x+self.thrustComponents.x,self.drag.x,self.maxVelocity.x)
     self.x += (self.velocity.x)*FlxG.elapsed;
     self.velocity.y = FlxG.computeVelocity(self.velocity.y,self.acceleration.y+self.thrustComponents.y,self.drag.y,self.maxVelocity.y)
     self.y += (self.velocity.y)*FlxG.elapsed;
Ejemplo n.º 12
0
 def render(self):
     #NOTE: While this will only draw the tiles that are actually on screen, it will ALWAYS draw one screen's worth of tiles
     FlxCore.render(self)
     self.getScreenXY(self._p);
     #print self._p.x,self._p.y
     #self.position=(self._p.x,self._p.y)
     #raw_input()
     tx = Math.floor(-self._p.x/self._tileSize);
     ty = Math.floor(-self._p.y/self._tileSize);
     if(tx < 0): 
         tx = 0;
     if(tx > self.widthInTiles-self._screenCols): 
         tx = self.widthInTiles-self._screenCols;
     if(ty < 0): 
         ty = 0;
     if(ty > self.heightInTiles-self._screenRows): 
         ty = self.heightInTiles-self._screenRows;
     ri =int(ty*self.widthInTiles+tx);
     self._p.x += tx*self._tileSize;
     self._p.y += ty*self._tileSize;
     opx = self._p.x;
     for r in range(self._screenRows):
         cri = ri;
         for c in range(self._screenCols):
             #print self._rects[cri]
             #raw_input()
             if(self._rects[cri] != None):
                 im=self._pixels.get_region(self._rects[cri].x,self._rects[cri].y,self._rects[cri].width,self._rects[cri].height)#.x,self._rects[cri].y, self._rects[cri].width,self._rects[cri].height)
                 #tmp=Sprite(im)
                 #tmp.position=(self._p.x,self._p.y)
                 #print r,c,"tile",self._p.x,self._p.y
                 #self.add(tmp)
                 r=FlxRect(self._p.x,self._p.y,self._rects[cri].width,self._rects[cri].height)
                 im.blit(self._p.x,self._p.y);
             cri+=1;
             self._p.x += self._tileSize;
         ri += self.widthInTiles;
         self._p.x = opx;
         self._p.y += self._tileSize;
Ejemplo n.º 13
0
 def __init__(self):
     FlxCore.__init__(self)
     self._children = FlxArray();
Ejemplo n.º 14
0
 def render(self):
     FlxCore.render(self);
     for  i in  range(len(self._children)):
         if((self._children[i] != None) and self._children[i].exists and self._children[i].visible):
             self._children[i].render();
Ejemplo n.º 15
0
 def update(self):
     FlxCore.update(self);
     for i in range( len(self._children)):
        
         if((self._children[i] != None) and self._children[i].exists and self._children[i].active):
             self._children[i].update();
Ejemplo n.º 16
0
 def __init__(self,Graphic=None,X=0,Y=0,Animated=false,Reverse=false,Width=0,Height=0,Color=0):
     
     if(Graphic != None):
         #image = pyglet.resource.image(Graphic)
         self.pixels = Graphic;
         pass
     else:
         self.pixels= pygame.image.load("data/logo.png")
         #pixels = FlxG.createBitmap(Width,Height,Color);
     FlxCore.__init__(self)
     
     #self.position=(X,FlxG.height-Y);
     #self.anchor=(0,0)
     #print dir(self.pixels)
     self.x = X;
     self.y = Y;
     
     if(Width == 0):
         if(Animated):
             Width = self.pixels.height;
         else:
             Width = self.pixels.width;
     self.width =Width 
     self._bw = Width;
     self.height = self.pixels.height;
     self._bh = self.height;
     self.offset = FlxPoint();
     
     self.velocity = FlxPoint();
     self.acceleration = FlxPoint();
     self.drag = FlxPoint();
     self.maxVelocity = FlxPoint(10000,10000);
     
     self.angle = 0;
     self.angularVelocity = 0;
     self.angularAacceleration = 0;
     self.angularDrag = 0;
     self.maxAngular = 10000;
     
     self.thrust = 0;
     
     self.scale = FlxPoint(1,1);
     
     self.finished = false;
     self._facing = true;
     self._animations = FlxArray();
     if(Reverse):
         #pass
         self._flipped = self.pixels.width>>1;
     else:
         self._flipped = 0;
     
     self._curAnim = None;
     self._curFrame = 0;
     self._frameTimer = 0;
     
     self._p = FlxPoint(self.x,self.y);
     self._pZero = FlxPoint();
     self._r = FlxRect(0,0,self._bw,self._bh);
     #self._pixels = BitmapData(width,height);
     #print self._bw,self._bh
     
     #raw_input()
     self._pixels=self.pixels.get_region(0,0,self._bw,self._bh)#,self._pZero);
     
     self.health = 1;
     self._alpha = 1;
     
     self._callback = None;
Ejemplo n.º 17
0
 def __init__(self,X, Y, Text="", Color=0xffffffff, Font=None, Size=18, Justification=None, Angle=0):
     pyglet.text.Label.__init__(self,Text,font_name=Font,font_size=Size,x=X,y=Y)
     FlxCore.__init__(self);
     self.x=X
     self.y=Y
Ejemplo n.º 18
0
 def destroy(self):
     FlxCore.destroy(self)
     self.callback = None
     self.tilemap = None
Ejemplo n.º 19
0
 def render(self):
     FlxCore.render(self)
     for i in range(len(self._children)):
         if ((self._children[i] != None) and self._children[i].exists
                 and self._children[i].visible):
             self._children[i].render()
Ejemplo n.º 20
0
 def __init__(self):
     FlxCore.__init__(self)
     self._children = FlxArray()
Ejemplo n.º 21
0
 def destroy(self):
     FlxCore.destroy(self);
     self.callback = None;
     self.tilemap = None