def main():
filename = "C:\Users\Rio\AppData\Roaming\.minecraft\saves\New World1_8"
worldEditor = WorldEditor(filename, readonly=True)
dim = worldEditor.getDimension()
positions = list(dim.chunkPositions())
installs = minecraftinstall.GetInstalls()
install = installs.getDefaultInstall()
loader = install.getResourceLoader(install.findVersion1_8(), None)
def loadModels():
o.models = BlockModels(worldEditor.blocktypes, loader)
def loadTextures():
o.textureAtlas = TextureAtlas(worldEditor, loader, o.models, overrideMaxSize=2048)
o.textureAtlas.load()
def cookQuads():
o.models.cookQuads(o.textureAtlas)
def buildMeshes():
o.worldScene = WorldScene(dim, o.textureAtlas)
worker = o.worldScene.workOnChunk(dim.getChunk(*positions[0]))
for i in worker:
pass
print("loadModels x1 in %0.2fms" % (timeit.timeit(loadModels, number=1) * 1000))
print("loadTextures x1 in %0.2fms" % (timeit.timeit(loadTextures, number=1) * 1000))
print("cookQuads x1 in %0.2fms" % (timeit.timeit(cookQuads, number=1) * 1000))
print("buildMeshes x1 in %0.2fms" % (timeit.timeit(buildMeshes, number=1) * 1000))
def testCreate(tmpdir):
temppath = tmpdir.join("AnvilCreate")
temppath.mkdir()
pc_world = WorldEditor(filename=temppath.strpath,
create=True,
adapterClass=AnvilWorldAdapter)
pc_world.close()
def testFill(world):
dim = world.getDimension()
bounds = dim.bounds
box = BoundingBox(bounds.origin + (bounds.size / 2), (64, bounds.height / 2, 64))
x, y, z = numpy.array(list(box.positions)).transpose()
dim.fillBlocks(box, world.blocktypes["planks"])
def checkEqual(a, b):
"""
:type a: ndarray
:type b: ndarray
"""
equal = a == b
if not equal.all():
assert False, "Coordinates not equal to %s: \nX: %s\nY: %s\nZ: %s" % (b, x[~equal], y[~equal], z[~equal])
for cp in box.chunkPositions():
chunk = dim.getChunk(*cp)
for cy in chunk.bounds.sectionPositions(*cp):
assert chunk.getSection(cy) is not None, "Section %s not found" % cy
checkEqual(dim.getBlocks(x, y, z).Blocks, world.blocktypes["planks"].ID)
dim.fillBlocks(box, world.blocktypes["stone"], [world.blocktypes["planks"]])
world.saveChanges()
world.close()
filename = world.filename
world = WorldEditor(filename)
checkEqual(world.getDimension().getBlocks(x, y, z).Blocks, world.blocktypes["stone"].ID)
def testCreate():
temppath = mktemp("AnvilCreate")
pc_world = WorldEditor(filename=temppath,
create=True,
adapterClass=AnvilWorldAdapter)
pc_world.close()
shutil.rmtree(temppath)
def test_extid_pc_world(extid_pc_world):
extid_pc_world.saveChanges()
extid_pc_world.close()
filename = extid_pc_world.filename
del extid_pc_world
level = WorldEditor(filename=filename)
assert level.getDimension().getBlockID(0,2,5) == 2048
def test_extid_pc_world(extid_pc_world):
extid_pc_world.saveChanges()
extid_pc_world.close()
filename = extid_pc_world.filename
del extid_pc_world
level = WorldEditor(filename=filename)
assert level.getDimension().getBlockID(0, 2, 5) == 2048
def main():
filename = "C:\Users\Rio\AppData\Roaming\.minecraft\saves\New World1_8"
ray = Ray((1827.21, 184.79, 286.4), (.25, -.948, .18))
editor = WorldEditor(filename, readonly=True)
dim = editor.getDimension()
bounds = dim.bounds
def timeCast():
for i in range(100):
pos = rayCast(ray, dim)
print("timeCast x100 in %0.2fms" % (timeit.timeit(timeCast, number=1) * 1000))
def extid_pc_world(tmpdir):
filename = tmpdir.join("pc_extended_ids").strpath
level = WorldEditor(filename, create=True, adapterClass=AnvilWorldAdapter)
dim = level.getDimension()
dim.createChunk(0, 0)
for x in range(0, 10):
dim.setBlockID(x, 2, 5, 2048)
return level
def extid_pc_world(tmpdir):
filename = tmpdir.join("pc_extended_ids").strpath
level = WorldEditor(filename, create=True, adapterClass=AnvilWorldAdapter)
dim = level.getDimension()
dim.createChunk(0, 0)
for x in range(0, 10):
dim.setBlockID(x, 2, 5, 2048)
return level
def alpha_test_level():
level = TempLevel("alpha",
createFunc=lambda f: WorldEditor(f, create=True))
level.createChunk(0, 0)
for x in range(0, 10):
level.setBlockID(x, 2, 5, 2048)
level.saveChanges()
level.close()
level = WorldEditor(filename=level.filename)
return level
def reloadRecentWorlds(self):
recentWorlds = RecentFilesSetting.value()
self.recentWorldsMenu = QtGui.QMenu()
def _triggered(f):
def triggered():
self.accept()
self.editWorldClicked.emit(f)
return triggered
dead = []
for filename in recentWorlds:
if not os.path.exists(filename):
dead.append(filename)
continue
try:
displayName, lastPlayed, versionInfo = WorldEditor.getWorldInfo(
filename)
action = self.recentWorldsMenu.addAction(displayName)
action._editWorld = _triggered(filename)
action.triggered.connect(action._editWorld)
except EnvironmentError as e:
log.exception("Failed to load world info")
if len(dead):
for f in dead:
recentWorlds.remove(f)
RecentFilesSetting.setValue(recentWorlds)
self.recentWorldsButton.setMenu(self.recentWorldsMenu)
async def Load(self, msg):
print("Received message: Load")
global PATHS, editor, dimension
if msg.path not in PATHS:
return
print("Loading world:", msg.path)
if editor is not None:
dimension = None
editor.close()
editor = WorldEditor(msg.path, readonly=True)
dimension = editor.getDimension()
return LoadResponse()
def testCreate(self):
# log.info("Schematic from indev")
size = (64, 64, 64)
temp = mktemp("testcreate.schematic")
editor = createSchematic(shape=size, blocktypes='Classic')
editor.filename = temp
dim = editor.getDimension()
level = self.schematicLevel
dim.importSchematic(level, (0, 0, 0))
assert((schematic.Blocks[0:64, 0:64, 0:64] == level.adapter.Blocks[0:64, 0:64, 0:64]).all())
dim.importSchematic(level, (-32, -32, -32))
assert((schematic.Blocks[0:32, 0:32, 0:32] == level.adapter.Blocks[32:64, 32:64, 32:64]).all())
schematic.saveChanges()
schem = WorldEditor("test_files/Station.schematic")
tempEditor = createSchematic(shape=(1, 1, 3))
tempDim = tempEditor.getDimension()
tempDim.copyBlocks(schem, BoundingBox((0, 0, 0), (1, 1, 3)), (0, 0, 0))
level = self.anvilLevel
for cx, cz in itertools.product(xrange(0, 4), xrange(0, 4)):
try:
level.createChunk(cx, cz)
except ValueError:
pass
dim.copyBlocks(level.getDimension(), BoundingBox((0, 0, 0), (64, 64, 64,)), (0, 0, 0))
os.remove(temp)
def reloadRecentWorlds(self):
recentWorlds = RecentFilesSetting.value()
self.recentWorldsMenu = QtGui.QMenu()
def _triggered(f):
def triggered():
self.accept()
self.editWorldClicked.emit(f)
return triggered
dead = []
for filename in recentWorlds:
if not os.path.exists(filename):
dead.append(filename)
continue
try:
displayName, lastPlayed, versionInfo = WorldEditor.getWorldInfo(filename)
action = self.recentWorldsMenu.addAction(displayName)
action._editWorld = _triggered(filename)
action.triggered.connect(action._editWorld)
except EnvironmentError as e:
log.exception("Failed to load world info")
if len(dead):
for f in dead:
recentWorlds.remove(f)
RecentFilesSetting.setValue(recentWorlds)
self.recentWorldsButton.setMenu(self.recentWorldsMenu)
def TempLevel(filename, createFunc=None):
if not os.path.exists(filename):
filename = join(TEST_FILES_DIR, filename)
result = None
tmpname = mktemp(os.path.basename(filename))
if os.path.exists(filename):
if os.path.isdir(filename):
shutil.copytree(filename, tmpname)
else:
shutil.copy(filename, tmpname)
elif createFunc:
result = createFunc(tmpname)
else:
raise IOError, "File %s not found." % filename
def removeTemp():
if tmpname:
filename = tmpname
if os.path.isdir(filename):
shutil.rmtree(filename)
else:
os.unlink(filename)
atexit.register(removeTemp)
if result:
return result
else:
return WorldEditor(tmpname)
def test_relight(schematic_world, pc_world):
anvilDim = pc_world.getDimension()
bounds = anvilDim.bounds
point = bounds.origin + (bounds.size * (0.5, 0.25, 0.5))
stationDim = schematic_world.getDimension()
anvilDim.copyBlocks(stationDim, stationDim.bounds, point, create=True)
pc_world.saveChanges()
cx = int(point.x + 32) >> 4
cz = int(point.z + 32) >> 4
def check():
sl = 0
bl = 0
chunk = pc_world.getDimension().getChunk(cx, cz)
for cy in chunk.sectionPositions():
section = chunk.getSection(cy)
sl += numpy.sum(section.SkyLight)
bl += numpy.sum(section.BlockLight)
assert (sl, bl) == (245085, 48261) # was 367965, why??
check()
pc_world.close()
pc_world = WorldEditor(pc_world.filename)
check()
def test_relight():
pc_world = TempLevel("AnvilWorld")
anvilDim = pc_world.getDimension()
bounds = anvilDim.bounds
point = bounds.origin + (bounds.size * (0.5, 0.5, 0.5))
box = bounds.expand(-100, 0, -100)
chunks = [(cx, cz) for cx, cz in anvilDim.chunkPositions()
if (cx << 4, 1, cz << 4) not in box]
for c in chunks:
anvilDim.deleteChunk(*c)
station = TempLevel("station.schematic")
stationDim = station.getDimension()
anvilDim.copyBlocks(stationDim, stationDim.bounds, point, create=True)
pc_world.saveChanges()
cx = int(point.x + 32) >> 4
cz = int(point.z + 32) >> 4
def check():
sl = numpy.sum(pc_world.getChunk(cx, cz).SkyLight)
bl = numpy.sum(pc_world.getChunk(cx, cz).BlockLight)
assert (sl, bl) == (341328, 43213)
check()
pc_world.close()
pc_world = WorldEditor(templevel.tmpname)
check()
def test_session_lock(self):
temp = TempLevel("AnvilWorld")
level = temp
level2 = WorldEditor(level.filename, resume=False)
def touch():
level.saveChanges()
self.assertRaises(SessionLockLost, touch)
def manmade_relight():
t = templevel.TempLevel("TimeRelight",
createFunc=lambda f: WorldEditor(f, create=True))
world = t
station = WorldEditor("test_files/station.schematic")
times = 2
for x in range(times):
for z in range(times):
world.copyBlocksFrom(station,
station.bounds,
(x * station.Width, 63, z * station.Length),
create=True)
t = timeit(lambda: world.generateLights(world.chunkPositions), number=1)
print "Relight manmade building: %d chunks in %.02f seconds (%.02fms per chunk)" % (
world.chunkCount, t, t / world.chunkCount * 1000)
def test_relight():
templevel = TempLevel("AnvilWorld")
anvilLevel = templevel
anvilDim = anvilLevel.getDimension()
bounds = anvilDim.bounds
point = bounds.origin + (bounds.size * (0.5, 0.5, 0.5))
box = bounds.expand(-100, 0, -100)
# box = BoundingBox((256, 0, 256), (64, anvilLevel.Height, 64))
chunks = [(cx, cz) for cx, cz in anvilDim.chunkPositions()
if (cx << 4, 1, cz << 4) not in box]
for c in chunks:
anvilDim.deleteChunk(*c)
#anvilLevel = WorldEditor(filename=temppath, create=True)
station = WorldEditor("test_files/station.schematic")
stationDim = station.getDimension()
anvilDim.copyBlocks(stationDim, stationDim.bounds, point, create=True)
for cPos in anvilDim.chunkPositions():
anvilDim.getChunk(*cPos)
#anvilLevel.copyBlocksFrom(station, station.bounds, point + (station.Width, 0, 0), create=True)
anvilLevel.generateLights()
anvilLevel.saveChanges()
cx = int(point.x + 32) >> 4
cz = int(point.z + 32) >> 4
# os.system(sys.executable + " ../mcedit.py " + anvilLevel.filename)
def check():
sl = numpy.sum(anvilLevel.getChunk(cx, cz).SkyLight)
bl = numpy.sum(anvilLevel.getChunk(cx, cz).BlockLight)
assert (sl, bl) == (341328, 43213)
check()
anvilLevel.close()
anvilLevel = WorldEditor(templevel.tmpname)
check()
def test_schematic_extended_ids(tmpdir):
filename = tmpdir.join("schematic_extended_ids.schematic").strpath
s = createSchematic(shape=(1, 1, 5))
s.adapter.Blocks[0, 0, 0] = 2048
s.saveToFile(filename)
del s
s = WorldEditor(filename)
assert s.adapter.Blocks[0, 0, 0] == 2048
def importSchematic(self, filename):
schematic = WorldEditor(filename, readonly=True)
ray = self.editorTab.currentView().rayAtCenter()
pos, face = rayCastInBounds(ray, self.currentDimension)
if pos is None:
pos = ray.point
name = os.path.basename(filename)
imp = PendingImport(schematic, pos, name)
command = PasteImportCommand(self, imp, "Import %s" % name)
self.undoStack.push(command)
def test_relight():
templevel = TempLevel("AnvilWorld")
anvilLevel = templevel
anvilDim = anvilLevel.getDimension()
bounds = anvilDim.bounds
point = bounds.origin + (bounds.size * (0.5, 0.5, 0.5))
box = bounds.expand(-100, 0, -100)
# box = BoundingBox((256, 0, 256), (64, anvilLevel.Height, 64))
chunks = [(cx, cz) for cx, cz in anvilDim.chunkPositions() if (cx << 4, 1, cz << 4) not in box]
for c in chunks:
anvilDim.deleteChunk(*c)
#anvilLevel = WorldEditor(filename=temppath, create=True)
station = WorldEditor("test_files/station.schematic")
stationDim = station.getDimension()
anvilDim.copyBlocks(stationDim, stationDim.bounds, point, create=True)
for cPos in anvilDim.chunkPositions():
anvilDim.getChunk(*cPos)
#anvilLevel.copyBlocksFrom(station, station.bounds, point + (station.Width, 0, 0), create=True)
anvilLevel.generateLights()
anvilLevel.saveChanges()
cx = int(point.x + 32) >> 4
cz = int(point.z + 32) >> 4
# os.system(sys.executable + " ../mcedit.py " + anvilLevel.filename)
def check():
sl = numpy.sum(anvilLevel.getChunk(cx, cz).SkyLight)
bl = numpy.sum(anvilLevel.getChunk(cx, cz).BlockLight)
assert (sl, bl) == (341328, 43213)
check()
anvilLevel.close()
anvilLevel = WorldEditor(templevel.tmpname)
check()
def load_empty_world():
"Load the empty world."
root = path.abspath(path.join(path.dirname(__file__), ".."))
folder = path.join(root, "assets", "EmptyMap")
result = path.join(root, "MapResult")
shutil.rmtree(result, ignore_errors=True)
shutil.rmtree(path.join(root, "##MapResult.UNDO##"), ignore_errors=True)
shutil.copytree(folder, result)
return WorldEditor(result)
def testFill(any_world):
dim = any_world.getDimension()
bounds = dim.bounds
box = BoundingBox(bounds.origin + (bounds.size / 2),
(64, bounds.height / 2, 64))
x, y, z = numpy.array(list(box.positions)).transpose()
dim.fillBlocks(box, any_world.blocktypes["planks"])
def checkEqual(a, b):
"""
:type a: ndarray
:type b: ndarray
"""
equal = a == b
if not equal.all():
assert False, "Coordinates not equal to %s: \nX: %s\nY: %s\nZ: %s" % (
b, x[~equal], y[~equal], z[~equal])
for cp in box.chunkPositions():
chunk = dim.getChunk(*cp)
for cy in chunk.bounds.sectionPositions(*cp):
assert chunk.getSection(
cy) is not None, "Section %s not found" % cy
checkEqual(
dim.getBlocks(x, y, z).Blocks, any_world.blocktypes["planks"].ID)
dim.fillBlocks(box, any_world.blocktypes["stone"],
[any_world.blocktypes["planks"]])
any_world.saveChanges()
any_world.close()
filename = any_world.filename
any_world = WorldEditor(filename)
checkEqual(any_world.getDimension().getBlocks(x, y, z).Blocks,
any_world.blocktypes["stone"].ID)
def __init__(self, worlds=None):
super(WorldListModel, self).__init__()
if worlds is None:
worlds = []
self.worlds = []
for f in worlds:
try:
info = WorldEditor.getWorldInfo(f)
except Exception as e:
log.warn("Error while getting world info, skipping...", exc_info=1)
continue
else:
self.worlds.append((f, info))
def main():
filename = "C:\Users\Rio\AppData\Roaming\.minecraft\saves\New World1_8"
worldEditor = WorldEditor(filename, readonly=True)
dim = worldEditor.getDimension()
positions = list(dim.chunkPositions())
installs = minecraftinstall.GetInstalls()
install = installs.getDefaultInstall()
loader = install.getResourceLoader(install.findVersion1_8(), None)
def loadModels():
o.models = BlockModels(worldEditor.blocktypes, loader)
def loadTextures():
o.textureAtlas = TextureAtlas(worldEditor,
loader,
o.models,
overrideMaxSize=2048)
o.textureAtlas.load()
def cookQuads():
o.models.cookQuads(o.textureAtlas)
def buildMeshes():
o.worldScene = WorldScene(dim, o.textureAtlas)
worker = o.worldScene.workOnChunk(dim.getChunk(*positions[0]))
for i in worker:
pass
print("loadModels x1 in %0.2fms" %
(timeit.timeit(loadModels, number=1) * 1000))
print("loadTextures x1 in %0.2fms" %
(timeit.timeit(loadTextures, number=1) * 1000))
print("cookQuads x1 in %0.2fms" %
(timeit.timeit(cookQuads, number=1) * 1000))
print("buildMeshes x1 in %0.2fms" %
(timeit.timeit(buildMeshes, number=1) * 1000))
def __init__(self, worlds=None):
super(WorldListModel, self).__init__()
if worlds is None:
worlds = []
self.worlds = []
for f in worlds:
try:
info = WorldEditor.getWorldInfo(f)
except Exception as e:
log.warn("Error while getting world info, skipping...",
exc_info=1)
continue
else:
self.worlds.append((f, info))
def test_extid_extract(tmpdir, extid_pc_world):
for size in [
(15, 15, 15),
(16, 16, 16),
(15, 16, 16),
(15, 16, 15),
]:
schem = extractSchematicFrom(extid_pc_world.getDimension(),
BoundingBox((0, 0, 0), size))
filename = tmpdir.join("extid_extract_%s_%s_%s" % size).strpath
schem.saveToFile(filename)
del schem
schem = WorldEditor(filename)
assert (schem.adapter.Blocks > 255).any()
def createSchematic(shape, blocktypes='Alpha'):
"""
Create a new .schematic of the given shape and blocktypes and return a WorldEditor.
Parameters
----------
shape : tuple of int
blocktypes : BlockTypeSet or str
Returns
-------
WorldEditor
"""
from mceditlib.worldeditor import WorldEditor
adapter = SchematicFileAdapter(shape=shape, blocktypes=blocktypes)
editor = WorldEditor(adapter=adapter)
return editor
def __init__(self, filename, configuredBlocks, readonly=False,
progressCallback=None):
"""
:param filename:
:type filename: str
:param configuredBlocks:
:type configuredBlocks: dict???
:param readonly:
:type readonly: bool
:param progressCallback:
:type progressCallback: callable
:return:
:rtype:
"""
from mcedit2 import __version__ as v
progressMax = 8 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.resourceLoader = minecraftinstall.getResourceLoaderForFilename(filename)
self.loader = None
self.blockModels = None
self.textureAtlas = None
self.editorTab = None
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.configuredBlocks = None
self.copiedSchematic = None # xxx should be app global!!
""":type : WorldEditor"""
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit %(version)s") % {"version": v})
msgBox.setText(self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(self.tr(
"MCEdit may have crashed. An undo history was found for this world. You may try "
"to resume editing with the saved undo history, or start over with the current "
"state of the world."))
resumeBtn = msgBox.addButton("Resume Editing", QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History", QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
# xxxxx resume editing not implemented in session - need to restore undo history!
clicked = None
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename, readonly=readonly, resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"), self, triggered=self.cut, enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"), self, triggered=self.copy, enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"), self, triggered=self.paste,
enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"), self,
triggered=self.pasteBlocks, enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"), self,
triggered=self.pasteEntities, enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"), self, triggered=self.deleteSelection,
enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"), self,
triggered=self.deleteBlocks, enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(self.tr("Delete Entities"), self,
triggered=self.deleteEntities, enabled=False)
self.actionDeleteEntities.setShortcut(QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"), self, triggered=self.fill, enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"), self,
triggered=self.findReplace, enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
self.actionAnalyze = QtGui.QAction(self.tr("Analyze"), self, triggered=self.analyze,
enabled=True)
# self.actionAnalyze.setShortcut(QtGui.QKeySequence.Analyze)
self.actionAnalyze.setObjectName("actionAnalyze")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menuEdit.addAction(self.actionAnalyze)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"), self, triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"), self, triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"), self, triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"), self, triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(self.tr("Show Exports Library"), self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# - Chunk -
self.menuChunk = QtGui.QMenu(self.tr("Chunk"))
self.actionDeleteChunks = QtGui.QAction(self.tr("Delete Chunks"), self, triggered=self.deleteChunks)
self.actionCreateChunks = QtGui.QAction(self.tr("Create Chunks"), self, triggered=self.createChunks)
self.actionRepopChunks = QtGui.QAction(self.tr("Mark Chunks For Repopulation"),
self, triggered=self.repopChunks)
self.menuChunk.addAction(self.actionDeleteChunks)
self.menuChunk.addAction(self.actionCreateChunks)
self.menuChunk.addAction(self.actionRepopChunks)
self.menus.append(self.menuChunk)
# --- Resources ---
self.geometryCache = GeometryCache()
progress("Loading textures and models...")
self.setConfiguredBlocks(configuredBlocks) # Must be called after resourceLoader is in place
self.editorOverlay = scenenode.Node()
self.biomeTypes = BiomeTypes()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.mapPanel = MapPanel(self)
self.worldInfoPanel = WorldInfoPanel(self)
self.panels = [self.playerPanel, self.worldInfoPanel, self.mapPanel]
self.panelActions = []
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {action.toolName: action for action in self.toolActions}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(dimAction)
mcVersionButton = self.changeMCVersionButton = QtGui.QToolButton()
mcVersionButton.setText(self.minecraftVersionLabel())
mcVersionAction = self.changeMCVersionAction = QtGui.QWidgetAction(self)
mcVersionAction.setDefaultWidget(mcVersionButton)
self.mcVersionMenu = QtGui.QMenu()
mcVersionButton.setMenu(self.mcVersionMenu)
mcVersionButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(mcVersionAction)
resourcePackButton = self.changeResourcePackButton = QtGui.QToolButton()
resourcePackButton.setText(self.resourcePackLabel())
resourcePackAction = self.changeResourcePackAction = QtGui.QWidgetAction(self)
resourcePackAction.setDefaultWidget(resourcePackButton)
self.resourcePackMenu = QtGui.QMenu()
resourcePackButton.setMenu(self.resourcePackMenu)
resourcePackButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(resourcePackAction)
self._updateVersionsAndResourcePacks()
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.editorTab.urlsDropped.connect(self.urlsWereDropped)
self.editorTab.mapItemDropped.connect(self.mapItemWasDropped)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"), objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append((Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
# Must be called after toolChanged is connected to editorTab
self.toolActions[0].trigger()
if hasattr(progress, 'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.", progress.progressCount)
class EditorSession(QtCore.QObject):
def __init__(self, filename, configuredBlocks, readonly=False,
progressCallback=None):
"""
:param filename:
:type filename: str
:param configuredBlocks:
:type configuredBlocks: dict???
:param readonly:
:type readonly: bool
:param progressCallback:
:type progressCallback: callable
:return:
:rtype:
"""
from mcedit2 import __version__ as v
progressMax = 8 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.resourceLoader = minecraftinstall.getResourceLoaderForFilename(filename)
self.loader = None
self.blockModels = None
self.textureAtlas = None
self.editorTab = None
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.configuredBlocks = None
self.copiedSchematic = None # xxx should be app global!!
""":type : WorldEditor"""
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit %(version)s") % {"version": v})
msgBox.setText(self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(self.tr(
"MCEdit may have crashed. An undo history was found for this world. You may try "
"to resume editing with the saved undo history, or start over with the current "
"state of the world."))
resumeBtn = msgBox.addButton("Resume Editing", QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History", QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
# xxxxx resume editing not implemented in session - need to restore undo history!
clicked = None
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename, readonly=readonly, resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"), self, triggered=self.cut, enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"), self, triggered=self.copy, enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"), self, triggered=self.paste,
enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"), self,
triggered=self.pasteBlocks, enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"), self,
triggered=self.pasteEntities, enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"), self, triggered=self.deleteSelection,
enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"), self,
triggered=self.deleteBlocks, enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(self.tr("Delete Entities"), self,
triggered=self.deleteEntities, enabled=False)
self.actionDeleteEntities.setShortcut(QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"), self, triggered=self.fill, enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"), self,
triggered=self.findReplace, enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
self.actionAnalyze = QtGui.QAction(self.tr("Analyze"), self, triggered=self.analyze,
enabled=True)
# self.actionAnalyze.setShortcut(QtGui.QKeySequence.Analyze)
self.actionAnalyze.setObjectName("actionAnalyze")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menuEdit.addAction(self.actionAnalyze)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"), self, triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"), self, triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"), self, triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"), self, triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(self.tr("Show Exports Library"), self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# - Chunk -
self.menuChunk = QtGui.QMenu(self.tr("Chunk"))
self.actionDeleteChunks = QtGui.QAction(self.tr("Delete Chunks"), self, triggered=self.deleteChunks)
self.actionCreateChunks = QtGui.QAction(self.tr("Create Chunks"), self, triggered=self.createChunks)
self.actionRepopChunks = QtGui.QAction(self.tr("Mark Chunks For Repopulation"),
self, triggered=self.repopChunks)
self.menuChunk.addAction(self.actionDeleteChunks)
self.menuChunk.addAction(self.actionCreateChunks)
self.menuChunk.addAction(self.actionRepopChunks)
self.menus.append(self.menuChunk)
# --- Resources ---
self.geometryCache = GeometryCache()
progress("Loading textures and models...")
self.setConfiguredBlocks(configuredBlocks) # Must be called after resourceLoader is in place
self.editorOverlay = scenenode.Node()
self.biomeTypes = BiomeTypes()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.mapPanel = MapPanel(self)
self.worldInfoPanel = WorldInfoPanel(self)
self.panels = [self.playerPanel, self.worldInfoPanel, self.mapPanel]
self.panelActions = []
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {action.toolName: action for action in self.toolActions}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(dimAction)
mcVersionButton = self.changeMCVersionButton = QtGui.QToolButton()
mcVersionButton.setText(self.minecraftVersionLabel())
mcVersionAction = self.changeMCVersionAction = QtGui.QWidgetAction(self)
mcVersionAction.setDefaultWidget(mcVersionButton)
self.mcVersionMenu = QtGui.QMenu()
mcVersionButton.setMenu(self.mcVersionMenu)
mcVersionButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(mcVersionAction)
resourcePackButton = self.changeResourcePackButton = QtGui.QToolButton()
resourcePackButton.setText(self.resourcePackLabel())
resourcePackAction = self.changeResourcePackAction = QtGui.QWidgetAction(self)
resourcePackAction.setDefaultWidget(resourcePackButton)
self.resourcePackMenu = QtGui.QMenu()
resourcePackButton.setMenu(self.resourcePackMenu)
resourcePackButton.setPopupMode(QtGui.QToolButton.InstantPopup)
self.panelActions.append(resourcePackAction)
self._updateVersionsAndResourcePacks()
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.editorTab.urlsDropped.connect(self.urlsWereDropped)
self.editorTab.mapItemDropped.connect(self.mapItemWasDropped)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"), objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append((Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
# Must be called after toolChanged is connected to editorTab
self.toolActions[0].trigger()
if hasattr(progress, 'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.", progress.progressCount)
def minecraftVersionLabel(self):
version = minecraftinstall.currentVersionOption.value()
return "Minecraft Version: %s" % version
def resourcePackLabel(self):
resourcePack = minecraftinstall.currentResourcePackOption.value()
return "Resource Pack: %s" % resourcePack
def _updateVersionsAndResourcePacks(self):
self.mcVersionMapper = QtCore.QSignalMapper()
self.mcVersionMapper.mapped[str].connect(self.changeMCVersion)
self.resourcePackMapper = QtCore.QSignalMapper()
self.resourcePackMapper.mapped[str].connect(self.changeResourcePack)
self.mcVersionMenu.clear()
self.resourcePackMenu.clear()
defaultAction = self.resourcePackMenu.addAction(self.tr("(No resource pack)"))
self.resourcePackMapper.setMapping(defaultAction, "")
install = minecraftinstall.GetInstalls().getCurrentInstall()
for version in sorted(install.versions, reverse=True):
versionAction = self.mcVersionMenu.addAction(version)
self.mcVersionMapper.setMapping(versionAction, version)
versionAction.triggered.connect(self.mcVersionMapper.map)
for resourcePack in sorted(install.resourcePacks):
resourcePackAction = self.resourcePackMenu.addAction(resourcePack)
self.resourcePackMapper.setMapping(resourcePackAction, resourcePack)
resourcePackAction.triggered.connect(self.resourcePackMapper.map)
def changeResourcePack(self, packName):
minecraftinstall.currentResourcePackOption.setValue(packName or "")
self.resourceLoader = minecraftinstall.getResourceLoaderForFilename(self.filename)
self.changeResourcePackButton.setText(self.resourcePackLabel())
self.reloadModels()
def changeMCVersion(self, version):
minecraftinstall.currentVersionOption.setValue(version)
self.resourceLoader = minecraftinstall.getResourceLoaderForFilename(self.filename)
self.changeMCVersionButton.setText(self.minecraftVersionLabel())
self.reloadModels()
# Connecting these signals to the EditorTab creates a circular reference through
# the Qt objects, preventing the EditorSession from being destroyed
def focusWorldView(self):
self.editorTab.currentView().setFocus()
def updateView(self):
self.editorTab.currentView().update()
def toolDidChange(self, tool):
self.editorTab.toolDidChange(tool)
# --- Block config ---
# Emitted when configuredBlocks is changed. TextureAtlas and BlockModels will also have changed.
configuredBlocksChanged = QtCore.Signal()
def setConfiguredBlocks(self, configuredBlocks):
blocktypes = self.worldEditor.blocktypes
if self.configuredBlocks is not None:
# Remove all previously configured blocks
deadJsons = []
for json in blocktypes.blockJsons:
if '__configured__' in json:
deadJsons.append(json)
deadIDs = set((j['internalName'], j['meta']) for j in deadJsons)
blocktypes.allBlocks[:] = [
bt for bt in blocktypes.allBlocks
if (bt.internalName, bt.meta) not in deadIDs
]
for json in deadJsons:
internalName = json['internalName']
fakeState = json['blockState']
blocktypes.blockJsons.remove(json)
ID = blocktypes.IDsByName[internalName]
del blocktypes.IDsByState[internalName + fakeState]
del blocktypes.statesByID[ID, json['meta']]
for blockDef in configuredBlocks:
internalName = blockDef.internalName
if internalName not in blocktypes.IDsByName:
# no ID mapped to this name, skip
continue
if blockDef.meta == 0:
blockType = blocktypes[internalName]
blockJson = blockType.json
else:
# not automatically created by FML mapping loader
ID = blocktypes.IDsByName[internalName]
fakeState = '[%d]' % blockDef.meta
nameAndState = internalName + fakeState
blocktypes.blockJsons[nameAndState] = {
'displayName': internalName,
'internalName': internalName,
'blockState': fakeState,
'unknown': False,
'meta': blockDef.meta,
}
blockType = BlockType(ID, blockDef.meta, blocktypes)
blocktypes.allBlocks.append(blockType)
blocktypes.IDsByState[nameAndState] = ID, blockDef.meta
blocktypes.statesByID[ID, blockDef.meta] = nameAndState
blockJson = blockType.json
blockJson['forcedModel'] = blockDef.modelPath
blockJson['forcedModelTextures'] = blockDef.modelTextures
blockJson['forcedModelRotation'] = blockDef.modelRotations
blockJson['forcedRotationFlags'] = blockDef.rotationFlags
blockJson['__configured__'] = True
self.configuredBlocks = configuredBlocks
self.reloadModels()
self.configuredBlocksChanged.emit()
def reloadModels(self):
self.blockModels = BlockModels(self.worldEditor.blocktypes, self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader, self.blockModels)
# May be called before editorTab is created
if self.editorTab:
for view in self.editorTab.views:
view.setTextureAtlas(self.textureAtlas)
# --- Selection ---
selectionChanged = QtCore.Signal(BoundingBox)
_currentSelection = None
@property
def currentSelection(self):
return self._currentSelection
@currentSelection.setter
def currentSelection(self, box):
self._currentSelection = box
self.enableSelectionCommands(box is not None and box.volume != 0)
self.enableChunkSelectionCommands(box is not None)
self.selectionChanged.emit(box)
def enableSelectionCommands(self, enable):
self.actionCut.setEnabled(enable)
self.actionCopy.setEnabled(enable)
self.actionPaste.setEnabled(enable)
self.actionPaste_Blocks.setEnabled(enable)
self.actionPaste_Entities.setEnabled(enable)
self.actionClear.setEnabled(enable)
self.actionDeleteBlocks.setEnabled(enable)
self.actionDeleteEntities.setEnabled(enable)
self.actionFill.setEnabled(enable)
self.actionExport.setEnabled(enable)
def enableChunkSelectionCommands(self, enable):
self.actionDeleteChunks.setEnabled(enable)
self.actionCreateChunks.setEnabled(enable)
self.actionRepopChunks.setEnabled(enable)
# --- Menu commands ---
# - World -
def save(self):
self.undoStack.clearUndoBlock()
saveTask = self.worldEditor.saveChangesIter()
showProgress("Saving...", saveTask)
self.dirty = False
# - Edit -
def cut(self):
command = SimpleRevisionCommand(self, "Cut")
with command.begin():
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Cutting...", task)
task = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Cutting...", task)
self.undoStack.push(command)
def copy(self):
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Copying...", task)
def paste(self):
if self.copiedSchematic is None:
return
view = self.editorTab.currentView()
imp = PendingImport(self.copiedSchematic, view.mouseBlockPos, self.tr("<Pasted Object>"))
command = PasteImportCommand(self, imp, "Paste")
self.undoStack.push(command)
def pasteBlocks(self):
NotImplementedYet()
def pasteEntities(self):
NotImplementedYet()
def findReplace(self):
self.findReplaceDialog.exec_()
def analyze(self):
if self.currentSelection is None:
return
task = self.currentDimension.analyzeIter(self.currentSelection)
showProgress("Analyzing...", task)
outputDialog = AnalyzeOutputDialog(self, task.blocks,
task.entityCounts,
task.tileEntityCounts,
task.dimension.worldEditor.displayName)
def deleteSelection(self):
command = SimpleRevisionCommand(self, "Delete")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
task = ComposeOperations(fillTask, entitiesTask)
showProgress("Deleting...", task)
self.pushCommand(command)
def deleteBlocks(self):
command = SimpleRevisionCommand(self, "Delete Blocks")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Deleting...", fillTask)
self.pushCommand(command)
def deleteEntities(self):
command = SimpleRevisionCommand(self, "Delete Entities")
with command.begin():
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
showProgress("Deleting...", entitiesTask)
self.pushCommand(command)
def fill(self):
fillCommand(self)
# - Select -
def selectAll(self):
command = SelectCommand(self, self.currentDimension.bounds, self.tr("Select All"))
self.pushCommand(command)
def deselect(self):
command = SelectCommand(self, None)
command.setText(self.tr("Deselect"))
self.pushCommand(command)
# - Chunk -
def deleteChunks(self):
if self.currentSelection is None:
return
command = SimpleRevisionCommand(self, self.tr("Delete Chunks"))
with command.begin():
for cx in range(self.currentSelection.mincx, self.currentSelection.maxcx):
for cz in range(self.currentSelection.mincz, self.currentSelection.maxcz):
self.currentDimension.deleteChunk(cx, cz)
self.pushCommand(command)
def createChunks(self):
QtGui.QMessageBox.warning(QtGui.qApp.mainWindow, "Not implemented.", "Create chunks is not implemented yet!")
def repopChunks(self):
QtGui.QMessageBox.warning(QtGui.qApp.mainWindow, "Not implemented.", "Repop chunks is not implemented yet!")
# - Dimensions -
dimensionChanged = QtCore.Signal(object)
_dimDisplayNames = {"": "Overworld",
"DIM-1": "Nether",
"DIM1": "The End",
}
def dimensionDisplayName(self, dimName):
return self._dimDisplayNames.get(dimName, dimName)
def dimensionMenuLabel(self, dimName):
return self.tr("Dimension: %s" % self.dimensionDisplayName(dimName))
def gotoDimension(self, dimName):
dim = self.worldEditor.getDimension(dimName)
if dim is self.currentDimension:
return
log.info("Going to dimension %s", dimName)
self.changeDimensionButton.setText(self.dimensionMenuLabel(dimName))
self.currentDimension = dim
self.loader = chunkloader.ChunkLoader(self.currentDimension)
self.loader.chunkCompleted.connect(self.chunkDidComplete)
self.loader.allChunksDone.connect(self.updateView)
self.revisionChanged.connect(self.loader.revisionDidChange)
self.dimensionChanged.emit(dim)
# - Import/export -
def import_(self):
# prompt for a file to import
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getOpenFileName(QtGui.qApp.mainWindow, self.tr("Import"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
self.importSchematic(filename)
def export(self):
# prompt for filename and format. maybe use custom browser to save to export library??
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getSaveFileName(QtGui.qApp.mainWindow,
self.tr("Export Schematic"),
startingDir,
"Schematic files (*.schematic)")
if result:
filename = result[0]
if filename:
task = self.currentDimension.exportSchematicIter(self.currentSelection)
schematic = showProgress("Copying...", task)
schematic.saveToFile(filename)
# --- Drag-and-drop ---
def urlsWereDropped(self, mimeData, position, face):
log.info("URLs dropped:\n%s", mimeData.urls())
def mapItemWasDropped(self, mimeData, position, face):
log.info("Map item dropped.")
assert mimeData.hasFormat(MimeFormats.MapItem)
mapIDString = mimeData.data(MimeFormats.MapItem).data()
mapIDs = mapIDString.split(", ")
mapIDs = [int(m) for m in mapIDs]
mapID = mapIDs[0] # xxx only one at a time for now
position = position + face.vector
x, y, z = position
cx = x >> 4
cz = z >> 4
try:
chunk = self.currentDimension.getChunk(cx, cz)
except ChunkNotPresent:
log.info("Refusing to import map into non-existent chunk %s", (cx, cz))
return
ref = self.worldEditor.createEntity("ItemFrame")
if ref is None:
return
facing = ref.facingForMCEditFace(face)
if facing is None:
# xxx by camera vector?
facing = ref.SouthFacing
ref.Item.Damage = mapID
ref.Item.id = "minecraft:filled_map"
ref.Position = position + (0.5, 0.5, 0.5)
ref.TilePos = position # 1.7/1.8 issues should be handled by ref...
ref.Facing = facing
log.info("Created map ItemFrame with ID %s, importing...", mapID)
command = SimpleRevisionCommand(self, self.tr("Import map %(mapID)s") % {"mapID": mapID})
with command.begin():
chunk.addEntity(ref)
log.info(nbt.nested_string(ref.rootTag))
self.pushCommand(command)
# --- Library support ---
def importSchematic(self, filename):
schematic = WorldEditor(filename, readonly=True)
ray = self.editorTab.currentView().rayAtCenter()
pos, face = rayCastInBounds(ray, self.currentDimension)
if pos is None:
pos = ray.point
name = os.path.basename(filename)
imp = PendingImport(schematic, pos, name)
command = PasteImportCommand(self, imp, "Import %s" % name)
self.undoStack.push(command)
# --- Undo support ---
revisionChanged = QtCore.Signal(RevisionChanges)
def undoIndexChanged(self, index):
self.editorTab.currentView().update()
def pushCommand(self, command):
log.info("Pushing command %s" % command.text())
self.undoStack.push(command)
def setUndoBlock(self, callback):
self.undoStack.setUndoBlock(callback)
def removeUndoBlock(self, callback):
self.undoStack.removeUndoBlock(callback)
def beginUndo(self):
self.undoStack.clearUndoBlock()
self.dirty = True
self.worldEditor.beginUndo()
def commitUndo(self):
exhaust(self.commitUndoIter())
def commitUndoIter(self):
for status in self.worldEditor.commitUndoIter():
yield status
changes = self.worldEditor.getRevisionChanges(self.currentRevision-1, self.currentRevision)
self.revisionChanged.emit(changes)
def undoForward(self):
self.worldEditor.redo()
changes = self.worldEditor.getRevisionChanges(self.currentRevision-1, self.currentRevision)
self.revisionChanged.emit(changes)
def undoBackward(self):
self.worldEditor.undo()
changes = self.worldEditor.getRevisionChanges(self.currentRevision, self.currentRevision+1)
self.revisionChanged.emit(changes)
def gotoRevision(self, index):
if index != self.currentRevision:
changes = self.worldEditor.getRevisionChanges(self.currentRevision, index)
self.worldEditor.gotoRevision(index)
self.revisionChanged.emit(changes)
@property
def currentRevision(self):
return self.worldEditor.currentRevision
# --- Misplaced startup code? ---
def loadDone(self):
# Called by MCEditApp after the view is on screen to make sure view.center() works correctly
# xxx was needed because view.centerOnPoint used a depthbuffer read for that, now what?
try:
try:
player = self.worldEditor.getPlayer()
center = Vector(*player.Position) + (0, 1.8, 0)
dimNo = player.Dimension
dimName = self.worldEditor.dimNameFromNumber(dimNo)
log.info("Setting view angle to single-player player's view in dimension %s.",
dimName)
rotation = player.Rotation
if dimName:
self.gotoDimension(dimName)
try:
self.editorTab.currentView().yawPitch = rotation
except AttributeError:
pass
except PlayerNotFound:
try:
center = self.worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = self.currentDimension.bounds.origin + (self.currentDimension.bounds.size * 0.5)
self.editorTab.miniMap.centerOnPoint(center)
self.editorTab.currentView().centerOnPoint(center, distance=0)
except Exception as e:
log.exception("Error while centering on player for world editor: %s", e)
# --- Tools ---
def toolShortcut(self, name):
toolShortcuts = {
"Select": "S",
"Create": "D",
}
return toolShortcuts.get(name, "")
def getTool(self, name):
for t in self.tools:
if t.name == name:
return t
def chooseTool(self, name):
oldTool = self.currentTool
self.currentTool = self.getTool(name)
if oldTool is not self.currentTool:
if oldTool:
oldTool.toolInactive()
self.currentTool.toolActive()
self.toolChanged.emit(self.currentTool)
self.actionsByName[name].setChecked(True)
toolChanged = QtCore.Signal(object)
def chunkDidComplete(self):
from mcedit2 import editorapp
editorapp.MCEditApp.app.updateStatusLabel(None, None, None, self.loader.cps,
self.editorTab.currentView().fps)
def updateStatusFromEvent(self, event):
from mcedit2 import editorapp
if event.blockPosition:
id = self.currentDimension.getBlockID(*event.blockPosition)
data = self.currentDimension.getBlockData(*event.blockPosition)
block = self.worldEditor.blocktypes[id, data]
biomeID = self.currentDimension.getBiomeID(event.blockPosition[0],
event.blockPosition[2])
biome = self.biomeTypes.types.get(biomeID)
if biome is not None:
biomeName = biome.name
else:
biomeName = "Unknown biome"
biomeText = "%s (%d)" % (biomeName, biomeID)
editorapp.MCEditApp.app.updateStatusLabel(event.blockPosition, block, biomeText,
self.loader.cps, event.view.fps)
else:
editorapp.MCEditApp.app.updateStatusLabel('(N/A)', None, None, self.loader.cps,
event.view.fps)
def viewMousePress(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mousePress') and event.blockPosition is not None:
self.currentTool.mousePress(event)
self.editorTab.currentView().update()
def viewMouseMove(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseMove'):
self.currentTool.mouseMove(event)
self.editorTab.currentView().update()
def viewMouseDrag(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseDrag'):
self.currentTool.mouseDrag(event)
self.editorTab.currentView().update()
def viewMouseRelease(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseRelease'):
self.currentTool.mouseRelease(event)
self.editorTab.currentView().update()
# --- EditorTab handling ---
def tabCaption(self):
return util.displayName(self.filename)
def closeTab(self):
if self.worldEditor is None:
return True
if self.dirty:
msgBox = QtGui.QMessageBox(self.editorTab.window())
msgBox.setText("The world has been modified.")
msgBox.setInformativeText("Do you want to save your changes?")
msgBox.setStandardButtons(
QtGui.QMessageBox.Save | QtGui.QMessageBox.Discard | QtGui.QMessageBox.Cancel)
msgBox.setDefaultButton(QtGui.QMessageBox.Save)
ret = msgBox.exec_()
if ret == QtGui.QMessageBox.Save:
self.save()
if ret == QtGui.QMessageBox.Cancel:
return False
for panel in self.panels:
panel.close()
self.editorTab.saveState()
self.worldEditor.close()
self.worldEditor = None
return True
# --- Inspector ---
def inspectBlock(self, pos):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectBlock(pos)
def inspectEntity(self, entity):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectEntity(entity)
def inspectChunk(self, cx, cz):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectChunk(cx, cz)
# --- Zooming ---
def zoomAndInspectBlock(self, pos):
self.zoomToPoint(pos)
self.inspectBlock(pos)
def zoomAndInspectEntity(self, entity):
self.zoomToPoint(entity.Position)
self.inspectEntity(entity)
def zoomToPoint(self, point):
self.editorTab.currentView().centerOnPoint(point, 15)
# --- Blocktype handling ---
def unknownBlocks(self):
for blocktype in self.worldEditor.blocktypes:
if blocktype.unknown:
yield blocktype.internalName
def copy_temp_level(tmpdir, filename):
return WorldEditor(copy_temp_file(tmpdir, filename).strpath)
def manmade_relight(test):
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
stationEditor = WorldEditor("test_files/station.schematic")
station = stationEditor.getDimension()
startCopy = time.time()
box = do_copy(dim, station, False)
copyTime = time.time() - startCopy
print("Copy took %f seconds. Reducing relight-in-copyBlocks times by this much." % copyTime)
positions = []
for cx, cz in box.chunkPositions():
for cy in box.sectionPositions(cx, cz):
positions.append((cx, cy, cz))
assert len(positions) > box.chunkCount
if test == "post" or test == "all":
def postCopy(): # profiling
start = time.time()
count = 0
print("Relighting outside of copyBlocks. Updating %d cells" % (len(positions) * 16 * 16 * 16))
for cx, cy, cz in positions:
indices = numpy.indices((16, 16, 16), numpy.int32)
indices.shape = 3, 16*16*16
indices += ([cx << 4], [cy << 4], [cz << 4])
x, y, z = indices
relight.updateLightsByCoord(dim, x, y, z)
count += 1
t = time.time() - start
print "Relight manmade building (outside copyBlocks): " \
"%d (out of %d) chunk-sections in %.02f seconds (%f sections per second; %dms per section)" \
% (count, len(positions), t, count / t, 1000 * t / count)
postCopy()
if test == "smart" or test == "all":
def allSections():
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
start = time.time()
do_copy(dim, station, "all")
t = time.time() - start - copyTime
print "Relight manmade building (in copyBlocks, all sections): " \
"%d chunk-sections in %.02f seconds (%f sections per second; %dms per section)" \
% (len(positions), t, len(positions) / t, 1000 * t / len(positions))
allSections()
if test == "section" or test == "all":
def perSection():
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
start = time.time()
do_copy(dim, station, "section")
t = time.time() - start - copyTime
print "Relight manmade building (in copyBlocks, for each section): " \
"%d chunk-sections in %.02f seconds (%f sections per second; %dms per section)" \
% (len(positions), t, len(positions) / t, 1000 * t / len(positions))
perSection()
class EditorSession(QtCore.QObject):
def __init__(self, filename, versionInfo, readonly=False, progressCallback=None):
progressMax = 7 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.copiedSchematic = None
""":type : WorldEditor"""
self.versionInfo = versionInfo
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit tech demo"))
msgBox.setText(self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(self.tr(
"MCEdit may have crashed. An undo history was found for this world. You may try to resume editing "
"with the saved undo history, or start over with the current state of the world."))
resumeBtn = msgBox.addButton("Resume Editing", QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History", QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
clicked = None # xxxxx
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename, readonly=readonly, resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"), self, triggered=self.cut, enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"), self, triggered=self.copy, enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"), self, triggered=self.paste, enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"), self, triggered=self.pasteBlocks, enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"), self, triggered=self.pasteEntities, enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"), self, triggered=self.deleteSelection, enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"), self, triggered=self.deleteBlocks, enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(self.tr("Delete Entities"), self, triggered=self.deleteEntities, enabled=False)
self.actionDeleteEntities.setShortcut(QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"), self, triggered=self.fill, enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"), self, triggered=self.findReplace, enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"), self, triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"), self, triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"), self, triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"), self, triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(self.tr("Show Exports Library"), self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# --- Resources ---
progress("Loading resources...")
i, v, p = self.versionInfo
self.resourceLoader = i.getResourceLoader(v, p)
self.geometryCache = GeometryCache()
self.blockModels = BlockModels(self.worldEditor.blocktypes, self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader, self.blockModels)
self.editorOverlay = scenegraph.Node()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.panels = [self.playerPanel]
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {action.toolName: action for action in self.toolActions}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(dimButton.InstantPopup)
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"), objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append((Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
self.toolActions[0].trigger() # Must be called after toolChanged is connected to editorTab
if hasattr(progress, 'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.", progress.progressCount)
def dispose(self):
if self.textureAtlas:
self.textureAtlas.dispose()
self.textureAtlas = None
if self.editorTab:
self.editorTab.destroy()
self.editorTab = None
if self.worldEditor:
self.worldEditor.close()
self.worldEditor = None
# Connecting these signals to the EditorTab creates a circular reference through
# the Qt objects, preventing the EditorSession from being destroyed
def focusWorldView(self):
self.editorTab.currentView().setFocus()
def updateView(self):
self.editorTab.currentView().update()
def toolDidChange(self, tool):
self.editorTab.toolDidChange(tool)
# --- Selection ---
selectionChanged = QtCore.Signal(BoundingBox)
_currentSelection = None
@property
def currentSelection(self):
return self._currentSelection
@currentSelection.setter
def currentSelection(self, box):
self._currentSelection = box
self.enableSelectionCommands(box is not None and box.volume != 0)
self.selectionChanged.emit(box)
def enableSelectionCommands(self, enable):
self.actionCut.setEnabled(enable)
self.actionCopy.setEnabled(enable)
self.actionPaste.setEnabled(enable)
self.actionPaste_Blocks.setEnabled(enable)
self.actionPaste_Entities.setEnabled(enable)
self.actionClear.setEnabled(enable)
self.actionDeleteBlocks.setEnabled(enable)
self.actionDeleteEntities.setEnabled(enable)
self.actionFill.setEnabled(enable)
self.actionExport.setEnabled(enable)
# --- Menu commands ---
# - World -
def save(self):
self.undoStack.clearUndoBlock()
self.worldEditor.saveChanges()
self.dirty = False
# - Edit -
def cut(self):
command = SimpleRevisionCommand(self, "Cut")
with command.begin():
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Cutting...", task)
task = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Cutting...", task)
self.undoStack.push(command)
def copy(self):
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Copying...", task)
def paste(self):
if self.copiedSchematic is None:
return
view = self.editorTab.currentView()
imp = PendingImport(self.copiedSchematic, view.mouseBlockPos, self.tr("<Pasted Object>"))
command = PasteImportCommand(self, imp, "Paste")
self.undoStack.push(command)
def pasteBlocks(self):
NotImplementedYet()
def pasteEntities(self):
NotImplementedYet()
def findReplace(self):
self.findReplaceDialog.exec_()
def deleteSelection(self):
command = SimpleRevisionCommand(self, "Delete")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
task = ComposeOperations(fillTask, entitiesTask)
showProgress("Deleting...", task)
self.pushCommand(command)
def deleteBlocks(self):
command = SimpleRevisionCommand(self, "Delete Blocks")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Deleting...", fillTask)
self.pushCommand(command)
def deleteEntities(self):
command = SimpleRevisionCommand(self, "Delete Entities")
with command.begin():
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
showProgress("Deleting...", entitiesTask)
self.pushCommand(command)
def fill(self):
fillCommand(self)
# - Select -
def selectAll(self):
command = SelectCommand(self, self.currentDimension.bounds, self.tr("Select All"))
self.pushCommand(command)
def deselect(self):
command = SelectCommand(self, None)
command.setText(self.tr("Deselect"))
self.pushCommand(command)
# - Dimensions -
dimensionChanged = QtCore.Signal(object)
_dimDisplayNames = {"": "Overworld",
"DIM-1": "Nether",
"DIM1": "The End",
}
def dimensionDisplayName(self, dimName):
return self._dimDisplayNames.get(dimName, dimName)
def dimensionMenuLabel(self, dimName):
return self.tr("Dimension: %s" % self.dimensionDisplayName(dimName))
def gotoDimension(self, dimName):
dim = self.worldEditor.getDimension(dimName)
if dim is self.currentDimension:
return
log.info("Going to dimension %s", dimName)
self.changeDimensionButton.setText(self.dimensionMenuLabel(dimName))
self.currentDimension = dim
self.loader = chunkloader.ChunkLoader(self.currentDimension)
self.loader.chunkCompleted.connect(self.chunkDidComplete)
self.loader.allChunksDone.connect(self.updateView)
self.dimensionChanged.emit(dim)
# - Import/export -
def import_(self):
# prompt for a file to import
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getOpenFileName(self.mainWindow, self.tr("Import"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
self.importSchematic(filename)
def export(self):
# prompt for filename and format. maybe use custom browser to save to export library??
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getSaveFileName(QtGui.qApp.mainWindow,
self.tr("Export Schematic"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
task = self.currentDimension.exportSchematicIter(self.currentSelection)
schematic = showProgress("Copying...", task)
schematic.saveToFile(filename)
# --- Library support ---
def importSchematic(self, filename):
schematic = WorldEditor(filename, readonly=True)
ray = self.editorTab.currentView().rayAtCenter()
pos, face = rayCastInBounds(ray, self.currentDimension)
if pos is None:
pos = ray.point
name = os.path.basename(filename)
imp = PendingImport(schematic, pos, name)
command = PasteImportCommand(self, imp, "Import %s" % name)
self.undoStack.push(command)
# --- Undo support ---
revisionChanged = QtCore.Signal(int)
def undoIndexChanged(self, index):
self.editorTab.currentView().update()
def pushCommand(self, command):
self.undoStack.push(command)
def setUndoBlock(self, callback):
self.undoStack.setUndoBlock(callback)
def removeUndoBlock(self, callback):
self.undoStack.removeUndoBlock(callback)
def beginUndo(self):
self.undoStack.clearUndoBlock()
self.dirty = True
self.worldEditor.beginUndo()
def commitUndo(self):
self.worldEditor.commitUndo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def undoForward(self):
self.worldEditor.redo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def undoBackward(self):
self.worldEditor.undo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def gotoRevision(self, index):
if index != self.currentRevision:
self.worldEditor.gotoRevision(index)
self.revisionChanged.emit(self.worldEditor.currentRevision)
@property
def currentRevision(self):
return self.worldEditor.currentRevision
# --- Misplaced startup code? ---
def loadDone(self):
# Called by MCEditApp after the view is on screen to make sure view.center() works correctly xxx used depth
# buffer read for that, now what?
try:
player = self.worldEditor.getPlayer()
center = Vector(*player.Position) + (0, 1.8, 0)
log.info("Setting view angle to single-player player's view.")
rotation = player.Rotation
try:
self.editorTab.currentView().yawPitch = rotation
except AttributeError:
pass
except PlayerNotFound:
try:
center = self.worldEditor.worldSpawnPosition()
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = self.currentDimension.bounds.origin + (self.currentDimension.bounds.size * 0.5)
self.editorTab.miniMap.centerOnPoint(center)
self.editorTab.currentView().centerOnPoint(center, distance=0)
# --- Tools ---
def toolShortcut(self, name):
toolShortcuts = {
"Select": "S",
"Create": "D",
}
return toolShortcuts.get(name, "")
def getTool(self, name):
for t in self.tools:
if t.name == name:
return t
def chooseTool(self, name):
oldTool = self.currentTool
self.currentTool = self.getTool(name)
if oldTool is not self.currentTool:
if oldTool:
oldTool.toolInactive()
self.currentTool.toolActive()
self.toolChanged.emit(self.currentTool)
self.actionsByName[name].setChecked(True)
toolChanged = QtCore.Signal(object)
def chunkDidComplete(self):
from mcedit2 import editorapp
editorapp.MCEditApp.app.updateStatusLabel(None, None, self.loader.cps, self.editorTab.currentView().fps)
def updateStatusFromEvent(self, event):
from mcedit2 import editorapp
if event.blockPosition:
id = self.currentDimension.getBlockID(*event.blockPosition)
data = self.currentDimension.getBlockData(*event.blockPosition)
block = self.worldEditor.blocktypes[id, data]
editorapp.MCEditApp.app.updateStatusLabel(event.blockPosition, block, self.loader.cps, event.view.fps)
else:
editorapp.MCEditApp.app.updateStatusLabel('(N/A)', None, self.loader.cps, event.view.fps)
def viewMousePress(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mousePress') and event.blockPosition is not None:
self.currentTool.mousePress(event)
self.editorTab.currentView().update()
def viewMouseMove(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseMove'):
self.currentTool.mouseMove(event)
self.editorTab.currentView().update()
def viewMouseDrag(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseDrag'):
self.currentTool.mouseDrag(event)
self.editorTab.currentView().update()
def viewMouseRelease(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseRelease'):
self.currentTool.mouseRelease(event)
self.editorTab.currentView().update()
# --- EditorTab handling ---
def tabCaption(self):
return util.displayName(self.filename)
def closeTab(self):
if self.worldEditor is None:
return True
if self.dirty:
msgBox = QtGui.QMessageBox(self.editorTab.window())
msgBox.setText("The world has been modified.")
msgBox.setInformativeText("Do you want to save your changes?")
msgBox.setStandardButtons(QtGui.QMessageBox.Save | QtGui.QMessageBox.Discard | QtGui.QMessageBox.Cancel)
msgBox.setDefaultButton(QtGui.QMessageBox.Save)
ret = msgBox.exec_()
if ret == QtGui.QMessageBox.Save:
self.save()
if ret == QtGui.QMessageBox.Cancel:
return False
self.editorTab.saveState()
self.worldEditor.close()
self.worldEditor = None
return True
# --- Inspector ---
def inspectBlock(self, pos):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectBlock(pos)
def inspectEntity(self, entity):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectEntity(entity)
# --- Zooming ---
def zoomAndInspectBlock(self, pos):
self.zoomToPoint(pos)
self.inspectBlock(pos)
def zoomAndInspectEntity(self, entity):
self.zoomToPoint(entity.Position)
self.inspectEntity(entity)
def zoomToPoint(self, point):
self.editorTab.currentView().centerOnPoint(point, 15)
def manmade_relight(test):
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
stationEditor = WorldEditor("test_files/station.schematic")
station = stationEditor.getDimension()
startCopy = time.time()
box = do_copy(dim, station, False)
copyTime = time.time() - startCopy
print ("Copy took %f seconds. Reducing relight-in-copyBlocks times by this much." % copyTime)
positions = []
for cx, cz in box.chunkPositions():
for cy in box.sectionPositions(cx, cz):
positions.append((cx, cy, cz))
assert len(positions) > box.chunkCount
if test == "post" or test == "all":
def postCopy(): # profiling
start = time.time()
count = 0
print ("Relighting outside of copyBlocks. Updating %d cells" % (len(positions) * 16 * 16 * 16))
for cx, cy, cz in positions:
indices = numpy.indices((16, 16, 16), numpy.int32)
indices.shape = 3, 16 * 16 * 16
indices += ([cx << 4], [cy << 4], [cz << 4])
x, y, z = indices
relight.updateLightsByCoord(dim, x, y, z)
count += 1
t = time.time() - start
print "Relight manmade building (outside copyBlocks): " "%d (out of %d) chunk-sections in %.02f seconds (%f sections per second; %dms per section)" % (
count,
len(positions),
t,
count / t,
1000 * t / count,
)
postCopy()
if test == "smart" or test == "all":
def allSections():
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
start = time.time()
do_copy(dim, station, "all")
t = time.time() - start - copyTime
print "Relight manmade building (in copyBlocks, all sections): " "%d chunk-sections in %.02f seconds (%f sections per second; %dms per section)" % (
len(positions),
t,
len(positions) / t,
1000 * t / len(positions),
)
allSections()
if test == "section" or test == "all":
def perSection():
world = templevel.TempLevel("AnvilWorld")
dim = world.getDimension()
start = time.time()
do_copy(dim, station, "section")
t = time.time() - start - copyTime
print "Relight manmade building (in copyBlocks, for each section): " "%d chunk-sections in %.02f seconds (%f sections per second; %dms per section)" % (
len(positions),
t,
len(positions) / t,
1000 * t / len(positions),
)
perSection()
def __init__(self, filename, versionInfo, readonly=False, progressCallback=None):
progressMax = 7 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.copiedSchematic = None
""":type : WorldEditor"""
self.versionInfo = versionInfo
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit tech demo"))
msgBox.setText(self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(self.tr(
"MCEdit may have crashed. An undo history was found for this world. You may try to resume editing "
"with the saved undo history, or start over with the current state of the world."))
resumeBtn = msgBox.addButton("Resume Editing", QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History", QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
clicked = None # xxxxx
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename, readonly=readonly, resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"), self, triggered=self.cut, enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"), self, triggered=self.copy, enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"), self, triggered=self.paste, enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"), self, triggered=self.pasteBlocks, enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"), self, triggered=self.pasteEntities, enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"), self, triggered=self.deleteSelection, enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"), self, triggered=self.deleteBlocks, enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(self.tr("Delete Entities"), self, triggered=self.deleteEntities, enabled=False)
self.actionDeleteEntities.setShortcut(QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"), self, triggered=self.fill, enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"), self, triggered=self.findReplace, enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"), self, triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"), self, triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"), self, triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"), self, triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(self.tr("Show Exports Library"), self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# --- Resources ---
progress("Loading resources...")
i, v, p = self.versionInfo
self.resourceLoader = i.getResourceLoader(v, p)
self.geometryCache = GeometryCache()
self.blockModels = BlockModels(self.worldEditor.blocktypes, self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader, self.blockModels)
self.editorOverlay = scenegraph.Node()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.panels = [self.playerPanel]
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {action.toolName: action for action in self.toolActions}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(dimButton.InstantPopup)
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"), objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append((Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
self.toolActions[0].trigger() # Must be called after toolChanged is connected to editorTab
if hasattr(progress, 'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.", progress.progressCount)
def unpackPocket(tmpname):
zf = zipfile.ZipFile("test_files/PocketWorldAdapter.zip")
zf.extractall(tmpname)
return WorldEditor(tmpname + "/PocketWorldAdapter")
def __init__(self,
filename,
versionInfo,
readonly=False,
progressCallback=None):
progressMax = 7 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.copiedSchematic = None
""":type : WorldEditor"""
self.versionInfo = versionInfo
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit tech demo"))
msgBox.setText(
self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(
self.
tr("MCEdit may have crashed. An undo history was found for this world. You may try to resume editing "
"with the saved undo history, or start over with the current state of the world."
))
resumeBtn = msgBox.addButton("Resume Editing",
QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History",
QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
clicked = None # xxxxx
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename,
readonly=readonly,
resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"),
self,
triggered=self.cut,
enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"),
self,
triggered=self.copy,
enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"),
self,
triggered=self.paste,
enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"),
self,
triggered=self.pasteBlocks,
enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"),
self,
triggered=self.pasteEntities,
enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"),
self,
triggered=self.deleteSelection,
enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"),
self,
triggered=self.deleteBlocks,
enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(
self.tr("Delete Entities"),
self,
triggered=self.deleteEntities,
enabled=False)
self.actionDeleteEntities.setShortcut(
QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"),
self,
triggered=self.fill,
enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"),
self,
triggered=self.findReplace,
enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"),
self,
triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"),
self,
triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"),
self,
triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"),
self,
triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(
self.tr("Show Exports Library"),
self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# --- Resources ---
progress("Loading resources...")
i, v, p = self.versionInfo
self.resourceLoader = i.getResourceLoader(v, p)
self.geometryCache = GeometryCache()
self.blockModels = BlockModels(self.worldEditor.blocktypes,
self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader,
self.blockModels)
self.editorOverlay = scenegraph.Node()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.panels = [self.playerPanel]
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {
action.toolName: action
for action in self.toolActions
}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(dimButton.InstantPopup)
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"),
objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append(
(Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
self.toolActions[0].trigger(
) # Must be called after toolChanged is connected to editorTab
if hasattr(progress,
'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.",
progress.progressCount)
class EditorSession(QtCore.QObject):
def __init__(self,
filename,
versionInfo,
readonly=False,
progressCallback=None):
progressMax = 7 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.copiedSchematic = None
""":type : WorldEditor"""
self.versionInfo = versionInfo
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit tech demo"))
msgBox.setText(
self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(
self.
tr("MCEdit may have crashed. An undo history was found for this world. You may try to resume editing "
"with the saved undo history, or start over with the current state of the world."
))
resumeBtn = msgBox.addButton("Resume Editing",
QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History",
QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
clicked = None # xxxxx
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename,
readonly=readonly,
resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"),
self,
triggered=self.cut,
enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"),
self,
triggered=self.copy,
enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"),
self,
triggered=self.paste,
enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"),
self,
triggered=self.pasteBlocks,
enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"),
self,
triggered=self.pasteEntities,
enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"),
self,
triggered=self.deleteSelection,
enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"),
self,
triggered=self.deleteBlocks,
enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(
self.tr("Delete Entities"),
self,
triggered=self.deleteEntities,
enabled=False)
self.actionDeleteEntities.setShortcut(
QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"),
self,
triggered=self.fill,
enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"),
self,
triggered=self.findReplace,
enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"),
self,
triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"),
self,
triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"),
self,
triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"),
self,
triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(
self.tr("Show Exports Library"),
self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# --- Resources ---
progress("Loading resources...")
i, v, p = self.versionInfo
self.resourceLoader = i.getResourceLoader(v, p)
self.geometryCache = GeometryCache()
self.blockModels = BlockModels(self.worldEditor.blocktypes,
self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader,
self.blockModels)
self.editorOverlay = scenegraph.Node()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.panels = [self.playerPanel]
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {
action.toolName: action
for action in self.toolActions
}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(dimButton.InstantPopup)
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"),
objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append(
(Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
self.toolActions[0].trigger(
) # Must be called after toolChanged is connected to editorTab
if hasattr(progress,
'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.",
progress.progressCount)
def dispose(self):
if self.textureAtlas:
self.textureAtlas.dispose()
self.textureAtlas = None
if self.editorTab:
self.editorTab.destroy()
self.editorTab = None
if self.worldEditor:
self.worldEditor.close()
self.worldEditor = None
# Connecting these signals to the EditorTab creates a circular reference through
# the Qt objects, preventing the EditorSession from being destroyed
def focusWorldView(self):
self.editorTab.currentView().setFocus()
def updateView(self):
self.editorTab.currentView().update()
def toolDidChange(self, tool):
self.editorTab.toolDidChange(tool)
# --- Selection ---
selectionChanged = QtCore.Signal(BoundingBox)
_currentSelection = None
@property
def currentSelection(self):
return self._currentSelection
@currentSelection.setter
def currentSelection(self, box):
self._currentSelection = box
self.enableSelectionCommands(box is not None and box.volume != 0)
self.selectionChanged.emit(box)
def enableSelectionCommands(self, enable):
self.actionCut.setEnabled(enable)
self.actionCopy.setEnabled(enable)
self.actionPaste.setEnabled(enable)
self.actionPaste_Blocks.setEnabled(enable)
self.actionPaste_Entities.setEnabled(enable)
self.actionClear.setEnabled(enable)
self.actionDeleteBlocks.setEnabled(enable)
self.actionDeleteEntities.setEnabled(enable)
self.actionFill.setEnabled(enable)
self.actionExport.setEnabled(enable)
# --- Menu commands ---
# - World -
def save(self):
self.undoStack.clearUndoBlock()
self.worldEditor.saveChanges()
self.dirty = False
# - Edit -
def cut(self):
command = SimpleRevisionCommand(self, "Cut")
with command.begin():
task = self.currentDimension.exportSchematicIter(
self.currentSelection)
self.copiedSchematic = showProgress("Cutting...", task)
task = self.currentDimension.fillBlocksIter(
self.currentSelection, "air")
showProgress("Cutting...", task)
self.undoStack.push(command)
def copy(self):
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Copying...", task)
def paste(self):
if self.copiedSchematic is None:
return
view = self.editorTab.currentView()
imp = PendingImport(self.copiedSchematic, view.mouseBlockPos,
self.tr("<Pasted Object>"))
command = PasteImportCommand(self, imp, "Paste")
self.undoStack.push(command)
def pasteBlocks(self):
NotImplementedYet()
def pasteEntities(self):
NotImplementedYet()
def findReplace(self):
self.findReplaceDialog.exec_()
def deleteSelection(self):
command = SimpleRevisionCommand(self, "Delete")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(
self.currentSelection, "air")
entitiesTask = RemoveEntitiesOperation(self.currentDimension,
self.currentSelection)
task = ComposeOperations(fillTask, entitiesTask)
showProgress("Deleting...", task)
self.pushCommand(command)
def deleteBlocks(self):
command = SimpleRevisionCommand(self, "Delete Blocks")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(
self.currentSelection, "air")
showProgress("Deleting...", fillTask)
self.pushCommand(command)
def deleteEntities(self):
command = SimpleRevisionCommand(self, "Delete Entities")
with command.begin():
entitiesTask = RemoveEntitiesOperation(self.currentDimension,
self.currentSelection)
showProgress("Deleting...", entitiesTask)
self.pushCommand(command)
def fill(self):
fillCommand(self)
# - Select -
def selectAll(self):
command = SelectCommand(self, self.currentDimension.bounds,
self.tr("Select All"))
self.pushCommand(command)
def deselect(self):
command = SelectCommand(self, None)
command.setText(self.tr("Deselect"))
self.pushCommand(command)
# - Dimensions -
dimensionChanged = QtCore.Signal(object)
_dimDisplayNames = {
"": "Overworld",
"DIM-1": "Nether",
"DIM1": "The End",
}
def dimensionDisplayName(self, dimName):
return self._dimDisplayNames.get(dimName, dimName)
def dimensionMenuLabel(self, dimName):
return self.tr("Dimension: %s" % self.dimensionDisplayName(dimName))
def gotoDimension(self, dimName):
dim = self.worldEditor.getDimension(dimName)
if dim is self.currentDimension:
return
log.info("Going to dimension %s", dimName)
self.changeDimensionButton.setText(self.dimensionMenuLabel(dimName))
self.currentDimension = dim
self.loader = chunkloader.ChunkLoader(self.currentDimension)
self.loader.chunkCompleted.connect(self.chunkDidComplete)
self.loader.allChunksDone.connect(self.updateView)
self.dimensionChanged.emit(dim)
# - Import/export -
def import_(self):
# prompt for a file to import
startingDir = Settings().value("import_dialog/starting_dir",
getUserSchematicsDirectory())
result = QtGui.QFileDialog.getOpenFileName(self.mainWindow,
self.tr("Import"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
self.importSchematic(filename)
def export(self):
# prompt for filename and format. maybe use custom browser to save to export library??
startingDir = Settings().value("import_dialog/starting_dir",
getUserSchematicsDirectory())
result = QtGui.QFileDialog.getSaveFileName(QtGui.qApp.mainWindow,
self.tr("Export Schematic"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
task = self.currentDimension.exportSchematicIter(
self.currentSelection)
schematic = showProgress("Copying...", task)
schematic.saveToFile(filename)
# --- Library support ---
def importSchematic(self, filename):
schematic = WorldEditor(filename, readonly=True)
ray = self.editorTab.currentView().rayAtCenter()
pos, face = rayCastInBounds(ray, self.currentDimension)
if pos is None:
pos = ray.point
name = os.path.basename(filename)
imp = PendingImport(schematic, pos, name)
command = PasteImportCommand(self, imp, "Import %s" % name)
self.undoStack.push(command)
# --- Undo support ---
revisionChanged = QtCore.Signal(int)
def undoIndexChanged(self, index):
self.editorTab.currentView().update()
def pushCommand(self, command):
self.undoStack.push(command)
def setUndoBlock(self, callback):
self.undoStack.setUndoBlock(callback)
def removeUndoBlock(self, callback):
self.undoStack.removeUndoBlock(callback)
def beginUndo(self):
self.undoStack.clearUndoBlock()
self.dirty = True
self.worldEditor.beginUndo()
def commitUndo(self):
self.worldEditor.commitUndo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def undoForward(self):
self.worldEditor.redo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def undoBackward(self):
self.worldEditor.undo()
self.revisionChanged.emit(self.worldEditor.currentRevision)
def gotoRevision(self, index):
if index != self.currentRevision:
self.worldEditor.gotoRevision(index)
self.revisionChanged.emit(self.worldEditor.currentRevision)
@property
def currentRevision(self):
return self.worldEditor.currentRevision
# --- Misplaced startup code? ---
def loadDone(self):
# Called by MCEditApp after the view is on screen to make sure view.center() works correctly xxx used depth
# buffer read for that, now what?
try:
player = self.worldEditor.getPlayer()
center = Vector(*player.Position) + (0, 1.8, 0)
log.info("Setting view angle to single-player player's view.")
rotation = player.Rotation
try:
self.editorTab.currentView().yawPitch = rotation
except AttributeError:
pass
except PlayerNotFound:
try:
center = self.worldEditor.worldSpawnPosition()
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = self.currentDimension.bounds.origin + (
self.currentDimension.bounds.size * 0.5)
self.editorTab.miniMap.centerOnPoint(center)
self.editorTab.currentView().centerOnPoint(center, distance=0)
# --- Tools ---
def toolShortcut(self, name):
toolShortcuts = {
"Select": "S",
"Create": "D",
}
return toolShortcuts.get(name, "")
def getTool(self, name):
for t in self.tools:
if t.name == name:
return t
def chooseTool(self, name):
oldTool = self.currentTool
self.currentTool = self.getTool(name)
if oldTool is not self.currentTool:
if oldTool:
oldTool.toolInactive()
self.currentTool.toolActive()
self.toolChanged.emit(self.currentTool)
self.actionsByName[name].setChecked(True)
toolChanged = QtCore.Signal(object)
def chunkDidComplete(self):
from mcedit2 import editorapp
editorapp.MCEditApp.app.updateStatusLabel(
None, None, self.loader.cps,
self.editorTab.currentView().fps)
def updateStatusFromEvent(self, event):
from mcedit2 import editorapp
if event.blockPosition:
id = self.currentDimension.getBlockID(*event.blockPosition)
data = self.currentDimension.getBlockData(*event.blockPosition)
block = self.worldEditor.blocktypes[id, data]
editorapp.MCEditApp.app.updateStatusLabel(event.blockPosition,
block, self.loader.cps,
event.view.fps)
else:
editorapp.MCEditApp.app.updateStatusLabel('(N/A)', None,
self.loader.cps,
event.view.fps)
def viewMousePress(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool,
'mousePress') and event.blockPosition is not None:
self.currentTool.mousePress(event)
self.editorTab.currentView().update()
def viewMouseMove(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseMove'):
self.currentTool.mouseMove(event)
self.editorTab.currentView().update()
def viewMouseDrag(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseDrag'):
self.currentTool.mouseDrag(event)
self.editorTab.currentView().update()
def viewMouseRelease(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseRelease'):
self.currentTool.mouseRelease(event)
self.editorTab.currentView().update()
# --- EditorTab handling ---
def tabCaption(self):
return util.displayName(self.filename)
def closeTab(self):
if self.worldEditor is None:
return True
if self.dirty:
msgBox = QtGui.QMessageBox(self.editorTab.window())
msgBox.setText("The world has been modified.")
msgBox.setInformativeText("Do you want to save your changes?")
msgBox.setStandardButtons(QtGui.QMessageBox.Save
| QtGui.QMessageBox.Discard
| QtGui.QMessageBox.Cancel)
msgBox.setDefaultButton(QtGui.QMessageBox.Save)
ret = msgBox.exec_()
if ret == QtGui.QMessageBox.Save:
self.save()
if ret == QtGui.QMessageBox.Cancel:
return False
self.editorTab.saveState()
self.worldEditor.close()
self.worldEditor = None
return True
# --- Inspector ---
def inspectBlock(self, pos):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectBlock(pos)
def inspectEntity(self, entity):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectEntity(entity)
# --- Zooming ---
def zoomAndInspectBlock(self, pos):
self.zoomToPoint(pos)
self.inspectBlock(pos)
def zoomAndInspectEntity(self, entity):
self.zoomToPoint(entity.Position)
self.inspectEntity(entity)
def zoomToPoint(self, point):
self.editorTab.currentView().centerOnPoint(point, 15)
def bench_temp_level(filename):
path = bench_temp_file(filename)
return WorldEditor(path.strpath)
def createSchematic(shape, blocktypes='Alpha'):
from mceditlib.worldeditor import WorldEditor
adapter = SchematicFileAdapter(shape=shape, blocktypes=blocktypes)
editor = WorldEditor(adapter=adapter)
return editor
class EditorSession(QtCore.QObject):
def __init__(self, filename, resourceLoader, configuredBlocks, readonly=False,
progressCallback=None):
"""
:param filename:
:type filename: str
:param resourceLoader:
:type resourceLoader: mcedit2.resourceloader.ResourceLoader
:param configuredBlocks:
:type configuredBlocks: dict???
:param readonly:
:type readonly: bool
:param progressCallback:
:type progressCallback: callable
:return:
:rtype:
"""
from mcedit2 import __version__ as v
progressMax = 8 # fixme
if progressCallback is None:
def progress(status):
pass
else:
def progress(status):
progressCallback(progress.progressCount, progressMax, status)
progress.progressCount += 1
progress.progressCount = 0
QtCore.QObject.__init__(self)
self.undoStack = MCEUndoStack()
self.loader = None
self.blockModels = None
self.textureAtlas = None
self.filename = filename
self.dockWidgets = []
self.undoBlock = None
self.currentTool = None
self.dirty = False
self.configuredBlocks = None
self.copiedSchematic = None # xxx should be app global!!
""":type : WorldEditor"""
# --- Open world editor ---
try:
progress("Creating WorldEditor...")
self.worldEditor = WorldEditor(filename, readonly=readonly)
except UndoFolderExists:
msgBox = QtGui.QMessageBox()
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setWindowTitle(self.tr("MCEdit %(version)s") % {"version": v})
msgBox.setText(self.tr("This world was not properly closed by MCEdit."))
msgBox.setInformativeText(self.tr(
"MCEdit may have crashed. An undo history was found for this world. You may try "
"to resume editing with the saved undo history, or start over with the current "
"state of the world."))
resumeBtn = msgBox.addButton("Resume Editing", QtGui.QMessageBox.ApplyRole)
msgBox.addButton("Discard History", QtGui.QMessageBox.DestructiveRole)
# msgBox.exec_()
# clicked = msgBox.clickedButton()
# xxxxx resume editing not implemented in session - need to restore undo history!
clicked = None
resume = clicked is resumeBtn
try:
self.worldEditor = WorldEditor(filename, readonly=readonly, resume=resume)
except NotImplementedError:
NotImplementedYet()
raise IOError("Uh-oh")
self.worldEditor.requireRevisions()
self.currentDimension = None
progress("Creating menus...")
# --- Menus ---
self.menus = []
# - Edit -
self.menuEdit = QtGui.QMenu(self.tr("Edit"))
self.menuEdit.setObjectName("menuEdit")
self.actionCut = QtGui.QAction(self.tr("Cut"), self, triggered=self.cut, enabled=False)
self.actionCut.setShortcut(QtGui.QKeySequence.Cut)
self.actionCut.setObjectName("actionCut")
self.actionCopy = QtGui.QAction(self.tr("Copy"), self, triggered=self.copy, enabled=False)
self.actionCopy.setShortcut(QtGui.QKeySequence.Copy)
self.actionCopy.setObjectName("actionCopy")
self.actionPaste = QtGui.QAction(self.tr("Paste"), self, triggered=self.paste,
enabled=False)
self.actionPaste.setShortcut(QtGui.QKeySequence.Paste)
self.actionPaste.setObjectName("actionPaste")
self.actionPaste_Blocks = QtGui.QAction(self.tr("Paste Blocks"), self,
triggered=self.pasteBlocks, enabled=False)
self.actionPaste_Blocks.setShortcut(QtGui.QKeySequence("Ctrl+Shift+V"))
self.actionPaste_Blocks.setObjectName("actionPaste_Blocks")
self.actionPaste_Entities = QtGui.QAction(self.tr("Paste Entities"), self,
triggered=self.pasteEntities, enabled=False)
self.actionPaste_Entities.setShortcut(QtGui.QKeySequence("Ctrl+Alt+V"))
self.actionPaste_Entities.setObjectName("actionPaste_Entities")
self.actionClear = QtGui.QAction(self.tr("Delete"), self, triggered=self.deleteSelection,
enabled=False)
self.actionClear.setShortcut(QtGui.QKeySequence.Delete)
self.actionClear.setObjectName("actionClear")
self.actionDeleteBlocks = QtGui.QAction(self.tr("Delete Blocks"), self,
triggered=self.deleteBlocks, enabled=False)
self.actionDeleteBlocks.setShortcut(QtGui.QKeySequence("Shift+Del"))
self.actionDeleteBlocks.setObjectName("actionDeleteBlocks")
self.actionDeleteEntities = QtGui.QAction(self.tr("Delete Entities"), self,
triggered=self.deleteEntities, enabled=False)
self.actionDeleteEntities.setShortcut(QtGui.QKeySequence("Shift+Alt+Del"))
self.actionDeleteEntities.setObjectName("actionDeleteEntities")
self.actionFill = QtGui.QAction(self.tr("Fill"), self, triggered=self.fill, enabled=False)
self.actionFill.setShortcut(QtGui.QKeySequence("Shift+Ctrl+F"))
self.actionFill.setObjectName("actionFill")
self.actionFindReplace = QtGui.QAction(self.tr("Find/Replace"), self,
triggered=self.findReplace, enabled=True)
self.actionFindReplace.setShortcut(QtGui.QKeySequence.Find)
self.actionFindReplace.setObjectName("actionFindReplace")
self.actionAnalyze = QtGui.QAction(self.tr("Analyze"), self, triggered=self.analyze,
enabled=True)
# self.actionAnalyze.setShortcut(QtGui.QKeySequence.Analyze)
self.actionAnalyze.setObjectName("actionAnalyze")
undoAction = self.undoStack.createUndoAction(self.menuEdit)
undoAction.setShortcut(QtGui.QKeySequence.Undo)
redoAction = self.undoStack.createRedoAction(self.menuEdit)
redoAction.setShortcut(QtGui.QKeySequence.Redo)
self.menuEdit.addAction(undoAction)
self.menuEdit.addAction(redoAction)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionCut)
self.menuEdit.addAction(self.actionCopy)
self.menuEdit.addAction(self.actionPaste)
self.menuEdit.addAction(self.actionPaste_Blocks)
self.menuEdit.addAction(self.actionPaste_Entities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionClear)
self.menuEdit.addAction(self.actionDeleteBlocks)
self.menuEdit.addAction(self.actionDeleteEntities)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFill)
self.menuEdit.addSeparator()
self.menuEdit.addAction(self.actionFindReplace)
self.menuEdit.addAction(self.actionAnalyze)
self.menus.append(self.menuEdit)
# - Select -
self.menuSelect = QtGui.QMenu(self.tr("Select"))
self.actionSelectAll = QtGui.QAction(self.tr("Select All"), self, triggered=self.selectAll)
self.actionSelectAll.setShortcut(QtGui.QKeySequence.SelectAll)
self.menuSelect.addAction(self.actionSelectAll)
self.actionDeselect = QtGui.QAction(self.tr("Deselect"), self, triggered=self.deselect)
self.actionDeselect.setShortcut(QtGui.QKeySequence("Ctrl+D"))
self.menuSelect.addAction(self.actionDeselect)
self.menus.append(self.menuSelect)
# - Import/Export -
self.menuImportExport = QtGui.QMenu(self.tr("Import/Export"))
self.actionExport = QtGui.QAction(self.tr("Export"), self, triggered=self.export)
self.actionExport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+E"))
self.menuImportExport.addAction(self.actionExport)
self.actionImport = QtGui.QAction(self.tr("Import"), self, triggered=self.import_)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+D"))
self.menuImportExport.addAction(self.actionImport)
self.actionImport = QtGui.QAction(self.tr("Show Exports Library"), self,
triggered=QtGui.qApp.libraryDockWidget.toggleViewAction().trigger)
self.actionImport.setShortcut(QtGui.QKeySequence("Ctrl+Shift+L"))
self.menuImportExport.addAction(self.actionImport)
self.menus.append(self.menuImportExport)
# - Chunk -
self.menuChunk = QtGui.QMenu(self.tr("Chunk"))
self.actionDeleteChunks = QtGui.QAction(self.tr("Delete Chunks"), self, triggered=self.deleteChunks)
self.actionCreateChunks = QtGui.QAction(self.tr("Create Chunks"), self, triggered=self.createChunks)
self.actionRepopChunks = QtGui.QAction(self.tr("Mark Chunks For Repopulation"),
self, triggered=self.repopChunks)
self.menuChunk.addAction(self.actionDeleteChunks)
self.menuChunk.addAction(self.actionCreateChunks)
self.menuChunk.addAction(self.actionRepopChunks)
self.menus.append(self.menuChunk)
# --- Resources ---
self.resourceLoader = resourceLoader
self.geometryCache = GeometryCache()
progress("Loading textures and models...")
self.setConfiguredBlocks(configuredBlocks) # Must be called after resourceLoader is in place
self.editorOverlay = scenegraph.Node()
self.biomeTypes = BiomeTypes()
# --- Panels ---
progress("Loading panels...")
self.playerPanel = PlayerPanel(self)
self.worldInfoPanel = WorldInfoPanel(self)
self.panels = [self.playerPanel, self.worldInfoPanel]
# --- Tools ---
progress("Loading tools...")
self.toolClasses = list(editortools.ToolClasses())
self.toolActionGroup = QtGui.QActionGroup(self)
self.tools = [cls(self) for cls in self.toolClasses]
self.toolActions = [tool.pickToolAction() for tool in self.tools]
self.actionsByName = {action.toolName: action for action in self.toolActions}
for tool in self.tools:
tool.toolPicked.connect(self.chooseTool)
for action in self.toolActions:
self.toolActionGroup.addAction(action)
self.selectionTool = self.getTool("Select")
self.moveTool = self.getTool("Move")
# --- Dimensions ---
def _dimChanged(f):
def _changed():
self.gotoDimension(f)
return _changed
dimButton = self.changeDimensionButton = QtGui.QToolButton()
dimButton.setText(self.dimensionMenuLabel(""))
dimAction = self.changeDimensionAction = QtGui.QWidgetAction(self)
dimAction.setDefaultWidget(dimButton)
dimMenu = self.dimensionsMenu = QtGui.QMenu()
for dimName in self.worldEditor.listDimensions():
displayName = self.dimensionDisplayName(dimName)
action = dimMenu.addAction(displayName)
action._changed = _dimChanged(dimName)
action.triggered.connect(action._changed)
dimButton.setMenu(dimMenu)
dimButton.setPopupMode(dimButton.InstantPopup)
progress("Loading overworld dimension")
self.gotoDimension("")
# --- Editor stuff ---
progress("Creating EditorTab...")
self.editorTab = EditorTab(self)
self.toolChanged.connect(self.toolDidChange)
self.undoStack.indexChanged.connect(self.undoIndexChanged)
self.findReplaceDialog = FindReplaceDialog(self)
for resultsWidget in self.findReplaceDialog.resultsWidgets:
self.dockWidgets.append((Qt.BottomDockWidgetArea, resultsWidget))
self.inspectorWidget = InspectorWidget(self)
self.inspectorDockWidget = QtGui.QDockWidget(self.tr("Inspector"), objectName="inspector")
self.inspectorDockWidget.setWidget(self.inspectorWidget)
self.inspectorDockWidget.hide()
self.dockWidgets.append((Qt.RightDockWidgetArea, self.inspectorDockWidget))
if len(self.toolActions):
# Must be called after toolChanged is connected to editorTab
self.toolActions[0].trigger()
if hasattr(progress, 'progressCount') and progress.progressCount != progressMax:
log.info("Update progressMax to %d, please.", progress.progressCount)
# Connecting these signals to the EditorTab creates a circular reference through
# the Qt objects, preventing the EditorSession from being destroyed
def focusWorldView(self):
self.editorTab.currentView().setFocus()
def updateView(self):
self.editorTab.currentView().update()
def toolDidChange(self, tool):
self.editorTab.toolDidChange(tool)
# --- Block config ---
# Emitted when configuredBlocks is changed. TextureAtlas and BlockModels will also have changed.
configuredBlocksChanged = QtCore.Signal()
def setConfiguredBlocks(self, configuredBlocks):
blocktypes = self.worldEditor.blocktypes
if self.configuredBlocks is not None:
# Remove all previously configured blocks
deadJsons = []
for json in blocktypes.blockJsons:
if '__configured__' in json:
deadJsons.append(json)
deadIDs = set((j['internalName'], j['meta']) for j in deadJsons)
blocktypes.allBlocks[:] = [
bt for bt in blocktypes.allBlocks
if (bt.internalName, bt.meta) not in deadIDs
]
for json in deadJsons:
internalName = json['internalName']
fakeState = json['blockState']
blocktypes.blockJsons.remove(json)
ID = blocktypes.IDsByName[internalName]
del blocktypes.IDsByState[internalName + fakeState]
del blocktypes.statesByID[ID, json['meta']]
for blockDef in configuredBlocks:
internalName = blockDef.internalName
if internalName not in blocktypes.IDsByName:
# no ID mapped to this name, skip
continue
if blockDef.meta == 0:
blockType = blocktypes[internalName]
blockJson = blockType.json
else:
# not automatically created by FML mapping loader
ID = blocktypes.IDsByName[internalName]
fakeState = '[%d]' % blockDef.meta
nameAndState = internalName + fakeState
blocktypes.blockJsons[nameAndState] = {
'displayName': internalName,
'internalName': internalName,
'blockState': fakeState,
'unknown': False,
'meta': blockDef.meta,
}
blockType = BlockType(ID, blockDef.meta, blocktypes)
blocktypes.allBlocks.append(blockType)
blocktypes.IDsByState[nameAndState] = ID, blockDef.meta
blocktypes.statesByID[ID, blockDef.meta] = nameAndState
blockJson = blockType.json
blockJson['forcedModel'] = blockDef.modelPath
blockJson['forcedModelTextures'] = blockDef.modelTextures
blockJson['forcedModelRotation'] = blockDef.modelRotations
blockJson['forcedRotationFlags'] = blockDef.rotationFlags
blockJson['__configured__'] = True
self.configuredBlocks = configuredBlocks
self.blockModels = BlockModels(self.worldEditor.blocktypes, self.resourceLoader)
self.textureAtlas = TextureAtlas(self.worldEditor, self.resourceLoader, self.blockModels)
self.configuredBlocksChanged.emit()
# --- Selection ---
selectionChanged = QtCore.Signal(BoundingBox)
_currentSelection = None
@property
def currentSelection(self):
return self._currentSelection
@currentSelection.setter
def currentSelection(self, box):
self._currentSelection = box
self.enableSelectionCommands(box is not None and box.volume != 0)
self.enableChunkSelectionCommands(box is not None)
self.selectionChanged.emit(box)
def enableSelectionCommands(self, enable):
self.actionCut.setEnabled(enable)
self.actionCopy.setEnabled(enable)
self.actionPaste.setEnabled(enable)
self.actionPaste_Blocks.setEnabled(enable)
self.actionPaste_Entities.setEnabled(enable)
self.actionClear.setEnabled(enable)
self.actionDeleteBlocks.setEnabled(enable)
self.actionDeleteEntities.setEnabled(enable)
self.actionFill.setEnabled(enable)
self.actionExport.setEnabled(enable)
def enableChunkSelectionCommands(self, enable):
self.actionDeleteChunks.setEnabled(enable)
self.actionCreateChunks.setEnabled(enable)
self.actionRepopChunks.setEnabled(enable)
# --- Menu commands ---
# - World -
def save(self):
self.undoStack.clearUndoBlock()
saveTask = self.worldEditor.saveChangesIter()
showProgress("Saving...", saveTask)
self.dirty = False
# - Edit -
def cut(self):
command = SimpleRevisionCommand(self, "Cut")
with command.begin():
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Cutting...", task)
task = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Cutting...", task)
self.undoStack.push(command)
def copy(self):
task = self.currentDimension.exportSchematicIter(self.currentSelection)
self.copiedSchematic = showProgress("Copying...", task)
def paste(self):
if self.copiedSchematic is None:
return
view = self.editorTab.currentView()
imp = PendingImport(self.copiedSchematic, view.mouseBlockPos, self.tr("<Pasted Object>"))
command = PasteImportCommand(self, imp, "Paste")
self.undoStack.push(command)
def pasteBlocks(self):
NotImplementedYet()
def pasteEntities(self):
NotImplementedYet()
def findReplace(self):
self.findReplaceDialog.exec_()
def analyze(self):
if self.currentSelection is None:
return
task = self.currentDimension.analyzeIter(self.currentSelection)
showProgress("Analyzing...", task)
outputDialog = AnalyzeOutputDialog(self, task.blocks,
task.entityCounts,
task.tileEntityCounts,
task.dimension.worldEditor.displayName)
def deleteSelection(self):
command = SimpleRevisionCommand(self, "Delete")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
task = ComposeOperations(fillTask, entitiesTask)
showProgress("Deleting...", task)
self.pushCommand(command)
def deleteBlocks(self):
command = SimpleRevisionCommand(self, "Delete Blocks")
with command.begin():
fillTask = self.currentDimension.fillBlocksIter(self.currentSelection, "air")
showProgress("Deleting...", fillTask)
self.pushCommand(command)
def deleteEntities(self):
command = SimpleRevisionCommand(self, "Delete Entities")
with command.begin():
entitiesTask = RemoveEntitiesOperation(self.currentDimension, self.currentSelection)
showProgress("Deleting...", entitiesTask)
self.pushCommand(command)
def fill(self):
fillCommand(self)
# - Select -
def selectAll(self):
command = SelectCommand(self, self.currentDimension.bounds, self.tr("Select All"))
self.pushCommand(command)
def deselect(self):
command = SelectCommand(self, None)
command.setText(self.tr("Deselect"))
self.pushCommand(command)
# - Chunk -
def deleteChunks(self):
if self.currentSelection is None:
return
command = SimpleRevisionCommand(self, self.tr("Delete Chunks"))
with command.begin():
for cx in range(self.currentSelection.mincx, self.currentSelection.maxcx):
for cz in range(self.currentSelection.mincz, self.currentSelection.maxcz):
self.currentDimension.deleteChunk(cx, cz)
self.pushCommand(command)
def createChunks(self):
QtGui.QMessageBox.warning(QtGui.qApp.mainWindow, "Not implemented.", "Create chunks is not implemented yet!")
def repopChunks(self):
QtGui.QMessageBox.warning(QtGui.qApp.mainWindow, "Not implemented.", "Repop chunks is not implemented yet!")
# - Dimensions -
dimensionChanged = QtCore.Signal(object)
_dimDisplayNames = {"": "Overworld",
"DIM-1": "Nether",
"DIM1": "The End",
}
def dimensionDisplayName(self, dimName):
return self._dimDisplayNames.get(dimName, dimName)
def dimensionMenuLabel(self, dimName):
return self.tr("Dimension: %s" % self.dimensionDisplayName(dimName))
def gotoDimension(self, dimName):
dim = self.worldEditor.getDimension(dimName)
if dim is self.currentDimension:
return
log.info("Going to dimension %s", dimName)
self.changeDimensionButton.setText(self.dimensionMenuLabel(dimName))
self.currentDimension = dim
self.loader = chunkloader.ChunkLoader(self.currentDimension)
self.loader.chunkCompleted.connect(self.chunkDidComplete)
self.loader.allChunksDone.connect(self.updateView)
self.revisionChanged.connect(self.loader.revisionDidChange)
self.dimensionChanged.emit(dim)
# - Import/export -
def import_(self):
# prompt for a file to import
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getOpenFileName(QtGui.qApp.mainWindow, self.tr("Import"),
startingDir,
"All files (*.*)")
if result:
filename = result[0]
if filename:
self.importSchematic(filename)
def export(self):
# prompt for filename and format. maybe use custom browser to save to export library??
startingDir = Settings().value("import_dialog/starting_dir", getUserSchematicsDirectory())
result = QtGui.QFileDialog.getSaveFileName(QtGui.qApp.mainWindow,
self.tr("Export Schematic"),
startingDir,
"Schematic files (*.schematic)")
if result:
filename = result[0]
if filename:
task = self.currentDimension.exportSchematicIter(self.currentSelection)
schematic = showProgress("Copying...", task)
schematic.saveToFile(filename)
# --- Library support ---
def importSchematic(self, filename):
schematic = WorldEditor(filename, readonly=True)
ray = self.editorTab.currentView().rayAtCenter()
pos, face = rayCastInBounds(ray, self.currentDimension)
if pos is None:
pos = ray.point
name = os.path.basename(filename)
imp = PendingImport(schematic, pos, name)
command = PasteImportCommand(self, imp, "Import %s" % name)
self.undoStack.push(command)
# --- Undo support ---
revisionChanged = QtCore.Signal(RevisionChanges)
def undoIndexChanged(self, index):
self.editorTab.currentView().update()
def pushCommand(self, command):
log.info("Pushing command %s" % command.text())
self.undoStack.push(command)
def setUndoBlock(self, callback):
self.undoStack.setUndoBlock(callback)
def removeUndoBlock(self, callback):
self.undoStack.removeUndoBlock(callback)
def beginUndo(self):
self.undoStack.clearUndoBlock()
self.dirty = True
self.worldEditor.beginUndo()
def commitUndo(self):
exhaust(self.commitUndoIter())
def commitUndoIter(self):
for status in self.worldEditor.commitUndoIter():
yield status
changes = self.worldEditor.getRevisionChanges(self.currentRevision-1, self.currentRevision)
self.revisionChanged.emit(changes)
def undoForward(self):
self.worldEditor.redo()
changes = self.worldEditor.getRevisionChanges(self.currentRevision-1, self.currentRevision)
self.revisionChanged.emit(changes)
def undoBackward(self):
self.worldEditor.undo()
changes = self.worldEditor.getRevisionChanges(self.currentRevision, self.currentRevision+1)
self.revisionChanged.emit(changes)
def gotoRevision(self, index):
if index != self.currentRevision:
changes = self.worldEditor.getRevisionChanges(self.currentRevision, index)
self.worldEditor.gotoRevision(index)
self.revisionChanged.emit(changes)
@property
def currentRevision(self):
return self.worldEditor.currentRevision
# --- Misplaced startup code? ---
def loadDone(self):
# Called by MCEditApp after the view is on screen to make sure view.center() works correctly
# xxx was needed because view.centerOnPoint used a depthbuffer read for that, now what?
try:
try:
player = self.worldEditor.getPlayer()
center = Vector(*player.Position) + (0, 1.8, 0)
dimNo = player.Dimension
dimName = self.worldEditor.dimNameFromNumber(dimNo)
log.info("Setting view angle to single-player player's view in dimension %s.",
dimName)
rotation = player.Rotation
if dimName:
self.gotoDimension(dimName)
try:
self.editorTab.currentView().yawPitch = rotation
except AttributeError:
pass
except PlayerNotFound:
try:
center = self.worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = self.currentDimension.bounds.origin + (self.currentDimension.bounds.size * 0.5)
self.editorTab.miniMap.centerOnPoint(center)
self.editorTab.currentView().centerOnPoint(center, distance=0)
except Exception as e:
log.exception("Error while centering on player for world editor: %s", e)
# --- Tools ---
def toolShortcut(self, name):
toolShortcuts = {
"Select": "S",
"Create": "D",
}
return toolShortcuts.get(name, "")
def getTool(self, name):
for t in self.tools:
if t.name == name:
return t
def chooseTool(self, name):
oldTool = self.currentTool
self.currentTool = self.getTool(name)
if oldTool is not self.currentTool:
if oldTool:
oldTool.toolInactive()
self.currentTool.toolActive()
self.toolChanged.emit(self.currentTool)
self.actionsByName[name].setChecked(True)
toolChanged = QtCore.Signal(object)
def chunkDidComplete(self):
from mcedit2 import editorapp
editorapp.MCEditApp.app.updateStatusLabel(None, None, None, self.loader.cps,
self.editorTab.currentView().fps)
def updateStatusFromEvent(self, event):
from mcedit2 import editorapp
if event.blockPosition:
id = self.currentDimension.getBlockID(*event.blockPosition)
data = self.currentDimension.getBlockData(*event.blockPosition)
block = self.worldEditor.blocktypes[id, data]
biomeID = self.currentDimension.getBiomeID(event.blockPosition[0],
event.blockPosition[2])
biome = self.biomeTypes.types.get(biomeID)
if biome is not None:
biomeName = biome.name
else:
biomeName = "Unknown biome"
biomeText = "%s (%d)" % (biomeName, biomeID)
editorapp.MCEditApp.app.updateStatusLabel(event.blockPosition, block, biomeText,
self.loader.cps, event.view.fps)
else:
editorapp.MCEditApp.app.updateStatusLabel('(N/A)', None, None, self.loader.cps,
event.view.fps)
def viewMousePress(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mousePress') and event.blockPosition is not None:
self.currentTool.mousePress(event)
self.editorTab.currentView().update()
def viewMouseMove(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseMove'):
self.currentTool.mouseMove(event)
self.editorTab.currentView().update()
def viewMouseDrag(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseDrag'):
self.currentTool.mouseDrag(event)
self.editorTab.currentView().update()
def viewMouseRelease(self, event):
self.updateStatusFromEvent(event)
if hasattr(self.currentTool, 'mouseRelease'):
self.currentTool.mouseRelease(event)
self.editorTab.currentView().update()
# --- EditorTab handling ---
def tabCaption(self):
return util.displayName(self.filename)
def closeTab(self):
if self.worldEditor is None:
return True
if self.dirty:
msgBox = QtGui.QMessageBox(self.editorTab.window())
msgBox.setText("The world has been modified.")
msgBox.setInformativeText("Do you want to save your changes?")
msgBox.setStandardButtons(
QtGui.QMessageBox.Save | QtGui.QMessageBox.Discard | QtGui.QMessageBox.Cancel)
msgBox.setDefaultButton(QtGui.QMessageBox.Save)
ret = msgBox.exec_()
if ret == QtGui.QMessageBox.Save:
self.save()
if ret == QtGui.QMessageBox.Cancel:
return False
for panel in self.panels:
panel.close()
self.editorTab.saveState()
self.worldEditor.close()
self.worldEditor = None
return True
# --- Inspector ---
def inspectBlock(self, pos):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectBlock(pos)
def inspectEntity(self, entity):
self.inspectorDockWidget.show()
self.inspectorWidget.inspectEntity(entity)
# --- Zooming ---
def zoomAndInspectBlock(self, pos):
self.zoomToPoint(pos)
self.inspectBlock(pos)
def zoomAndInspectEntity(self, entity):
self.zoomToPoint(entity.Position)
self.inspectEntity(entity)
def zoomToPoint(self, point):
self.editorTab.currentView().centerOnPoint(point, 15)
# --- Blocktype handling ---
def unknownBlocks(self):
for blocktype in self.worldEditor.blocktypes:
if blocktype.unknown:
yield blocktype.internalName
def testCreate():
temppath = mktemp("AnvilCreate")
pc_world = WorldEditor(filename=temppath, create=True, adapterClass=AnvilWorldAdapter)
pc_world.close()
shutil.rmtree(temppath)
def testCreate(tmpdir):
temppath = tmpdir.join("AnvilCreate")
temppath.mkdir()
pc_world = WorldEditor(filename=temppath.strpath, create=True, adapterClass=AnvilWorldAdapter)
pc_world.close()