259 lines
8.2 KiB
Python
259 lines
8.2 KiB
Python
import json
|
|
import sys
|
|
from tools.dusk.event import Event
|
|
from PyQt5.QtWidgets import QFileDialog, QMessageBox
|
|
from PyQt5.QtCore import QTimer
|
|
import os
|
|
from tools.dusk.chunk import Chunk
|
|
from tools.dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
|
|
import traceback
|
|
|
|
MAP_DEFAULT_PATH = os.path.join(os.path.dirname(__file__), '../../assets/map/')
|
|
EDITOR_CONFIG_PATH = os.path.join(os.path.dirname(__file__), '.editor')
|
|
|
|
class Map:
|
|
def __init__(self, parent):
|
|
self.parent = parent
|
|
self.data = {}
|
|
self.dataOriginal = {}
|
|
self.position = [None, None, None] # x, y, z
|
|
self.topLeftX = None
|
|
self.topLeftY = None
|
|
self.topLeftZ = None
|
|
self.chunks = {}
|
|
self.onMapData = Event()
|
|
self.onPositionChange = Event()
|
|
self.onEntityData = Event()
|
|
self.mapFileName = None
|
|
self.lastFile = None
|
|
self.firstLoad = True
|
|
|
|
index = 0
|
|
for x in range(MAP_WIDTH):
|
|
for y in range(MAP_HEIGHT):
|
|
for z in range(MAP_DEPTH):
|
|
self.chunks[index] = Chunk(self, x, y, z)
|
|
index += 1
|
|
|
|
# Only in editor instances:
|
|
self.moveTo(0, 0, 0)
|
|
if parent is not None:
|
|
QTimer.singleShot(16, self.loadLastFile)
|
|
|
|
def loadLastFile(self):
|
|
if not os.path.exists(EDITOR_CONFIG_PATH):
|
|
return
|
|
try:
|
|
with open(EDITOR_CONFIG_PATH, 'r') as f:
|
|
config = json.load(f)
|
|
lastFile = config.get('lastFile')
|
|
lastPosition = config.get('lastPosition')
|
|
leftPanelIndex = config.get('leftPanelIndex')
|
|
if lastFile and os.path.exists(lastFile):
|
|
self.load(lastFile)
|
|
if lastPosition and isinstance(lastPosition, list) and len(lastPosition) == 3:
|
|
self.moveTo(*lastPosition)
|
|
if leftPanelIndex is not None:
|
|
self.parent.leftPanel.tabs.setCurrentIndex(leftPanelIndex)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
def updateEditorConfig(self):
|
|
if self.parent is None:
|
|
return
|
|
try:
|
|
mapFileName = self.getMapFilename()
|
|
config = {
|
|
'lastFile': mapFileName if mapFileName else "",
|
|
'lastPosition': self.position,
|
|
'leftPanelIndex': self.parent.leftPanel.tabs.currentIndex()
|
|
}
|
|
config_dir = os.path.dirname(EDITOR_CONFIG_PATH)
|
|
if not os.path.exists(config_dir):
|
|
os.makedirs(config_dir, exist_ok=True)
|
|
with open(EDITOR_CONFIG_PATH, 'w') as f:
|
|
json.dump(config, f, indent=2)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
def newFile(self):
|
|
self.data = {}
|
|
self.dataOriginal = {}
|
|
self.mapFileName = None
|
|
self.lastFile = None
|
|
for chunk in self.chunks.values():
|
|
chunk.new()
|
|
self.moveTo(0, 0, 0)
|
|
self.onMapData.invoke(self.data)
|
|
self.updateEditorConfig()
|
|
|
|
def save(self, fname=None):
|
|
if not self.getMapFilename() and fname is None:
|
|
filePath, _ = QFileDialog.getSaveFileName(None, "Save Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
|
|
if not filePath:
|
|
return
|
|
self.mapFileName = filePath
|
|
if fname:
|
|
self.mapFileName = fname
|
|
try:
|
|
with open(self.getMapFilename(), 'w') as f:
|
|
json.dump(self.data, f, indent=2)
|
|
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
|
for chunk in self.chunks.values():
|
|
chunk.save()
|
|
self.updateEditorConfig()
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
QMessageBox.critical(None, "Save Error", f"Failed to save map file:\n{e}")
|
|
|
|
def load(self, fileName):
|
|
try:
|
|
with open(fileName, 'r') as f:
|
|
self.data = json.load(f)
|
|
self.mapFileName = fileName
|
|
self.dataOriginal = json.loads(json.dumps(self.data)) # Deep copy
|
|
for chunk in self.chunks.values():
|
|
chunk.load()
|
|
self.onMapData.invoke(self.data)
|
|
self.updateEditorConfig()
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
QMessageBox.critical(None, "Load Error", f"Failed to load map file:\n{e}")
|
|
|
|
def isMapFileDirty(self):
|
|
return json.dumps(self.data, sort_keys=True) != json.dumps(self.dataOriginal, sort_keys=True)
|
|
|
|
def isDirty(self):
|
|
return self.isMapFileDirty() or self.anyChunksDirty()
|
|
|
|
def getMapFilename(self):
|
|
return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
|
|
|
|
def getMapDirectory(self):
|
|
if self.mapFileName is None:
|
|
return None
|
|
dirname = os.path.dirname(self.mapFileName)
|
|
return dirname
|
|
|
|
def getChunkDirectory(self):
|
|
dirName = self.getMapDirectory()
|
|
if dirName is None:
|
|
return None
|
|
return os.path.join(dirName, 'chunks')
|
|
|
|
def anyChunksDirty(self):
|
|
for chunk in self.chunks.values():
|
|
if chunk.isDirty():
|
|
return True
|
|
return False
|
|
|
|
def moveTo(self, x, y, z):
|
|
if self.position == [x, y, z]:
|
|
return
|
|
|
|
# We need to decide if the chunks should be unloaded here or not.
|
|
newTopLeftChunkX = x // CHUNK_WIDTH - (MAP_WIDTH // 2)
|
|
newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
|
|
newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
|
|
|
|
if (newTopLeftChunkX != self.topLeftX or
|
|
newTopLeftChunkY != self.topLeftY or
|
|
newTopLeftChunkZ != self.topLeftZ):
|
|
|
|
chunksToUnload = []
|
|
chunksToKeep = []
|
|
for chunk in self.chunks.values():
|
|
chunkWorldX = chunk.x
|
|
chunkWorldY = chunk.y
|
|
chunkWorldZ = chunk.z
|
|
if (chunkWorldX < newTopLeftChunkX or
|
|
chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
|
|
chunkWorldY < newTopLeftChunkY or
|
|
chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or
|
|
chunkWorldZ < newTopLeftChunkZ or
|
|
chunkWorldZ >= newTopLeftChunkZ + MAP_DEPTH):
|
|
chunksToUnload.append(chunk)
|
|
else:
|
|
chunksToKeep.append(chunk)
|
|
|
|
# Unload chunks that are out of the new bounds.
|
|
for chunk in chunksToUnload:
|
|
if chunk.isDirty():
|
|
print(f"Can't move map, some chunks are dirty: ({chunk.x}, {chunk.y}, {chunk.z})")
|
|
return
|
|
|
|
# Now we can safely unload the chunks.
|
|
chunkIndex = 0
|
|
newChunks = {}
|
|
for chunk in chunksToKeep:
|
|
newChunks[chunkIndex] = chunk
|
|
chunkIndex += 1
|
|
|
|
for xPos in range(newTopLeftChunkX, newTopLeftChunkX + MAP_WIDTH):
|
|
for yPos in range(newTopLeftChunkY, newTopLeftChunkY + MAP_HEIGHT):
|
|
for zPos in range(newTopLeftChunkZ, newTopLeftChunkZ + MAP_DEPTH):
|
|
# Check if we already have this chunk.
|
|
found = False
|
|
for chunk in chunksToKeep:
|
|
if chunk.x == xPos and chunk.y == yPos and chunk.z == zPos:
|
|
found = True
|
|
break
|
|
if not found:
|
|
# Create a new chunk.
|
|
newChunk = chunksToUnload.pop()
|
|
newChunk.reload(xPos, yPos, zPos)
|
|
newChunks[chunkIndex] = newChunk
|
|
chunkIndex += 1
|
|
|
|
self.chunks = newChunks
|
|
self.topLeftX = newTopLeftChunkX
|
|
self.topLeftY = newTopLeftChunkY
|
|
self.topLeftZ = newTopLeftChunkZ
|
|
|
|
self.position = [x, y, z]
|
|
self.onPositionChange.invoke(self.position)
|
|
if not self.firstLoad:
|
|
self.updateEditorConfig()
|
|
self.firstLoad = False
|
|
|
|
def moveRelative(self, x, y, z):
|
|
self.moveTo(
|
|
self.position[0] + x,
|
|
self.position[1] + y,
|
|
self.position[2] + z
|
|
)
|
|
|
|
def draw(self):
|
|
for chunk in self.chunks.values():
|
|
chunk.draw()
|
|
|
|
for chunk in self.chunks.values():
|
|
for entity in chunk.entities.values():
|
|
entity.draw()
|
|
|
|
# Only render on Region tab
|
|
if self.parent.leftPanel.tabs.currentWidget() == self.parent.leftPanel.regionPanel:
|
|
for chunk in self.chunks.values():
|
|
for region in chunk.regions.values():
|
|
region.draw()
|
|
|
|
def getChunkAtWorldPos(self, x, y, z):
|
|
chunkX = x // CHUNK_WIDTH
|
|
chunkY = y // CHUNK_HEIGHT
|
|
chunkZ = z // CHUNK_DEPTH
|
|
for chunk in self.chunks.values():
|
|
if chunk.x == chunkX and chunk.y == chunkY and chunk.z == chunkZ:
|
|
return chunk
|
|
return None
|
|
|
|
def getTileAtWorldPos(self, x, y, z):
|
|
chunk = self.getChunkAtWorldPos(x, y, z)
|
|
if not chunk:
|
|
print("No chunk found at position:", (x, y, z))
|
|
return None
|
|
|
|
tileX = x % CHUNK_WIDTH
|
|
tileY = y % CHUNK_HEIGHT
|
|
tileZ = z % CHUNK_DEPTH
|
|
tileIndex = tileX + tileY * CHUNK_WIDTH + tileZ * CHUNK_WIDTH * CHUNK_HEIGHT
|
|
return chunk.tiles.get(tileIndex) |