mapmanager.py

import pickle
class Mapmanager():
   """ Управление картой """
   def __init__(self):
       self.model = 'block' # модель кубика лежит в файле block.egg
       # # используются следующие текстуры:
       self.texture = 'stone.png'         
       self.colors = [
           (0.2, 0.2, 0.35, 1),
           (0.2, 0.5, 0.2, 1),
           (0.7, 0.2, 0.2, 1),
           (0.5, 0.3, 0.0, 1)
       ] #rgba
       # создаём основной узел карты:
       self.startNew()
       # self.addBlock((0,10, 0))


   def startNew(self):
       """создаёт основу для новой карты"""
       self.land = render.attachNewNode("Land") # узел, к которому привязаны все блоки карты


   def getColor(self, z):
       if z < len(self.colors):
           return self.colors[z]
       else:
           return self.colors[len(self.colors) - 1]


   def addBlock(self, position, texture = 'stone.png'):
       # создаём строительные блоки
       self.texture = texture
       self.block = loader.loadModel(self.model)
       self.block.setTexture(loader.loadTexture(self.texture))
       self.block.setPos(position)
       #self.color = self.getColor(int(position[2]))
       #self.block.setColor(self.color)


       self.block.setTag("at", str(position))
       self.block.setTag("texture", self.texture)


       self.block.reparentTo(self.land)


   def clear(self):
       """обнуляет карту"""
       self.land.removeNode()
       self.startNew()


   def loadLand(self, filename):
       """создаёт карту земли из текстового файла, возвращает её размеры"""
       self.clear()
       with open(filename) as file:
           y = 0
           for line in file:
               x = 0
               line = line.split(' ')
               for z in line:
                   for z0 in range(int(z)+1):
                       block = self.addBlock((x, y, z0))
                   x += 1
               y += 1
       return x,y
  
   def findBlocks(self, pos):
       return self.land.findAllMatches("=at=" + str(pos))


   def isEmpty(self, pos):
       blocks = self.findBlocks(pos)
       if blocks:
           return False
       else:
           return True


   def findHighestEmpty(self, pos):
       x, y, z = pos
       z = 1
       while not self.isEmpty((x, y, z)):
           z += 1
       return (x, y, z)


   def buildBlock(self, pos, texture):
       """Ставим блок с учётом гравитации: """
       x, y, z = pos
       new = self.findHighestEmpty(pos)
       if new[2] <= z + 1:
           self.addBlock(new, texture)


   def delBlock(self, position):
       """удаляет блоки в указанной позиции """
       blocks = self.findBlocks(position)
       for block in blocks:
           block.removeNode()


   def delBlockFrom(self, position):
       x, y, z = self.findHighestEmpty(position)
       pos = x, y, z - 1
       for block in self.findBlocks(pos):
               block.removeNode()


   def saveMap(self):
       """сохраняет все блоки, включая постройки, в бинарный файл"""


       """возвращает коллекцию NodePath для всех существующих в карте мира блоков"""
       blocks = self.land.getChildren()
       # открываем бинарный файл на запись
       with open('my_map.dat', 'wb') as fout:


           # сохраняем в начало файла количество блоков
           pickle.dump(len(blocks), fout)


           # обходим все блоки
           for block in blocks:
               # сохраняем позицию
               x, y, z = block.getPos()
               texture = block.getTag('texture')
               data = (int(x), int(y), int(z), texture)
               pickle.dump(data, fout)


   def loadMap(self):
       # удаляем все блоки
       self.clear()


       # открываем бинарный файл на чтение
       with open('my_map.dat', 'rb') as fin:
          
           # считываем количество блоков
           length = pickle.load(fin)


           for i in range(length):
               # считываем позицию
               data = pickle.load(fin)


               # создаём новый блок
               self.addBlock((data[0], data[1], data[2]), data[3])