API tools faq
paste
Advertisement
jee7

TIA Tetris - Versioon 45

jee7
Nov 23rd, 2014
200
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 19.28 KB | None | 0 0
raw download clone embed print report
  1. import pygame, random, math
  2.  
  3. def looKaart(laius, kõrgus, sümbol = 0):
  4.     kaart = []
  5.     for x in range(laius):
  6.             kaart.append([])
  7.             for y in range(kõrgus):
  8.                 kaart[x].append(sümbol)
  9.  
  10.     return kaart
  11.  
  12.  
  13. def kopeeriKaart(kaart1, kaart2):
  14.     for x in range(len(kaart2)):
  15.         for y in range(len(kaart2[0])):
  16.             kaart1[x][y] = kaart2[x][y]
  17.  
  18.     return kaart1
  19.  
  20.  
  21. class Ruut:
  22.     laius = 15
  23.  
  24.     def __init__(self, värv = 0):
  25.         self.värv = värv
  26.  
  27.     def joonista(self, x, y):
  28.         äärX = Kaart.äärX
  29.         äärY = Kaart.äärY
  30.        
  31.         if self.värv == 0:
  32.             pygame.draw.rect(ekraan, (20, 20, 20), (äärX + x * Ruut.laius, äärY + y * Ruut.laius, Ruut.laius, Ruut.laius))
  33.             pygame.draw.rect(ekraan, (0, 0, 0), (äärX + x * Ruut.laius + 1, äärY + y * Ruut.laius + 1, Ruut.laius - 2, Ruut.laius - 2))
  34.         else:
  35.             värv = self.värv
  36.             alumineVärv = (max(0, värv[0] - 10), max(0, värv[1] - 10), max(0, värv[2] - 10))
  37.             pygame.draw.rect(ekraan, alumineVärv, (äärX + x * Ruut.laius, äärY + y * Ruut.laius, Ruut.laius, Ruut.laius))
  38.  
  39.             ülemineVärv = [min(üksVärv + 10, 255) for üksVärv in värv]
  40.             pygame.draw.rect(ekraan, ülemineVärv, (äärX + x * Ruut.laius, äärY + y * Ruut.laius, Ruut.laius - 1, Ruut.laius - 1))
  41.  
  42.             pygame.draw.rect(ekraan, värv, (äärX + x * Ruut.laius + 1, äärY + y * Ruut.laius + 1, Ruut.laius - 2, Ruut.laius - 2))
  43.                
  44.        
  45.  
  46. class Skoor:
  47.  
  48.     def __init__(self):
  49.         self.skoor = 0
  50.  
  51.     def suurenda(self, ridadeArv):
  52.         if ridadeArv == 1:
  53.             self.skoor = self.skoor + 1
  54.         elif ridadeArv == 2:
  55.             self.skoor = self.skoor + 3
  56.         elif ridadeArv == 3:
  57.             self.skoor = self.skoor + 5
  58.         elif ridadeArv == 4:
  59.             self.skoor = self.skoor + 8
  60.  
  61.     def joonista(self):
  62.         tekst = font.render("Skoor: " + str(self.skoor), True, (200, 200, 200))
  63.         ekraan.blit(tekst, (5, 2))
  64.  
  65.  
  66. class Müra:
  67.  
  68.     def __init__(self, amplituud, sagedus, kasSujuv = True):
  69.         self.punktid = random.sample(range(100000 * amplituud), sagedus)
  70.         self.punktid = [x / 100000 for x in self.punktid]
  71.         if kasSujuv:
  72.             self.sujuvda()
  73.  
  74.     def sujuvda(self):
  75.         uuedPunktid = [self.punktid[0]]
  76.         for i in range(1, len(self.punktid) - 1):
  77.             uuedPunktid.append(0.25 * self.punktid[i - 1] + 0.5 * self.punktid[i] + 0.25 * self.punktid[i+1])
  78.  
  79.         uuedPunktid.append(self.punktid[len(self.punktid) - 1])
  80.         self.punktid = uuedPunktid
  81.  
  82.     def interpoleeri(self, eelmine, järgmine, x):
  83.         x = x * math.pi
  84.         kaal = 0.5 * (1 - math.cos(x))
  85.  
  86.         return eelmine * (1 - kaal) + järgmine * kaal
  87.  
  88.     def sämpli(self, x, laius):
  89.         müraXtäpne = x * len(self.punktid) / laius
  90.         müraX = int(müraXtäpne)
  91.         müraY = int(self.interpoleeri(self.punktid[müraX - 1], self.punktid[müraX], müraX - müraXtäpne))
  92.  
  93.         return müraY
  94.        
  95.  
  96. #See klass hoiab väljaku seisu ja oskab seda joonistada
  97. class Kaart:
  98.     laius = 10  #niipalju ruute laiuses
  99.     kõrgus = 15 #niipalju ruute kõrguses
  100.     äärX = 0
  101.     äärY = 20
  102.     tühiRuut = Ruut(0)
  103.     reaKaotamiseAeg = 1000
  104.  
  105.     def __init__(self):
  106.         #Teeme 2-mõõtmelise listi
  107.         self.kaart = looKaart(self.laius, self.kõrgus)
  108.         self.täisRead = []
  109.         self.kasKaotanRidu = False
  110.         self.kaotanRiduKaart = False
  111.         self.kaotanRiduRead = []
  112.         self.kaotanRiduAeg = False
  113.        
  114.  
  115.     def joonista(self):
  116.         #Joonistame ruudud
  117.         for x, rida in enumerate(self.kaart):
  118.             for y, lahter in enumerate(rida):
  119.                 kasJoonistas = False
  120.                 if lahter != 0:
  121.                     kasJoonistas = lahter.joonista(x, y)
  122.                 if lahter == 0:
  123.                     Kaart.tühiRuut.joonista(x, y)
  124.  
  125.         #Rea kaotamise animatsioon
  126.         if self.kasKaotanRidu:
  127.             vaheAeg = self.kaotanRiduAeg - pygame.time.get_ticks()
  128.             if vaheAeg < 0:
  129.                 self.kaotanRiduAeg = False
  130.                 self.kaotanRiduRead = []
  131.                 self.kasKaotanRidu = False
  132.                 self.kaart = kopeeriKaart(self.kaart, self.kaotanRiduKaart)
  133.             protsent = 1 - vaheAeg / Kaart.reaKaotamiseAeg
  134.            
  135.             for rida in self.kaotanRiduRead:
  136.                 eelminePunkt = False
  137.                 for x in range(0, int(protsent * Kaart.laius * Ruut.laius)):
  138.                     müraY = rida[1].sämpli(x, Kaart.laius * Ruut.laius)
  139.            
  140.                     punkt = [x, Kaart.äärY + rida[0] * Ruut.laius + müraY]
  141.                     if eelminePunkt:
  142.                         sinine = 100 + 150 * (müraY / Ruut.laius)
  143.                         muu = 50 + 150 * (1 - sinine / 255)
  144.                         pygame.draw.aaline(ekraan, (muu, muu, sinine), eelminePunkt, punkt)
  145.                        
  146.                     eelminePunkt = punkt
  147.  
  148.  
  149.  
  150.     def lisaKujund(self, kujund):
  151.         kasSaabLisada = True
  152.         for lokaalneX, rida in enumerate(kujund.kujund):
  153.             for lokaalneY, lahter in enumerate(rida):
  154.                 if kujund.kujund[lokaalneX][lokaalneY]:
  155.                     kasSaabLisada &= self.kaart[kujund.x + lokaalneX][kujund.y + lokaalneY] == 0
  156.  
  157.         if kasSaabLisada:
  158.             for lokaalneX, rida in enumerate(kujund.kujund):
  159.                 for lokaalneY, lahter in enumerate(rida):
  160.                     if kujund.kujund[lokaalneX][lokaalneY]:
  161.                         self.kaart[kujund.x + lokaalneX][kujund.y + lokaalneY] = kujund;
  162.  
  163.         return kasSaabLisada
  164.  
  165.  
  166.     def kaotaRead(self):
  167.         kaardiKoopia = looKaart(self.laius, self.kõrgus)
  168.         kaardiKoopia = kopeeriKaart(kaardiKoopia, self.kaart)
  169.  
  170.         koopiaNihe = 0
  171.         self.täisRead.sort()
  172.         print(self.täisRead)
  173.         for y in self.täisRead:
  174.             print("Kaotame rea: " + str(y))
  175.             self.kaotanRiduRead.append([y, Müra(Ruut.laius, 90)])
  176.             for x in range(len(self.kaart)):
  177.                 for koopiaY in range(y, -1, -1):
  178.                     if koopiaY - koopiaNihe <= 0:
  179.                         kaardiKoopia[x][koopiaY] = 0
  180.                     else:
  181.                         kaardiKoopia[x][koopiaY] = kaardiKoopia[x][koopiaY - 1]
  182.  
  183.         self.täisRead = []
  184.         print(self.täisRead)
  185.         print("Ridade kaotamine läbi")
  186.         #self.kaart = kopeeriKaart(self.kaart, kaardiKoopia)
  187.         self.kaotanRiduKaart = kaardiKoopia
  188.         self.kaotanRiduAeg = pygame.time.get_ticks() + Kaart.reaKaotamiseAeg
  189.         self.kasKaotanRidu = True
  190.  
  191.  
  192.     def uuenda(self, kujund):
  193.         kasSaabLiikuda = kujund.y < len(self.kaart[0]) - len(kujund.kujund[0])
  194.         if kasSaabLiikuda:
  195.             for x in range(len(kujund.kujund)):
  196.                 for y in range(len(kujund.kujund[0])):
  197.                     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):
  198.                         kasSaabLiikuda = False
  199.  
  200.                     if not kasSaabLiikuda:
  201.                         break
  202.  
  203.         #Kui kujundi all on veel tühjasi ridu:
  204.         if kasSaabLiikuda:
  205.             kujund.liigu(self, pygame.K_DOWN)
  206.         else:
  207.             self.lukusta(kujund)
  208.  
  209.  
  210.     def lukusta(self, kujund):
  211.         #Kujund ei saa enam liikuda, lukustame selle kujundi (kirjutame värvid väljakule)
  212.         print("Lukusta")
  213.         kujund.kasElus = False
  214.         for x in range(len(kujund.kujund)):
  215.             for y in range(len(kujund.kujund[0])):
  216.                 if kujund.kujund[x][y]:
  217.                     self.kaart[kujund.x + x][kujund.y + y] = kujund.kujund[x][y]
  218.  
  219.         for y in range(len(kujund.kujund[0])):
  220.             kasRidaTäis = True
  221.             for x in range(len(self.kaart)):
  222.                 kasRidaTäis &= self.kaart[x][kujund.y + y] != 0
  223.  
  224.             if kasRidaTäis:
  225.                 self.täisRead.append(kujund.y + y)
  226.  
  227.      
  228. #Klass, mille objektid on erinevad kujundid
  229. class Kujund:
  230.  
  231.     def __init__(self, x, y, kujund, värv):
  232.         self.x = x             #Kujundi asukoht kaardil
  233.         self.y = y          
  234.         self.kujund = kujund[0]   #2-mõõtmeline list, mis hoiab kujundit
  235.         self.pöörded = kujund
  236.         self.pööre = 0
  237.         self.värv = värv
  238.         self.kasElus = True
  239.  
  240.         for pööre in self.pöörded:
  241.             for x in range(len(pööre)):
  242.                 for y in range(len(pööre[x])):
  243.                     if pööre[x][y]:
  244.                         pööre[x][y] = Ruut(self.värv)
  245.                    
  246.  
  247.     def joonista(self, kaardiX, kaardiY):
  248.         #Joonistame kujundi vastavatele kordinaatidele, kui kujund on seal
  249.         x = kaardiX - self.x
  250.         y = kaardiY - self.y
  251.         if x >= 0 and y >= 0 and self.kujund[x][y]:
  252.             self.kujund[x][y].joonista(kaardiX, kaardiY)
  253.  
  254.             return True
  255.         else:
  256.  
  257.             return False
  258.  
  259.     def liigu(self, kaart, suund):
  260.         deltaX = 0
  261.         deltaY = 0
  262.  
  263.         #Leiame, kui palju liikuda mingites suundades
  264.         if suund == pygame.K_LEFT:
  265.             deltaX = -1
  266.         elif suund == pygame.K_RIGHT:
  267.             deltaX = 1
  268.         elif suund == pygame.K_DOWN:
  269.             deltaY = 1
  270.         else:
  271.             return
  272.  
  273.         #Vasakul võib olla tühjasi tulpi (et kujund oleks tsentris)
  274.         vasakulTühjasiTulpi = 0
  275.         for x in range(len(self.kujund)):
  276.             kasTühi = True
  277.             for y in range(len(self.kujund[0])):
  278.                 kasTühi &= not self.kujund[x][y]
  279.  
  280.             if kasTühi:
  281.                 vasakulTühjasiTulpi += 1
  282.             else:
  283.                 break;
  284.  
  285.         #Vaatame, kas üldse saab liikuda vastavas suunas
  286.         kasSaabLiikuda = True
  287.         for x in range(len(self.kujund)):
  288.             for y in range(len(self.kujund[0])):
  289.                 uusX = self.x + deltaX + x
  290.                 uusY = self.y + deltaY + y
  291.                 kasSaabLiikuda &= uusX >= -vasakulTühjasiTulpi
  292.                 kasSaabLiikuda &= uusY < len(kaart.kaart[0])
  293.                 kasSaabLiikuda &= uusX < len(kaart.kaart)
  294.                 if kasSaabLiikuda and self.kujund[x][y]:
  295.                     #Liikuda saab siis, kui kõik uued kujundi ruudud on hetkel tühjad
  296.                     kasSaabLiikuda &= (kaart.kaart[uusX][uusY] == 0 or kaart.kaart[uusX][uusY] == self)
  297.  
  298.         if kasSaabLiikuda:
  299.             self.kustutaKaardilt(kaart)
  300.             self.x += deltaX
  301.             self.y += deltaY
  302.             self.asetaKaardile(kaart)
  303.  
  304.  
  305.     def pööra(self, kaart, kasVastupäeva):
  306.         if kasVastupäeva:
  307.             indeks = self.pööre + 1
  308.         else:
  309.             indeks = self.pööre - 1
  310.  
  311.         indeks %= len(self.pöörded)
  312.         uusKujund = self.pöörded[indeks]
  313.         kasSaabPöörata = True
  314.  
  315.         #Vaatame, kas üldse saab pöörata
  316.         for x in range(len(uusKujund)):
  317.             for y in range(len(uusKujund[0])):
  318.                 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]):
  319.                     #Pööre viib kaardilt välja, ei saa pöörata
  320.                     kasSaabPöörata &= False
  321.                     continue
  322.                
  323.                 if uusKujund[x][y] and (kaart.kaart[self.x + x][self.y + y] != 0 and kaart.kaart[self.x + x][self.y + y] != self):
  324.                     #Uus ruut ei ole vaba ruut, ei saa pöörata
  325.                     kasSaabPöörata &= False
  326.  
  327.         print("Saab pöörata: " + str(kasSaabPöörata))
  328.         if kasSaabPöörata:
  329.             self.kustutaKaardilt(kaart)
  330.             self.pööre = indeks
  331.             self.kujund = uusKujund
  332.             self.asetaKaardile(kaart)
  333.            
  334.  
  335.     def kustutaKaardilt(self, kaart):
  336.         for x in range(len(self.kujund)):
  337.             for y in range(len(self.kujund[0])):
  338.                 if self.kujund[x][y]:
  339.                     kaart.kaart[self.x + x][self.y + y] = 0
  340.  
  341.  
  342.     def asetaKaardile(self, kaart):
  343.         for x in range(len(self.kujund)):
  344.             for y in range(len(self.kujund[0])):
  345.                 if self.kujund[x][y]:
  346.                     kaart.kaart[self.x + x][self.y + y] = self
  347.  
  348.        
  349.  
  350. class KujundiGeneraator:
  351.  
  352.     def __init__(self):
  353.         self.kujundid = [
  354.             [ # --- kujund
  355.                 [[False, False, False, False], [True, True, True, True]],
  356.                 [[False, True], [False, True], [False, True], [False, True]]
  357.             ],
  358.             [ # _|_ kujund
  359.                 [[False, True, False], [True, True, True]],
  360.                 [[False, True, False], [False, True, True], [False, True, False]],
  361.                 [[False, False, False], [True, True, True], [False, True, False]],
  362.                 [[False, True], [True, True], [False, True]]
  363.             ],
  364.             [ # kasti kujund
  365.                 [[True, True], [True, True]]
  366.             ],
  367.             [ # |__ kujund
  368.                 [[True, False, False], [True, True, True]],
  369.                 [[True, True], [True, False], [True, False]],
  370.                 [[True, True, True], [False, False, True]],
  371.                 [[False, True], [False, True], [True, True]]
  372.             ],
  373.             [ # __| kujund
  374.                 [[True, True, True], [True, False, False]],
  375.                 [[True, True], [False, True], [False, True]],
  376.                 [[False, False, True], [True, True, True]],
  377.                 [[True, False], [True, False], [True, True]]
  378.             ],
  379.             [ # _|- kujund
  380.                 [[True, True, False], [False, True, True]],
  381.                 [[False, True], [True, True], [True, False]],
  382.             ],
  383.             [ # -|_ kujund
  384.                 [[False, True, True], [True, True, False]],
  385.                 [[True, False], [True, True], [False, True]],
  386.             ],
  387.         ]
  388.         self.värvid = [
  389.             (100, 0, 0),
  390.             (100, 100, 0),
  391.             (0, 100, 0),
  392.             (0, 100, 100),
  393.             (0, 0, 100),
  394.             (100, 0, 100)
  395.         ]
  396.  
  397.     def genereeri(self):
  398.  
  399.         return Kujund(10, 0, random.choice(self.kujundid), random.choice(self.värvid))
  400.  
  401.  
  402. class Mäng:
  403.  
  404.     algkiirus = 500
  405.  
  406.     def alusta(self):
  407.         self.kaart = Kaart()
  408.         self.skoor = Skoor()
  409.         self.kujundiGeneraator = kujundiGeneraator = KujundiGeneraator()
  410.         self.kasMängKäib = True
  411.         self.kiirus = Mäng.algkiirus
  412.         self.looKujund()
  413.         pygame.time.set_timer(UUENDUS, self.kiirus)
  414.  
  415.     def looKujund(self):
  416.         self.kujund = self.kujundiGeneraator.genereeri()
  417.         self.kujund.x = len(self.kaart.kaart) // 2
  418.         self.kasMängKäib &= self.kaart.lisaKujund(self.kujund)
  419.         print("Lisa kujund")
  420.  
  421.     def joonista(self):
  422.         self.kaart.joonista()
  423.         self.skoor.joonista()
  424.         if not self.kasMängKäib:
  425.             taustaPind = pygame.Surface(aknaMõõtmed, pygame.SRCALPHA)
  426.             taustaPind.fill((60, 60, 60, 200))
  427.             ekraan.blit(taustaPind, (0,0))
  428.  
  429.             tekst = font.render("Mäng läbi!", True, (200, 40, 40))
  430.             tekstiKast = tekst.get_rect()
  431.             tekstiKast.centerx = aknaMõõtmed[0] // 2 - tekstiKast[0] // 2
  432.             tekstiKast.centery = aknaMõõtmed[1] // 2 - 10
  433.             ekraan.blit(tekst, tekstiKast)
  434.  
  435.             tekst = fontVäike.render("Vajuta [SPACE] jätkamiseks!", True, (220, 220, 220))
  436.             tekstiKast = tekst.get_rect()
  437.             tekstiKast.centerx = aknaMõõtmed[0] // 2 - tekstiKast[0] // 2
  438.             tekstiKast.centery = aknaMõõtmed[1] // 2 + 10
  439.             ekraan.blit(tekst, tekstiKast)
  440.  
  441.     def muudaKiirust(self):
  442.         #self.kiirus = 2 * self.kiirus // 3
  443.         self.kiirus = int(Mäng.algkiirus * 0.7 ** (self.skoor.skoor // 10))
  444.         print("Uus kiirus: " + str(self.kiirus))
  445.  
  446.     def event(self, event):
  447.         if self.kasMängKäib:
  448.             if event.type == UUENDUS:
  449.                 self.eventUuendus()
  450.             elif event.type == pygame.KEYDOWN:
  451.                 self.eventKlahvivajutus(event.key)
  452.             else:
  453.                 self.eventMuu(event)
  454.         else:
  455.             if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
  456.                 self.alusta()
  457.        
  458.  
  459.     def eventUuendus(self):
  460.         if not self.kaart.kasKaotanRidu:
  461.             if len(self.kaart.täisRead) > 0:
  462.                 pygame.time.set_timer(UUENDUS, 0)
  463.                 self.skoor.suurenda(len(self.kaart.täisRead))
  464.                 self.kaart.kaotaRead()
  465.                 self.kaart.joonista()
  466.                 self.muudaKiirust()
  467.                 pygame.time.set_timer(UUENDUS, self.kiirus)
  468.             else:
  469.                 if not self.kujund.kasElus:
  470.                     self.looKujund()
  471.                 else:
  472.                     self.kaart.uuenda(self.kujund)
  473.  
  474.     def eventMuu(self, event):
  475.         klahvid = pygame.key.get_pressed()
  476.         if event.type == PÖÖRA_VP:
  477.             if klahvid[pygame.K_q]:
  478.                 self.kujund.pööra(self.kaart, True)
  479.                 pygame.time.set_timer(PÖÖRA_VP, 100)
  480.             else:
  481.                 pygame.time.set_timer(PÖÖRA_VP, 0)
  482.         elif event.type == PÖÖRA_PP:
  483.             if klahvid[pygame.K_w]:
  484.                 self.kujund.pööra(self.kaart, False)
  485.                 pygame.time.set_timer(PÖÖRA_PP, 100)
  486.             else:
  487.                 pygame.time.set_timer(PÖÖRA_PP, 0)
  488.         elif event.type == LIIGU:
  489.             if klahvid[pygame.K_DOWN]:
  490.                 self.kujund.liigu(self.kaart, pygame.K_DOWN)
  491.                 pygame.time.set_timer(LIIGU, 100)
  492.             elif klahvid[pygame.K_LEFT]:
  493.                 self.kujund.liigu(self.kaart, pygame.K_LEFT)
  494.                 pygame.time.set_timer(LIIGU, 100)
  495.             elif klahvid[pygame.K_RIGHT]:
  496.                 self.kujund.liigu(self.kaart, pygame.K_RIGHT)
  497.                 pygame.time.set_timer(LIIGU, 100)
  498.             else:
  499.                 pygame.time.set_timer(LIIGU, 0)
  500.        
  501.  
  502.     def eventKlahvivajutus(self, klahv):
  503.         if klahv == pygame.K_q:
  504.             self.kujund.pööra(self.kaart, True)
  505.             pygame.time.set_timer(PÖÖRA_VP, 300)
  506.         elif klahv == pygame.K_w:
  507.             self.kujund.pööra(self.kaart, False)
  508.             pygame.time.set_timer(PÖÖRA_PP, 300)
  509.         else:
  510.             self.kujund.liigu(self.kaart, klahv)
  511.             pygame.time.set_timer(LIIGU, 300)
  512.  
  513.        
  514.    
  515. #Alustame Pygame asju
  516. pygame.init()
  517. #Vastava suurusega aken (globaalsed muutujad)
  518. aknaMõõtmed = [Ruut.laius * Kaart.laius, Ruut.laius * Kaart.kõrgus + 20]
  519. ekraan = pygame.display.set_mode(aknaMõõtmed)
  520.  
  521. #Globaalne font
  522. font = pygame.font.SysFont("monospace", 14)
  523. fontVäike = pygame.font.SysFont("monospace", 12)
  524.  
  525. #Globaalsed evendid
  526. UUENDUS = pygame.USEREVENT + 1
  527. LIIGU = pygame.USEREVENT + 2
  528. PÖÖRA_VP = pygame.USEREVENT + 3
  529. PÖÖRA_PP = pygame.USEREVENT + 4
  530.  
  531. mäng = Mäng()
  532. mäng.alusta()
  533.  
  534.  
  535. while True:
  536.     ekraan.fill((0,0,0))
  537.  
  538.     mäng.joonista()
  539.  
  540.     pygame.display.flip()
  541.     pygame.time.delay(10)
  542.  
  543.     events = pygame.event.get()
  544.     for event in events:
  545.         mäng.event(event)
  546.  
  547.         if event.type == pygame.QUIT:
  548.             #quit()
  549.             exit()
  550.             break;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!