903 lines
29 KiB
Python
903 lines
29 KiB
Python
import numpy as np
|
|
import struct
|
|
import re
|
|
from . import mapblock, blockfuncs, utils
|
|
# TODO: Log failed blocks, etc.
|
|
|
|
#
|
|
# clone command
|
|
#
|
|
|
|
def clone(inst, args):
|
|
offset = args.offset_v
|
|
if args.blockmode:
|
|
blockOffset = offset.map(lambda n: round(n / 16))
|
|
offset = blockOffset * 16
|
|
|
|
if offset == utils.Vec3(0, 0, 0):
|
|
inst.log("fatal", "Offset cannot be zero.")
|
|
elif args.blockmode:
|
|
inst.log("info", f"blockmode: Offset rounded to {tuple(offset)}.")
|
|
|
|
inst.begin()
|
|
|
|
if args.blockmode:
|
|
blockKeys = utils.get_mapblocks(inst.db, area=args.area,
|
|
includePartial=False)
|
|
else:
|
|
dstArea = args.area + offset
|
|
blockKeys = utils.get_mapblocks(inst.db, area=dstArea,
|
|
includePartial=True)
|
|
|
|
# Sort the block positions based on the direction of the offset.
|
|
# This is to prevent reading from an already modified block.
|
|
sortDir = offset.map(lambda n: -1 if n > 0 else 1)
|
|
# Prevent rolling over in the rare case of a block at -2048.
|
|
sortOffset = sortDir.map(lambda n: -1 if n == -1 else 0)
|
|
|
|
def sortKey(blockKey):
|
|
blockPos = utils.Vec3.from_block_key(blockKey)
|
|
sortPos = blockPos * sortDir + sortOffset
|
|
return sortPos.to_block_key()
|
|
|
|
blockKeys.sort(key=sortKey)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
pos = utils.Vec3.from_block_key(key)
|
|
|
|
if args.blockmode:
|
|
# Keys correspond to source blocks.
|
|
dstPos = pos + blockOffset
|
|
if not dstPos.is_valid_block_pos():
|
|
continue
|
|
|
|
srcData = inst.db.get_block(key)
|
|
if not mapblock.is_valid_generated(srcData):
|
|
continue
|
|
|
|
inst.db.set_block(dstPos.to_block_key(), srcData, force=True)
|
|
else:
|
|
# Keys correspond to destination blocks.
|
|
dstData = inst.db.get_block(key)
|
|
if not mapblock.is_valid_generated(dstData):
|
|
continue
|
|
|
|
dstBlock = mapblock.Mapblock(dstData)
|
|
merge = blockfuncs.MapblockMerge(dstBlock)
|
|
|
|
dstBlockOverlap = utils.get_block_overlap(pos, dstArea)
|
|
srcOverlapArea = dstBlockOverlap - offset
|
|
srcBlocksIncluded = utils.get_mapblock_area(srcOverlapArea,
|
|
includePartial=True)
|
|
|
|
for srcPos in srcBlocksIncluded:
|
|
if not srcPos.is_valid_block_pos():
|
|
continue
|
|
|
|
srcData = inst.db.get_block(srcPos.to_block_key())
|
|
if not mapblock.is_valid_generated(srcData):
|
|
continue
|
|
|
|
srcBlock = mapblock.Mapblock(srcData)
|
|
srcBlockFrag = utils.get_block_overlap(srcPos, srcOverlapArea)
|
|
srcToDestFrag = utils.get_block_overlap(pos,
|
|
srcBlockFrag + offset, relative=True)
|
|
|
|
srcCornerPos = srcPos * 16
|
|
merge.add_layer(srcBlock,
|
|
srcBlockFrag - srcCornerPos, srcToDestFrag)
|
|
|
|
merge.merge()
|
|
inst.db.set_block(key, dstBlock.serialize())
|
|
|
|
#
|
|
# overlay command
|
|
#
|
|
|
|
def overlay(inst, args):
|
|
if args.offset_v:
|
|
offset = args.offset_v
|
|
else:
|
|
offset = utils.Vec3(0, 0, 0)
|
|
|
|
if offset != utils.Vec3(0, 0, 0) and args.invert:
|
|
if args.invert:
|
|
inst.log("fatal", "Cannot offset an inverted selection.")
|
|
|
|
if args.blockmode:
|
|
blockOffset = offset.map(lambda n: round(n / 16))
|
|
offset = blockOffset * 16
|
|
if args.offset_v:
|
|
inst.log("info", f"blockmode: Offset rounded to {tuple(offset)}.")
|
|
|
|
inst.begin()
|
|
|
|
if args.blockmode:
|
|
blockKeys = utils.get_mapblocks(inst.sdb, area=args.area,
|
|
invert=args.invert, includePartial=False)
|
|
else:
|
|
dstArea = args.area + offset
|
|
blockKeys = utils.get_mapblocks(inst.db, area=dstArea,
|
|
invert=args.invert, includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
pos = utils.Vec3.from_block_key(key)
|
|
|
|
if args.blockmode:
|
|
# Keys correspond to source blocks.
|
|
dstPos = pos + blockOffset
|
|
if not dstPos.is_valid_block_pos():
|
|
continue
|
|
|
|
srcData = inst.sdb.get_block(key)
|
|
if not mapblock.is_valid_generated(srcData):
|
|
continue
|
|
|
|
inst.db.set_block(dstPos.to_block_key(), srcData, force=True)
|
|
else:
|
|
# Keys correspond to destination blocks.
|
|
dstData = inst.db.get_block(key)
|
|
if not mapblock.is_valid_generated(dstData):
|
|
continue
|
|
|
|
dstBlock = mapblock.Mapblock(dstData)
|
|
|
|
if args.invert:
|
|
# Inverted selections currently cannot have an offset.
|
|
srcData = inst.sdb.get_block(key)
|
|
if not mapblock.is_valid_generated(srcData):
|
|
continue
|
|
|
|
dstBlockOverlap = utils.get_block_overlap(pos, dstArea,
|
|
relative=True)
|
|
if dstBlockOverlap:
|
|
srcBlock = mapblock.Mapblock(srcData)
|
|
merge = blockfuncs.MapblockMerge(srcBlock)
|
|
merge.add_layer(dstBlock, dstBlockOverlap, dstBlockOverlap)
|
|
merge.merge()
|
|
inst.db.set_block(key, srcBlock.serialize())
|
|
else:
|
|
inst.db.set_block(key, srcData)
|
|
else:
|
|
merge = blockfuncs.MapblockMerge(dstBlock)
|
|
|
|
dstBlockOverlap = utils.get_block_overlap(pos, dstArea)
|
|
srcOverlapArea = dstBlockOverlap - offset
|
|
srcBlocksIncluded = utils.get_mapblock_area(srcOverlapArea,
|
|
includePartial=True)
|
|
|
|
for srcPos in srcBlocksIncluded:
|
|
if not srcPos.is_valid_block_pos():
|
|
continue
|
|
|
|
srcData = inst.sdb.get_block(srcPos.to_block_key())
|
|
if not mapblock.is_valid_generated(srcData):
|
|
continue
|
|
|
|
srcBlock = mapblock.Mapblock(srcData)
|
|
srcBlockFrag = utils.get_block_overlap(srcPos,
|
|
srcOverlapArea)
|
|
srcToDestFrag = utils.get_block_overlap(pos,
|
|
srcBlockFrag + offset, relative=True)
|
|
|
|
srcCornerPos = srcPos * 16
|
|
merge.add_layer(srcBlock, srcBlockFrag - srcCornerPos,
|
|
srcToDestFrag)
|
|
|
|
merge.merge()
|
|
inst.db.set_block(key, dstBlock.serialize())
|
|
|
|
#
|
|
# deleteblocks command
|
|
#
|
|
|
|
def delete_blocks(inst, args):
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db,
|
|
area=args.area, invert=args.invert)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
inst.db.delete_block(key)
|
|
|
|
#
|
|
# fill command
|
|
#
|
|
|
|
def fill(inst, args):
|
|
# TODO: Option to delete metadata, set param2, etc.
|
|
fillNode = args.replacenode_b
|
|
|
|
inst.log("warning",
|
|
"fill will NOT affect param1, param2,\n"
|
|
"node metadata, or node timers. Improper usage\n"
|
|
"could result in unneeded map clutter.")
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db,
|
|
area=args.area, invert=args.invert,
|
|
includePartial=not args.blockmode)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
nimap = block.deserialize_nimap()
|
|
(nodeData, param1, param2) = block.deserialize_node_data()
|
|
|
|
if args.area:
|
|
blockPos = utils.Vec3.from_block_key(key)
|
|
overlap = utils.get_block_overlap(blockPos, args.area,
|
|
relative=True)
|
|
|
|
if (args.blockmode or not args.area
|
|
or overlap == None or overlap.is_full_mapblock()):
|
|
# Fill the whole mapblock.
|
|
nodeData[:] = 0
|
|
nimap = [fillNode]
|
|
else:
|
|
# Fill part of the mapblock.
|
|
if fillNode not in nimap:
|
|
nimap.append(fillNode)
|
|
fillId = nimap.index(fillNode)
|
|
|
|
if args.invert:
|
|
mask = np.ones(nodeData.shape, dtype="bool")
|
|
else:
|
|
mask = np.zeros(nodeData.shape, dtype="bool")
|
|
|
|
mask[overlap.to_array_slices()] = not args.invert
|
|
nodeData[mask] = fillId
|
|
# Remove duplicates/unused ID(s).
|
|
blockfuncs.clean_nimap(nimap, nodeData)
|
|
|
|
block.serialize_node_data(nodeData, param1, param2)
|
|
block.serialize_nimap(nimap)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# replacenodes command
|
|
#
|
|
|
|
def replace_nodes(inst, args):
|
|
# TODO: Option to delete metadata, param2, etc.
|
|
searchNode = args.searchnode_b
|
|
replaceNode = args.replacenode_b
|
|
|
|
if searchNode == replaceNode:
|
|
inst.log("fatal", "Search node and replace node are the same.")
|
|
|
|
inst.log("warning",
|
|
"replacenodes will NOT affect param1, param2,\n"
|
|
"node metadata, or node timers. Improper usage\n"
|
|
"could result in unneeded map clutter.")
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert,
|
|
includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
nimap = block.deserialize_nimap()
|
|
|
|
if searchNode not in nimap:
|
|
continue
|
|
|
|
searchId = nimap.index(searchNode)
|
|
(nodeData, param1, param2) = block.deserialize_node_data()
|
|
|
|
if args.area:
|
|
blockPos = utils.Vec3.from_block_key(key)
|
|
overlap = utils.get_block_overlap(blockPos, args.area,
|
|
relative=True)
|
|
|
|
if (not args.area or overlap == None or overlap.is_full_mapblock()):
|
|
# Replace in whole mapblock.
|
|
if replaceNode in nimap:
|
|
replaceId = nimap.index(replaceNode)
|
|
# Delete the unneeded node name from the index.
|
|
del nimap[searchId]
|
|
nodeData[nodeData == searchId] = replaceId
|
|
nodeData[nodeData > searchId] -= 1
|
|
else:
|
|
nimap[searchId] = replaceNode
|
|
else:
|
|
# Replace in a portion of the mapblock.
|
|
if replaceNode not in nimap:
|
|
nimap.append(replaceNode)
|
|
replaceId = nimap.index(replaceNode)
|
|
|
|
if args.invert:
|
|
mask = np.ones(nodeData.shape, dtype="bool")
|
|
else:
|
|
mask = np.zeros(nodeData.shape, dtype="bool")
|
|
|
|
mask[overlap.to_array_slices()] = not args.invert
|
|
mask &= nodeData == searchId
|
|
nodeData[mask] = replaceId
|
|
# Remove duplicates/unused ID(s).
|
|
blockfuncs.clean_nimap(nimap, nodeData)
|
|
|
|
block.serialize_nimap(nimap)
|
|
block.serialize_node_data(nodeData, param1, param2)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# setparam2 command
|
|
#
|
|
|
|
def set_param2(inst, args):
|
|
searchNode = args.searchnode_b
|
|
|
|
if args.paramval < 0 or args.paramval > 255:
|
|
inst.log("fatal", "param2 value must be between 0 and 255.")
|
|
|
|
if not searchNode and not args.area:
|
|
inst.log("fatal", "This command requires area and/or searchnode.")
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
|
|
if searchNode:
|
|
nimap = block.deserialize_nimap()
|
|
try:
|
|
searchId = nimap.index(searchNode)
|
|
except ValueError:
|
|
# Block doesn't really contain the target node, skip.
|
|
continue
|
|
|
|
(nodeData, param1, param2) = block.deserialize_node_data()
|
|
|
|
if args.area:
|
|
blockPos = utils.Vec3.from_block_key(key)
|
|
overlap = utils.get_block_overlap(blockPos, args.area,
|
|
relative=True)
|
|
|
|
if not args.area or overlap == None or overlap.is_full_mapblock():
|
|
# Work on whole mapblock.
|
|
if searchNode:
|
|
param2[nodeData == searchId] = args.paramval
|
|
else:
|
|
param2[:] = args.paramval
|
|
else:
|
|
# Work on partial mapblock.
|
|
if args.invert:
|
|
mask = np.ones(nodeData.shape, dtype="bool")
|
|
else:
|
|
mask = np.zeros(nodeData.shape, dtype="bool")
|
|
|
|
if overlap:
|
|
slices = overlap.to_array_slices()
|
|
mask[slices] = not args.invert
|
|
|
|
if searchNode:
|
|
mask &= nodeData == searchId
|
|
|
|
param2[mask] = args.paramval
|
|
|
|
block.serialize_node_data(nodeData, param1, param2)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# deletemeta command
|
|
#
|
|
|
|
def delete_meta(inst, args):
|
|
if not args.searchnode and not args.area:
|
|
inst.log("fatal", "This command requires area and/or searchnode.")
|
|
|
|
searchNode = args.searchnode_b
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
|
|
if searchNode:
|
|
nimap = block.deserialize_nimap()
|
|
if searchNode not in nimap:
|
|
continue
|
|
searchId = struct.pack(">H", nimap.index(searchNode))
|
|
|
|
if args.area:
|
|
cornerPos = utils.Vec3.from_block_key(key) * 16
|
|
|
|
metaList = block.deserialize_metadata()
|
|
modified = False
|
|
for j, meta in utils.SafeEnum(metaList):
|
|
if args.area:
|
|
relPos = utils.Vec3.from_u16_key(meta["pos"])
|
|
if args.area.contains(relPos + cornerPos) == args.invert:
|
|
continue
|
|
|
|
if searchNode and block.get_raw_content(meta["pos"]) != searchId:
|
|
continue
|
|
|
|
del metaList[j]
|
|
modified = True
|
|
|
|
if modified:
|
|
block.serialize_metadata(metaList)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# setmetavar command
|
|
#
|
|
|
|
def set_meta_var(inst, args):
|
|
if not args.searchnode and not args.area:
|
|
# TODO: Warn?
|
|
inst.log("fatal", "This command requires area and/or searchnode.")
|
|
|
|
metaKey = args.metakey_b
|
|
metaValue = args.metavalue_b
|
|
searchNode = args.searchnode_b
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
for i, blockKey in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(blockKey))
|
|
|
|
if searchNode:
|
|
nimap = block.deserialize_nimap()
|
|
if searchNode not in nimap:
|
|
continue
|
|
searchId = struct.pack(">H", nimap.index(searchNode))
|
|
|
|
if args.area:
|
|
cornerPos = utils.Vec3.from_block_key(blockKey) * 16
|
|
|
|
metaList = block.deserialize_metadata()
|
|
modified = False
|
|
for j, meta in enumerate(metaList):
|
|
if args.area:
|
|
relPos = utils.Vec3.from_u16_key(meta["pos"])
|
|
if args.area.contains(cornerPos + relPos) == args.invert:
|
|
continue
|
|
|
|
if searchNode and block.get_raw_content(meta["pos"]) != searchId:
|
|
continue
|
|
|
|
metaVars = blockfuncs.deserialize_metadata_vars(meta["vars"],
|
|
meta["numVars"], block.metadata_version)
|
|
|
|
if metaKey in metaVars:
|
|
# TODO: Create/delete variables, bytes input.
|
|
metaVars[metaKey] = (metaValue, metaVars[metaKey][1])
|
|
metaList[j]["vars"] = blockfuncs.serialize_metadata_vars(
|
|
metaVars, block.metadata_version)
|
|
modified = True
|
|
|
|
if modified:
|
|
block.serialize_metadata(metaList)
|
|
inst.db.set_block(blockKey, block.serialize())
|
|
|
|
#
|
|
# replaceininv command
|
|
#
|
|
|
|
def replace_in_inv(inst, args):
|
|
searchNode = args.searchnode_b
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
|
|
if searchNode:
|
|
nimap = block.deserialize_nimap()
|
|
if searchNode not in nimap:
|
|
continue
|
|
searchId = struct.pack(">H", nimap.index(searchNode))
|
|
|
|
if args.area:
|
|
cornerPos = utils.Vec3.from_block_key(key) * 16
|
|
|
|
metaList = block.deserialize_metadata()
|
|
modified = False
|
|
for j, meta in enumerate(metaList):
|
|
if args.area:
|
|
relPos = utils.Vec3.from_u16_key(meta["pos"])
|
|
if args.area.contains(cornerPos + relPos) == args.invert:
|
|
continue
|
|
|
|
if searchNode and block.get_raw_content(meta["pos"]) != searchId:
|
|
continue
|
|
|
|
invList = meta["inv"].split(b"\n")
|
|
for k, item in enumerate(invList):
|
|
splitItem = item.split(b" ", 4)
|
|
|
|
if (splitItem[0] == b"Item" and
|
|
splitItem[1] == args.searchitem_b):
|
|
if args.replaceitem_b == b"Empty":
|
|
splitItem = [b"Empty"]
|
|
else:
|
|
splitItem[1] = args.replaceitem_b
|
|
# Delete item metadata.
|
|
if len(splitItem) == 5 and args.deletemeta:
|
|
del splitItem[4]
|
|
|
|
invList[k] = b" ".join(splitItem)
|
|
modified = True
|
|
|
|
metaList[j]["inv"] = b"\n".join(invList)
|
|
|
|
if modified:
|
|
block.serialize_metadata(metaList)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# deletetimers
|
|
#
|
|
|
|
def delete_timers(inst, args):
|
|
searchNode = args.searchnode_b
|
|
|
|
if not searchNode and not args.area:
|
|
# TODO: Warn?
|
|
inst.log("fatal", "This command requires area and/or searchnode.")
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db, searchData=searchNode,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
|
|
if searchNode:
|
|
nimap = block.deserialize_nimap()
|
|
if searchNode not in nimap:
|
|
continue
|
|
searchId = struct.pack(">H", nimap.index(searchNode))
|
|
|
|
if args.area:
|
|
cornerPos = utils.Vec3.from_block_key(key) * 16
|
|
|
|
timerList = block.deserialize_node_timers()
|
|
modified = False
|
|
for j, timer in utils.SafeEnum(timerList):
|
|
if args.area:
|
|
relPos = utils.Vec3.from_u16_key(timer["pos"])
|
|
if args.area.contains(cornerPos + relPos) == args.invert:
|
|
continue
|
|
|
|
if searchNode and block.get_raw_content(timer["pos"]) != searchId:
|
|
continue
|
|
|
|
del timerList[j]
|
|
modified = True
|
|
|
|
if modified:
|
|
block.serialize_node_timers(timerList)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
#
|
|
# deleteobjects
|
|
#
|
|
|
|
def delete_objects(inst, args):
|
|
ITEM_ENT_NAME = b"__builtin:item"
|
|
searchObj = args.searchobj_b
|
|
|
|
inst.begin()
|
|
blockKeys = utils.get_mapblocks(inst.db,
|
|
searchData=ITEM_ENT_NAME if args.items else searchObj,
|
|
area=args.area, invert=args.invert, includePartial=True)
|
|
|
|
itemstringFormat = re.compile(
|
|
b'\["itemstring"\] = "(?P<name>[a-zA-Z0-9_:]+)')
|
|
|
|
for i, key in enumerate(blockKeys):
|
|
inst.update_progress(i, len(blockKeys))
|
|
block = mapblock.Mapblock(inst.db.get_block(key))
|
|
|
|
objList = block.deserialize_static_objects()
|
|
modified = False
|
|
for j, obj in utils.SafeEnum(objList):
|
|
if args.area:
|
|
pos = utils.Vec3.from_v3f1000(obj["pos"])
|
|
if args.area.contains(pos) == args.invert:
|
|
continue
|
|
|
|
objectData = blockfuncs.deserialize_object_data(obj["data"])
|
|
|
|
if args.items: # Search for item entities.
|
|
if objectData["name"] != ITEM_ENT_NAME:
|
|
continue
|
|
|
|
if searchObj:
|
|
itemstring = itemstringFormat.search(objectData["data"])
|
|
if not itemstring or itemstring.group("name") != searchObj:
|
|
continue
|
|
else: # Search for regular entities (mobs, carts, et cetera).
|
|
if searchObj and objectData["name"] != searchObj:
|
|
continue
|
|
|
|
del objList[j]
|
|
modified = True
|
|
|
|
if modified:
|
|
block.serialize_static_objects(objList)
|
|
inst.db.set_block(key, block.serialize())
|
|
|
|
|
|
COMMAND_DEFS = {
|
|
# Argument format: (<name>: <required>)
|
|
|
|
"clone": {
|
|
"func": clone,
|
|
"help": "Clone the given area to a new location.",
|
|
"args": {
|
|
"area": True,
|
|
"offset": True,
|
|
"blockmode": False,
|
|
}
|
|
},
|
|
|
|
"overlay": {
|
|
"func": overlay,
|
|
"help": "Copy part or all of an input file into the primary file.",
|
|
"args": {
|
|
"input_file": True,
|
|
"area": False,
|
|
"invert": False,
|
|
"offset": False,
|
|
"blockmode": False,
|
|
}
|
|
},
|
|
|
|
"deleteblocks": {
|
|
"func": delete_blocks,
|
|
"help": "Delete all mapblocks in the given area.",
|
|
"args": {
|
|
"area": True,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"fill": {
|
|
"func": fill,
|
|
"help": "Fill the given area with one node.",
|
|
"args": {
|
|
"replacenode": True,
|
|
"area": True,
|
|
"invert": False,
|
|
"blockmode": False,
|
|
}
|
|
},
|
|
|
|
"replacenodes": {
|
|
"func": replace_nodes,
|
|
"help": "Replace all of one node with another node.",
|
|
"args": {
|
|
"searchnode": True,
|
|
"replacenode": True,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"setparam2": {
|
|
"func": set_param2,
|
|
"help": "Set param2 values of a certain node and/or a certain area.",
|
|
"args": {
|
|
"paramval": True,
|
|
"searchnode": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"deletemeta": {
|
|
"func": delete_meta,
|
|
"help": "Delete metadata from a certain node and/or a certain area.",
|
|
"args": {
|
|
"searchnode": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"setmetavar": {
|
|
"func": set_meta_var,
|
|
"help": "Set a variable in node metadata.",
|
|
"args": {
|
|
"metakey": True,
|
|
"metavalue": True,
|
|
"searchnode": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"replaceininv": {
|
|
"func": replace_in_inv,
|
|
"help": "Replace a certain item with another in node inventories.",
|
|
"args": {
|
|
"searchitem": True,
|
|
"replaceitem": True,
|
|
"deletemeta": False,
|
|
"searchnode": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"deletetimers": {
|
|
"func": delete_timers,
|
|
"help": "Delete node timers from a certain node and/or area.",
|
|
"args": {
|
|
"searchnode": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
|
|
"deleteobjects": {
|
|
"func": delete_objects,
|
|
"help": "Delete static objects of a certain name and/or from a"
|
|
"certain area.",
|
|
"args": {
|
|
"searchobj": False,
|
|
"items": False,
|
|
"area": False,
|
|
"invert": False,
|
|
}
|
|
},
|
|
}
|
|
|
|
|
|
class MapEditArgs:
|
|
"""Basic class to assign arguments to."""
|
|
def has_not_none(self, name):
|
|
return getattr(self, name, None) != None
|
|
|
|
|
|
class MapEditError(Exception):
|
|
"""Raised by MapEditInstance.log("error", msg)."""
|
|
pass
|
|
|
|
|
|
class MapEditInstance:
|
|
"""Verifies certain input and handles the execution of commands."""
|
|
|
|
STANDARD_WARNING = (
|
|
"This tool can permanently damage your Minetest world.\n"
|
|
"Always EXIT Minetest and BACK UP the map database before use.")
|
|
|
|
def __init__(self):
|
|
self.progress = utils.Progress()
|
|
self.print_warnings = True
|
|
self.db = None
|
|
self.sdb = None
|
|
|
|
def log(self, level, msg):
|
|
if level == "info":
|
|
print("INFO: " +
|
|
"\n ".join(msg.split("\n")))
|
|
elif level == "warning":
|
|
if self.print_warnings:
|
|
print("WARNING: " +
|
|
"\n ".join(msg.split("\n")))
|
|
elif level == "fatal":
|
|
print("ERROR: " +
|
|
"\n ".join(msg.split("\n")))
|
|
raise MapEditError()
|
|
|
|
def begin(self):
|
|
if self.print_warnings:
|
|
self.log("warning", self.STANDARD_WARNING)
|
|
if input("Proceed? (Y/n): ").lower() != "y":
|
|
raise MapEditError()
|
|
|
|
self.progress.set_start()
|
|
|
|
def finalize(self):
|
|
committed = False
|
|
|
|
if self.db:
|
|
if self.db.is_modified():
|
|
committed = True
|
|
self.log("info", "Committing to database...")
|
|
|
|
self.db.close(commit=True)
|
|
|
|
if self.sdb:
|
|
self.sdb.close()
|
|
|
|
if committed:
|
|
self.log("info", "Finished.")
|
|
|
|
def update_progress(self, completed, total):
|
|
self.progress.update_bar(completed, total)
|
|
|
|
def _verify_and_run(self, args):
|
|
self.print_warnings = not args.no_warnings
|
|
|
|
if bool(args.p1) != bool(args.p2):
|
|
self.log("fatal", "Missing --p1 or --p2 argument.")
|
|
|
|
if args.has_not_none("p1") and args.has_not_none("p2"):
|
|
args.area = utils.Area.from_args(args.p1, args.p2)
|
|
else:
|
|
args.area = None
|
|
|
|
if not args.area and args.has_not_none("invert") and args.invert:
|
|
self.log("fatal", "Cannot invert without a defined area.")
|
|
|
|
if args.has_not_none("offset"):
|
|
args.offset_v = utils.Vec3(*(n for n in args.offset))
|
|
else:
|
|
args.offset_v = None
|
|
|
|
# Verify any node/item names.
|
|
nameFormat = re.compile("^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$")
|
|
|
|
for paramName in ("searchnode", "replacenode", "searchitem",
|
|
"replaceitem", "metakey", "metavalue", "searchobj"):
|
|
if not hasattr(args, paramName):
|
|
continue
|
|
|
|
if args.has_not_none(paramName):
|
|
value = getattr(args, paramName)
|
|
if (paramName not in ("metakey", "metavalue")
|
|
and value != "air"
|
|
and not (paramName == "replaceitem"
|
|
and value == "Empty")
|
|
and nameFormat.match(value) == None):
|
|
self.log("fatal",
|
|
f"Invalid value for {paramName}: '{value}'")
|
|
|
|
# Translate to bytes so we don't have to do it later.
|
|
bParam = bytes(value, "utf-8")
|
|
else:
|
|
bParam = None
|
|
|
|
setattr(args, paramName + "_b", bParam)
|
|
|
|
# Attempt to open database(s).
|
|
if args.has_not_none("input_file"):
|
|
if args.input_file == args.file:
|
|
self.log("fatal",
|
|
"Primary and secondary map files are the same.")
|
|
|
|
try:
|
|
self.sdb = utils.DatabaseHandler(args.input_file)
|
|
except Exception as e:
|
|
self.log("fatal", f"Failed to open secondary database: {e}")
|
|
|
|
try:
|
|
self.db = utils.DatabaseHandler(args.file)
|
|
except Exception as e:
|
|
self.log("fatal", f"Failed to open primary database: {e}")
|
|
|
|
COMMAND_DEFS[args.command]["func"](self, args)
|
|
|
|
def run(self, args):
|
|
try:
|
|
self._verify_and_run(args)
|
|
except MapEditError:
|
|
pass
|
|
|
|
self.progress.update_final()
|
|
self.finalize()
|