def createschematic():
a = (128 * 129 * (maxup + abs(maxdown) + 1))
schematic = nbt.NBTFile()
schematic["Height"] = nbt.TAG_Short(value=(abs(maxdown) + maxup + 1))
schematic["Length"] = nbt.TAG_Short(value=129)
schematic["Width"] = nbt.TAG_Short(value=128)
tempblocks = array.array('B', [0] * a)
tempdata = array.array('B', [0] * a)
for x in xrange(128):
for y in xrange(128):
tempblocks[s(x, y)] = blockid[tempcolors[m(x, y)]]
tempdata[s(x, y)] = blockdata[tempcolors[m(x, y)]]
tempblocks[s(x, 128)] = 3
tempdata[s(x, 128)] = 0
schematic["Blocks"] = nbt.TAG_Byte_Array()
schematic["Data"] = nbt.TAG_Byte_Array()
schematic["Blocks"].value = bytearray(tempblocks)
schematic["Data"].value = bytearray(tempdata)
schematic["Materials"] = nbt.TAG_String(value="Alpha")
print "Writing file..."
schematic.write_file(schematicpath)
print "Schematic successfully created!"
print "max height up: " + repr(maxup)
print "max height down: " + repr(abs(maxdown))
print "Minimum height you should build at: " + repr(maxup + 64)
def render_topographic_chunk((chunk_file, map_size, render_options)):
chunk = nbt.NBTFile(chunk_file, 'rb')
array_offset_X = (abs(map_size['x_min']) +
chunk['Level']['xPos'].value) * Level.chunk_size_X
array_offset_Z = (abs(map_size['z_min']) +
chunk['Level']['zPos'].value) * Level.chunk_size_Z
try:
blocks = numpy.fromstring(chunk['Level']['Blocks'].value,
dtype=numpy.uint8).reshape(
Level.chunk_size_X, Level.chunk_size_Z,
Level.chunk_size_Y)
for y in xrange(Level.chunk_size_Y):
profile = Level.topographic_translator[blocks[..., y]]
water = (profile == -1) * 1
colors = Level.topographic_colors[((profile + water) * (y + 2)) +
water].reshape(
Level.chunk_size_X,
Level.chunk_size_Z,
Level.color_depth)
image_array[array_offset_Z:array_offset_Z + Level.chunk_size_Z,
array_offset_X:array_offset_X +
Level.chunk_size_X] = overlay_chunk(
colors.swapaxes(0, 1),
image_array[array_offset_Z:array_offset_Z +
Level.chunk_size_Z,
array_offset_X:array_offset_X +
Level.chunk_size_X])
print 'Finished chunk %s' % str((array_offset_X, array_offset_Z))
except IndexError, err:
print 'Failed chunk: %s' % err
def filterEntities(value, args):
buff = io.BytesIO(value)
outBuff = io.BytesIO()
removed = False
while True:
try:
tree = nbt.NBTFile(buffer=buff)
try:
name = tree['CustomName']
tree.write_file(buffer=outBuff)
except KeyError:
try:
if tree['IsTamed']:
tree.write_file(buffer=outBuff)
elif "+minecraft:charged_creeper" in tree["definitions"]:
tree.write_file(buffer=outBuff)
elif not tree["NaturalSpawn"]:
found = False
for definition in tree['definitions']:
if definition in entitiesFiler:
removed = True
found = True
break
if not found:
tree.write_file(buffer=outBuff)
else:
removed = True
except KeyError as e:
tree.write_file(buffer=outBuff)
except nbt.MalformedFileError:
break
if removed:
return outBuff
else:
return None
def __init__(self, level_file):
self.level_file = level_file
try:
self.level_file = nbt.NBTFile(self.level_file, 'rb')
#do something here to checkout the level file?
except IOError, err:
#should probably do something more worthwhile here
raise err
def render_chunk((map_size, chunk_file)):
chunk_setup = time.time()
map_chunk_offset_X = abs(map_size['x_min'])
map_chunk_offset_Z = abs(map_size['z_min'])
map_image_size = (
(abs(map_size['x_max']) + map_chunk_offset_X) * Mapper.chunk_size_X +
16,
(abs(map_size['z_max']) + map_chunk_offset_Z) * Mapper.chunk_size_Z +
16)
block_colors = numpy.array([
Mapper.block_colors.get(color, (255, 255, 255))
for color in xrange(255)
],
dtype=numpy.uint8)
chunk = nbt.NBTFile(chunk_file, 'rb')
chunk_pos_X = chunk['Level']['xPos'].value
chunk_pos_Z = chunk['Level']['zPos'].value
chunk_pixel_offset_X = (chunk_pos_X +
map_chunk_offset_X) * Mapper.chunk_size_X
chunk_pixel_offset_Z = (chunk_pos_Z +
map_chunk_offset_Z) * Mapper.chunk_size_Z
end_chunk_setup = time.time()
chunk_render = time.time()
try:
blocks = numpy.fromstring(chunk['Level']['Blocks'].value,
dtype=numpy.uint8).reshape(16, 16, 128)
tops = [z[z.nonzero()][-1] for x in blocks for z in x]
colors = block_colors[tops].reshape(16, 16, 3)
image_array = numpy.memmap(mmap_filen,
dtype=numpy.uint8,
mode='r+',
shape=(map_image_size[1], map_image_size[0],
3))
image_array[(map_chunk_offset_Z + chunk_pos_Z) *
16:(map_chunk_offset_Z + chunk_pos_Z) * 16 + 16,
(map_chunk_offset_X + chunk_pos_X) *
16:(map_chunk_offset_X + chunk_pos_X) * 16 +
16] = colors.swapaxes(0, 1)
del image_array
except:
pass
end_chunk_render = time.time()
return (end_chunk_setup - chunk_setup, end_chunk_render - chunk_render)
def getPosition(world):
name, path = world
nbtfile = nbt.NBTFile(os.path.join(path, "level.dat"), "rb")
data = nbtfile["Data"]
player = data["Player"]
if player:
nbtpos = player["Pos"]
pos = (int(nbtpos[0].value), int(nbtpos[1].value),
int(nbtpos[2].value))
else:
pos = (data["SpawnX"].value, data["SpawnY"].value,
data["SpawnZ"].value)
return pos
def region_chunks(chunk_region_file):
chunk_region = file(chunk_region_file, 'rb')
# Read where each chunk is
locations_and_sizes = _1024_UINT32_STRUCT.unpack(chunk_region.read(_1024_UINT32_STRUCT.size))
# Now convert them to (location, size) tuples
locations_and_sizes = map(bytes_to_location_and_size, locations_and_sizes)
for location, size_ in locations_and_sizes:
if location and size_:
chunk_region.seek(location)
size = UINT32_STRUCT.unpack(chunk_region.read(UINT32_STRUCT.size))[0] - 1
compression_type = ord(chunk_region.read(1))
data = chunk_region.read(size).decode('zlib') + '\0'
nbt_ = nbt.NBTFile()
nbt_.parse_file(file=StringIO.StringIO(data))
yield nbt_
def render_oblique_chunk((chunk_file, map_size, render_options)):
chunk = nbt.NBTFile(chunk_file, 'rb')
array_offset_X = (abs(map_size['x_min']) +
chunk['Level']['xPos'].value) * Level.chunk_size_X
array_offset_Z = (abs(map_size['z_min']) +
chunk['Level']['zPos'].value) * Level.chunk_size_Z
try:
blocks = numpy.fromstring(chunk['Level']['Blocks'].value,
dtype=numpy.uint8).reshape(
Level.chunk_size_X, Level.chunk_size_Z,
Level.chunk_size_Y)
new_chunk_pixels = image_array[array_offset_Z:array_offset_Z +
Level.chunk_size_Z * 2 +
Level.chunk_size_Y,
array_offset_X:array_offset_X +
Level.chunk_size_X]
for y in range(Level.chunk_size_Y):
colors = Level.base_block_colors[blocks[..., y]].reshape(
Level.chunk_size_X, Level.chunk_size_Z, Level.color_depth)
shaded_colors = Level.base_block_colors[blocks[..., y]].reshape(
Level.chunk_size_X, Level.chunk_size_Z, Level.color_depth)
for z, x in itertools.product(
*map(xrange, [Level.chunk_size_X, Level.chunk_size_Z])):
try:
new_chunk_pixels[(Level.chunk_size_Y - y) + z,
x] = overlay_pixel(
colors[x, z],
new_chunk_pixels[(Level.chunk_size_Y -
y) + z, x])
new_chunk_pixels[(Level.chunk_size_Y - y) + z + 1,
x] = overlay_pixel(
shaded_colors[x, z],
new_chunk_pixels[(Level.chunk_size_Y -
y) + z + 1, x])
except IndexError:
pass
image_array[array_offset_Z:array_offset_Z + Level.chunk_size_Z * 2 +
Level.chunk_size_Y, array_offset_X:array_offset_X +
Level.chunk_size_X] = new_chunk_pixels
except IndexError, err:
print 'Failed chunk: %s' % err
def fixPendingTicks(key, value, args): buff = io.BytesIO(value) outBuff = io.BytesIO() modified = 0 while True : try : tree = nbt.NBTFile(buffer=buff) try : if tree['tickList']: print(key.x*16, key.z*16, len(tree['tickList'])) print(tree.pretty_tree()) # modified += 1 # newList = nbt.TAG_List(type=nbt.TAG_Compound, name='tickList') # tree['tickList'] = newList # tree.write_file(buffer=outBuff) except KeyError: pass except nbt.MalformedFileError: break return modified, outBuff
def notify_save(self):
global names
data = nbt.NBTFile(level_file)["Data"]
time = data["DayTime"].value % 24000
rain = data["raining"].value
thunder = data["thundering"].value
index = bisect.bisect(names, (time, ))
name = random.choice(names[index - 1][1])
text = "[*] 'Tis " + name + " in Loafyland with "
if rain:
if thunder:
text += "a severe thunderstorm warning."
else:
text += "a chance of showers."
else:
text += "partly cloudy skies."
self.reply.say(text)
def main(args):
date = datetime.datetime.now()
worldBorders = []
if args.worldBorders :
worldBorders = getWorldBordersFromFile(args.worldBorders)
world = ""
if args.world.endswith('db'):
world = args.world
else :
world = os.path.join(args.world, 'db')
spawners = {}
ships = {}
with leveldb.DB(world) as db :
if args.worldBorders or args.removeEntities or args.pendingTicks or args.dumpHSA or args.findSpawners or args.compact:
print("Reading database")
for entry in db:
if not isinstance(entry, Row):
print(entry)
continue
key = Key.fromBytes(entry.key)
if not key :
continue
if args.worldBorders and (key.dimension, key.x, key.z) not in worldBorders:
print("Removing d:%s x:%s z:%s"%( key.dimension, key.x, key.z))
db.delete(entry.key)
continue
if key.tag == 50 and args.removeEntities :
outBuff = filterEntities(entry.value, args)
if outBuff :
db.put(entry.key, outBuff.getvalue())
elif key.tag == 51 and args.pendingTicks:
db.delete(entry.key)
# removed, outBuff = fixPendingTicks(key, entry.value, args)
# if removed:
# print("Removed %d pendingTicks in d:%s, x:%s, z:%s"%( removed, key.dimension, key.x, key.z))
# db.put(entry.key, outBuff.getvalue())
elif key.tag == 49 and args.findSpawners:
buff = io.BytesIO(entry.value)
if entry.value :
tree = nbt.NBTFile(buffer=buff)
if tree['id'] == "MobSpawner":
spawners[Position(tree['x'].value, tree['y'].value, tree['z'].value, key.dimension)] = tree
elif key.tag == 57 and args.dumpHSA:
amount = int.from_bytes(entry.value[0:4],"little")
# newAmount = 0
# newData = b""
for x in range(amount):
hsa = HSA.fromBytes(entry.value[x*25+4:(x+1)*25+4], key.dimension)
print(hsa)
# elif key.tag == 47 and args.compact :
# palette = { 0x2 : (32,1,False) , 0x4 : (16,2,False), 0x6 : (10,3,True) , 0x8 : (8,4,False) , 0xa : (6,5,True) , 0xc: (5,6,True) , 0x10: (4,8,False) , 0x20 : (2,16,False) }
# pal = int(entry.value[2])
# chunkPalFormat = palette[pal]
# size = len(entry.value)
# end = (4096//chunkPalFormat[0])*4 + int(chunkPalFormat[2])*4
# # print(key, len(entry.value), pal, chunkPalFormat, end+7)
# buff = io.BytesIO(entry.value[end+7:])
# chunkPalette = []
# while True :
# try :
# tree = nbt.NBTFile(buffer=buff)
# # print(tree.pretty_tree())
# chunkPalette.append(tree)
# except nbt.MalformedFileError:
# break
# data = entry.value[3:end]
# usedId = set()
# for index in range(0,end,4):
# value = int.from_bytes(data[index:index+3], byteorder="big")
# for blockId in range(0,32, chunkPalFormat[1]):
# blockVal = (value >> blockId) & ((1<<chunkPalFormat[1])-1)
# # print(blockId, blockVal, chunkPalette[blockVal]["name"])
# usedId.add(blockVal)
# if len(usedId) > len(chunkPalette):
# print(key, len(entry.value), pal, chunkPalFormat, end+7)
# print(usedId, len(chunkPalette), int.from_bytes(entry.value[end+3:end+7], "little"))
if args.compact:
db.compactRange(None,0,None,0)
if args.findSpawners:
findSpawners(spawners, args.nbProcess)
def render_topographic_chunk_file((chunk_file, map_size, render_options)):
_render_topographic_chunk(nbt.NBTFile(chunk_file, 'rb'), map_size, render_options)
def render_oblique_chunk((chunk_file, map_size, render_options)):
_render_oblique_chunk(nbt.NBTFile(chunk_file, 'rb'), map_size, render_options)
def render_overhead_chunk_file((chunk_file, map_size, render_options)):
_render_overhead_chunk(nbt.NBTFile(chunk_file, 'rb'), map_size, render_options)
#!/usr/bin/python
import numpy
import nbt
blocks = numpy.fromstring(nbt.NBTFile('/home/aheadley/.minecraft/saves/World1/0/0/c.0.0.dat','rb')['Level']['Blocks'].value, dtype=numpy.uint8).reshape(16,16,128)
print blocks
import nbt
import sys
if __name__ == '__main__':
with open(sys.argv[1], 'rb') as fd:
tree = nbt.NBTFile(buffer=fd)
print(tree.pretty_tree())
x, y, z = tree['size']
blocks, logged = tree['structure']['block_indices']
i = 0
blockPalette = tree['structure']['palette']['default']['block_palette']
for xx in range(int(x)):
for yy in range(int(y)):
for zz in range(int(z)):
print("x : %d, y:%s, z:%s -> %s" %
(xx, yy, zz, blockPalette[int(blocks[i])]))
i += 1
import nbt
import array
#Loads the map.dat file, which must be numbered 777 and in the python main directory
mappath = raw_input(
"Please type the full filename path of the map.dat file you wish to convert\n"
)
mapfile = nbt.NBTFile(mappath, 'rb')
schematicpath = raw_input(
"\nPlease type the full filename path of the schematic file you wish to create\nThe file name must end in \".schematic\"\nSaving directly to the C drive requires administrator privileges\n"
)
print
blocksBytes = mapfile['data']['colors'].value
tempcolors = [0] * 16384
tempcolors = [i for i in blocksBytes]
#maximum amount the schematic will vertically rise from the starting level
maxup = 0
#max amount the schematic will vertically decline from the starting level
maxdown = 0
#maps the relative height of each (x, y) position, but takes m(x, y) as an input
height = [0] * (128 * 128)
edgeheight = [0] * 128
#blockid[map color index number] = block id number
blockid = [
7, 7, 7, 7, 2, 2, 2, 2, 88, 88, 88, 88, 13, 13, 13, 13, 46, 46, 46, 46,
174, 174, 174, 174, 101, 101, 101, 101, 116, 116, 116, 116, 80, 80, 80, 80,
82, 82, 82, 82, 3, 3, 3, 3, 4, 4, 4, 4, 9, 9, 9, 9, 5, 5, 5, 5, 35, 35, 35,
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
def getLevelInfo(self, worldName=False):
""" Return an NBT object of the world's level.dat. """
if not worldName: worldName = self.wrapper.server.worldName
if not worldName: raise Exception("Server Uninitiated")
f = nbt.NBTFile("%s/level.dat" % worldName, "rb")
return f["Data"]
