Source

pygamegsoc12 / alchemymadness / blocks.py

Full commit
"""Mixing potion"""

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

class Block(DirtySprite):
    rect = Rect(0, 0, 30, 30)
    changed = False

    def __init__(self, color, *groups):
        super(Block, self).__init__(*groups)

        self._image = pygame.Surface(self.rect.size) # Sprite image
        self._color = color  # Block color
        self.changed = True
        self.dirty = 1

    @property
    def image(self):
        if self.changed:
            self._image = resources.block.copy()
            self._image.fill(self._color, special_flags=pygame.locals.BLEND_RGBA_MULT)
        return self._image

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, value):
        self._color = value
        self.changed = True


    def grid_pos(self, pos, grid_rect):
        """ set the rect for the given (x,y) grid pos
        """
        gx, gy = pos
        x, y = gx * BLOCK_W, gy * BLOCK_H
        x += grid_rect[0]
        y += grid_rect[1]
        self.rect = pygame.Rect(x, y, BLOCK_W, BLOCK_H)
        self.changed = True
        self.dirty = 1



class Blocks(object):
    """ contains 3 Block() instances.
    """
    def __init__(self, parent):
        super(Blocks, self).__init__()

        self.parent = parent
        self.colors = [(255,0,0), (0,255,0), (0,0,255)]

        # 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) for c in self.colors]
        self.on_moved()

    def on_moved(self):
        for b, pos in zip(self.blocks, self.grid_positions):
            b.grid_pos(pos, self.parent.rect)


    def update(self, time):
        pass
        

    def action_move_left(self):
        for b in self.grid_positions:
            b[0] -= 1
            if b[0] < 0:
                b[0] = 0
        self.on_moved()

    def action_move_right(self):
        for b in self.grid_positions:
            b[0] += 1
            if b[0] >= GRID_SIZE_W:
                b[0] = GRID_SIZE_W - 1
        self.on_moved()


    def action_move_up(self):
        for b in self.grid_positions:
            b[1] -= 1
            if b[1] < 0:
                b[1] = 0
        self.on_moved()

    def action_move_down(self):
        for b in self.grid_positions:
            b[1] += 1
            if b[1] >= GRID_SIZE_H:
                b[1] = GRID_SIZE_H - 1
        self.on_moved()


class Grid(object):
    """ Contains Blocks()
    """
    def __init__(self):
        super(Grid, self).__init__()
        self.GRID_SIZE_W = GRID_SIZE_W
        self.GRID_SIZE_H = GRID_SIZE_H

        self.rect = pygame.Rect(100, 100, GRID_SIZE_W * BLOCK_W, GRID_SIZE_H * BLOCK_H)

        self.restart()
    def restart(self):
        self.init_grid()
        self.blocks = Blocks(self)


    def init_grid(self):
        # init our 10x10 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)

        #import pprint
        #pprint.pprint(self.grid)







class Grids(object):
    """ This contains all the main Grid objects.
    """
    NUM_GRIDS = 4
    def __init__(self):
        """
        """
        self.grids = [Grid() for x in range(self.NUM_GRIDS)]