Esempio n. 1
0
    def render(self, x=0, y=0):
        if self.mode == "G0":
            dispsurf0.lock()
            self.pixy = 0
            self.pixx = 0
            self.chunkcnt = 0
            self.addr = self.offset
            self.chunk = self.membus[libSBTCVM.numstruct(self.addr)]
            while self.pixy != 81:
                self.pixx = 0
                while self.pixx != 114:
                    if self.chunkcnt == 0:
                        self.chunkcnt = 1
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[6]) + (self.chunk[7]) +
                                     (self.chunk[8]))
                    elif self.chunkcnt == 1:
                        self.chunkcnt = 2
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[9]) + (self.chunk[10]) +
                                     (self.chunk[11]))
                    elif self.chunkcnt == 2:
                        self.chunkcnt = 0

                        self.part = ((self.chunk[12]) + (self.chunk[13]) +
                                     (self.chunk[14]))
                        self.addr = libSBTCVM.trunkto6(
                            libbaltcalc.btadd(self.addr, "+"))
                        self.chunk = self.membus[libSBTCVM.numstruct(
                            self.addr)]
                    self.R1 = shadlook0(self.part[0])
                    self.G1 = shadlook0(self.part[1])
                    self.B1 = shadlook0(self.part[2])
                    #print (self.R1, self.G1, self.B1)
                    #dispsurf0.set_at((self.pixx, self.pixy),(self.R1, self.G1, self.B1))
                    dispsurf0pixarray[self.pixx,
                                      self.pixy] = (self.R1, self.G1, self.B1)
                    self.pixx += 1
                self.pixy += 1
            dispsurf0.unlock()
            return self.screensurf.blit(
                pygame.transform.scale(dispsurf0, (648, 460)), (x, y))
        if self.mode == "G2":
            dispsurf0.lock()
            self.pixy = 0
            self.pixx = 0
            self.chunkcnt = 0
            self.addr = self.offset
            self.chunk = self.membus[libSBTCVM.numstruct(self.addr)]
            while self.pixy != 81:
                self.pixx = 0
                while self.pixx != 114:
                    if self.chunkcnt == 0:
                        self.chunkcnt = 1
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[6]))
                    elif self.chunkcnt == 1:
                        self.chunkcnt = 2
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[7]))
                    elif self.chunkcnt == 2:
                        self.chunkcnt = 3
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[8]))
                    elif self.chunkcnt == 3:
                        self.chunkcnt = 4
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[9]))
                    elif self.chunkcnt == 4:
                        self.chunkcnt = 5
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[10]))
                    elif self.chunkcnt == 5:
                        self.chunkcnt = 6
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[11]))
                    elif self.chunkcnt == 6:
                        self.chunkcnt = 7
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[12]))
                    elif self.chunkcnt == 7:
                        self.chunkcnt = 8
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[13]))
                    elif self.chunkcnt == 8:
                        self.chunkcnt = 0

                        self.part = ((self.chunk[14]))
                        self.addr = libSBTCVM.trunkto6(
                            libbaltcalc.btadd(self.addr, "+"))
                        self.chunk = self.membus[libSBTCVM.numstruct(
                            self.addr)]
                    self.GREY = shadlook0mapped0(self.part)
                    #dispsurf0.set_at((self.pixx, self.pixy),(self.GREY, self.GREY, self.GREY))
                    dispsurf0pixarray[self.pixx, self.pixy] = self.GREY
                    #print self.chunkcnt
                    #print self.pixx
                    #print self.pixy
                    self.pixx += 1
                self.pixy += 1
            dispsurf0.unlock()
            return self.screensurf.blit(
                pygame.transform.scale(dispsurf0, (648, 460)), (x, y))
        if self.mode == "G3":
            dispsurf1.lock()
            self.pixy = 0
            self.pixx = 0
            self.chunkcnt = 0
            self.addr = self.offset
            self.chunk = self.membus[libSBTCVM.numstruct(self.addr)]
            while self.pixy != 38:
                self.pixx = 0
                while self.pixx != 54:
                    if self.chunkcnt == 0:
                        self.chunkcnt = 1
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[6]) + (self.chunk[7]) +
                                     (self.chunk[8]))
                    elif self.chunkcnt == 1:
                        self.chunkcnt = 2
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[9]) + (self.chunk[10]) +
                                     (self.chunk[11]))
                    elif self.chunkcnt == 2:
                        self.chunkcnt = 0

                        self.part = ((self.chunk[12]) + (self.chunk[13]) +
                                     (self.chunk[14]))
                        self.addr = libSBTCVM.trunkto6(
                            libbaltcalc.btadd(self.addr, "+"))
                        self.chunk = self.membus[libSBTCVM.numstruct(
                            self.addr)]
                    self.R1 = shadlook0(self.part[0])
                    self.G1 = shadlook0(self.part[1])
                    self.B1 = shadlook0(self.part[2])
                    #print (self.R1, self.G1, self.B1)
                    #dispsurf1.set_at((self.pixx, self.pixy),(self.R1, self.G1, self.B1))
                    dispsurf1pixarray[self.pixx,
                                      self.pixy] = (self.R1, self.G1, self.B1)
                    self.pixx += 1
                self.pixy += 1
            dispsurf1.unlock()
            return self.screensurf.blit(
                pygame.transform.scale(dispsurf1, (648, 460)), (x, y))
        if self.mode == "G4":
            dispsurf1.lock()
            self.pixy = 0
            self.pixx = 0
            self.chunkcnt = 0
            self.addr = self.offset
            self.chunk = self.membus[libSBTCVM.numstruct(self.addr)]
            while self.pixy != 38:
                self.pixx = 0
                while self.pixx != 54:
                    if self.chunkcnt == 0:
                        self.chunkcnt = 1
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[6]))
                    elif self.chunkcnt == 1:
                        self.chunkcnt = 2
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[7]))
                    elif self.chunkcnt == 2:
                        self.chunkcnt = 3
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[8]))
                    elif self.chunkcnt == 3:
                        self.chunkcnt = 4
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[9]))
                    elif self.chunkcnt == 4:
                        self.chunkcnt = 5
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[10]))
                    elif self.chunkcnt == 5:
                        self.chunkcnt = 6
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[11]))
                    elif self.chunkcnt == 6:
                        self.chunkcnt = 7
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[12]))
                    elif self.chunkcnt == 7:
                        self.chunkcnt = 8
                        #self.chunk=self.membus[libSBTCVM.numstruct(self.addr)]
                        self.part = ((self.chunk[13]))
                    elif self.chunkcnt == 8:
                        self.chunkcnt = 0
                        self.part = ((self.chunk[14]))
                        self.addr = libSBTCVM.trunkto6(
                            libbaltcalc.btadd(self.addr, "+"))
                        self.chunk = self.membus[libSBTCVM.numstruct(
                            self.addr)]
                    self.GREY = shadlook0mapped1(self.part)
                    #dispsurf1.set_at((self.pixx, self.pixy),(self.GREY, self.GREY, self.GREY))
                    dispsurf1pixarray[self.pixx, self.pixy] = self.GREY
                    #print self.chunkcnt
                    #print self.pixx
                    #print self.pixy
                    self.pixx += 1
                self.pixy += 1
            dispsurf1.unlock()
            return self.screensurf.blit(
                pygame.transform.scale(dispsurf1, (648, 460)), (x, y))
            return self.screensurf.blit(dispsurf1, (x, y))
