#Spill klossgårundt

import pygame
from pygame.locals import *
import random
from time import sleep
#Dette spillet baserer all bevegelse
#på koordinater i ei todimensjonal liste,
#litt som i Game of Life.
#Vi bruker objekter som vi lagrer i lista


class Block:
    def __init__(self):
        self._image = pygame.image.load("block.png")

    def show(self,skjerm,coords):#coords er en tuppel
        skjerm.blit(self._image,coords) #kopierer bildet til skjermen

    def __repr__(self):
        return "block"

class Background:
    def __init__(self):
        self._image = pygame.image.load("background.png")

    def show(self,skjerm,coords):
        skjerm.blit(self._image,coords)

    def __repr__(self):
        return "back"

class Bomb:
    def __init__(self):
        self._image = pygame.image.load("bomb.png")

    def show(self,skjerm,coords):
        skjerm.blit(self._image,coords)

class Baguette:
    def __init__(self):
        self._image = pygame.image.load("baguette.png")

    def show(self,skjerm,coords):
        skjerm.blit(self._image,coords)
        
class Heart:
    def __init__(self):
        #her har vi flere mulige bilder
        self._image1 = pygame.image.load("hjerte1.png")
        self._image2 = pygame.image.load("hjerte2.png")
        self._image3 = pygame.image.load("hjerte3.png")
        self._image4 = pygame.image.load("hjerte4.png")
        
        #vi lagrer dem i ordbok, så det er lettere
        self._images = {4:self._image1,
            3:self._image2,
            2:self._image3,
            1:self._image4}

    def show(self,skjerm, value):
        self._image = self._images[value]
        #tegnes i venstre hjørne (0,0)
        skjerm.blit(self._images[value],(0, 0))

