commentaires--
[minwii.git] / src / pgu / vid.py
1 """Sprite and tile engine.
2
3 <p>[[tilevid]], [[isovid]], [[hexvid]] are all subclasses of
4 this interface.</p>
5
6 <p>Includes support for:</p>
7
8 <ul>
9 <li> Foreground Tiles
10 <li> Background Tiles
11 <li> Sprites
12 <li> Sprite-Sprite Collision handling
13 <li> Sprite-Tile Collision handling
14 <li> Scrolling
15 <li> Loading from PGU tile and sprite formats (optional)
16 <li> Set rate FPS (optional)
17 </ul>
18
19 <p>This code was previously known as the King James Version (named after the
20 Bible of the same name for historical reasons.)</p>
21 """
22
23 import pygame
24 from pygame.rect import Rect
25 from pygame.locals import *
26 import math
27
28 class Sprite:
29 """The object used for Sprites.
30
31 <pre>Sprite(ishape,pos)</pre>
32
33 <dl>
34 <dt>ishape <dd>an image, or an image, rectstyle. The rectstyle will
35 describe the shape of the image, used for collision
36 detection.
37 <dt>pos <dd>initial (x,y) position of the Sprite.
38 </dl>
39
40 <strong>Attributes</strong>
41 <dl>
42 <dt>rect <dd>the current position of the Sprite
43 <dt>_rect <dd>the previous position of the Sprite
44 <dt>groups <dd>the groups the Sprite is in
45 <dt>agroups <dd>the groups the Sprite can hit in a collision
46 <dt>hit <dd>the handler for hits -- hit(g,s,a)
47 <dt>loop <dd>the loop handler, called once a frame
48 </dl>
49 """
50 def __init__(self,ishape,pos):
51 if not isinstance(ishape, tuple):
52 ishape = ishape,None
53 image,shape = ishape
54 if shape == None:
55 shape = pygame.Rect(0,0,image.get_width(),image.get_height())
56 if isinstance(shape, tuple): shape = pygame.Rect(shape)
57 self.image = image
58 self._image = self.image
59 self.shape = shape
60 self.rect = pygame.Rect(pos[0],pos[1],shape.w,shape.h)
61 self._rect = pygame.Rect(self.rect)
62 self.irect = pygame.Rect(pos[0]-self.shape.x,pos[1]-self.shape.y,
63 image.get_width(),image.get_height())
64 self._irect = pygame.Rect(self.irect)
65 self.groups = 0
66 self.agroups = 0
67 self.updated = 1
68
69 def setimage(self,ishape):
70 """Set the image of the Sprite.
71
72 <pre>Sprite.setimage(ishape)</pre>
73
74 <dl>
75 <dt>ishape <dd>an image, or an image, rectstyle. The rectstyle will
76 describe the shape of the image, used for collision detection.
77 </dl>
78 """
79 if not isinstance(ishape, tuple):
80 ishape = ishape,None
81 image,shape = ishape
82 if shape == None:
83 shape = pygame.Rect(0,0,image.get_width(),image.get_height())
84 if isinstance(shape, tuple):
85 shape = pygame.Rect(shape)
86 self.image = image
87 self.shape = shape
88 self.rect.w,self.rect.h = shape.w,shape.h
89 self.irect.w,self.irect.h = image.get_width(),image.get_height()
90 self.updated = 1
91
92
93 class Tile:
94 """Tile Object used by TileCollide.
95
96 <pre>Tile(image=None)</pre>
97 <dl>
98 <dt>image <dd>an image for the Tile.
99 </dl>
100
101 <strong>Attributes</strong>
102 <dl>
103 <dt>agroups <dd>the groups the Tile can hit in a collision
104 <dt>hit <dd>the handler for hits -- hit(g,t,a)
105 </dl>
106 """
107 def __init__(self,image=None):
108 self.image = image
109 self.agroups = 0
110
111 def __setattr__(self,k,v):
112 if k == 'image' and v != None:
113 self.image_h = v.get_height()
114 self.image_w = v.get_width()
115 self.__dict__[k] = v
116
117 class _Sprites(list):
118 def __init__(self):
119 list.__init__(self)
120 self.removed = []
121
122 def append(self,v):
123 list.append(self,v)
124 v.updated = 1
125
126 def remove(self,v):
127 list.remove(self,v)
128 v.updated = 1
129 self.removed.append(v)
130
131 class Vid:
132 """An engine for rendering Sprites and Tiles.
133
134 <pre>Vid()</pre>
135
136 <strong>Attributes</strong>
137 <dl>
138 <dt>sprites <dd>a list of the Sprites to be displayed. You may append and
139 remove Sprites from it.
140 <dt>images <dd>a dict for images to be put in.
141 <dt>size <dd>the width, height in Tiles of the layers. Do not modify.
142 <dt>view <dd>a pygame.Rect of the viewed area. You may change .x, .y,
143 etc to move the viewed area around.
144 <dt>bounds <dd>a pygame.Rect (set to None by default) that sets the bounds
145 of the viewable area. Useful for setting certain borders
146 as not viewable.
147 <dt>tlayer <dd>the foreground tiles layer
148 <dt>clayer <dd>the code layer (optional)
149 <dt>blayer <dd>the background tiles layer (optional)
150 <dt>groups <dd>a hash of group names to group values (32 groups max, as a tile/sprites
151 membership in a group is determined by the bits in an integer)
152 </dl>
153 """
154
155 def __init__(self):
156 self.tiles = [None for x in xrange(0,256)]
157 self.sprites = _Sprites()
158 self.images = {} #just a store for images.
159 self.layers = None
160 self.size = None
161 self.view = pygame.Rect(0,0,0,0)
162 self._view = pygame.Rect(self.view)
163 self.bounds = None
164 self.updates = []
165 self.groups = {}
166
167
168 def resize(self,size,bg=0):
169 """Resize the layers.
170
171 <pre>Vid.resize(size,bg=0)</pre>
172
173 <dl>
174 <dt>size <dd>w,h in Tiles of the layers
175 <dt>bg <dd>set to 1 if you wish to use both a foreground layer and a
176 background layer
177 </dl>
178 """
179 self.size = size
180 w,h = size
181 self.layers = [[[0 for x in xrange(0,w)] for y in xrange(0,h)]
182 for z in xrange(0,4)]
183 self.tlayer = self.layers[0]
184 self.blayer = self.layers[1]
185 if not bg: self.blayer = None
186 self.clayer = self.layers[2]
187 self.alayer = self.layers[3]
188
189 self.view.x, self.view.y = 0,0
190 self._view.x, self.view.y = 0,0
191 self.bounds = None
192
193 self.updates = []
194
195 def set(self,pos,v):
196 """Set a tile in the foreground to a value.
197
198 <p>Use this method to set tiles in the foreground, as it will make
199 sure the screen is updated with the change. Directly changing
200 the tlayer will not guarantee updates unless you are using .paint()
201 </p>
202
203 <pre>Vid.set(pos,v)</pre>
204
205 <dl>
206 <dt>pos <dd>(x,y) of tile
207 <dt>v <dd>value
208 </dl>
209 """
210 if self.tlayer[pos[1]][pos[0]] == v: return
211 self.tlayer[pos[1]][pos[0]] = v
212 self.alayer[pos[1]][pos[0]] = 1
213 self.updates.append(pos)
214
215 def get(self,pos):
216 """Get the tlayer at pos.
217
218 <pre>Vid.get(pos): return value</pre>
219
220 <dl>
221 <dt>pos <dd>(x,y) of tile
222 </dl>
223 """
224 return self.tlayer[pos[1]][pos[0]]
225
226 def paint(self,s):
227 """Paint the screen.
228
229 <pre>Vid.paint(screen): return [updates]</pre>
230
231 <dl>
232 <dt>screen <dd>a pygame.Surface to paint to
233 </dl>
234
235 <p>returns the updated portion of the screen (all of it)</p>
236 """
237 return []
238
239 def update(self,s):
240 """Update the screen.
241
242 <pre>Vid.update(screen): return [updates]</pre>
243
244 <dl>
245 <dt>screen <dd>a pygame.Rect to update
246 </dl>
247
248 <p>returns a list of updated rectangles.</p>
249 """
250 self.updates = []
251 return []
252
253 def tga_load_level(self,fname,bg=0):
254 """Load a TGA level.
255
256 <pre>Vid.tga_load_level(fname,bg=0)</pre>
257
258 <dl>
259 <dt>g <dd>a Tilevid instance
260 <dt>fname <dd>tga image to load
261 <dt>bg <dd>set to 1 if you wish to load the background layer
262 </dl>
263 """
264 if type(fname) == str: img = pygame.image.load(fname)
265 else: img = fname
266 w,h = img.get_width(),img.get_height()
267 self.resize((w,h),bg)
268 for y in range(0,h):
269 for x in range(0,w):
270 t,b,c,_a = img.get_at((x,y))
271 self.tlayer[y][x] = t
272 if bg: self.blayer[y][x] = b
273 self.clayer[y][x] = c
274
275 def tga_save_level(self,fname):
276 """Save a TGA level.
277
278 <pre>Vid.tga_save_level(fname)</pre>
279
280 <dl>
281 <dt>fname <dd>tga image to save to
282 </dl>
283 """
284 w,h = self.size
285 img = pygame.Surface((w,h),SWSURFACE,32)
286 img.fill((0,0,0,0))
287 for y in range(0,h):
288 for x in range(0,w):
289 t = self.tlayer[y][x]
290 b = 0
291 if self.blayer:
292 b = self.blayer[y][x]
293 c = self.clayer[y][x]
294 _a = 0
295 img.set_at((x,y),(t,b,c,_a))
296 pygame.image.save(img,fname)
297
298
299
300 def tga_load_tiles(self,fname,size,tdata={}):
301 """Load a TGA tileset.
302
303 <pre>Vid.tga_load_tiles(fname,size,tdata={})</pre>
304
305 <dl>
306 <dt>g <dd>a Tilevid instance
307 <dt>fname <dd>tga image to load
308 <dt>size <dd>(w,h) size of tiles in pixels
309 <dt>tdata <dd>tile data, a dict of tile:(agroups, hit handler, config)
310 </dl>
311 """
312 TW,TH = size
313 if type(fname) == str: img = pygame.image.load(fname).convert_alpha()
314 else: img = fname
315 w,h = img.get_width(),img.get_height()
316
317 n = 0
318 for y in range(0,h,TH):
319 for x in range(0,w,TW):
320 i = img.subsurface((x,y,TW,TH))
321 tile = Tile(i)
322 self.tiles[n] = tile
323 if n in tdata:
324 agroups,hit,config = tdata[n]
325 tile.agroups = self.string2groups(agroups)
326 tile.hit = hit
327 tile.config = config
328 n += 1
329
330
331 def load_images(self,idata):
332 """Load images.
333
334 <pre>Vid.load_images(idata)</pre>
335
336 <dl>
337 <dt>idata <dd>a list of (name, fname, shape)
338 </dl>
339 """
340 for name,fname,shape in idata:
341 self.images[name] = pygame.image.load(fname).convert_alpha(),shape
342
343 def run_codes(self,cdata,rect):
344 """Run codes.
345
346 <pre>Vid.run_codes(cdata,rect)</pre>
347
348 <dl>
349 <dt>cdata <dd>a dict of code:(handler function, value)
350 <dt>rect <dd>a tile rect of the parts of the layer that should have
351 their codes run
352 </dl>
353 """
354 tw,th = self.tiles[0].image.get_width(),self.tiles[0].image.get_height()
355
356 x1,y1,w,h = rect
357 clayer = self.clayer
358 t = Tile()
359 for y in range(y1,y1+h):
360 for x in range(x1,x1+w):
361 n = clayer[y][x]
362 if n in cdata:
363 fnc,value = cdata[n]
364 t.tx,t.ty = x,y
365 t.rect = pygame.Rect(x*tw,y*th,tw,th)
366 fnc(self,t,value)
367
368
369 def string2groups(self,str):
370 """Convert a string to groups.
371
372 <pre>Vid.string2groups(str): return groups</pre>
373 """
374 if str == None: return 0
375 return self.list2groups(str.split(","))
376
377 def list2groups(self,igroups):
378 """Convert a list to groups.
379 <pre>Vid.list2groups(igroups): return groups</pre>
380 """
381 for s in igroups:
382 if not s in self.groups:
383 self.groups[s] = 2**len(self.groups)
384 v = 0
385 for s,n in self.groups.items():
386 if s in igroups: v|=n
387 return v
388
389 def groups2list(self,groups):
390 """Convert a groups to a list.
391 <pre>Vid.groups2list(groups): return list</pre>
392 """
393 v = []
394 for s,n in self.groups.items():
395 if (n&groups)!=0: v.append(s)
396 return v
397
398 def hit(self,x,y,t,s):
399 tiles = self.tiles
400 tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()
401 t.tx = x
402 t.ty = y
403 t.rect = Rect(x*tw,y*th,tw,th)
404 t._rect = t.rect
405 if hasattr(t,'hit'):
406 t.hit(self,t,s)
407
408 def loop(self):
409 """Update and hit testing loop. Run this once per frame.
410 <pre>Vid.loop()</pre>
411 """
412 self.loop_sprites() #sprites may move
413 self.loop_tilehits() #sprites move
414 self.loop_spritehits() #no sprites should move
415 for s in self.sprites:
416 s._rect = pygame.Rect(s.rect)
417
418 def loop_sprites(self):
419 as_ = self.sprites[:]
420 for s in as_:
421 if hasattr(s,'loop'):
422 s.loop(self,s)
423
424 def loop_tilehits(self):
425 tiles = self.tiles
426 tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()
427
428 layer = self.layers[0]
429
430 as_ = self.sprites[:]
431 for s in as_:
432 self._tilehits(s)
433
434 def _tilehits(self,s):
435 tiles = self.tiles
436 tw,th = tiles[0].image.get_width(),tiles[0].image.get_height()
437 layer = self.layers[0]
438
439 for _z in (0,):
440 if s.groups != 0:
441
442 _rect = s._rect
443 rect = s.rect
444
445 _rectx = _rect.x
446 _recty = _rect.y
447 _rectw = _rect.w
448 _recth = _rect.h
449
450 rectx = rect.x
451 recty = rect.y
452 rectw = rect.w
453 recth = rect.h
454
455 rect.y = _rect.y
456 rect.h = _rect.h
457
458 hits = []
459 ct,cb,cl,cr = rect.top,rect.bottom,rect.left,rect.right
460 #nasty ol loops
461 y = ct/th*th
462 while y < cb:
463 x = cl/tw*tw
464 yy = y/th
465 while x < cr:
466 xx = x/tw
467 t = tiles[layer[yy][xx]]
468 if (s.groups & t.agroups)!=0:
469 #self.hit(xx,yy,t,s)
470 d = math.hypot(rect.centerx-(xx*tw+tw/2),
471 rect.centery-(yy*th+th/2))
472 hits.append((d,t,xx,yy))
473
474 x += tw
475 y += th
476
477 hits.sort()
478 #if len(hits) > 0: print self.frame,hits
479 for d,t,xx,yy in hits:
480 self.hit(xx,yy,t,s)
481
482 #switching directions...
483 _rect.x = rect.x
484 _rect.w = rect.w
485 rect.y = recty
486 rect.h = recth
487
488 hits = []
489 ct,cb,cl,cr = rect.top,rect.bottom,rect.left,rect.right
490 #nasty ol loops
491 y = ct/th*th
492 while y < cb:
493 x = cl/tw*tw
494 yy = y/th
495 while x < cr:
496 xx = x/tw
497 t = tiles[layer[yy][xx]]
498 if (s.groups & t.agroups)!=0:
499 d = math.hypot(rect.centerx-(xx*tw+tw/2),
500 rect.centery-(yy*th+th/2))
501 hits.append((d,t,xx,yy))
502 #self.hit(xx,yy,t,s)
503 x += tw
504 y += th
505
506 hits.sort()
507 #if len(hits) > 0: print self.frame,hits
508 for d,t,xx,yy in hits:
509 self.hit(xx,yy,t,s)
510
511 #done with loops
512 _rect.x = _rectx
513 _rect.y = _recty
514
515
516 def loop_spritehits(self):
517 as_ = self.sprites[:]
518
519 groups = {}
520 for n in range(0,31):
521 groups[1<<n] = []
522 for s in as_:
523 g = s.groups
524 n = 1
525 while g:
526 if (g&1)!=0: groups[n].append(s)
527 g >>= 1
528 n <<= 1
529
530 for s in as_:
531 if s.agroups!=0:
532 rect1,rect2 = s.rect,Rect(s.rect)
533 #if rect1.centerx < 320: rect2.x += 640
534 #else: rect2.x -= 640
535 g = s.agroups
536 n = 1
537 while g:
538 if (g&1)!=0:
539 for b in groups[n]:
540 if (s != b and (s.agroups & b.groups)!=0
541 and s.rect.colliderect(b.rect)):
542 s.hit(self,s,b)
543
544 g >>= 1
545 n <<= 1
546
547
548 def screen_to_tile(self,pos):
549 """Convert a screen position to a tile position.
550 <pre>Vid.screen_to_tile(pos): return pos</pre>
551 """
552 return pos
553
554 def tile_to_screen(self,pos):
555 """Convert a tile position to a screen position.
556 <pre>Vid.tile_to_screen(pos): return pos</pre>
557 """
558 return pos
559
560 # vim: set filetype=python sts=4 sw=4 noet si :