def json_format(self):
gLogger.set_section("RandomEventMonster")
gLogger.info("writing JSON randomeventmonster.json")
data= dict()
data["random_event_monster"] = dict()
for key in self.properties:
prop = self.properties[key]
data["random_event_monster"][str(key)] = dict()
data["random_event_monster"][str(key)]["interval"] = int(prop.interval)
data["random_event_monster"][str(key)]["replace"] = int(prop.replace)
data["random_event_monster"][str(key)]["active_attack"] = int(prop.active_attack)
data["random_event_monster"][str(key)]["positions"] = list()
for position in prop.position:
vPos = dict()
vPos["world"] = position.id_world
vPos["x"] = position.x
vPos["y"] = position.y
vPos["z"] = position.z
data["random_event_monster"][str(key)]["positions"].append(vPos)
with open(self.out_filename_json, 'w') as fd:
json.dump(data, fd, indent=4)
gLogger.reset_section()
def write_json(self, name):
gLogger.set_section("define")
self.filename_out_json = g_project.path_json_header + 'header_' + name + '.json'
gLogger.info("writing header:", self.filename_out_json)
with open(self.filename_out_json, 'w') as fd:
json.dump(self.datas, fd, indent=4)
gLogger.reset_section()
def __compare__(self, title, based, used, result):
gLogger.info("Filtering:", title)
arr_find = list()
for binary in used:
gLogger.info("\tBinary:", binary)
for path in used[binary]:
count_find = 0
for value in used[binary][path]:
if value not in based:
gLogger.info(
"\t\t{hdr} used but no declared".format(hdr=title))
else:
arr_find.append(value)
count_find = count_find + 1
gLogger.info(
"\t\tFile: {path} {hdr} [{use}/{declared}]".format(
path=path,
hdr=title,
use=count_find,
declared=len(used[binary][path])))
i = 0
with open(result, "w") as fd:
for b in based:
if b not in arr_find:
fd.write(b + "\n")
i = i + 1
gLogger.info("{title} unused: {count}".format(title=title, count=i))
return arr_find
def load(self, f):
gLogger.set_section("propkarma")
self.in_filename = f
gLogger.info("Loading: ", self.in_filename)
with open(self.in_filename, "r", encoding="ISO-8859-1") as fd:
for line in fd:
line = line.replace("\n", "")
line = line.replace(" ", "\t")
if "//" in line or \
len(line) <= 0 or \
line == "":
continue
arr = line.split("\t")
cpy = list()
for it in arr:
if len(it) > 0:
cpy.append(it)
arr = cpy
if len(arr) < len(KarmaProperties):
continue
id_karma = arr[KarmaProperties["nGrade"]]
self.karmas[id_karma] = dict()
for key in KarmaProperties:
value = convert_value(
key,
arr[KarmaProperties[key]].replace("\"",
"").replace(" ", ""))
self.karmas[id_karma][key] = value
gLogger.reset_section()
def write_json_config(self):
gLogger.set_section("propkarma")
gLogger.info("writing config JSON")
with open(self.out_filename_json, 'w') as fd:
json.dump(self.karmas, fd, indent=4)
gLogger.reset_section()
def load(self, file_prop, ):
gLogger.set_section("propmover")
self.in_filename = file_prop
gLogger.info("Loading: ", self.in_filename)
with open(self.in_filename, "r", encoding="ISO-8859-1") as fd:
for line in fd:
if skip_preproc(line) is True:
continue
if "//" in line:
continue
line = line.replace("\n", "")
arr = line.split("\t")
copy = []
for it in arr:
if it != "":
copy.append(it)
arr = copy
if len(MoverParams) != len(arr):
continue
mover_id = arr[0]
self.movers[mover_id] = dict()
for key in MoverParams:
self.movers[mover_id][key] = arr[MoverParams[key]].replace("\"", "")
gLogger.reset_section()
return True
def load(self, f):
gLogger.set_section("proptroupeskill")
self.in_filename = f
gLogger.info("Loading: ", self.in_filename)
with open(self.in_filename, "r") as fd:
for line in fd:
line = line.replace("\n", "")
line = line.replace(" ", "\t")
if "//" in line or \
len(line) <= 0 or \
line == "":
continue
arr = line.split("\t")
cpy = list()
for it in arr:
if it != "" and len(it) > 0:
cpy.append(it)
arr = cpy
if len(arr) < len(TroupeSkillProperties):
continue
id_ts = arr[TroupeSkillProperties["dwID"]]
self.troupeSkills[id_ts] = dict()
for k in TroupeSkillProperties:
self.troupeSkills[id_ts][k] = arr[TroupeSkillProperties[k]]
gLogger.reset_section()
def load(self, f):
gLogger.set_section("define")
gLogger.info("Loading: ", f)
self.filename_in = f
with open(f, "r") as fd:
for line in fd:
line = line.replace("\n", "")
line = line.replace(" ", "\t")
if "//" in line or len(line) <= 0 \
or line == "" \
or skip_preproc(line) is True:
continue
line = line.replace("#define", "")
line = line.replace("# define", "")
arr = line.split("\t")
key = ""
value = ""
for it in arr:
if it != "" and len(it) > 0:
try:
value = int(it)
except ValueError:
if key == "":
key = it
else:
value = it
if key != "" and value != "":
break
if key != "" and value != "" and key not in self.datas:
self.datas[key] = value
gLogger.reset_section()
return self.datas
def load(self, f):
gLogger.set_section("msghdr")
gLogger.info("loading:", f)
self.__load_msgdhr__(f)
self.__load_ressource__(self.file_packets, self.packets_used)
self.__load_ressource__(self.file_snapshots, self.snapshots_used)
gLogger.reset_section()
def filter(self, mdlobj):
gLogger.set_section("world")
obj_in_world = list()
sfx_in_world = list()
for it in self.worlds:
world = self.worlds[it]
gLogger.info("filtering {id}".format(id=str(world.id)))
gLogger.info(
"directory: {directory} height: {height} width: {width} indoor: {indoor}"
.format(directory=world.directory,
height=world.size.y,
width=world.size.x,
indoor=world.indoor))
for y in range(0, world.size.y):
for x in range(0, world.size.x):
for obj in world.lands[y][x].objs:
if obj.dwModelID not in obj_in_world:
obj_in_world.append(obj.dwModelID)
for sfx in world.lands[y][x].sfxs:
if sfx.dwModelID not in sfx_in_world:
sfx_in_world.append(sfx.dwModelID)
gLogger.write(
gProject.path_filter + "world_" + str(world.id) +
"_obj_find.txt", obj_in_world,
"Unique Obj: {total}".format(total=len(obj_in_world)))
gLogger.write(
gProject.path_filter + "world_sfx_find.txt", sfx_in_world,
"Unique Sfx: {total}".format(total=len(sfx_in_world)))
gLogger.reset_section()
def __write_json_format__(self):
gLogger.set_section("propmover")
gLogger.info("writing config JSON")
with open(self.out_filename_json, 'w') as fd:
json.dump(self.movers, fd, indent=4)
gLogger.reset_section()
def __load_state__(self, q, fd, line):
sep = fd.readline().replace("\t", "").replace("\n", "")
if len(sep) != 1 or sep != "{":
message = "error: [{char}]".format(char=sep)
gLogger.info(message)
return None
number = line.replace("state", "").replace(" ", "").replace("\t", "")
q.State[number] = dict()
last_inc = ""
while True:
line = fd.readline().replace("\n", "").replace("\t", "")
if len(line) <= 0:
continue
elif "}" in line:
break
else:
if "(" in line or ")" in line:
continue
if "IDS" not in line:
if line not in q.State[number]:
q.State[number][line] = ""
last_inc = line
elif "IDS" in line:
q.State[number][last_inc] = line
return True
def __load_dialog__(self, q, fd):
sep = fd.readline().replace("\t", "").replace("\n", "")
if len(sep) != 1 or sep != "(":
message = "error: [{char}]".format(char=sep)
gLogger.info(message)
return None
action = None
text = None
while True:
line = fd.readline().replace("\n", "").replace("\t", "").replace(
",", "").replace(" ", "")
if len(line) <= 0 or line == "":
continue
if ")" in line:
break
if action is None:
action = line
elif text is None:
text = line
if action is None or text is None:
return False
action = action.replace(",", "")
if action in QAction:
action = QAction[action]
text = text.replace(",", "")
q.Dialog[action] = text
return True
def __load_setting__(self, q, fd):
sep = fd.readline().replace("\t", "").replace("\n", "")
if len(sep) != 1 or sep != "{":
message = "error: [{char}]".format(char=sep)
gLogger.info(message)
return None
while True:
line = fd.readline().replace("\n", "").replace("\t", "").replace(
" ", "").replace("\"", "")
if len(line) <= 0:
continue
elif "}" in line:
break
else:
line = line.replace("(", ",").replace(")", "").replace(";", "")
arr = line.split(",")
if len(arr) <= 1:
gLogger.error("syntaxe line error:", q.Id, line)
return None
fct = arr[0]
q.Setting[fct] = list()
i = 1
while i < len(arr):
q.Setting[fct].append(arr[i])
i = i + 1
return True
def load(self, file_prop):
gLogger.set_section("propmoverex")
self.in_filename = file_prop
gLogger.info("loading:", self.in_filename)
movers = dict()
with open(self.in_filename, "r", encoding="ISO-8859-1") as fd:
id = ""
for line in fd:
line = line.replace("\t", "").replace("\n", "").replace(
" ", "").replace(";", "")
if len(line) == 0:
continue
if "MI_" in line and line[0] == 'M' and line[
1] == 'I' and line[2] == '_':
id = line
movers[id] = list()
continue
if id != "":
movers[id].append(line)
for it in movers:
mover = movers[it]
prop = PropExtend()
prop.load(it, mover)
self.properties[it] = prop
gLogger.reset_section()
def load(self, f):
gLogger.set_section("text")
gLogger.info("Loading: ", f)
self.filename_in = f
self.datas = dict()
with open(f, "r", encoding="ISO-8859-1") as fd:
for line in fd:
line = line.replace("\n", "")
line = line.replace(" ", "\t")
if "//" in line or len(line) <= 0 or line == "":
continue
arr = line.split("\t")
key = arr[0]
value = ""
for it in arr:
if len(it) <= 0 or it == "" or it == key or it == " ":
continue
if value == "" or len(value) <= 0:
value = it
else:
value += str(" " + it)
if key != "" and key not in self.datas:
self.datas[key] = value
gLogger.reset_section()
def write_json(self, name):
gLogger.set_section("text")
gLogger.info("writing text", name, "JSON")
self.filename_out_json = g_project.path_json_text + 'text_' + name + '.json'
with open(self.filename_out_json, 'w') as fd:
json.dump(self.datas, fd, indent=4)
gLogger.reset_section()
def __write_config_xml__(self):
gLogger.set_section("propQuest")
gLogger.info("writing quest XML")
root = ET.Element("quests")
for it in self.Quests:
quest = self.Quests[it]
section_quest = ET.SubElement(root, "quest")
section_questions = ET.SubElement(section_quest, "questions")
section_conditions = ET.SubElement(section_quest, "conditions")
section_states = ET.SubElement(section_quest, "states")
section_quest.set("dwID", quest.Id.replace("\"", ""))
section_quest.set("szTitle", quest.Title)
for action in quest.Dialog:
sub_section = ET.SubElement(section_questions, "dialog")
sub_section.set("action", action)
sub_section.set("text", quest.Dialog[action])
for fct in quest.Setting:
setting = quest.Setting[fct]
section_condition = ET.SubElement(section_conditions,
"condition")
section_condition.set("function", fct)
if fct == "SetBeginCondPreviousQuest":
section_condition.set("nBeginCondPreviousQuestType",
setting[0])
for i in range(0, len(setting)):
if fct in ParamCondition:
section_condition.set(ParamCondition[fct][i],
setting[i])
elif fct == "SetBeginCondJob":
section_condition.set(setting[i], "1")
elif fct == "SetBeginCondPreviousQuest":
if i == 0:
section_condition.set(
"nBeginCondPreviousQuestType", setting[0])
else:
section_condition.set(setting[i], "1")
else:
gLogger.error("condition unknow", it, fct)
for value in quest.State:
state = quest.State[value]
section = ET.SubElement(section_states, "state")
section.set("type", value)
for fct in state:
param = state[fct]
section.set(fct, param)
tree = ET.ElementTree(root)
tree.write(self.out_filename_xml,
pretty_print=True,
xml_declaration=True)
gLogger.reset_section()
def load(self, f):
gLogger.set_section("mdldyna")
gLogger.info("Loading: ", f)
pointer = None
with open(f, "r", encoding="ISO-8859-1") as fd:
type_model = ""
index = ""
for line in fd:
line = self.__remove_element__(line)
if "{" in line or "}" in line:
continue
arr = self.__filter_arr__(line.split("\t"))
if arr is None or len(arr) <= 0 or arr == []:
continue
if len(arr) == 2 and "MTI" not in arr[1] and arr[1].isdigit():
type_model = TypeItem[int(arr[1])]
if type_model == "item":
pointer = self.items
elif type_model == "ctrl":
pointer = self.ctrls
elif type_model == "sfx":
pointer = self.sfxs
elif type_model == "ship":
pointer = self.ships
elif type_model == "path":
pointer = self.paths
elif type_model == "region":
pointer = self.regions
elif type_model == "mvr":
pointer = self.movers
else:
pointer = None
if pointer is not None and len(arr) == 2 and "MTI" in arr[1]:
pointer[index]["motion"][arr[0].replace(
'"', "")] = arr[1].replace('"', "")
pass
if len(arr) != 12:
continue
if len(arr) == 12 and pointer is not None:
index = arr[1]
pointer[index] = dict()
if type_model == "mvr":
pointer[index]["motion"] = dict()
for i in ModelParams:
key = ModelParams[i]
value = arr[i].replace('"', "")
if len(value) == 0:
value = ""
pointer[index][key] = value
gLogger.reset_section()
def write(self, f, defines, sep="\t"):
gLogger.set_section("define")
gLogger.info("writing:", f)
with open(f, "w") as fd:
for it in defines:
define = defines[it]
line = define.toString()
line = line.replace(" ", sep)
fd.write(line + "\n")
gLogger.reset_section()
return True
def __write_config_json__(self):
gLogger.set_section("propquest")
gLogger.info("writing quest JSON")
data = dict()
for name_quest in self.Quests:
quest = self.Quests[name_quest]
data[name_quest] = {
"id": quest.Id.replace("\"", ""),
"title": quest.Title,
"dialog": [],
"condition": {},
"type": {}
}
for action in quest.Dialog:
data[name_quest]["dialog"].append({
"action": action,
"text": quest.Dialog[action]
})
for name_function in quest.Setting:
setting = quest.Setting[name_function]
condition = dict()
if name_function == 'SetBeginCondPreviousQuest':
condition["nBeginCondPreviousQuestType"] = setting[0]
for i in range(0, len(setting)):
if name_function in ParamCondition:
condition[ParamCondition[name_function]
[i]] = setting[i]
elif name_function == "SetBeginCondJob":
condition[setting[i]] = 1
elif name_function == "SetBeginCondPreviousQuest":
if i == 0:
condition["nBeginCondPreviousQuestType"] = setting[
0]
else:
condition["nBeginCondPreviousQuestType"] = 1
else:
gLogger.error("condition unknow", name_quest,
name_function)
data[name_quest]["condition"][name_function] = condition
for value in quest.State:
for state in quest.State[value]:
data[name_quest]["type"][
QAction[value]] = quest.State[value][state]
with open(self.out_filename_json, 'w') as fd:
json.dump(data, fd, indent=4)
gLogger.reset_section()
def __write_xml__(self):
gLogger.set_section("diepenalty")
gLogger.info("writing:", self.out_filename_xml)
root = ET.Element("penalties")
for k in self.data:
section = ET.SubElement(root, k)
for j in self.data[k]:
sub_section = ET.SubElement(section, "penalty")
sub_section.set("id", str(j))
sub_section.set("value", str(self.data[k][j]))
tree = ET.ElementTree(root)
tree.write(self.out_filename_xml, pretty_print=True, xml_declaration=True)
gLogger.reset_section()
def __write_format_xml__(self):
gLogger.set_section("letter")
gLogger.info("writing:", self.out_filename_xml)
root = ET.Element("letters")
for k in self.data["letters"]:
section = ET.SubElement(root, "letter")
section.set("text", k)
tree = ET.ElementTree(root)
tree.write(self.out_filename_xml,
pretty_print=True,
xml_declaration=True)
gLogger.reset_section()
def load(self, filename):
gLogger.set_section("letter")
self.in_filename = filename
gLogger.info("loading:", self.in_filename)
with open(self.in_filename, 'r', encoding="utf-8") as fd:
for line in fd:
line = line.replace("\n", "")
if len(line) == 0:
continue
self.data["letters"].append(line)
print(self.data)
gLogger.reset_section()
def load(self, f):
gLogger.set_section("propquest")
self.in_filename = f
gLogger.info("loading:", self.in_filename)
new_quest = True
with open(self.in_filename, "r") as fd:
q = None
for line in fd:
line = line.replace("\n", "")
line = line.replace(" ", "\t")
if "\\" in line or line == "" or line == "\t":
continue
s = False
for it in line:
if it != "\t":
s = True
break
if s is False:
continue
if new_quest is True:
q = Quest()
new_quest = False
line = line.replace("\t", "")
q.Id = line
fd.readline()
continue
if "SetTitle" in line:
if self.__load_set_title__(q, fd) is None:
return None
elif "setting" in line or "Setting" in line:
if self.__load_setting__(q, fd) is None:
return None
elif "SetDialog" in line:
if self.__load_dialog__(q, fd) is None:
return None
elif "state" in line:
if self.__load_state__(q, fd, line) is None:
return None
else:
self.Quests[q.Id] = q
line = line.replace("\t", "")
if len(line) != 1 or line != "}":
gLogger.error("line != }", line)
return None
new_quest = True
gLogger.reset_section()
return True
def load(self, filename):
gLogger.set_section("filter")
self.in_filename = filename
gLogger.info("loading:", self.in_filename)
with open(self.in_filename, 'r', encoding="utf-8") as fd:
for line in fd:
line = line.replace("\n", "")
arr = line.split('"')
if len(arr) < 4:
continue
self.data[str(arr[1])] = str(arr[3])
gLogger.reset_section()
def filter(self):
gLogger.info("Filtering propmover")
gLogger.set_section("propmover")
mover_undeclared = []
mover_unused = []
weapon_undeclared = []
mover_name_undeclared = []
mover_comment_undeclared = []
# pass
for key in self.movers:
mover = self.movers[key]
# if key not in self.define.datas:
# mover_undeclared.append(key)
# if mover["szComment"] not in self.text.datas:
# mover_comment_undeclared.append(key)
# if mover["szName"] not in self.text.datas:
# mover_name_undeclared.append(key)
if self.items is not None:
if mover["dwAtk1"] not in self.items:
weapon_undeclared.append(mover["dwAtk1"])
if mover["dwAtk2"] not in self.items:
weapon_undeclared.append(mover["dwAtk2"])
if mover["dwAtk3"] not in self.items:
weapon_undeclared.append(mover["dwAtk3"])
gLogger.write(g_project.path_filter + "mover_undeclared.txt", mover_undeclared,
"{infos}: {undeclared}/{total}".format(
infos="Movers undeclared:",
undeclared=len(mover_undeclared),
total=len(self.movers)))
gLogger.write(g_project.path_filter + "mover_unused.txt", mover_unused, "{infos}: {undeclared}/{total}".format(
infos="Movers mover_unused:",
undeclared=len(mover_unused),
total=len(self.movers)))
gLogger.write(g_project.path_filter + "mover_name_undeclared.txt", mover_name_undeclared,
"{infos}: {undeclared}/{total}".format(
infos="Movers mover_name_undeclared:",
undeclared=len(mover_name_undeclared),
total=len(self.movers)))
gLogger.write(g_project.path_filter + "mover_comment_undeclared.txt", mover_comment_undeclared,
"{infos}: {undeclared}/{total}".format(
infos="Movers mover_comment_undeclared:",
undeclared=len(mover_comment_undeclared),
total=len(self.movers)))
gLogger.reset_section()
return mover_undeclared, mover_unused, weapon_undeclared, mover_name_undeclared, mover_comment_undeclared
def filter(self, textKarma):
gLogger.set_section("propkarma")
karma_name_undeclared = list()
karma_comment_undeclared = list()
karma_color_invalid = list()
gLogger.info("name and comment")
for it in self.karmas:
karma = self.karmas[it]
if karma.szName not in textKarma and karma.szName not in karma_name_undeclared:
karma_name_undeclared.append(karma.szName)
if karma.szComment not in textKarma and karma.szComment not in karma_name_undeclared:
karma_comment_undeclared.append(karma.szComment)
gLogger.info("color")
for it in self.karmas:
karma = self.karmas[it]
try:
nb = int(str(karma.dwColor), 16)
except:
if karma.dwColor not in karma_color_invalid:
karma_color_invalid.append(karma.dwColor)
gLogger.write(
g_project.path_filter + "karma_name_undeclared.txt",
karma_name_undeclared, "{infos}: {undeclared}/{total}".format(
infos="names undeclared:",
undeclared=len(karma_name_undeclared),
total=len(self.karmas)))
gLogger.write(
g_project.path_filter + "karma_comment_undeclared.txt",
karma_comment_undeclared, "{infos}: {undeclared}/{total}".format(
infos="comment undeclared:",
undeclared=len(karma_comment_undeclared),
total=len(self.karmas)))
gLogger.write(
g_project.path_filter + "karma_color_invalid.txt",
karma_color_invalid, "{infos}: {undeclared}/{total}".format(
infos="color invalid:",
undeclared=len(karma_color_invalid),
total=len(self.karmas)))
gLogger.reset_section()
return karma_name_undeclared, karma_comment_undeclared
def write_xml_config(self):
gLogger.set_section("propkarma")
gLogger.info("writing config XML")
root = ET.Element("karmas")
for it in self.karmas:
karma = self.karmas[it]
section = ET.SubElement(root, "grade")
for key in karma:
value = karma[key]
section.set(str(key), str(value))
tree = ET.ElementTree(root)
tree.write(self.out_filename_xml,
pretty_print=True,
xml_declaration=True)
gLogger.reset_section()
def json_format(self):
gLogger.set_section("propmoverex")
gLogger.info("writing JSON propmoverex")
data = dict()
data["prop_mover_extend"] = {}
for key in self.properties:
prop = self.properties[key]
data["prop_mover_extend"][str(key)] = dict()
data["prop_mover_extend"][str(key)]["id_mover"] = str(
prop.id_mover)
data["prop_mover_extend"][str(key)]["max_item"] = int(
prop.max_item)
data["prop_mover_extend"][str(key)]["gold_min"] = int(
prop.gold.min)
data["prop_mover_extend"][str(key)]["gold_max"] = int(
prop.gold.max)
if len(prop.items) > 0:
data["prop_mover_extend"][str(key)]["items"] = list()
for it in prop.items:
item = prop.items[it]
item_data = dict()
item_data["id_item"] = item.id
item_data["probability"] = item.probability
item_data["level_min"] = item.level_min
item_data["level_max"] = item.level_max
item_data["number"] = item.number
data["prop_mover_extend"][str(key)]["items"].append(
item_data)
if len(prop.kinds) > 0:
data["prop_mover_extend"][str(key)]["kinds"] = list()
for it in prop.kinds:
kind = prop.kinds[it]
kind_data = dict()
kind_data["id_item"] = kind.id
kind_data["level_min"] = kind.min
kind_data["level_max"] = kind.max
data["prop_mover_extend"][str(key)]["kinds"].append(
kind_data)
with open(self.out_filename_json, 'w') as fd:
json.dump(data, fd, indent=4)
gLogger.reset_section()
