#!/user/bin/env python


import sys
import os
import pygame
from pygame.locals import *


#--- Our Variables
res = (32, 32)
#size = (20 * res[0], 17 * res[1])
speed = [0, 0]

#--- Init pygame
os.environ["SDL_VIDEO_CENTERED"] = "1"
pygame.init

#--- Display
pygame.display.set_caption("Rectangle Man: Story of a Square")
screen = pygame.display.set_mode((20 * res[0], 17 * res[1]))


class Character(object):
    def __init__(self, Size):
        self.rect = pygame.Rect(0, 0, Size[0], Size[1])
        self.Wize = Size


class Player(Character):

    def __init__(self, Size, Speed):
        Character.__init__(self, Size)
        self.topSpeed = Speed
        self.uc = 16
        self.currentJump = 0
        self.totJumpNum = 2
        self.jIncrement = 1
        self.jumping = False

    #def tick():


    def move(self, dx, dy):
        if dx != 0:
            self.move_single_axis(dx, 0)
        if dy != 0:
            self.move_single_axis(0, dy)

    def move_single_axis(self, dx, dy):
        self.rect.x += dx
        self.rect.y += dy

        tx, ty = int(player.rect.x / res[0]), int(player.rect.y / res[1])
        rects = [[tx, ty], [tx + 1, ty], [tx, ty + 1], [tx + 1, ty + 1]]

        for h in rects:
            if levels.map[int(h[0])][int(h[1])].tNum == 1:
                wam = levels.map[int(h[0])][int(h[1])].rect
                if self.rect.colliderect(wam):
                    if dx > 0:
                        self.rect.right = wam.left
                    if dx < 0:
                        self.rect.left = wam.right
                    if dy > 0:
                        self.rect.bottom = wam.top
                        global jump
                        jump = 0
                        speed[1] = 0
                    if dy < 0:
                        self.rect.top = wam.bottom
                        speed[1] = 0
                    return


class Wall(object):

    def __init__(self, pos):
        self.rect = pygame.Rect(pos[0], pos[1], pos[2], pos[3])
        self.tNum = pos[4]
        self.tile = pos[5]


class Level(object):

    def __init__(self, (size, resolution, mapArray, playerStart)):
        self.size = size
        self.res = resolution
        self.map =  mapArray
        self.start = playerStart


#--- Variables
clock = pygame.time.Clock()
uCr = False

def translate(rect):
    global camera
    return pygame.Rect(rect.x - camera.x, rect.y - camera.y, rect.w, rect.h)

def getEvents():
    global camera
    for event in pygame.event.get():
        if event.type == KEYDOWN:
            if event.key == K_UP:
                if player.jumping == False:
                    player.jumping = True
                    player.currentJump += 1
                    speed[1] = -player.topSpeed[1]
                    player.increment = 1
            if event.key == K_DOWN:
                player.rect = pygame.Rect(player.rect.x, player.rect.y + player.Wize[1] / 2, player.Wize[0], player.Wize[1] / 2)
                pygame.draw.rect(screen, (0, 0, 0), ballbuff)
            if event.key == K_LEFT:
                speed[0] = -player.topSpeed[0]
            if event.key == K_RIGHT:
                speed[0] = player.topSpeed[0]
        if event.type == KEYUP:
            if event.key == K_UP:
                player.increment = 2
            if event.key == K_DOWN and speed[1] > 0:
                q = player.rect.x
                player.move(0, -res[1]/2)
                if player.rect.x == q:
                    player.move(0, res[1]/2)
                    player.rect = pygame.Rect(player.rect.x, player.rect.y - player.Wize[1] / 2, player.Wize[0], player.Wize[1])
            if event.key == K_LEFT and speed[0] < 0:
                speed[0] = 0
            if event.key == K_RIGHT and speed[0] > 0:
                speed[0] = 0
        if event.type == pygame.QUIT:
            gameRunning = False
            sys.exit()

def parseLevel(filename):
    COMMA_ITER = 6
    pos, walls, tot = [], [], []
    fileObj = open(filename)
    s = fileObj.read()
    fileObj.close()
    mRes = s.find(".", 0)
    tot = [float(res[0]) / float(s[0: mRes]), float(res[1]) / float(s[0: mRes])]
    mx = s.find(".", mRes + 1)
    my = s.find("(", mx)
    strPart = 0
    for i in range(0, int(s[mRes + 1: mx])):
        walls.append([])
        for e in range(0, int(s[mx + 1: my])):
            strPart = s.find("(", strPart) + 1
            strPart2 = s.find(")", strPart)
            for la in range(0, COMMA_ITER):
                final = s.find(",", strPart, strPart2)
                pos.append(int(s[strPart: final]))
                strPart = final + 1
            if pos[4] == 2:
                pos[4] = 0
                star = (pos[0] * tot[0], pos[1] * tot[1])
            walls[i].append(Wall((pos[0] * tot[0], pos[1] * tot[1], pos[2] * tot[0], pos[3] * tot[1], pos[4], pos[5])))
            pos = []
    return ((mx, my), tot, walls, star)

levels = Level(parseLevel("level.txt"))
player = Player((res[0] - 1, res[1]), (4 * levels.res[0], 10 * levels.res[1]))
player.rect.x, player.rect.y = levels.start[0], levels.start[1]
camera = pygame.Rect(0, 0, screen.get_width(), screen.get_height())
tileset = pygame.transform.scale(pygame.image.load("tileset.bmp"), (res[0], res[1] * 9)).convert()

gameRunning = True
while gameRunning:
    ballbuff = pygame.Rect(player.rect.x, player.rect.y, res[0], player.rect.bottom - player.rect.top)
    getEvents()

    player.move(speed[0], speed[1])
    camera.x = player.rect.x - (camera.width / 2)
    if camera.x < 0:
        camera.x = 0
    if camera.x + camera.width > len(levels.map) * res[0]:
        camera.x = (len(levels.map) * res[0]) - camera.width

    camera.y = player.rect.y - (camera.height / 2)
    if camera.y < 0:
        camera.y = 0
    if camera.y + camera.height > len(levels.map[0]) * res[1]:
        camera.y = (len(levels.map[0]) * res[1]) - camera.height
    if speed[1] < player.topSpeed[1]:
        if speed[1] < 0:
            speed[1] += player.increment * player.res[1]
        else:
            speed[1] += 1 * player.res[1]
    if player.jumping:
        if (speed[1] >= 0) and (player.currentJump <= player.totJumpNum - 1):
            player.jumping = False

    screen.fill((0, 0, 0))
    for i in range(0, len(levels.map)):
        for e in range(0, len(levels.map[i])):
            rect = translate(levels.map[i][e].rect)
            til = pygame.surface.Surface((res[0],res[1]))
            til.set_colorkey((73,154,191))
            til.blit(tileset, (0, -levels.map[i][e].tile * res[1], res[0], res[1]))
            screen.blit(til, rect)

    rect = translate(player.rect)
    pygame.draw.rect(screen, (255, 200, 0), rect)

    clock.tick(30)
    pygame.display.flip()