path: root/pgu/vid.py

"""Sprite and tile engine.

<p>[[tilevid]], [[isovid]], [[hexvid]] are all subclasses of
this interface.</p>

<p>Includes support for:</p>

<ul>
<li> Foreground Tiles
<li> Background Tiles
<li> Sprites
<li> Sprite-Sprite Collision handling
<li> Sprite-Tile Collision handling
<li> Scrolling 
<li> Loading from PGU tile and sprite formats (optional)
<li> Set rate FPS (optional)
</ul>

<p>This code was previously known as the King James Version (named after the
Bible of the same name for historical reasons.)</p>
"""

import pygame
from pygame.rect import Rect
from pygame.locals import *
import math

class Sprite:
    """The object used for Sprites.
    
    <pre>Sprite(ishape,pos)</pre>
    
    <dl>
    <dt>ishape <dd>an image, or an image, rectstyle.  The rectstyle will
                describe the shape of the image, used for collision
                detection.
    <dt>pos <dd>initial (x,y) position of the Sprite.
    </dl>
    
    <strong>Attributes</strong>
    <dl>
    <dt>rect <dd>the current position of the Sprite
    <dt>_rect <dd>the previous position of the Sprite
    <dt>groups <dd>the groups the Sprite is in
    <dt>agroups <dd>the groups the Sprite can hit in a collision
    <dt>hit <dd>the handler for hits -- hit(g,s,a)
    <dt>loop <dd>the loop handler, called once a frame
    </dl>
    """
    def __init__(self,ishape,pos):
        if not isinstance(ishape, tuple):
            ishape = ishape,None
        image,shape = ishape
        if shape == None:
            shape = pygame.Rect(0,0,image.get_width(),image.get_height())
        if isinstance(shape, tuple): shape = pygame.Rect(shape)
        self.image = image
        self._image = self.image
        self.shape = shape
        self.rect = pygame.Rect(pos[0],pos[1],shape.w,shape.h)
        self._rect = pygame.Rect(self.rect)
        self.irect = pygame.Rect(pos[0]-self.shape.x,pos[1]-self.shape.y,
            image.get_width(),image.get_height())
        self._irect = pygame.Rect(self.irect)
        self.groups = 0
        self.agroups = 0
        self.updated = 1
        
    def setimage(self,ishape):
        """Set the image of the Sprite.
        
        <pre>Sprite.setimage(ishape)</pre>
        
        <dl>
        <dt>ishape <dd>an image, or an image, rectstyle.  The rectstyle will
                  describe the shape of the image, used for collision detection.
        </dl>
        """        
        if not isinstance(ishape, tuple):
            ishape = ishape,None
        image,shape = ishape
        if shape == None:
            shape = pygame.Rect(0,0,image.get_width(),image.get_height())
        if isinstance(shape, tuple):
            shape = pygame.Rect(shape)
        self.image = image
        self.shape = shape
        self.rect.w,self.rect.h = shape.w,shape.h
        self.irect.w,self.irect.h = image.get_width(),image.get_height()
        self.updated = 1

        
class Tile:
    """Tile Object used by TileCollide.
    
    <pre>Tile(image=None)</pre>
    <dl>
    <dt>image <dd>an image for the Tile.
    </dl>
    
    <strong>Attributes</strong>
    <dl>
    <dt>agroups <dd>the groups the Tile can hit in a collision
    <dt>hit <dd>the handler for hits -- hit(g,t,a)
    </dl>
    """
    def __init__(self,image=None):
        self.image = image
        self.agroups = 0
        
    def __setattr__(self,k,v):
        if k == 'image' and v != None:
            self.image_h = v.get_height()
            self.image_w = v.get_width()
        self.__dict__[k] = v

class _Sprites(list):
    def __init__(self):
        list.__init__(self)
        self.removed = []
        
    def append(self,v):
        list.append(self,v)
        v.updated = 1
        
    def remove(self,v):
        list.remove(self,v)
        v.updated = 1
        self.removed.append(v)
        
