API tools faq
paste
Advertisement
jee7

TIA Tetris - Versioon 44

jee7
Nov 23rd, 2014
133
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 19.15 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.                         pygame.draw.line(ekraan, (255, 255, 255), eelminePunkt, punkt)
  143.                        
  144.                     eelminePunkt = punkt
  145.  
  146.  
  147.  
  148.     def lisaKujund(self, kujund):
  149.         kasSaabLisada = True
  150.         for lokaalneX, rida in enumerate(kujund.kujund):
  151.             for lokaalneY, lahter in enumerate(rida):
  152.                 if kujund.kujund[lokaalneX][lokaalneY]:
  153.                     kasSaabLisada &= self.kaart[kujund.x + lokaalneX][kujund.y + lokaalneY] == 0
  154.  
  155.         if kasSaabLisada:
  156.             for lokaalneX, rida in enumerate(kujund.kujund):
  157.                 for lokaalneY, lahter in enumerate(rida):
  158.                     if kujund.kujund[lokaalneX][lokaalneY]:
  159.                         self.kaart[kujund.x + lokaalneX][kujund.y + lokaalneY] = kujund;
  160.  
  161.         return kasSaabLisada
  162.  
  163.  
  164.     def kaotaRead(self):
  165.         kaardiKoopia = looKaart(self.laius, self.kõrgus)
  166.         kaardiKoopia = kopeeriKaart(kaardiKoopia, self.kaart)
  167.  
  168.         koopiaNihe = 0
  169.         self.täisRead.sort()
  170.         print(self.täisRead)
  171.         for y in self.täisRead:
  172.             print("Kaotame rea: " + str(y))
  173.             self.kaotanRiduRead.append([y, Müra(Ruut.laius, 90)])
  174.             for x in range(len(self.kaart)):
  175.                 for koopiaY in range(y, -1, -1):
  176.                     if koopiaY - koopiaNihe <= 0:
  177.                         kaardiKoopia[x][koopiaY] = 0
  178.                     else:
  179.                         kaardiKoopia[x][koopiaY] = kaardiKoopia[x][koopiaY - 1]
  180.  
  181.         self.täisRead = []
  182.         print(self.täisRead)
  183.         print("Ridade kaotamine läbi")
  184.         #self.kaart = kopeeriKaart(self.kaart, kaardiKoopia)
  185.         self.kaotanRiduKaart = kaardiKoopia
  186.         self.kaotanRiduAeg = pygame.time.get_ticks() + Kaart.reaKaotamiseAeg
  187.         self.kasKaotanRidu = True
  188.  
  189.  
  190.     def uuenda(self, kujund):
  191.         kasSaabLiikuda = kujund.y < len(self.kaart[0]) - len(kujund.kujund[0])
  192.         if kasSaabLiikuda:
  193.             for x in range(len(kujund.kujund)):
  194.                 for y in range(len(kujund.kujund[0])):
  195.                     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):
  196.                         kasSaabLiikuda = False
  197.  
  198.                     if not kasSaabLiikuda:
  199.                         break
  200.  
  201.         #Kui kujundi all on veel tühjasi ridu:
  202.         if kasSaabLiikuda:
  203.             kujund.liigu(self, pygame.K_DOWN)
  204.         else:
  205.             self.lukusta(kujund)
  206.  
  207.  
  208.     def lukusta(self, kujund):
  209.         #Kujund ei saa enam liikuda, lukustame selle kujundi (kirjutame värvid väljakule)
  210.         print("Lukusta")
  211.         kujund.kasElus = False
  212.         for x in range(len(kujund.kujund)):
  213.             for y in range(len(kujund.kujund[0])):
  214.                 if kujund.kujund[x][y]:
  215.                     self.kaart[kujund.x + x][kujund.y + y] = kujund.kujund[x][y]
  216.  
  217.         for y in range(len(kujund.kujund[0])):
  218.             kasRidaTäis = True
  219.             for x in range(len(self.kaart)):
  220.                 kasRidaTäis &= self.kaart[x][kujund.y + y] != 0
  221.  
  222.             if kasRidaTäis:
  223.                 self.täisRead.append(kujund.y + y)
  224.  
  225.      
  226. #Klass, mille objektid on erinevad kujundid
  227. class Kujund:
  228.  
  229.     def __init__(self, x, y, kujund, värv):
  230.         self.x = x             #Kujundi asukoht kaardil
  231.         self.y = y          
  232.         self.kujund = kujund[0]   #2-mõõtmeline list, mis hoiab kujundit
  233.         self.pöörded = kujund
  234.         self.pööre = 0
  235.         self.värv = värv
  236.         self.kasElus = True
  237.  
  238.         for pööre in self.pöörded:
  239.             for x in range(len(pööre)):
  240.                 for y in range(len(pööre[x])):
  241.                     if pööre[x][y]:
  242.                         pööre[x][y] = Ruut(self.värv)
  243.                    
  244.  
  245.     def joonista(self, kaardiX, kaardiY):
  246.         #Joonistame kujundi vastavatele kordinaatidele, kui kujund on seal
  247.         x = kaardiX - self.x
  248.         y = kaardiY - self.y
  249.         if x >= 0 and y >= 0 and self.kujund[x][y]:
  250.             self.kujund[x][y].joonista(kaardiX, kaardiY)
  251.  
  252.             return True
  253.         else:
  254.  
  255.             return False
  256.  
  257.     def liigu(self, kaart, suund):
  258.         deltaX = 0
  259.         deltaY = 0
  260.  
  261.         #Leiame, kui palju liikuda mingites suundades
  262.         if suund == pygame.K_LEFT:
  263.             deltaX = -1
  264.         elif suund == pygame.K_RIGHT:
  265.             deltaX = 1
  266.         elif suund == pygame.K_DOWN:
  267.             deltaY = 1
  268.         else:
  269.             return
  270.  
  271.         #Vasakul võib olla tühjasi tulpi (et kujund oleks tsentris)
  272.         vasakulTühjasiTulpi = 0
  273.         for x in range(len(self.kujund)):
  274.             kasTühi = True
  275.             for y in range(len(self.kujund[0])):
  276.                 kasTühi &= not self.kujund[x][y]
  277.  
  278.             if kasTühi:
  279.                 vasakulTühjasiTulpi += 1
  280.             else:
  281.                 break;
  282.  
  283.         #Vaatame, kas üldse saab liikuda vastavas suunas
  284.         kasSaabLiikuda = True
  285.         for x in range(len(self.kujund)):
  286.             for y in range(len(self.kujund[0])):
  287.                 uusX = self.x + deltaX + x
  288.                 uusY = self.y + deltaY + y
  289.                 kasSaabLiikuda &= uusX >= -vasakulTühjasiTulpi
  290.                 kasSaabLiikuda &= uusY < len(kaart.kaart[0])
  291.                 kasSaabLiikuda &= uusX < len(kaart.kaart)
  292.                 if kasSaabLiikuda and self.kujund[x][y]:
  293.                     #Liikuda saab siis, kui kõik uued kujundi ruudud on hetkel tühjad
  294.                     kasSaabLiikuda &= (kaart.kaart[uusX][uusY] == 0 or kaart.kaart[uusX][uusY] == self)
  295.  
  296.         if kasSaabLiikuda:
  297.             self.kustutaKaardilt(kaart)
  298.             self.x += deltaX
  299.             self.y += deltaY
  300.             self.asetaKaardile(kaart)
  301.  
  302.  
  303.     def pööra(self, kaart, kasVastupäeva):
  304.         if kasVastupäeva:
  305.             indeks = self.pööre + 1
  306.         else:
  307.             indeks = self.pööre - 1
  308.  
  309.         indeks %= len(self.pöörded)
  310.         uusKujund = self.pöörded[indeks]
  311.         kasSaabPöörata = True
  312.  
  313.         #Vaatame, kas üldse saab pöörata
  314.         for x in range(len(uusKujund)):
  315.             for y in range(len(uusKujund[0])):
  316.                 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]):
  317.                     #Pööre viib kaardilt välja, ei saa pöörata
  318.                     kasSaabPöörata &= False
  319.                     continue
  320.                
  321.                 if uusKujund[x][y] and (kaart.kaart[self.x + x][self.y + y] != 0 and kaart.kaart[self.x + x][self.y + y] != self):
  322.                     #Uus ruut ei ole vaba ruut, ei saa pöörata
  323.                     kasSaabPöörata &= False
  324.  
  325.         print("Saab pöörata: " + str(kasSaabPöörata))
  326.         if kasSaabPöörata:
  327.             self.kustutaKaardilt(kaart)
  328.             self.pööre = indeks
  329.             self.kujund = uusKujund
  330.             self.asetaKaardile(kaart)
  331.            
  332.  
  333.     def kustutaKaardilt(self, kaart):
  334.         for x in range(len(self.kujund)):
  335.             for y in range(len(self.kujund[0])):
  336.                 if self.kujund[x][y]:
  337.                     kaart.kaart[self.x + x][self.y + y] = 0
  338.  
  339.  
  340.     def asetaKaardile(self, kaart):
  341.         for x in range(len(self.kujund)):
  342.             for y in range(len(self.kujund[0])):
  343.                 if self.kujund[x][y]:
  344.                     kaart.kaart[self.x + x][self.y + y] = self
  345.  
  346.        
  347.  
  348. class KujundiGeneraator:
  349.  
  350.     def __init__(self):
  351.         self.kujundid = [
  352.             [ # --- kujund
  353.                 [[False, False, False, False], [True, True, True, True]],
  354.                 [[False, True], [False, True], [False, True], [False, True]]
  355.             ],
  356.             [ # _|_ kujund
  357.                 [[False, True, False], [True, True, True]],
  358.                 [[False, True, False], [False, True, True], [False, True, False]],
  359.                 [[False, False, False], [True, True, True], [False, True, False]],
  360.                 [[False, True], [True, True], [False, True]]
  361.             ],
  362.             [ # kasti kujund
  363.                 [[True, True], [True, True]]
  364.             ],
  365.             [ # |__ kujund
  366.                 [[True, False, False], [True, True, True]],
  367.                 [[True, True], [True, False], [True, False]],
  368.                 [[True, True, True], [False, False, True]],
  369.                 [[False, True], [False, True], [True, True]]
  370.             ],
  371.             [ # __| kujund
  372.                 [[True, True, True], [True, False, False]],
  373.                 [[True, True], [False, True], [False, True]],
  374.                 [[False, False, True], [True, True, True]],
  375.                 [[True, False], [True, False], [True, True]]
  376.             ],
  377.             [ # _|- kujund
  378.                 [[True, True, False], [False, True, True]],
  379.                 [[False, True], [True, True], [True, False]],
  380.             ],
  381.             [ # -|_ kujund
  382.                 [[False, True, True], [True, True, False]],
  383.                 [[True, False], [True, True], [False, True]],
  384.             ],
  385.         ]
  386.         self.värvid = [
  387.             (100, 0, 0),
  388.             (100, 100, 0),
  389.             (0, 100, 0),
  390.             (0, 100, 100),
  391.             (0, 0, 100),
  392.             (100, 0, 100)
  393.         ]
  394.  
  395.     def genereeri(self):
  396.  
  397.         return Kujund(10, 0, random.choice(self.kujundid), random.choice(self.värvid))
  398.  
  399.  
  400. class Mäng:
  401.  
  402.     algkiirus = 500
  403.  
  404.     def alusta(self):
  405.         self.kaart = Kaart()
  406.         self.skoor = Skoor()
  407.         self.kujundiGeneraator = kujundiGeneraator = KujundiGeneraator()
  408.         self.kasMängKäib = True
  409.         self.kiirus = Mäng.algkiirus
  410.         self.looKujund()
  411.         pygame.time.set_timer(UUENDUS, self.kiirus)
  412.  
  413.     def looKujund(self):
  414.         self.kujund = self.kujundiGeneraator.genereeri()
  415.         self.kujund.x = len(self.kaart.kaart) // 2
  416.         self.kasMängKäib &= self.kaart.lisaKujund(self.kujund)
  417.         print("Lisa kujund")
  418.  
  419.     def joonista(self):
  420.         self.kaart.joonista()
  421.         self.skoor.joonista()
  422.         if not self.kasMängKäib:
  423.             taustaPind = pygame.Surface(aknaMõõtmed, pygame.SRCALPHA)
  424.             taustaPind.fill((60, 60, 60, 200))
  425.             ekraan.blit(taustaPind, (0,0))
  426.  
  427.             tekst = font.render("Mäng läbi!", True, (200, 40, 40))
  428.             tekstiKast = tekst.get_rect()
  429.             tekstiKast.centerx = aknaMõõtmed[0] // 2 - tekstiKast[0] // 2
  430.             tekstiKast.centery = aknaMõõtmed[1] // 2 - 10
  431.             ekraan.blit(tekst, tekstiKast)
  432.  
  433.             tekst = fontVäike.render("Vajuta [SPACE] jätkamiseks!", True, (220, 220, 220))
  434.             tekstiKast = tekst.get_rect()
  435.             tekstiKast.centerx = aknaMõõtmed[0] // 2 - tekstiKast[0] // 2
  436.             tekstiKast.centery = aknaMõõtmed[1] // 2 + 10
  437.             ekraan.blit(tekst, tekstiKast)
  438.  
  439.     def muudaKiirust(self):
  440.         #self.kiirus = 2 * self.kiirus // 3
  441.         self.kiirus = int(Mäng.algkiirus * 0.7 ** (self.skoor.skoor // 10))
  442.         print("Uus kiirus: " + str(self.kiirus))
  443.  
  444.     def event(self, event):
  445.         if self.kasMängKäib:
  446.             if event.type == UUENDUS:
  447.                 self.eventUuendus()
  448.             elif event.type == pygame.KEYDOWN:
  449.                 self.eventKlahvivajutus(event.key)
  450.             else:
  451.                 self.eventMuu(event)
  452.         else:
  453.             if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
  454.                 self.alusta()
  455.        
  456.  
  457.     def eventUuendus(self):
  458.         if not self.kaart.kasKaotanRidu:
  459.             if len(self.kaart.täisRead) > 0:
  460.                 pygame.time.set_timer(UUENDUS, 0)
  461.                 self.skoor.suurenda(len(self.kaart.täisRead))
  462.                 self.kaart.kaotaRead()
  463.                 self.kaart.joonista()
  464.                 self.muudaKiirust()
  465.                 pygame.time.set_timer(UUENDUS, self.kiirus)
  466.             else:
  467.                 if not self.kujund.kasElus:
  468.                     self.looKujund()
  469.                 else:
  470.                     self.kaart.uuenda(self.kujund)
  471.  
  472.     def eventMuu(self, event):
  473.         klahvid = pygame.key.get_pressed()
  474.         if event.type == PÖÖRA_VP:
  475.             if klahvid[pygame.K_q]:
  476.                 self.kujund.pööra(self.kaart, True)
  477.                 pygame.time.set_timer(PÖÖRA_VP, 100)
  478.             else:
  479.                 pygame.time.set_timer(PÖÖRA_VP, 0)
  480.         elif event.type == PÖÖRA_PP:
  481.             if klahvid[pygame.K_w]:
  482.                 self.kujund.pööra(self.kaart, False)
  483.                 pygame.time.set_timer(PÖÖRA_PP, 100)
  484.             else:
  485.                 pygame.time.set_timer(PÖÖRA_PP, 0)
  486.         elif event.type == LIIGU:
  487.             if klahvid[pygame.K_DOWN]:
  488.                 self.kujund.liigu(self.kaart, pygame.K_DOWN)
  489.                 pygame.time.set_timer(LIIGU, 100)
  490.             elif klahvid[pygame.K_LEFT]:
  491.                 self.kujund.liigu(self.kaart, pygame.K_LEFT)
  492.                 pygame.time.set_timer(LIIGU, 100)
  493.             elif klahvid[pygame.K_RIGHT]:
  494.                 self.kujund.liigu(self.kaart, pygame.K_RIGHT)
  495.                 pygame.time.set_timer(LIIGU, 100)
  496.             else:
  497.                 pygame.time.set_timer(LIIGU, 0)
  498.        
  499.  
  500.     def eventKlahvivajutus(self, klahv):
  501.         if klahv == pygame.K_q:
  502.             self.kujund.pööra(self.kaart, True)
  503.             pygame.time.set_timer(PÖÖRA_VP, 300)
  504.         elif klahv == pygame.K_w:
  505.             self.kujund.pööra(self.kaart, False)
  506.             pygame.time.set_timer(PÖÖRA_PP, 300)
  507.         else:
  508.             self.kujund.liigu(self.kaart, klahv)
  509.             pygame.time.set_timer(LIIGU, 300)
  510.  
  511.        
  512.    
  513. #Alustame Pygame asju
  514. pygame.init()
  515. #Vastava suurusega aken (globaalsed muutujad)
  516. aknaMõõtmed = [Ruut.laius * Kaart.laius, Ruut.laius * Kaart.kõrgus + 20]
  517. ekraan = pygame.display.set_mode(aknaMõõtmed)
  518.  
  519. #Globaalne font
  520. font = pygame.font.SysFont("monospace", 14)
  521. fontVäike = pygame.font.SysFont("monospace", 12)
  522.  
  523. #Globaalsed evendid
  524. UUENDUS = pygame.USEREVENT + 1
  525. LIIGU = pygame.USEREVENT + 2
  526. PÖÖRA_VP = pygame.USEREVENT + 3
  527. PÖÖRA_PP = pygame.USEREVENT + 4
  528.  
  529. mäng = Mäng()
  530. mäng.alusta()
  531.  
  532.  
  533. while True:
  534.     ekraan.fill((0,0,0))
  535.  
  536.     mäng.joonista()
  537.  
  538.     pygame.display.flip()
  539.     pygame.time.delay(10)
  540.  
  541.     events = pygame.event.get()
  542.     for event in events:
  543.         mäng.event(event)
  544.  
  545.         if event.type == pygame.QUIT:
  546.             #quit()
  547.             exit()
  548.             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!