TIA Tetris - Versioon 21

import pygame, random


def joonistaRuut(x, y, värv):
    alumineVärv = (max(0, värv[0] - 10), max(0, värv[1] - 10), max(0, värv[2] - 10))
    pygame.draw.rect(ekraan, alumineVärv, (x * ruuduLaius, y * ruuduLaius, ruuduLaius, ruuduLaius))

    ülemineVärv = [min(üksVärv + 10, 255) for üksVärv in värv]
    pygame.draw.rect(ekraan, ülemineVärv, (x * ruuduLaius, y * ruuduLaius, ruuduLaius - 1, ruuduLaius - 1))

    pygame.draw.rect(ekraan, värv, (x * ruuduLaius + 1, y * ruuduLaius + 1, ruuduLaius - 2, ruuduLaius - 2))



#See klass hoiab väljaku seisu ja oskab seda joonistada
class Kaart:
    laius = 20  #niipalju ruute laiuses
    kõrgus = 40 #niipalju ruute kõrguses

    def __init__(self):
        #Teeme 2-mõõtmelise listi
        self.kaart = []
        for x in range(Kaart.laius):
            self.kaart.append([])
            for y in range(Kaart.kõrgus):
                self.kaart[x].append(0)

    def joonista(self):
        #Joonistame ruudud
        for x, rida in enumerate(self.kaart):
            for y, lahter in enumerate(rida):
                kasJoonistas = False
                if lahter != 0:
                    if isinstance(lahter, Kujund):
                        kasJoonistas = lahter.joonista(x, y)
                    else:
                        joonistaRuut(x, y, lahter)
                        kasJoonistas = True

                if lahter == 0:
                    pygame.draw.rect(ekraan, (20, 20, 20), (x * ruuduLaius, y * ruuduLaius, ruuduLaius, ruuduLaius))
                    pygame.draw.rect(ekraan, (0, 0, 0), (x * ruuduLaius + 1, y * ruuduLaius + 1, ruuduLaius - 2, ruuduLaius - 2))
                elif not kasJoonistas:
                    pygame.draw.rect(ekraan, (80, 20, 20), (x * ruuduLaius, y * ruuduLaius, ruuduLaius, ruuduLaius))
                    pygame.draw.rect(ekraan, (60, 0, 0), (x * ruuduLaius + 1, y * ruuduLaius + 1, ruuduLaius - 2, ruuduLaius - 2))


    def lisaKujund(self, kujund):
        for lokaalneX, rida in enumerate(kujund.kujund):
            for lokaalneY, lahter in enumerate(rida):
                if kujund.kujund[lokaalneX][lokaalneY]:
                    self.kaart[kujund.x + lokaalneX][kujund.y + lokaalneY] = kujund;

    def uuenda(self, kujund):

        kasSaabLiikuda = kujund.y < len(self.kaart[0]) - len(kujund.kujund[0])
        if kasSaabLiikuda:
            for x in range(len(kujund.kujund)):
                for y in range(len(kujund.kujund[0])):
                    if (kujund.kujund[x][y] and (y + 1 == len(kujund.kujund[0]) or not kujund.kujund[x][y + 1]) and self.kaart[x + kujund.x][y + kujund.y + 1] != 0):
                        kasSaabLiikuda = False

                    if not kasSaabLiikuda:
                        break

        #Kui kujundi all on veel tühjasi ridu:
        if kasSaabLiikuda:
            kujund.liigu(self, pygame.K_DOWN)
        else:
            self.lukusta(kujund)


    def lukusta(self, kujund):
        #Kujund ei saa enam liikuda, lukustame selle kujundi (kirjutame värvid väljakule)
        print("Lukusta")
        kujund.kasElus = False
        for x in range(len(kujund.kujund)):
            for y in range(len(kujund.kujund[0])):
                if kujund.kujund[x][y]:
                    self.kaart[kujund.x + x][kujund.y + y] = kujund.värv

