1. pygame
  2. Untitled project
  3. pygamegsoc12

Source

pygamegsoc12 / alchemymadness / blocks.py

Diff from to

File alchemymadness/blocks.py

  • Ignore whitespace
 """Mixing potion"""
 
+import random
+from itertools import izip, chain
+
 import pygame
-from pygame.locals import Rect
 from pygame.sprite import DirtySprite
 
 import resources
-
-GRID_SIZE_W = 9
-GRID_SIZE_H = 16
-
-BLOCK_W = 30
-BLOCK_H = 30
-
-# small block size.
-SBLOCK_W = BLOCK_W / 2
-SBLOCK_H = BLOCK_H / 2
+import layout
 
 class Block(DirtySprite):
     """ A single block.
     """
+    rect = layout.Main.block_rect
+    changed = False # True if sprite image need to be regenerated
 
-    changed = False
-
-    def __init__(self, color, small, *groups):
+    def __init__(self, color, *groups):
         """
-            color - (r,g,b) tuple.
-            small - True if we are to be drawn small.
+            color - (r,g,b) tuple
         """
         super(Block, self).__init__(*groups)
-
-        self.small = small
-        if self.small:
-            self.rect = Rect(0, 0, SBLOCK_W, SBLOCK_W)
-        else:
-            self.rect = Rect(0, 0, BLOCK_W, BLOCK_W)
-
         self._image = pygame.Surface(self.rect.size) # Sprite image
+        self.t_image = resources.block
         self._color = color  # Block color
         self.changed = True
         self.dirty = 1
     @property
     def image(self):
         if self.changed:
-            if self.small:
-                self._image = resources.sblock.copy()
-            else:
-                self._image = resources.block.copy()
+            self._image = self.t_image.copy()
             self._image.fill(self._color, special_flags=pygame.locals.BLEND_RGBA_MULT)
         return self._image
 
         self.dirty = 1
 
 
+class SmallBlock(Block):
+    """ A single small block.
+    """
+    rect = layout.Main.small_block_rect
+
+    def __init__(self, color, *groups):
+        super(SmallBlock, self).__init__(color, *groups)
+        self.t_image = resources.sblock
+
 
 class Blocks(object):
     """ contains 3 Block() instances.
     """
+    av_colors = [(255,0,0), (0,255,0), (0,0,255)] # available colors
+
     def __init__(self, parent):
         """ parent - a Grid instance.
         """
         super(Blocks, self).__init__()
-
+        self.sprite_group = pygame.sprite.Group()
         self.parent = parent
-        #TODO: randomise these colors.
-        self.colors = [(255,0,0), (0,255,0), (0,0,255)]
-
+        BlockC = Block if not self.parent.small else SmallBlock
+        self.sprite_group.add([BlockC(random.choice(self.av_colors)) for i in range(3)])
         # how do we handle location, and rotation? We say where the grid it is on.
         #     top, left is (0,0)
         self.grid_positions = [[0,0], [1,0], [2,0]]
 
-        self.blocks = [Block(c, self.parent.small) for c in self.colors]
+
         self.on_moved()
 
     def on_moved(self):
         """ called when we have moved.
         """
         i = 0
-        for b, pos in zip(self.blocks, self.grid_positions):
+        for b, pos in izip(self.sprite_group, self.grid_positions):
             #print "on_moved {} {}".format(i, pos)
             b.grid_pos(pos, self.parent.rect)
             i += 1
 
     def update(self, time):
         pass
