FuckThisCollapse/fuckthiscollapse/Game.py

import pygame
import json
import copy
import time
import random

maps = [
]

random.seed(time.time())
for i in range(0, 16):
    newmap = []
    for i in range(0, 10):
        newrow = []
        for i in range(0, 16):
            newrow.append(random.randint(1, 4))
        newmap.append(newrow)
    maps.append(newmap)

class Game:
    # Debug flags, disable these before production
    DEBUG_MODE = True
    # -----

    MARBLE_WIDTH = 40
    MARBLE_HEIGHT = 40
    COLOR_MAGICPINK = (255, 0, 255, 0)
    COLOR_WHITE = (255, 255, 255, 255)
    COLOR_BLACK = (0, 0, 0, 255)
    SCREEN_WIDTH = 800
    SCREEN_HEIGHT = 600

    STATE_NONE = 0
    STATE_FALLING = 1
    STATE_SELECTED = 1 << 1
    STATE_DEAD = 1 << 2
    STATE_PLAYERTOUCHED = 1 << 3

    M_IDX_MOVES = 0
    M_IDX_TYPE = 1
    M_IDX_STATE = 2
    M_IDX_POS = 3
    M_IDX_VEL = 4

    P_IDX_X = 0
    P_IDX_Y = 1

    def __init__(self):
        pygame.init()
        self.__display__ = pygame.display.set_mode((Game.SCREEN_WIDTH, Game.SCREEN_HEIGHT))
        self.__blitTarget__ = self.__display__.convert_alpha()
        self.__marbles__ = []
        pygame.display.set_caption("Fuck This Collapse")
        self.__load_marbles__()
        self.__curMap__ = None
        self.__curMapRect__ = None
        self.__moves__ = 0
        self.__maxMarbleMoves__ = 4

        self.__selectedMarble__ = [-1, -1]
        self.__setSelectedMarble__([-1, -1])
        self.__selectionRect__ = None
        self.__selectionSurface__ = pygame.Surface(
            (Game.MARBLE_WIDTH, Game.MARBLE_HEIGHT),
            pygame.SRCALPHA | pygame.HWSURFACE)
        self.__selectionSurface__.fill((255,255,255, 128))

        self.__gameFont__ = pygame.font.SysFont(pygame.font.get_default_font(), 18)
        self.__debugFont__ = pygame.font.SysFont(pygame.font.get_default_font(), 12)
        self.__mapIndex__ = 0
        self.__setMap__(maps[self.__mapIndex__])
        #self.__setGroupState__(zap=True)

    def __load_marbles__(self):
        self.__marbles__.append(None)
        self.__marbles__.append(pygame.image.load('gfx/BlueSwirl.png'))
        self.__marbles__.append(pygame.image.load('gfx/MochaVolcano.png'))
        self.__marbles__.append(pygame.image.load('gfx/SwirlyEyeball.png'))
        self.__marbles__.append(pygame.image.load('gfx/ZebraGum.png'))

    def __setMap__(self, maparray):
        self.__curMap__ = []
        self.__curMapRect__ = pygame.Rect(
            ((Game.SCREEN_WIDTH - (Game.MARBLE_WIDTH * len(maparray[0])))/2),
            0,
            (Game.MARBLE_WIDTH * len(maparray[0])),
            (Game.MARBLE_HEIGHT * len(maparray))
        )

        x = self.__curMapRect__.left
        y = self.__curMapRect__.top
        for row in maparray:
            x = self.__curMapRect__.left
            mrow = []
            self.__curMap__.append(mrow) 
            for col in row:
                mrow.append(
                    [self.__maxMarbleMoves__, 
                     col, 
                     Game.STATE_NONE, 
                     [x, y], 
                     [0, 0]])
                x += Game.MARBLE_WIDTH
            y += Game.MARBLE_HEIGHT

    def __update__(self):
        for ri in range(len(self.__curMap__)-1, -1, -1):
            row = self.__curMap__[ri]
            ci = 0
            for col in row:
                if ( (col[Game.M_IDX_TYPE]) and (not self.__hasMarbleState__([ci, ri], Game.STATE_DEAD)) ):
                    if ( self.__curMap__[ri][ci][Game.M_IDX_TYPE] == 0 ):
                        self.__curMap__[ri][ci][Game.M_IDX_STATE] = Game.STATE_DEAD
                    elif ( self.__hasMarbleState__([ci, ri], Game.STATE_FALLING) ):
                        if ( col[Game.M_IDX_POS][Game.P_IDX_Y] > 800 ):
                            self.__curMap__[ri][ci][Game.M_IDX_STATE] = Game.STATE_DEAD
                            continue
                        col[Game.M_IDX_VEL][Game.P_IDX_Y] += 1

                        # OH GOD, MY EYES
                        nextri = (col[Game.M_IDX_POS][Game.P_IDX_Y] + (Game.MARBLE_HEIGHT)) / Game.MARBLE_HEIGHT
                        if ( ( (nextri) >= (len(self.__curMap__)) ) or
                             ( self.__hasMarbleState__([ci, nextri], Game.STATE_FALLING) ) or
                             ( self.__hasMarbleState__([ci, nextri], Game.STATE_DEAD) ) ):
                            col[Game.M_IDX_POS][Game.P_IDX_Y] += col[Game.M_IDX_VEL][Game.P_IDX_Y]
                        elif ( ( ri != (nextri-1 ) ) and 
                               ( not self.__hasMarbleState__([ci, nextri], Game.STATE_FALLING) ) and
                               ( not self.__hasMarbleState__([ci, nextri], Game.STATE_DEAD) ) ):
                            col[Game.M_IDX_POS][Game.P_IDX_Y] = ((nextri-1) * Game.MARBLE_HEIGHT)
                            self.__delMarbleState__([ci, ri], Game.STATE_FALLING)
                            self.__flipMarbles__([ci, ri], [ci, nextri-1])
                        else:
                            self.__delMarbleState__([ci, ri], Game.STATE_FALLING)
                        # --- THE GOGGLES DO NOTHING

                ci += 1
            ri += 1
        return

    def __draw__(self):
        self.__display__.fill(Game.COLOR_BLACK)
        self.__blitTarget__.fill(Game.COLOR_MAGICPINK)
        if not self.__curMap__:
            return
        ri = 0
        for row in self.__curMap__:
            ci = 0
            for col in row:
                if ( (col[Game.M_IDX_TYPE]) and (col[Game.M_IDX_STATE] != Game.STATE_DEAD)):
                    x = col[Game.M_IDX_POS][Game.P_IDX_X]
                    y = col[Game.M_IDX_POS][Game.P_IDX_Y]
                    self.__blitTarget__.blit(self.__marbles__[col[Game.M_IDX_TYPE]], (x, y))
                    text = self.__gameFont__.render("{}".format(col[Game.M_IDX_MOVES]), 1, Game.COLOR_WHITE)
                    textpos = text.get_rect(right = x + (Game.MARBLE_WIDTH),
                                            top = y)
                    self.__blitTarget__.blit(text, textpos)

                    if Game.DEBUG_MODE:
                        text = self.__gameFont__.render("{}".format(col[Game.M_IDX_STATE]), 1, Game.COLOR_WHITE)
                        textpos = text.get_rect(left = x,
                                                bottom = y + Game.MARBLE_HEIGHT)
                        self.__blitTarget__.blit(text, textpos)
                        text = self.__gameFont__.render("{},{}".format(ci, ri), 1, Game.COLOR_BLACK)
                        textpos = text.get_rect(centerx = x + (Game.MARBLE_WIDTH/2),
                                                centery = y + (Game.MARBLE_HEIGHT/2))
                        self.__blitTarget__.blit(text, textpos)
                ci += 1
            ri += 1

        if self.__selectionRect__ :
            self.__blitTarget__.blit(
                self.__selectionSurface__, 
                (self.__selectionRect__.left, self.__selectionRect__.top)
                )
        self.__display__.blit(self.__blitTarget__, (0, 0))

    def __canSelectMarble__(self, x, y):
        if self.__curMap__[y][x][Game.M_IDX_STATE] == Game.STATE_DEAD:
            return False
        if self.__selectedMarble__ == [-1, -1]:
            return True
        curx = self.__selectedMarble__[Game.P_IDX_X]
        cury = self.__selectedMarble__[Game.P_IDX_Y]
        selectable = [
            [curx - 1, cury - 1], # -S---
            [curx, cury - 1],     # --S--
            [curx + 1, cury - 1], # ---S-
            [curx - 1, cury],     # -SX--
            [curx + 1, cury],     # --XS-
            [curx - 1, cury + 1], # -S---
            [curx, cury + 1],     # --S--
            [curx + 1, cury + 1]  # ---S-
        ]
        if [x, y] not in selectable:
            return False
        return True

    def __flipMarbles__(self, m1, m2, force=False):
        # Skip empty (black) marbles
        if ( ( self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]][Game.M_IDX_TYPE] == 0 ) or
             ( self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]][Game.M_IDX_TYPE] == 0 ) ):
            return
        if ( ( self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]][Game.M_IDX_MOVES] <= 0 ) or
             ( self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]][Game.M_IDX_MOVES] <= 0 ) ):
            return

        # Swap marbles
        tmp = self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]]
        self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]] = self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]]
        self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]] = tmp

        # Swap positions of the marbles
        tmp = self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]][Game.M_IDX_POS]
        self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]][Game.M_IDX_POS] = self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]][Game.M_IDX_POS]
        self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]][Game.M_IDX_POS] = tmp

        # Decrement movecount remaining on both marbles
        self.__curMap__[m1[Game.P_IDX_Y]][m1[Game.P_IDX_X]][Game.M_IDX_MOVES] -= 1
        self.__curMap__[m2[Game.P_IDX_Y]][m2[Game.P_IDX_X]][Game.M_IDX_MOVES] -= 1

    def __setMarbleState__(self, pos, state):
        self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE] = state

    def __addMarbleState__(self, pos, state):
        cs = self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE]
        cs = ( cs | state )
        self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE] = cs

    def __delMarbleState__(self, pos, state):
        if ( not self.__hasMarbleState__(pos, state) ):
            return
        cs = self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE]
        cs = ( cs ^ state )
        self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE] = cs

    def __hasMarbleState__(self, pos, state):
        return ( (self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE] & state) == state)

    def __setSelectedMarble__(self, pos):
        if self.__selectedMarble__ != [-1, -1]:
            self.__delMarbleState__(self.__selectedMarble__, Game.STATE_SELECTED)
        self.__selectedMarble__ = pos
        if pos == [-1, -1]:
            self.__selectionRect__ = None
            return
        if ((self.__curMap__) and (self.__curMap__[pos[Game.P_IDX_Y]][pos[Game.P_IDX_X]][Game.M_IDX_STATE] == Game.STATE_DEAD)):
            self.__setSelectedMarble__([-1, -1])
            return
        self.__selectionRect__ = pygame.Rect(
            (self.__curMapRect__.left + (pos[Game.P_IDX_X] * Game.MARBLE_WIDTH)),
            (self.__curMapRect__.top + (pos[Game.P_IDX_Y] * Game.MARBLE_HEIGHT)),
            Game.MARBLE_WIDTH,
            Game.MARBLE_HEIGHT)
        self.__addMarbleState__(pos, Game.STATE_SELECTED)

    def __mouseClicked__(self, event):
        mouse_x = event.pos[Game.P_IDX_X]
        mouse_y = event.pos[Game.P_IDX_Y]
        marble_x = ( (mouse_x - self.__curMapRect__.left) / Game.MARBLE_WIDTH)
        marble_y = ( (mouse_y - self.__curMapRect__.top) / Game.MARBLE_HEIGHT)

        if ( ( not self.__curMapRect__.collidepoint((mouse_x, mouse_y)))  or
             (self.__curMap__[marble_y][marble_x][Game.M_IDX_TYPE] == 0 ) ):
            if self.__curMap__[self.__selectedMarble__[Game.P_IDX_Y]][self.__selectedMarble__[Game.P_IDX_X]][2] == Game.STATE_SELECTED :
                self.__curMap__[self.__selectedMarble__[Game.P_IDX_Y]][self.__selectedMarble__[Game.P_IDX_X]][2] = Game.STATE_NONE
            self.__setSelectedMarble__([-1, -1])
            self.__selectionRect__ = None
            return
        if self.__curMap__[marble_y][marble_x][Game.M_IDX_TYPE] == 0:
            return False
        if event.button == 1:
            self.__setSelectedMarble__([marble_x, marble_y])
            self.__addMarbleState__([marble_x, marble_y], Game.STATE_PLAYERTOUCHED)
            self.__setGroupState__()
        elif event.button in [2, 3]:
            if not self.__canSelectMarble__(marble_x, marble_y):
                return
            self.__delMarbleState__(self.__selectedMarble__, Game.STATE_SELECTED)
            self.__flipMarbles__(self.__selectedMarble__, [marble_x, marble_y])
            self.__setSelectedMarble__([marble_x, marble_y])
            self.__addMarbleState__([marble_x, marble_y], Game.STATE_PLAYERTOUCHED)
            self.__setGroupState__()
        return

    def __setGroupState__(self, zap=False):
        groups = {
            0: [],
            1: [],
            2: [],
            3: [],
            4: []
        }
        groups_of_3 = [
            [],
            [],
            [],
            [],
            []
        ]
        x = 0
        y = 0
        curMatchMarble = 0
        prevy = 0
        group = None
        for row in self.__curMap__: 
            x = 0
            for col in row:
                if col[Game.M_IDX_TYPE] != 0:
                    candidates = [
                                        # --X--
                        [x, y + 1]      # --C--
                    ]
                    for c in candidates:
                        cx = c[Game.P_IDX_X]
                        cy = c[Game.P_IDX_Y]
                        if ( (cy >= len(self.__curMap__)) or
                             (cy < 0 ) or
                             (cx >= len(self.__curMap__[cy])) or
                             (cx < 0 ) ):
                             continue
                        if ( self.__curMap__[cy][cx][Game.M_IDX_TYPE] == col[Game.M_IDX_TYPE] ):
                            curMatchMarble = col[Game.M_IDX_TYPE]
                            group = None
                            for group in groups[curMatchMarble]:
                                if ( ( [cx, cy] in group ) or 
                                     ( [x, y] in group ) ):
                                    break
                                group = None
                            if not group:
                                group = [[x, y]]
                                groups[curMatchMarble].append(group)
                            if [cx, cy] in group:
                                group.append([x, y])
                            else:
                                group.append([cx, cy])

                x += 1
            y += 1

        for marble, group in groups.iteritems():
            for grp in group:
                if len(grp) < 3:
                    continue
                # At least one marble in the set has to have been touched by the player
                for tpair in grp:
                    if self.__hasMarbleState__([tpair[Game.P_IDX_X], tpair[Game.P_IDX_Y]],
                                               Game.STATE_PLAYERTOUCHED):
                        break
                    tpair = None
                if not tpair:
                    continue

                print "Marking group as falling: {}".format(grp)
                for pair in grp:
                    if self.__hasMarbleState__([tpair[Game.P_IDX_X], tpair[Game.P_IDX_Y]],
                                               Game.STATE_SELECTED):
                        self.__setSelectedMarble__([-1, -1])
                    if zap:
                        self.__curMap__[pair[Game.P_IDX_Y]][pair[Game.P_IDX_X]][Game.M_IDX_STATE] = Game.STATE_DEAD
                    else:
                        self.__addMarbleState__(pair, Game.STATE_FALLING)

    def run(self):
        while True:
            self.__update__()
            self.__draw__()
            
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    return
                elif event.type == pygame.KEYUP:
                    if ( (pygame.key.get_pressed()[pygame.K_LCTRL]) and 
                         (event.key == pygame.K_LEFT) and
                         (self.__mapIndex__ > 0) ):
                        self.__mapIndex__ -= 1
                        self.__setMap__(maps[self.__mapIndex__])
                        self.__setSelectedMarble__([-1, -1])
                    elif ( (pygame.key.get_pressed()[pygame.K_LCTRL]) and 
                           (event.key == pygame.K_RIGHT) and
                           (self.__mapIndex__ < (len(maps)-1))):
                        self.__mapIndex__ += 1
                        self.__setMap__(maps[self.__mapIndex__])
                        self.__setSelectedMarble__([-1, -1])
                        

                elif event.type == pygame.MOUSEBUTTONUP:
                    self.__mouseClicked__(event)
            pygame.display.update()
        return