class Vid:
    """An engine for rendering Sprites and Tiles.
    
    <pre>Vid()</pre>
    
    <strong>Attributes</strong>
    <dl>
    <dt>sprites <dd>a list of the Sprites to be displayed.  You may append and
               remove Sprites from it.
    <dt>images  <dd>a dict for images to be put in.  
    <dt>size    <dd>the width, height in Tiles of the layers.  Do not modify.
    <dt>view    <dd>a pygame.Rect of the viewed area.  You may change .x, .y,
                etc to move the viewed area around.
    <dt>bounds  <dd>a pygame.Rect (set to None by default) that sets the bounds
                of the viewable area.  Useful for setting certain borders
                as not viewable.
    <dt>tlayer  <dd>the foreground tiles layer
    <dt>clayer  <dd>the code layer (optional)
    <dt>blayer  <dd>the background tiles layer (optional)
    <dt>groups  <dd>a hash of group names to group values (32 groups max, as a tile/sprites 
            membership in a group is determined by the bits in an integer)
    </dl>
    """
    
    def __init__(self):
        self.tiles = [None for x in xrange(0,256)]
        self.sprites = _Sprites()
        self.images = {} #just a store for images.
        self.layers = None
        self.size = None
        self.view = pygame.Rect(0,0,0,0)
        self._view = pygame.Rect(self.view)
        self.bounds = None
        self.updates = []
        self.groups = {}
    
        
    def resize(self,size,bg=0):
        """Resize the layers.
        
        <pre>Vid.resize(size,bg=0)</pre>
        
        <dl>        
        <dt>size <dd>w,h in Tiles of the layers
        <dt>bg   <dd>set to 1 if you wish to use both a foreground layer and a
                background layer
        </dl>
        """
        self.size = size
        w,h = size
        self.layers = [[[0 for x in xrange(0,w)] for y in xrange(0,h)]
            for z in xrange(0,4)]
        self.tlayer = self.layers[0]
        self.blayer = self.layers[1]
        if not bg: self.blayer = None
        self.clayer = self.layers[2]
        self.alayer = self.layers[3]
        
        self.view.x, self.view.y = 0,0
        self._view.x, self.view.y = 0,0
        self.bounds = None
        
        self.updates = []
    
    def set(self,pos,v):
        """Set a tile in the foreground to a value.
        
        <p>Use this method to set tiles in the foreground, as it will make
        sure the screen is updated with the change.  Directly changing
        the tlayer will not guarantee updates unless you are using .paint()
        </p>
        
        <pre>Vid.set(pos,v)</pre>
        
        <dl>
        <dt>pos <dd>(x,y) of tile
        <dt>v <dd>value
        </dl>
        """
        if self.tlayer[pos[1]][pos[0]] == v: return
        self.tlayer[pos[1]][pos[0]] = v
        self.alayer[pos[1]][pos[0]] = 1
        self.updates.append(pos)
        
    def get(self,pos):
        """Get the tlayer at pos.
        
        <pre>Vid.get(pos): return value</pre>
        
        <dl>
        <dt>pos <dd>(x,y) of tile
        </dl>
        """
        return self.tlayer[pos[1]][pos[0]]
    
    def paint(self,s):
        """Paint the screen.
        
        <pre>Vid.paint(screen): return [updates]</pre>
        
        <dl>
        <dt>screen <dd>a pygame.Surface to paint to
        </dl>
        
        <p>returns the updated portion of the screen (all of it)</p>
        """
        return []
                
    def update(self,s):
        """Update the screen.
        
        <pre>Vid.update(screen): return [updates]</pre>
        
        <dl>
        <dt>screen <dd>a pygame.Rect to update
        </dl>
        
        <p>returns a list of updated rectangles.</p>
        """
        self.updates = []
        return []

    def tga_load_level(self,fname,bg=0):
        """Load a TGA level.  
        
        <pre>Vid.tga_load_level(fname,bg=0)</pre>
        
        <dl>
        <dt>g        <dd>a Tilevid instance
        <dt>fname    <dd>tga image to load
        <dt>bg        <dd>set to 1 if you wish to load the background layer
        </dl>
        """
        if type(fname) == str: img = pygame.image.load(fname)
        else: img = fname
        w,h = img.get_width(),img.get_height()
        self.resize((w,h),bg)
        for y in range(0,h):
            for x in range(0,w):
                t,b,c,_a = img.get_at((x,y))
                self.tlayer[y][x] = t
                if bg: self.blayer[y][x] = b
                self.clayer[y][x] = c
                
    def tga_save_level(self,fname):
        """Save a TGA level.
        
        <pre>Vid.tga_save_level(fname)</pre>
        
        <dl>
        <dt>fname <dd>tga image to save to
        </dl>
        """
        w,h = self.size
        img = pygame.Surface((w,h),SWSURFACE,32)
        img.fill((0,0,0,0))
        for y in range(0,h):
            for x in range(0,w):
                t = self.tlayer[y][x]
                b = 0
                if self.blayer:
                    b = self.blayer[y][x]
                c = self.clayer[y][x]
                _a = 0
                img.set_at((x,y),(t,b,c,_a))
        pygame.image.save(img,fname)
                
                

    def tga_load_tiles(self,fname,size,tdata={}):
        """Load a TGA tileset.
        
        <pre>Vid.tga_load_tiles(fname,size,tdata={})</pre>
        
        <dl>
        <dt>g       <dd>a Tilevid instance
        <dt>fname    <dd>tga image to load
        <dt>size    <dd>(w,h) size of tiles in pixels
        <dt>tdata    <dd>tile data, a dict of tile:(agroups, hit handler, config)
        </dl>
        """
        TW,TH = size
        if type(fname) == str: img = pygame.image.load(fname).convert_alpha()
        else: img = fname
        w,h = img.get_width(),img.get_height()
        
        n = 0
        for y in range(0,h,TH):
            for x in range(0,w,TW):
                i = img.subsurface((x,y,TW,TH))
                tile = Tile(i)
                self.tiles[n] = tile
                if n in tdata:
                    agroups,hit,config = tdata[n]
                    tile.agroups = self.string2groups(agroups)
                    tile.hit = hit
                    tile.config = config
                n += 1


    def load_images(self,idata):
        """Load images.
        
        <pre>Vid.load_images(idata)</pre>
        
        <dl>
        <dt>idata <dd>a list of (name, fname, shape)
        </dl>
        """
        for name,fname,shape in idata:
            self.images[name] = pygame.image.load(fname).convert_alpha(),shape

    def run_codes(self,cdata,rect):
        """Run codes.
        
        <pre>Vid.run_codes(cdata,rect)</pre>
        
        <dl>
        <dt>cdata <dd>a dict of code:(handler function, value)
        <dt>rect <dd>a tile rect of the parts of the layer that should have
                 their codes run
        </dl>
        """
        tw,th = self.tiles[0].image.get_width(),self.tiles[0].image.get_height()

        x1,y1,w,h = rect
        clayer = self.clayer
        t = Tile()
        for y in range(y1,y1+h):
            for x in range(x1,x1+w):
                n = clayer[y][x]
                if n in cdata:
                    fnc,value = cdata[n]
                    t.tx,t.ty = x,y
                    t.rect = pygame.Rect(x*tw,y*th,tw,th)
                    fnc(self,t,value)

        
    def string2groups(self,str):
        """Convert a string to groups.
        
        <pre>Vid.string2groups(str): return groups</pre>
        """
        if str == None: return 0
        return self.list2groups(str.split(","))

    def list2groups(self,igroups):
        """Convert a list to groups.
        <pre>Vid.list2groups(igroups): return groups</pre>
        """
        for s in igroups:
            if not s in self.groups:
                self.groups[s] = 2**len(self.groups)
        v = 0
        for s,n in self.groups.items():
            if s in igroups: v|=n
        return v

    def groups2list(self,groups):
        """Convert a groups to a list.
        <pre>Vid.groups2list(groups): return list</pre>
        """
        v = []
        for s,n in self.groups.items():
            if (n&groups)!=0: v.append(s)
        return v

    def hit(self,x,y,t,s):
        tiles = self.tiles
        tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()
        t.tx = x
        t.ty = y
        t.rect = Rect(x*tw,y*th,tw,th)
        t._rect = t.rect
        if hasattr(t,'hit'):
            t.hit(self,t,s)

    def loop(self):
        """Update and hit testing loop.  Run this once per frame.
        <pre>Vid.loop()</pre>
        """
        self.loop_sprites() #sprites may move
        self.loop_tilehits() #sprites move
        self.loop_spritehits() #no sprites should move
        for s in self.sprites:
            s._rect = pygame.Rect(s.rect)
        
    def loop_sprites(self):
        as_ = self.sprites[:]
        for s in as_:
            if hasattr(s,'loop'):
                s.loop(self,s)

    def loop_tilehits(self):
        tiles = self.tiles
        tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()

        layer = self.layers[0]

        as_ = self.sprites[:]
        for s in as_:
            self._tilehits(s)
    
    def _tilehits(self,s):
        tiles = self.tiles
        tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()
        layer = self.layers[0]
        
        for _z in (0,): 
            if s.groups != 0:

                _rect = s._rect
                rect = s.rect

                _rectx = _rect.x
                _recty = _rect.y
                _rectw = _rect.w
                _recth = _rect.h

                rectx = rect.x
                recty = rect.y
                rectw = rect.w
                recth = rect.h

                rect.y = _rect.y
                rect.h = _rect.h

                hits = []
                ct,cb,cl,cr = rect.top,rect.bottom,rect.left,rect.right
                #nasty ol loops
                y = ct/th*th
                while y < cb:
                    x = cl/tw*tw
                    yy = y/th
                    while x < cr:
                        xx = x/tw
                        t = tiles[layer[yy][xx]]
                        if (s.groups & t.agroups)!=0:
                            #self.hit(xx,yy,t,s)
                            d = math.hypot(rect.centerx-(xx*tw+tw/2),
                                rect.centery-(yy*th+th/2))
                            hits.append((d,t,xx,yy))

                        x += tw
                    y += th
                
                hits.sort()
                #if len(hits) > 0: print self.frame,hits
                for d,t,xx,yy in hits:
                    self.hit(xx,yy,t,s)
                
                #switching directions...
                _rect.x = rect.x
                _rect.w = rect.w
                rect.y = recty
                rect.h = recth

                hits = []
                ct,cb,cl,cr = rect.top,rect.bottom,rect.left,rect.right
                #nasty ol loops
                y = ct/th*th
                while y < cb:
                    x = cl/tw*tw
                    yy = y/th
                    while x < cr:
                        xx = x/tw
                        t = tiles[layer[yy][xx]]
                        if (s.groups & t.agroups)!=0:
                            d = math.hypot(rect.centerx-(xx*tw+tw/2),
                                rect.centery-(yy*th+th/2))
                            hits.append((d,t,xx,yy))
                            #self.hit(xx,yy,t,s)
                        x += tw
                    y += th
                
                hits.sort()    
                #if len(hits) > 0: print self.frame,hits
                for d,t,xx,yy in hits:
                    self.hit(xx,yy,t,s)

                #done with loops
                _rect.x = _rectx
                _rect.y = _recty


    def loop_spritehits(self):
        as_ = self.sprites[:]
        
        groups = {}
        for n in range(0,31):
            groups[1<<n] = []
        for s in as_:
            g = s.groups
            n = 1
            while g:
                if (g&1)!=0: groups[n].append(s)
                g >>= 1
                n <<= 1
                
        for s in as_:
            if s.agroups!=0:
                rect1,rect2 = s.rect,Rect(s.rect)
                #if rect1.centerx < 320: rect2.x += 640
                #else: rect2.x -= 640
                g = s.agroups
                n = 1
                while g:
                    if (g&1)!=0:
                        for b in groups[n]:    
                            if (s != b and (s.agroups & b.groups)!=0
                                    and s.rect.colliderect(b.rect)):
                                s.hit(self,s,b)

                    g >>= 1
                    n <<= 1


    def screen_to_tile(self,pos):
        """Convert a screen position to a tile position.
        <pre>Vid.screen_to_tile(pos): return pos</pre>
        """
        return pos
        
    def tile_to_screen(self,pos):
        """Convert a tile position to a screen position.
        <pre>Vid.tile_to_screen(pos): return pos</pre>
        """
        return pos
                    
# vim: set filetype=python sts=4 sw=4 noet si :