#Klass, mille objektid on erinevad kujundid
class Kujund:

    def __init__(self, x, y, kujund, värv):
        self.x = x             #Kujundi asukoht kaardil
        self.y = y
        self.kujund = kujund[0]   #2-mõõtmeline list, mis hoiab kujundit
        self.pöörded = kujund
        self.pööre = 0
        self.värv = värv
        self.kasElus = True

    def joonista(self, kaardiX, kaardiY):
        #Joonistame kujundi vastavatele kordinaatidele, kui kujund on seal
        x = kaardiX - self.x
        y = kaardiY - self.y
        if self.kujund[x][y]:
            joonistaRuut(kaardiX, kaardiY, self.värv)

            return True
        else:

            return False

    def liigu(self, kaart, suund):
        deltaX = 0
        deltaY = 0
        if suund == pygame.K_LEFT:
            deltaX = -1
        elif suund == pygame.K_RIGHT:
            deltaX = 1
        elif suund == pygame.K_DOWN:
            deltaY = 1
        else:
            return

        kasSaabLiikuda = True
        for x in range(len(self.kujund)):
            for y in range(len(self.kujund[0])):
                uusX = self.x + deltaX + x
                uusY = self.y + deltaY + y
                kasSaabLiikuda &= uusX > 0
                kasSaabLiikuda &= uusY < len(kaart.kaart[0])
                kasSaabLiikuda &= uusX < len(kaart.kaart)
                if kasSaabLiikuda and self.kujund[x][y]:
                    kasSaabLiikuda &= (kaart.kaart[uusX][uusY] == 0 or kaart.kaart[uusX][uusY] == self)

        print(kasSaabLiikuda)

        if kasSaabLiikuda:
            self.kustutaKaardilt(kaart)
            self.x += deltaX
            self.y += deltaY
            self.asetaKaardile(kaart)


    def pööra(self, kaart, kasVastupäeva):
        if kasVastupäeva:
            indeks = self.pööre + 1
        else:
            indeks = self.pööre - 1

        uusKujund = self.pöörded[indeks]
        kasSaabPöörata = True
        for x in range(len(uusKujund)):
            for y in range(len(uusKujund[0])):
                if uusKujund[x][y] and (kaart.kaart[self.x + x][self.y + y] != 0 and kaart.kaart[self.x + x][self.y + y] != self):
                    kasSaabPöörata &= False

        print("Saab pöörata: " + str(kasSaabPöörata))
        if kasSaabPöörata:
            self.kustutaKaardilt(kaart)
            self.pööre = indeks
            self.kujund = uusKujund
            self.asetaKaardile(kaart)


    def kustutaKaardilt(self, kaart):
        for x in range(len(self.kujund)):
                for y in range(len(self.kujund[0])):
                    if self.kujund[x][y]:
                        kaart.kaart[self.x + x][self.y + y] = 0


    def asetaKaardile(self, kaart):
        for x in range(len(self.kujund)):
                for y in range(len(self.kujund[0])):
                    if self.kujund[x][y]:
                        kaart.kaart[self.x + x][self.y + y] = self



class KujundiGeneraator:

    def __init__(self):
        self.kujundid = [
            [
                [[False, False], [True, True], [False, False]], [[False, True], [False, True], [False, False]]
            ]
        ]
        self.värvid = [
            (100, 0, 0),
            (0, 100, 0),
            (0, 0, 100)
        ]

    def genereeri(self):

        return Kujund(10, 10, random.choice(self.kujundid), random.choice(self.värvid))


#Globaalne ruudu laius/kõrgus
ruuduLaius = 15
#Vastava suurusega aken
ekraan = pygame.display.set_mode([ruuduLaius * Kaart.laius, ruuduLaius * Kaart.kõrgus])
#Meie kaart
kaart = Kaart()

kujundiGeneraator = KujundiGeneraator()
kujund = kujundiGeneraator.genereeri()
kaart.lisaKujund(kujund)

UUENDUS = pygame.USEREVENT + 1
pygame.time.set_timer(UUENDUS, 500)


while True:
    ekraan.fill((0,0,0))

    kaart.joonista()


    pygame.display.flip()
    pygame.time.delay(10)

    events = pygame.event.get()
    for oneEvent in events:
        if oneEvent.type == UUENDUS:
            kaart.uuenda(kujund)
            if not kujund.kasElus:
                kujund = kujundiGeneraator.genereeri()
                kaart.lisaKujund(kujund)

        if oneEvent.type == pygame.KEYDOWN:
            if oneEvent.key == pygame.K_q:
                kujund.pööra(kaart, True)
            elif oneEvent.key == pygame.K_w:
                kujund.pööra(kaart, False)
            else:
                kujund.liigu(kaart, oneEvent.key)

        if oneEvent.type == pygame.QUIT:
            #quit()
            exit()
            break;