358 lines
11 KiB
Python
358 lines
11 KiB
Python
import os
|
|
import sys
|
|
from block import *
|
|
import content
|
|
|
|
mcmap = MCMap(sys.argv[1])
|
|
mtmap = MTMap(sys.argv[2])
|
|
|
|
if not os.path.exists(sys.argv[2]):
|
|
os.makedirs(sys.argv[2])
|
|
|
|
if not os.path.exists(sys.argv[2] + "/map_meta.txt"):
|
|
mg = open(sys.argv[2] + "/map_meta.txt", "w")
|
|
mg.write("mg_name = singlenode\n")
|
|
mg.write("mapgen_singlenode = \"ignore\"\n")
|
|
mg.write("waterlevel = 63\n")
|
|
mg.write("[end_of_params]\n")
|
|
mg.close()
|
|
|
|
if not os.path.exists(sys.argv[2] + "/world.mt"):
|
|
wo = open(sys.argv[2] + "/world.mt", "w")
|
|
wo.write("backend = sqlite3\n")
|
|
wo.write("gameid = minetest\n")
|
|
wo.write("load_mod_biome_lib = true\n")
|
|
wo.write("load_mod_bushes_classic = true\n")
|
|
wo.write("load_mod_ferns = true\n")
|
|
wo.write("load_mod_flowers_plus = true\n")
|
|
wo.write("load_mod_homedecor = true\n")
|
|
wo.write("load_mod_junglegrass = true\n")
|
|
wo.write("load_mod_mesecons = true\n")
|
|
wo.write("load_mod_moreblocks = true\n")
|
|
wo.write("load_mod_moretrees = true\n")
|
|
wo.write("load_mod_mushroom = true\n")
|
|
wo.write("load_mod_nether = true\n")
|
|
wo.write("load_mod_plants_lib = true\n")
|
|
wo.write("load_mod_poisonivy = true\n")
|
|
wo.write("load_mod_quartz = true\n")
|
|
wo.write("load_mod_singlenode = true\n")
|
|
wo.write("load_mod_vines = true\n")
|
|
wo.close()
|
|
|
|
#os.makedirs(sys.argv[2]+"/worldmods")
|
|
#os.makedirs(sys.argv[2]+"/worldmods/singlenode")
|
|
|
|
#sn = open(sys.argv[2]+"/worldmods/singlenode/init.lua", "w")
|
|
#sn.write("minetest.set_mapgen_params({mgname = \"singlenode\"})\n")
|
|
#sn.close()
|
|
|
|
if not os.path.exists(sys.argv[2]+"/moretrees_settings.txt"):
|
|
mo = open(sys.argv[2]+"/moretrees_settings.txt", "w")
|
|
mo.write("moretrees.enable_apple_tree = false\n")
|
|
mo.write("moretrees.enable_oak = false\n")
|
|
mo.write("moretrees.enable_sequoia = false\n")
|
|
mo.write("moretrees.enable_palm = false\n")
|
|
mo.write("moretrees.enable_pine = false\n")
|
|
mo.write("moretrees.enable_rubber_tree = false\n")
|
|
mo.write("moretrees.enable_willow = false\n")
|
|
mo.write("moretrees.enable_acacia = false\n")
|
|
mo.write("moretrees.enable_birch = false\n")
|
|
mo.write("moretrees.enable_spruce = false\n")
|
|
mo.write("moretrees.enable_jungle_tree = false\n")
|
|
mo.write("moretrees.enable_fir = false\n")
|
|
mo.write("moretrees.enable_beech = false\n")
|
|
mo.close()
|
|
|
|
nimap, ct = content.read_content(["MORETREES", "NETHER", "QUARTZ"])
|
|
mtmap.fromMCMap(mcmap, nimap, ct)
|
|
mtmap.save()
|
|
|
|
|
|
'''import zlib, gzip
|
|
import struct
|
|
import os
|
|
import sys
|
|
from io import StringIO
|
|
from tile_entities import te_convert
|
|
|
|
def nbt_read_tag(bytes, index, tag):
|
|
if tag <= 6:
|
|
plen = (None, 1, 2, 4, 8, 4, 8)[tag]
|
|
value = struct.unpack(">"+(None, "b", "h", "i", "q", "f", "d")[tag],
|
|
bytes[index:index+plen])[0]
|
|
index += plen
|
|
return value, index
|
|
elif tag == 7:
|
|
plen, index = nbt_read_tag(bytes, index, 3)
|
|
value = list(struct.unpack(">"+str(plen)+"B", bytes[index:index+plen]))
|
|
index += plen
|
|
return value, index
|
|
elif tag == 11:
|
|
plen, index = nbt_read_tag(bytes, index, 3)
|
|
value = list(struct.unpack(">"+str(plen)+"i", bytes[index:index+4*plen]))
|
|
index += 4*plen
|
|
return value, index
|
|
elif tag == 8:
|
|
plen, index = nbt_read_tag(bytes, index, 2)
|
|
value = bytes[index:index+plen].decode('utf-8')
|
|
index += plen
|
|
return value, index
|
|
elif tag == 9:
|
|
tagid = bytes[index]
|
|
index += 1
|
|
plen, index = nbt_read_tag(bytes, index, 3)
|
|
value = []
|
|
for i in range(plen):
|
|
v, index = nbt_read_tag(bytes, index, tagid)
|
|
value.append(v)
|
|
return value, index
|
|
elif tag == 10:
|
|
return nbt_read_named(bytes, index)
|
|
|
|
def nbt_read_named(bytes, index):
|
|
d = {}
|
|
while True:
|
|
if index >= len(bytes):
|
|
return d, index
|
|
tag = bytes[index]
|
|
index += 1
|
|
if tag == 0:
|
|
return d, index
|
|
name, index = nbt_read_tag(bytes, index, 8)
|
|
value, index = nbt_read_tag(bytes, index, tag)
|
|
d[name] = value
|
|
|
|
def nbt_read(bytes):
|
|
return nbt_read_named(bytes, 0)[0]
|
|
|
|
def to_int(bytes):
|
|
s = 0
|
|
for x in bytes:
|
|
s = (s<<8) + x
|
|
return s
|
|
|
|
def remove_half_bytes(d, key):
|
|
l = []
|
|
for x in d[key]:
|
|
l.append(x&0xf)
|
|
l.append((x>>4)&0xf)
|
|
d[key] = l
|
|
|
|
def to_anvil_data(block, key):
|
|
data = block[key]
|
|
del block[key]
|
|
l = [block["Sections"][i][key] for i in range(8)]
|
|
for yslice in range(8):
|
|
l_yslice = l[yslice]
|
|
k = 0
|
|
k2 = yslice << 4
|
|
for y in range(16):
|
|
for z in range(16):
|
|
for x in range(16):
|
|
l_yslice[k] = data[k2]
|
|
k += 1
|
|
k2 += 2048
|
|
k2 = (k2&0x7ff)+128
|
|
k2 = (k2&0x7f)+1
|
|
|
|
def format_block(block):
|
|
if block.get("isFormatted", False):
|
|
return block
|
|
block["isFormatted"] = True
|
|
if block.get("Sections", None) != None:
|
|
for section in block["Sections"]:
|
|
remove_half_bytes(section, "Data")
|
|
remove_half_bytes(section, "BlockLight")
|
|
remove_half_bytes(section, "SkyLight")
|
|
return block
|
|
remove_half_bytes(block, "Data")
|
|
remove_half_bytes(block, "BlockLight")
|
|
remove_half_bytes(block, "SkyLight")
|
|
block["Sections"] = [{"Y":i, "Blocks":[0]*4096, "Data":[0]*4096,
|
|
"BlockLight":[0]*4096, "SkyLight":[0]*4096}
|
|
for i in range(8)]
|
|
to_anvil_data(block, "Blocks")
|
|
to_anvil_data(block, "Data")
|
|
to_anvil_data(block, "BlockLight")
|
|
to_anvil_data(block, "SkyLight")
|
|
return block
|
|
|
|
|
|
def read_block(f, blockx, blockz):
|
|
ofs = (blockx%32 + (blockz%32)*32)*4
|
|
f.seek(ofs)
|
|
offset = to_int(f.read(3))<<12
|
|
if offset == 0:
|
|
return
|
|
f.seek(offset)
|
|
length = struct.unpack(">i", f.read(4))[0]
|
|
ctype = struct.unpack(">b", f.read(1))[0]
|
|
data = f.read(length - 1)
|
|
udata = zlib.decompress(data)
|
|
block = nbt_read(udata)['']["Level"]
|
|
return block
|
|
|
|
def read_dir(dirname):
|
|
filenames = [i for i in os.listdir(dirname) if i.endswith(".mcr") or i.endswith(".mca")]
|
|
blocks = {}
|
|
for filename in filenames:
|
|
s = filename.split(".")
|
|
chkx, chkz = int(s[1])*32, int(s[2])*32
|
|
with open(dirname+filename, "rb") as f:
|
|
for blockx in range(chkx, chkx+32):
|
|
for blockz in range(chkz, chkz+32):
|
|
block = read_block(f, blockx, blockz)
|
|
if block != None:
|
|
blocks[(blockx, blockz)] = block
|
|
return blocks
|
|
|
|
def read_content(enabled):
|
|
f = open("map_content.txt", "r")
|
|
lines = f.readlines()
|
|
f.close()
|
|
|
|
bd = {}
|
|
skip_level = 0
|
|
for line in lines:
|
|
if line[-1] == "\n":
|
|
line = line[:-1]
|
|
line = line.strip().split("//")[0].strip() # Remove comment
|
|
if len(line) >= 1 and line[0] == "#":
|
|
if line.startswith("#if"):
|
|
cond = line[4:]
|
|
if skip_level > 0 or cond not in enabled:
|
|
skip_level += 1
|
|
elif line.startswith("#else"):
|
|
if skip_level == 0:
|
|
skip_level = 1
|
|
elif skip_level == 1:
|
|
skip_level = 0
|
|
elif line.startswith("#endif"):
|
|
if skip_level > 0:
|
|
skip_level -= 1
|
|
continue
|
|
|
|
if skip_level > 0:
|
|
continue
|
|
|
|
s = line.split("\t")
|
|
if len(s) >= 2:
|
|
r = s[1].split(" ")
|
|
if len(r) == 0:
|
|
print(line)
|
|
raise ValueError("Malformed data")
|
|
name = r[0]
|
|
param2 = 0
|
|
for i in range(1, len(r)):
|
|
if r[i] != "":
|
|
param2 = int(r[i])
|
|
break
|
|
t = s[0].split(" ")
|
|
if len(t) == 2:
|
|
for data in t[1].split(","):
|
|
key = (int(t[0]), int(data))
|
|
if key not in bd:
|
|
bd[key] = (name, param2)
|
|
elif len(t) == 1:
|
|
for data in range(16):
|
|
key = (int(t[0]), data)
|
|
if key not in bd:
|
|
bd[key] = (name, param2)
|
|
|
|
blocks_len = max([i[0] for i in bd.keys()])+1
|
|
blocks = [[(None, 0),]*16 for i in range(blocks_len)]
|
|
for (id, data), value in bd.items():
|
|
blocks[id][data] = value
|
|
return blocks
|
|
|
|
blocks_id = read_content(["MORETREES", "QUARTZ", "NETHER"])
|
|
|
|
def get_name(id, data):
|
|
if id >= len(blocks_id):
|
|
return None, 0
|
|
return blocks_id[id][data]
|
|
|
|
def convert_section(section, tileentities, yslice):
|
|
n = len(section["Blocks"])
|
|
blocksdata = section["Blocks"]
|
|
data = section["Data"]
|
|
blocklight = section["BlockLight"]
|
|
skylight = section["SkyLight"]
|
|
blocks = [None]*n
|
|
param1 = [0]*n
|
|
param2 = [0]*n
|
|
metadata = [None]*n
|
|
for i in range(n):
|
|
blocks[i], param2[i] = get_name(blocksdata[i], data[i])
|
|
param1[i] = (max(blocklight[i], skylight[i])<<4)|blocklight[i]
|
|
for te in tileentities:
|
|
id = te["id"]
|
|
x, y, z = te["x"], te["y"], te["z"]
|
|
if y >> 4 != yslice:
|
|
continue
|
|
index = ((y&0xf)<<8)|((z&0xf)<<4)|(x&0xf)
|
|
f = te_convert.get(id.lower(), lambda arg: (None,None,None))
|
|
block, p2, meta = f(te)
|
|
if block != None:
|
|
blocks[index] = block
|
|
if p2 != None:
|
|
param2[index] = p2
|
|
if meta != None:
|
|
metadata[index] = meta
|
|
return (blocks, param1, param2, metadata)
|
|
|
|
def convert_block(block, yslice):
|
|
for section in block["Sections"]:
|
|
if section["Y"] == yslice:
|
|
return convert_section(section, block.get("TileEntities", []), yslice)
|
|
return None
|
|
|
|
def export_we(b, f):
|
|
blocks, param1, param2, metadata = b
|
|
L = []
|
|
f.write("return {")
|
|
write_comma = False
|
|
for i in range(len(blocks)):
|
|
x = i%16
|
|
z = (i//16)%16
|
|
y = i//256
|
|
if blocks[i] != None:
|
|
if write_comma:
|
|
f.write(",")
|
|
else:
|
|
write_comma = True
|
|
f.write("{x="+str(x)+",y="+str(y)+",z="+str(z)+',name="'+blocks[i]+'",param1='+str(param1[i])+",param2="+str(param2[i])+",meta=")
|
|
if metadata[i] == None:
|
|
f.write("{fields={},inventory={}}")
|
|
else:
|
|
f.write(metadata[i])
|
|
f.write("}")
|
|
f.write("}")
|
|
|
|
inputdir = sys.argv[1] + "region/"
|
|
blocks = read_dir(inputdir)
|
|
print("Reading done")
|
|
|
|
outputdir = sys.argv[2] + "blocks/"
|
|
if not os.path.exists(outputdir):
|
|
os.mkdir(outputdir)
|
|
|
|
done = 0
|
|
max_number = len(blocks)
|
|
for key, value in blocks.items():
|
|
#for key in [(i, j) for i in range(5, 9) for j in range(20, 35)]:
|
|
# value = blocks.get(key, None)
|
|
done += 1
|
|
if done%20 == 0:
|
|
print("Exported {} blocks on {}".format(done, max_number))
|
|
if value == None:
|
|
continue
|
|
for yslice in range(16):
|
|
value = format_block(value)
|
|
b = convert_block(value, yslice)
|
|
if b == None:
|
|
continue
|
|
with open(outputdir+str(key[0])+"."+str(yslice-4)+"."+str(key[1])+".we", "w") as f:
|
|
export_we(b, f)
|
|
'''
|