-        
-
-
 
     def has_collided(self):
         """ checks if we have collided with some other blocks.
         raise NotImplementedError()
 
 
-
-
-
     # action_* methods are inputs.
 
     def action_move_left(self):
             # oops!  out of bounds, so reverse moves.
             for b in self.grid_positions:
                 b[0] += 1
-                
+
         self.on_moved()
 
     def action_move_right(self):
         doit = True
         for b in self.grid_positions:
             b[0] += 1
-            if b[0] >= GRID_SIZE_W:
+            if b[0] >= self.parent.grid_size.w:
                 doit = False
         if not doit:
             for b in self.grid_positions:
         if not doit:
             for b in self.grid_positions:
                 b[1] += 1
-                
+
         self.on_moved()
 
     def action_move_down(self):
         doit = True
         for b in self.grid_positions:
             b[1] += 1
-            if b[1] >= GRID_SIZE_H:
+            if b[1] >= self.parent.grid_size.h:
                 doit = False
         if not doit:
             for b in self.grid_positions:
                 b[1] -= 1
-                
+
         self.on_moved()
 
 
-
-
-
-
-
-
-
 class Grid(object):
     """ Contains Blocks()
     """
+    grid_size = layout.Main.grid_size
     def __init__(self, grid_num):
         super(Grid, self).__init__()
+        self._sprite_group = pygame.sprite.Group()
         self.grid_num = grid_num
-        # draw the first one big.
         self.small = grid_num != 0
-
-        self.GRID_SIZE_W = GRID_SIZE_W
-        self.GRID_SIZE_H = GRID_SIZE_H
-
-        if self.small:
-            # TODO: get correct coords for where the grids are on screen.
-            if self.grid_num == 1:
-                self.rect = pygame.Rect(300, 20, GRID_SIZE_W * SBLOCK_W, GRID_SIZE_H * SBLOCK_H)
-            if self.grid_num == 2:
-                self.rect = pygame.Rect(470, 20, GRID_SIZE_W * SBLOCK_W, GRID_SIZE_H * SBLOCK_H)
-            if self.grid_num == 3:
-                self.rect = pygame.Rect(630, 20, GRID_SIZE_W * SBLOCK_W, GRID_SIZE_H * SBLOCK_H)
-        else:
-            self.rect = pygame.Rect(30, 20, GRID_SIZE_W * BLOCK_W, GRID_SIZE_H * BLOCK_H)
+        self.rect = layout.Main.grid_rects[grid_num]
 
         self.restart()
 
+    @property
+    def sprite_group(self):
+        self._sprite_group = pygame.sprite.Group(list(chain(self.blocks.sprite_group, self.grid.itervalues())))
+        return self._sprite_group
+
     def restart(self):
         """ restart this Grid instance.
         """
-        self.init_grid()
-        self.blocks = Blocks(self)
-
-
+        self.grid = {} # grid in form of dict - position : Block
+        self.blocks = Blocks(self) # currently moving block
         # TODO: what about frozen Blocks?
-
-
-
+        # theory:
+        # - when Blocks hits Block or grid frame, it pushes Block-s to grid
+        # - Block-s continue to move until hitting other Block or grid frame
 
     def init_grid(self):
         """ init_grid initialises the Grid to be all clear.
         """
-        # init our 10x10 grid, to show the color of each grid part.
+        # init our grid, to show the color of each grid part.
         #[[(0,0,0), ...],
         # ...
         #]
         self.grid = []
-        for x in range(self.GRID_SIZE_H):
-            self.grid.append([(0,0,0)] * self.GRID_SIZE_W)
+        for x in range(self.grid_size.h):
+            self.grid.append([(0,0,0)] * self.grid_size.h)
 
         #import pprint
         #pprint.pprint(self.grid)
 
 
-
-
-
-
-
 class Grids(object):
     """ This contains all the main Grid objects.
     """
-    NUM_GRIDS = 4
     def __init__(self, sprite_group):
         """ sprite_group - which we add sprites to.
         """
         self.sprite_group = sprite_group
-        self.grids = [Grid(x) for x in range(self.NUM_GRIDS)]
+        self.grids = [Grid(x) for x in range(len(layout.Main.grid_rects))]
 
         for grd in self.grids:
-            for b in grd.blocks.blocks:
-                self.sprite_group.add(b)
+            self.sprite_group.add(grd.sprite_group)