Esempio n. 2
0
 def render(self, x=0, y=0):
     if self.mode == "G0":
         self.pixy = 0
         self.pixx = 0
         self.chunkcnt = 0
         self.addr = self.offset
         while self.pixy != 81:
             self.pixx = 0
             while self.pixx != 114:
                 if self.chunkcnt == 0:
                     self.chunkcnt = 1
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[6]) + (self.chunk[7]) +
                                  (self.chunk[8]))
                 elif self.chunkcnt == 1:
                     self.chunkcnt = 2
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[9]) + (self.chunk[10]) +
                                  (self.chunk[11]))
                 elif self.chunkcnt == 2:
                     self.chunkcnt = 0
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[12]) + (self.chunk[13]) +
                                  (self.chunk[14]))
                     self.addr = libSBTCVM.trunkto6(
                         libbaltcalc.btadd(self.addr, "+"))
                 self.R1 = shadlook0(self.part[0])
                 self.G1 = shadlook0(self.part[1])
                 self.B1 = shadlook0(self.part[2])
                 #print (self.R1, self.G1, self.B1)
                 #dispsurf0.set_at((self.pixx, self.pixy),(self.R1, self.G1, self.B1))
                 self.cubeblocksurf0.fill((self.R1, self.G1, self.B1))
                 self.screensurf.blit(self.cubeblocksurf0,
                                      (((self.pixx * 5) + x),
                                       ((self.pixy * 5) + y)))
                 self.pixx += 1
             self.pixy += 1
         cubedisprect0.x = x
         cubedisprect0.y = y
         return cubedisprect0
         #return self.screensurf.blit(pygame.transform.scale(dispsurf0, (648, 460)), (x, y))
     if self.mode == "G2":
         self.pixy = 0
         self.pixx = 0
         self.chunkcnt = 0
         self.addr = self.offset
         while self.pixy != 81:
             self.pixx = 0
             while self.pixx != 114:
                 if self.chunkcnt == 0:
                     self.chunkcnt = 1
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[6]))
                 elif self.chunkcnt == 1:
                     self.chunkcnt = 2
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[7]))
                 elif self.chunkcnt == 2:
                     self.chunkcnt = 3
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[8]))
                 elif self.chunkcnt == 3:
                     self.chunkcnt = 4
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[9]))
                 elif self.chunkcnt == 4:
                     self.chunkcnt = 5
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[10]))
                 elif self.chunkcnt == 5:
                     self.chunkcnt = 6
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[11]))
                 elif self.chunkcnt == 6:
                     self.chunkcnt = 7
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[12]))
                 elif self.chunkcnt == 7:
                     self.chunkcnt = 8
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[13]))
                 elif self.chunkcnt == 8:
                     self.chunkcnt = 0
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[14]))
                     self.addr = libSBTCVM.trunkto6(
                         libbaltcalc.btadd(self.addr, "+"))
                 self.GREY = shadlook0(self.part)
                 #dispsurf0.set_at((self.pixx, self.pixy),(self.GREY, self.GREY, self.GREY))
                 self.cubeblocksurf0.fill((self.GREY, self.GREY, self.GREY))
                 self.screensurf.blit(self.cubeblocksurf0,
                                      (((self.pixx * 5) + x),
                                       ((self.pixy * 5) + y)))
                 #print self.chunkcnt
                 #print self.pixx
                 #print self.pixy
                 self.pixx += 1
             self.pixy += 1
         #return self.screensurf.blit(pygame.transform.scale(dispsurf0, (648, 460)), (x, y))
         cubedisprect0.x = x
         cubedisprect0.y = y
         return cubedisprect0
     if self.mode == "G3":
         self.pixy = 0
         self.pixx = 0
         self.chunkcnt = 0
         self.addr = self.offset
         while self.pixy != 38:
             self.pixx = 0
             while self.pixx != 54:
                 if self.chunkcnt == 0:
                     self.chunkcnt = 1
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[6]) + (self.chunk[7]) +
                                  (self.chunk[8]))
                 elif self.chunkcnt == 1:
                     self.chunkcnt = 2
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[9]) + (self.chunk[10]) +
                                  (self.chunk[11]))
                 elif self.chunkcnt == 2:
                     self.chunkcnt = 0
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[12]) + (self.chunk[13]) +
                                  (self.chunk[14]))
                     self.addr = libSBTCVM.trunkto6(
                         libbaltcalc.btadd(self.addr, "+"))
                 self.R1 = shadlook0(self.part[0])
                 self.G1 = shadlook0(self.part[1])
                 self.B1 = shadlook0(self.part[2])
                 #print (self.R1, self.G1, self.B1)
                 #dispsurf1.set_at((self.pixx, self.pixy),(self.R1, self.G1, self.B1))
                 self.cubeblocksurf1.fill((self.R1, self.G1, self.B1))
                 self.screensurf.blit(self.cubeblocksurf1,
                                      (((self.pixx * 12) + x),
                                       ((self.pixy * 12) + y)))
                 self.pixx += 1
             self.pixy += 1
         cubedisprect1.x = x
         cubedisprect1.y = y
         return cubedisprect1
         #return self.screensurf.blit(pygame.transform.scale(dispsurf1, (648, 460)), (x, y))
     if self.mode == "G4":
         self.pixy = 0
         self.pixx = 0
         self.chunkcnt = 0
         self.addr = self.offset
         while self.pixy != 38:
             self.pixx = 0
             while self.pixx != 54:
                 if self.chunkcnt == 0:
                     self.chunkcnt = 1
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[6]))
                 elif self.chunkcnt == 1:
                     self.chunkcnt = 2
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[7]))
                 elif self.chunkcnt == 2:
                     self.chunkcnt = 3
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[8]))
                 elif self.chunkcnt == 3:
                     self.chunkcnt = 4
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[9]))
                 elif self.chunkcnt == 4:
                     self.chunkcnt = 5
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[10]))
                 elif self.chunkcnt == 5:
                     self.chunkcnt = 6
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[11]))
                 elif self.chunkcnt == 6:
                     self.chunkcnt = 7
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[12]))
                 elif self.chunkcnt == 7:
                     self.chunkcnt = 8
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[13]))
                 elif self.chunkcnt == 8:
                     self.chunkcnt = 0
                     self.chunk = self.membus[libSBTCVM.numstruct(
                         self.addr)]
                     self.part = ((self.chunk[14]))
                     self.addr = libSBTCVM.trunkto6(
                         libbaltcalc.btadd(self.addr, "+"))
                 self.GREY = shadlook0(self.part)
                 #dispsurf1.set_at((self.pixx, self.pixy),(self.GREY, self.GREY, self.GREY))
                 #cubeblock1.x=((self.pixx * 12) + x)
                 #cubeblock1.y=((self.pixy * 12) + y)
                 #pygame.draw.rect(self.screensurf, (self.GREY, self.GREY, self.GREY), cubeblock1)
                 self.cubeblocksurf1.fill((self.GREY, self.GREY, self.GREY))
                 self.screensurf.blit(self.cubeblocksurf1,
                                      (((self.pixx * 12) + x),
                                       ((self.pixy * 12) + y)))
                 #print self.chunkcnt
                 #print self.pixx
                 #print self.pixy
                 self.pixx += 1
             self.pixy += 1
         cubedisprect1.x = x
         cubedisprect1.y = y
         return cubedisprect1