#Selve spillebrettet der vi lagrer alle objektene
class Brettet:
    def __init__(self, x, y,pixelSize):
        self._X = x
        self._Y = y
        self._brett = []
        #pixelsize brukes til å si hvor store bildene er.
        self._pSize = pixelSize
        for y in range(self._Y):
            temp = []
            for x in range(self._X):
                temp.append(Background())
            self._brett.append(temp)
        self._screen = pygame.display.set_mode(self.getSize())
        self._bCoords = [0,0]
        self._life = 4
        self._lifeMeter = Heart()
        self.updateLife()
        self._game_over = pygame.image.load("game_over2.png")

        
    #plasserer bomber på brettet
    def placeBomb(self):
        coords = self._randomCoords()
        self._brett[coords[0]][coords[1]] = Bomb()
        coords = self._randomCoords()
        self._brett[coords[0]][coords[1]] = Bomb()

    #plasserer baguetter på brettet
    def placeBaguette(self):
        coords = self._randomCoords()
        self._brett[coords[0]][coords[1]] = Baguette()
        
    #en metode som gir oss tilfeldige koordinater som ikke
    #overlapper med andre objekter
    def _randomCoords(self):
        rand_x = random.randint(0,self._X - 1)
        rand_y = random.randint(0,self._Y - 1)
        if not [rand_y,rand_x] == self._bCoords:
            return [rand_y,rand_x]
        #prøv igjen
        return self._randomCoords()
    
    #skriver ut brettet(til terminalen)
    def skrivut(self):
        print(self._brett)

    #oppdaterer helsemeteret
    def updateLife(self,value=0):
        self._life += value
        if self._life < 1:
            self.game_over()
        else:
            if self._life > 4:
                self._life = 4
            self._lifeMeter.show(self._screen,self._life)

    def game_over(self):
        self._screen.blit(self._game_over, (self._pSize,self._pSize))
        sleep(0.05)
        self._brett[self._bCoords[0]][self._bCoords[1]] = Background()

        
    #Bevegelsesmetoder
    def moveLeft(self):
        if self._bCoords[1] > 0:
            if type(self._brett[self._bCoords[0]][self._bCoords[1] - 1]) == Bomb:
                self.updateLife(-1)
            elif type(self._brett[self._bCoords[0]][self._bCoords[1] - 1]) == Baguette:
                self.updateLife(1)
            self._brett[self._bCoords[0]][self._bCoords[1] - 1] = self._brett[self._bCoords[0]][self._bCoords[1]]
            self._brett[self._bCoords[0]][self._bCoords[1]] = Background()
            self._bCoords[1] -= 1
            randomTall = random.randint(0,4)
            if randomTall == 0:
                self.placeBomb()
            if randomTall == 1:
                self.placeBaguette()

    def moveRight(self):
        if self._bCoords[1] < self._X -1 :
            if type(self._brett[self._bCoords[0]][self._bCoords[1] + 1]) == Bomb:
                self.updateLife(-1)
            elif type(self._brett[self._bCoords[0]][self._bCoords[1] + 1]) == Baguette:
                self.updateLife(1)
            self._brett[self._bCoords[0]][self._bCoords[1] + 1] = self._brett[self._bCoords[0]][self._bCoords[1]]
            self._brett[self._bCoords[0]][self._bCoords[1]] = Background()
            self._bCoords[1] += 1
            randomTall = random.randint(0,4)
            if randomTall == 0:
                self.placeBomb()
            if randomTall == 1:
                self.placeBaguette()

    def moveUp(self):
        if self._bCoords[0] > 0:
            if type(self._brett[self._bCoords[0] - 1][self._bCoords[1]]) == Bomb:
                self.updateLife(-1)
            elif type(self._brett[self._bCoords[0] - 1][self._bCoords[1]]) == Baguette:
                self.updateLife(1)
            self._brett[self._bCoords[0] - 1][self._bCoords[1]] = self._brett[self._bCoords[0]][self._bCoords[1]]
            self._brett[self._bCoords[0]][self._bCoords[1]] = Background()
            self._bCoords[0] -= 1
            randomTall = random.randint(0,4)
            if randomTall == 0:
                self.placeBomb()
            if randomTall == 1:
                self.placeBaguette()

    def moveDown(self):
        if self._bCoords[0] < self._Y - 1:
            if type(self._brett[self._bCoords[0] + 1][self._bCoords[1]]) == Bomb:
                self.updateLife(-1)
            elif type(self._brett[self._bCoords[0] + 1][self._bCoords[1]]) == Baguette:
                self.updateLife(1)
            self._brett[self._bCoords[0] + 1][self._bCoords[1]] = self._brett[self._bCoords[0]][self._bCoords[1]]
            self._brett[self._bCoords[0]][self._bCoords[1]] = Background()
            self._bCoords[0] += 1
            randomTall = random.randint(0,4)
            if randomTall == 0:
                self.placeBomb()
            if randomTall == 1:
                self.placeBaguette()

    #legger til spilleren på midten
    def initBlock(self,x,y):
        #print("legger til block")
        self._bCoords[0] = y
        self._bCoords[1] = x
        self._brett[y][x] = Block()

    def getSize(self):
        return (self._X * self._pSize, self._Y * self._pSize)

    def running(self):
        return self._running

    def quit(self):
        self._running = False
    #viser alle bildene??
    def show(self):
        for y in range(self._Y):
            for x in range(self._X):
                #print()
                #self._brett[y][x].show(self._screen,(self._X * self._pSize, self._Y * self._pSize))
                self._screen.blit(self._brett[y][x]._image, (x * self._pSize, y * self._pSize))

testBrett = Brettet(10,10,64)
testBrett.initBlock(4,4)
testBrett.show()
testBrett.skrivut()
running = 1
while running:
    event = pygame.event.poll()
    if event.type == pygame.QUIT:
        running = 0
        pygame.quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_LEFT:
            testBrett.moveLeft()
        if event.key == pygame.K_RIGHT:
            testBrett.moveRight()
        if event.key == pygame.K_DOWN:
            testBrett.moveDown()
        if event.key == pygame.K_UP:
            testBrett.moveUp()
    testBrett.show()
    testBrett.updateLife()
    pygame.display.flip()