TIA Tetris - Versioon 27

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 = 10  #niipalju ruute laiuses
    kõrgus = 20 #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)

        self.täisRead = []

    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:
                    #Seda osa ei tohiks kunagi juhtuda... kustutada pärast ära.
                    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 kaotaRead(self):
        for y in self.täisRead:
            print("Kaotame rea: " + str(y))
            self.täisRead.remove(y)
            for x in range(len(self.kaart)):
                self.kaart[x][y] = 0


    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

        for y in range(len(kujund.kujund[0])):
            kasRidaTäis = True
            for x in range(len(self.kaart)):
                kasRidaTäis &= self.kaart[x][kujund.y + y] != 0

            if kasRidaTäis:
                self.täisRead.append(kujund.y + y)


#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 x >= 0 and y >= 0 and self.kujund[x][y]:
            joonistaRuut(kaardiX, kaardiY, self.värv)

            return True
        else:

            return False

    def liigu(self, kaart, suund):
        deltaX = 0
        deltaY = 0

        #Leiame, kui palju liikuda mingites suundades
        if suund == pygame.K_LEFT:
            deltaX = -1
        elif suund == pygame.K_RIGHT:
            deltaX = 1
        elif suund == pygame.K_DOWN:
            deltaY = 1
        else:
            return

        #Vasakul võib olla tühjasi tulpi (et kujund oleks tsentris)
        vasakulTühjasiTulpi = 0
        for x in range(len(self.kujund)):
            kasTühi = True
            for y in range(len(self.kujund[0])):
                kasTühi &= not self.kujund[x][y]

            if kasTühi:
                vasakulTühjasiTulpi += 1
            else:
                break;

        #Vaatame, kas üldse saab liikuda vastavas suunas
        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 >= -vasakulTühjasiTulpi
                kasSaabLiikuda &= uusY < len(kaart.kaart[0])
                kasSaabLiikuda &= uusX < len(kaart.kaart)
                if kasSaabLiikuda and self.kujund[x][y]:
                    #Liikuda saab siis, kui kõik uued kujundi ruudud on hetkel tühjad
                    kasSaabLiikuda &= (kaart.kaart[uusX][uusY] == 0 or kaart.kaart[uusX][uusY] == self)

        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

        indeks %= len(self.pöörded)
        uusKujund = self.pöörded[indeks]
        kasSaabPöörata = True

        #Vaatame, kas üldse saab pöörata
        for x in range(len(uusKujund)):
            for y in range(len(uusKujund[0])):
                if self.x + x < 0 or self.x + x >= len(kaart.kaart) or self.y + y < 0 or self.y + y >= len(kaart.kaart[0]):
                    #Pööre viib kaardilt välja, ei saa pöörata
                    kasSaabPöörata &= False
                    continue

                if uusKujund[x][y] and (kaart.kaart[self.x + x][self.y + y] != 0 and kaart.kaart[self.x + x][self.y + y] != self):
                    #Uus ruut ei ole vaba ruut, ei saa pöörata
                    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 = [
            [ # --- kujund
                [[False, False, False], [True, True, True]],
                [[False, True], [False, True], [False, True]]
            ],
            [ # _|_ kujund
                [[False, True, False], [True, True, True]],
                [[False, True, False], [False, True, True], [False, True, False]],
                [[False, False, False], [True, True, True], [False, True, False]],
                [[False, True], [True, True], [False, True]]
            ]
        ]
        self.värvid = [
            (100, 0, 0),
            (0, 100, 0),
            (0, 0, 100)
        ]

    def genereeri(self):

        return Kujund(10, 0, 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()
kujund.x = len(kaart.kaart) // 2
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 len(kaart.täisRead) > 0:
            kaart.kaotaRead()
        else:
            if oneEvent.type == UUENDUS:
                kaart.uuenda(kujund)
                if not kujund.kasElus:
                    kujund = kujundiGeneraator.genereeri()
                    kujund.x = len(kaart.kaart) // 2
                    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;