158 lines
3.9 KiB
Python
158 lines
3.9 KiB
Python
import json
|
|
import os
|
|
from dusk.event import Event
|
|
from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
|
|
from dusk.tile import Tile
|
|
from dusk.entity import Entity
|
|
from dusk.region import Region
|
|
from editortool.map.vertexbuffer import VertexBuffer
|
|
from OpenGL.GL import *
|
|
|
|
class Chunk:
|
|
def __init__(self, map, x, y, z):
|
|
self.map = map
|
|
self.x = x
|
|
self.y = y
|
|
self.z = z
|
|
self.current = {}
|
|
self.original = {}
|
|
self.entities = {}
|
|
self.regions = {}
|
|
self.onChunkData = Event()
|
|
self.dirty = False
|
|
|
|
self.tiles = {}
|
|
self.vertexBuffer = VertexBuffer()
|
|
|
|
# Test Region
|
|
region = self.regions[0] = Region(self)
|
|
region.minX = 0
|
|
region.minY = 0
|
|
region.minZ = 0
|
|
region.maxX = 32
|
|
region.maxY = 32
|
|
region.maxZ = 32
|
|
region.updateVertexs()
|
|
|
|
# Gen tiles.
|
|
tileIndex = 0
|
|
for tz in range(CHUNK_DEPTH):
|
|
for ty in range(CHUNK_HEIGHT):
|
|
for tx in range(CHUNK_WIDTH):
|
|
self.tiles[tileIndex] = Tile(self, tx, ty, tz, tileIndex)
|
|
tileIndex += 1
|
|
|
|
# Update vertices
|
|
self.tileUpdateVertices()
|
|
|
|
def reload(self, newX, newY, newZ):
|
|
self.x = newX
|
|
self.y = newY
|
|
self.z = newZ
|
|
self.entities = {}
|
|
for tile in self.tiles.values():
|
|
tile.chunkReload(newX, newY, newZ)
|
|
self.load()
|
|
|
|
def tileUpdateVertices(self):
|
|
self.vertexBuffer.clear()
|
|
for tile in self.tiles.values():
|
|
tile.buffer(self.vertexBuffer)
|
|
self.vertexBuffer.buildData()
|
|
|
|
def load(self):
|
|
fname = self.getFilename()
|
|
if not fname or not os.path.exists(fname):
|
|
self.new()
|
|
return
|
|
try:
|
|
with open(fname, 'r') as f:
|
|
data = json.load(f)
|
|
|
|
if not 'shapes' in data:
|
|
data['shapes'] = []
|
|
|
|
# For each tile.
|
|
for tile in self.tiles.values():
|
|
tile.load(data)
|
|
|
|
# For each entity.
|
|
self.entities = {}
|
|
if 'entities' in data:
|
|
for id, entData in enumerate(data['entities']):
|
|
ent = Entity(self)
|
|
ent.load(entData)
|
|
self.entities[id] = ent
|
|
|
|
self.tileUpdateVertices()
|
|
self.dirty = False
|
|
self.onChunkData.invoke(self)
|
|
self.map.onEntityData.invoke()
|
|
except Exception as e:
|
|
raise RuntimeError(f"Failed to load chunk file: {e}")
|
|
|
|
def save(self):
|
|
if not self.isDirty():
|
|
return
|
|
|
|
dataOut = {
|
|
'shapes': [],
|
|
'entities': []
|
|
}
|
|
|
|
for tile in self.tiles.values():
|
|
dataOut['shapes'].append(tile.shape)
|
|
|
|
for ent in self.entities.values():
|
|
entData = {}
|
|
ent.save(entData)
|
|
dataOut['entities'].append(entData)
|
|
|
|
fname = self.getFilename()
|
|
if not fname:
|
|
raise ValueError("No filename specified for saving chunk.")
|
|
try:
|
|
with open(fname, 'w') as f:
|
|
json.dump(dataOut, f)
|
|
self.dirty = False
|
|
self.onChunkData.invoke(self)
|
|
except Exception as e:
|
|
raise RuntimeError(f"Failed to save chunk file: {e}")
|
|
|
|
def new(self):
|
|
for tile in self.tiles.values():
|
|
tile.shape = TILE_SHAPE_NULL
|
|
|
|
self.tileUpdateVertices()
|
|
self.dirty = False
|
|
self.onChunkData.invoke(self)
|
|
|
|
def isDirty(self):
|
|
return self.dirty
|
|
|
|
def getFilename(self):
|
|
if not self.map or not hasattr(self.map, 'getChunkDirectory'):
|
|
return None
|
|
dirPath = self.map.getChunkDirectory()
|
|
if dirPath is None:
|
|
return None
|
|
return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
|
|
|
|
def draw(self):
|
|
self.vertexBuffer.draw()
|
|
|
|
def addEntity(self, localX=0, localY=0, localZ=0):
|
|
ent = Entity(self, localX, localY, localZ)
|
|
self.entities[len(self.entities)] = ent
|
|
self.map.onEntityData.invoke()
|
|
self.dirty = True
|
|
return ent
|
|
|
|
def removeEntity(self, entity):
|
|
for key, val in list(self.entities.items()):
|
|
if val == entity:
|
|
del self.entities[key]
|
|
self.map.onEntityData.invoke()
|
|
self.dirty = True
|
|
return True
|
|
return False |