forked from mirrors/0ad
Dunedan
bcf97b608b
This enables some ruff rules for docstrings and comments. The idea is to not enforce the presence of docstrings, but to ensure they are properly formatted if they're present. For comments this adds checks that they don't contain code and verify the formatting of comments with "TODO" tags. As part of this, some commented out code which hasn't been touch in the past 10 years gets removed as well. The rules enabled enabled by this are: - check formatting of existing docstrings (D200-) - check comments for code (ERA) - check formatting of TODO tags (TD001, TD004-)
945 lines
32 KiB
Python
Executable File
945 lines
32 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- mode: python-mode; python-indent-offset: 4; -*-
|
|
#
|
|
# Copyright (C) 2023 Wildfire Games.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in
|
|
# all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
# THE SOFTWARE.
|
|
|
|
# ruff: noqa: SIM115
|
|
|
|
import glob
|
|
import os
|
|
import sys
|
|
import xml.etree.ElementTree as ET
|
|
from pathlib import Path
|
|
|
|
|
|
sys.path.append("../entity")
|
|
from scriptlib import SimulTemplateEntity
|
|
|
|
|
|
AttackTypes = ["Hack", "Pierce", "Crush", "Poison", "Fire"]
|
|
Resources = ["food", "wood", "stone", "metal"]
|
|
|
|
# Generic templates to load
|
|
# The way this works is it tries all generic templates
|
|
# But only loads those who have one of the following parents
|
|
# EG adding "template_unit.xml" will load all units.
|
|
LoadTemplatesIfParent = [
|
|
"template_unit_infantry.xml",
|
|
"template_unit_cavalry.xml",
|
|
"template_unit_champion.xml",
|
|
"template_unit_hero.xml",
|
|
]
|
|
|
|
# Those describe Civs to analyze.
|
|
# The script will load all entities that derive (to the nth degree) from one of
|
|
# the above templates.
|
|
Civs = [
|
|
"athen",
|
|
"brit",
|
|
"cart",
|
|
"gaul",
|
|
"iber",
|
|
"kush",
|
|
"han",
|
|
"mace",
|
|
"maur",
|
|
"pers",
|
|
"ptol",
|
|
"rome",
|
|
"sele",
|
|
"spart",
|
|
# "gaia",
|
|
]
|
|
|
|
# Remote Civ templates with those strings in their name.
|
|
FilterOut = ["marian", "thureophoros", "thorakites", "kardakes"]
|
|
|
|
# In the Civilization specific units table, do you want to only show the units
|
|
# that are different from the generic templates?
|
|
showChangedOnly = True
|
|
|
|
# Sorting parameters for the "roster variety" table
|
|
ComparativeSortByCav = True
|
|
ComparativeSortByChamp = True
|
|
ClassesUsedForSort = [
|
|
"Support",
|
|
"Pike",
|
|
"Spear",
|
|
"Sword",
|
|
"Archer",
|
|
"Javelin",
|
|
"Sling",
|
|
"Elephant",
|
|
]
|
|
|
|
# Disable if you want the more compact basic data. Enable to allow filtering and
|
|
# sorting in-place.
|
|
AddSortingOverlay = True
|
|
|
|
# This is the path to the /templates/ folder to consider. Change this for mod
|
|
# support.
|
|
modsFolder = Path(__file__).resolve().parents[3] / "binaries" / "data" / "mods"
|
|
basePath = modsFolder / "public" / "simulation" / "templates"
|
|
|
|
# For performance purposes, cache opened templates files.
|
|
globalTemplatesList = {}
|
|
sim_entity = SimulTemplateEntity(modsFolder, None)
|
|
|
|
|
|
def htbout(file, balise, value):
|
|
file.write("<" + balise + ">" + value + "</" + balise + ">\n")
|
|
|
|
|
|
def htout(file, value):
|
|
file.write("<p>" + value + "</p>\n")
|
|
|
|
|
|
def fastParse(template_name):
|
|
"""Run ET.parse() with memoising in a global table."""
|
|
if template_name in globalTemplatesList:
|
|
return globalTemplatesList[template_name]
|
|
parent_string = ET.parse(template_name).getroot().get("parent")
|
|
globalTemplatesList[template_name] = sim_entity.load_inherited(
|
|
"simulation/templates/", str(template_name), ["public"]
|
|
)
|
|
globalTemplatesList[template_name].set("parent", parent_string)
|
|
return globalTemplatesList[template_name]
|
|
|
|
|
|
def getParents(template_name):
|
|
template_data = fastParse(template_name)
|
|
parents_string = template_data.get("parent")
|
|
if parents_string is None:
|
|
return set()
|
|
parents = set()
|
|
for parent in parents_string.split("|"):
|
|
parents.add(parent)
|
|
for element in getParents(
|
|
sim_entity.get_file("simulation/templates/", parent + ".xml", "public")
|
|
):
|
|
parents.add(element)
|
|
|
|
return parents
|
|
|
|
|
|
def ExtractValue(value):
|
|
return float(value.text) if value is not None else 0.0
|
|
|
|
|
|
# This function checks that a template has the given parent.
|
|
def hasParentTemplate(template_name, parentName):
|
|
return any(parentName == parent + ".xml" for parent in getParents(template_name))
|
|
|
|
|
|
def CalcUnit(UnitName, existingUnit=None):
|
|
if existingUnit is not None:
|
|
unit = existingUnit
|
|
else:
|
|
unit = {
|
|
"HP": 0,
|
|
"BuildTime": 0,
|
|
"Cost": {
|
|
"food": 0,
|
|
"wood": 0,
|
|
"stone": 0,
|
|
"metal": 0,
|
|
"population": 0,
|
|
},
|
|
"Attack": {
|
|
"Melee": {"Hack": 0, "Pierce": 0, "Crush": 0},
|
|
"Ranged": {"Hack": 0, "Pierce": 0, "Crush": 0},
|
|
},
|
|
"RepeatRate": {"Melee": "0", "Ranged": "0"},
|
|
"PrepRate": {"Melee": "0", "Ranged": "0"},
|
|
"Resistance": {"Hack": 0, "Pierce": 0, "Crush": 0},
|
|
"Ranged": False,
|
|
"Classes": [],
|
|
"AttackBonuses": {},
|
|
"Restricted": [],
|
|
"WalkSpeed": 0,
|
|
"Range": 0,
|
|
"Spread": 0,
|
|
"Civ": None,
|
|
}
|
|
|
|
Template = fastParse(UnitName)
|
|
|
|
# 0ad started using unit class/category prefixed to the unit name
|
|
# separated by |, known as mixins since A25 (rP25223)
|
|
# We strip these categories for now
|
|
# This can be used later for classification
|
|
unit["Parent"] = Template.get("parent").split("|")[-1] + ".xml"
|
|
unit["Civ"] = Template.find("./Identity/Civ").text
|
|
unit["HP"] = ExtractValue(Template.find("./Health/Max"))
|
|
unit["BuildTime"] = ExtractValue(Template.find("./Cost/BuildTime"))
|
|
unit["Cost"]["population"] = ExtractValue(Template.find("./Cost/Population"))
|
|
|
|
resource_cost = Template.find("./Cost/Resources")
|
|
if resource_cost is not None:
|
|
for resource_type in list(resource_cost):
|
|
unit["Cost"][resource_type.tag] = ExtractValue(resource_type)
|
|
|
|
if Template.find("./Attack/Melee") is not None:
|
|
unit["RepeatRate"]["Melee"] = ExtractValue(Template.find("./Attack/Melee/RepeatTime"))
|
|
unit["PrepRate"]["Melee"] = ExtractValue(Template.find("./Attack/Melee/PrepareTime"))
|
|
|
|
for atttype in AttackTypes:
|
|
unit["Attack"]["Melee"][atttype] = ExtractValue(
|
|
Template.find("./Attack/Melee/Damage/" + atttype)
|
|
)
|
|
|
|
attack_melee_bonus = Template.find("./Attack/Melee/Bonuses")
|
|
if attack_melee_bonus is not None:
|
|
for Bonus in attack_melee_bonus:
|
|
Against = []
|
|
CivAg = []
|
|
if Bonus.find("Classes") is not None and Bonus.find("Classes").text is not None:
|
|
Against = Bonus.find("Classes").text.split(" ")
|
|
if Bonus.find("Civ") is not None and Bonus.find("Civ").text is not None:
|
|
CivAg = Bonus.find("Civ").text.split(" ")
|
|
Val = float(Bonus.find("Multiplier").text)
|
|
unit["AttackBonuses"][Bonus.tag] = {
|
|
"Classes": Against,
|
|
"Civs": CivAg,
|
|
"Multiplier": Val,
|
|
}
|
|
|
|
attack_restricted_classes = Template.find("./Attack/Melee/RestrictedClasses")
|
|
if attack_restricted_classes is not None:
|
|
newClasses = attack_restricted_classes.text.split(" ")
|
|
for elem in newClasses:
|
|
if elem.find("-") != -1:
|
|
newClasses.pop(newClasses.index(elem))
|
|
if elem in unit["Restricted"]:
|
|
unit["Restricted"].pop(newClasses.index(elem))
|
|
unit["Restricted"] += newClasses
|
|
|
|
elif Template.find("./Attack/Ranged") is not None:
|
|
unit["Ranged"] = True
|
|
unit["Range"] = ExtractValue(Template.find("./Attack/Ranged/MaxRange"))
|
|
unit["Spread"] = ExtractValue(Template.find("./Attack/Ranged/Projectile/Spread"))
|
|
unit["RepeatRate"]["Ranged"] = ExtractValue(Template.find("./Attack/Ranged/RepeatTime"))
|
|
unit["PrepRate"]["Ranged"] = ExtractValue(Template.find("./Attack/Ranged/PrepareTime"))
|
|
|
|
for atttype in AttackTypes:
|
|
unit["Attack"]["Ranged"][atttype] = ExtractValue(
|
|
Template.find("./Attack/Ranged/Damage/" + atttype)
|
|
)
|
|
|
|
if Template.find("./Attack/Ranged/Bonuses") is not None:
|
|
for Bonus in Template.find("./Attack/Ranged/Bonuses"):
|
|
Against = []
|
|
CivAg = []
|
|
if Bonus.find("Classes") is not None and Bonus.find("Classes").text is not None:
|
|
Against = Bonus.find("Classes").text.split(" ")
|
|
if Bonus.find("Civ") is not None and Bonus.find("Civ").text is not None:
|
|
CivAg = Bonus.find("Civ").text.split(" ")
|
|
Val = float(Bonus.find("Multiplier").text)
|
|
unit["AttackBonuses"][Bonus.tag] = {
|
|
"Classes": Against,
|
|
"Civs": CivAg,
|
|
"Multiplier": Val,
|
|
}
|
|
if Template.find("./Attack/Melee/RestrictedClasses") is not None:
|
|
newClasses = Template.find("./Attack/Melee/RestrictedClasses").text.split(" ")
|
|
for elem in newClasses:
|
|
if elem.find("-") != -1:
|
|
newClasses.pop(newClasses.index(elem))
|
|
if elem in unit["Restricted"]:
|
|
unit["Restricted"].pop(newClasses.index(elem))
|
|
unit["Restricted"] += newClasses
|
|
|
|
if Template.find("Resistance") is not None:
|
|
for atttype in AttackTypes:
|
|
unit["Resistance"][atttype] = ExtractValue(
|
|
Template.find("./Resistance/Entity/Damage/" + atttype)
|
|
)
|
|
|
|
if (
|
|
Template.find("./UnitMotion") is not None
|
|
and Template.find("./UnitMotion/WalkSpeed") is not None
|
|
):
|
|
unit["WalkSpeed"] = ExtractValue(Template.find("./UnitMotion/WalkSpeed"))
|
|
|
|
if Template.find("./Identity/VisibleClasses") is not None:
|
|
newClasses = Template.find("./Identity/VisibleClasses").text.split(" ")
|
|
for elem in newClasses:
|
|
if elem.find("-") != -1:
|
|
newClasses.pop(newClasses.index(elem))
|
|
if elem in unit["Classes"]:
|
|
unit["Classes"].pop(newClasses.index(elem))
|
|
unit["Classes"] += newClasses
|
|
|
|
if Template.find("./Identity/Classes") is not None:
|
|
newClasses = Template.find("./Identity/Classes").text.split(" ")
|
|
for elem in newClasses:
|
|
if elem.find("-") != -1:
|
|
newClasses.pop(newClasses.index(elem))
|
|
if elem in unit["Classes"]:
|
|
unit["Classes"].pop(newClasses.index(elem))
|
|
unit["Classes"] += newClasses
|
|
|
|
return unit
|
|
|
|
|
|
def WriteUnit(Name, UnitDict):
|
|
ret = "<tr>"
|
|
ret += '<td class="Sub">' + Name + "</td>"
|
|
ret += "<td>" + str("{:.0f}".format(float(UnitDict["HP"]))) + "</td>"
|
|
ret += "<td>" + str("{:.0f}".format(float(UnitDict["BuildTime"]))) + "</td>"
|
|
ret += "<td>" + str("{:.1f}".format(float(UnitDict["WalkSpeed"]))) + "</td>"
|
|
|
|
for atype in AttackTypes:
|
|
PercentValue = 1.0 - (0.9 ** float(UnitDict["Resistance"][atype]))
|
|
ret += (
|
|
"<td>"
|
|
+ str("{:.0f}".format(float(UnitDict["Resistance"][atype])))
|
|
+ " / "
|
|
+ str("%.0f" % (PercentValue * 100.0))
|
|
+ "%</td>"
|
|
)
|
|
|
|
attType = "Ranged" if UnitDict["Ranged"] is True else "Melee"
|
|
if UnitDict["RepeatRate"][attType] != "0":
|
|
for atype in AttackTypes:
|
|
repeatTime = float(UnitDict["RepeatRate"][attType]) / 1000.0
|
|
ret += (
|
|
"<td>"
|
|
+ str("%.1f" % (float(UnitDict["Attack"][attType][atype]) / repeatTime))
|
|
+ "</td>"
|
|
)
|
|
|
|
ret += "<td>" + str("%.1f" % (float(UnitDict["RepeatRate"][attType]) / 1000.0)) + "</td>"
|
|
else:
|
|
for _ in AttackTypes:
|
|
ret += "<td> - </td>"
|
|
ret += "<td> - </td>"
|
|
|
|
if UnitDict["Ranged"] is True and UnitDict["Range"] > 0:
|
|
ret += "<td>" + str("{:.1f}".format(float(UnitDict["Range"]))) + "</td>"
|
|
spread = float(UnitDict["Spread"])
|
|
ret += "<td>" + str(f"{spread:.1f}") + "</td>"
|
|
else:
|
|
ret += "<td> - </td><td> - </td>"
|
|
|
|
for rtype in Resources:
|
|
ret += "<td>" + str("{:.0f}".format(float(UnitDict["Cost"][rtype]))) + "</td>"
|
|
|
|
ret += "<td>" + str("{:.0f}".format(float(UnitDict["Cost"]["population"]))) + "</td>"
|
|
|
|
ret += '<td style="text-align:left;">'
|
|
for Bonus in UnitDict["AttackBonuses"]:
|
|
ret += "["
|
|
for classe in UnitDict["AttackBonuses"][Bonus]["Classes"]:
|
|
ret += classe + " "
|
|
ret += ": {}] ".format(UnitDict["AttackBonuses"][Bonus]["Multiplier"])
|
|
ret += "</td>"
|
|
|
|
ret += "</tr>\n"
|
|
return ret
|
|
|
|
|
|
# Sort the templates dictionary.
|
|
def SortFn(A):
|
|
sortVal = 0
|
|
for classe in ClassesUsedForSort:
|
|
sortVal += 1
|
|
if classe in A[1]["Classes"]:
|
|
break
|
|
if ComparativeSortByChamp is True and A[0].find("champion") == -1:
|
|
sortVal -= 20
|
|
if ComparativeSortByCav is True and A[0].find("cavalry") == -1:
|
|
sortVal -= 10
|
|
if A[1]["Civ"] is not None and A[1]["Civ"] in Civs:
|
|
sortVal += 100 * Civs.index(A[1]["Civ"])
|
|
return sortVal
|
|
|
|
|
|
def WriteColouredDiff(file, diff, isChanged):
|
|
"""Help to write coloured text.
|
|
|
|
diff value must always be computed as a unit_spec - unit_generic.
|
|
A positive imaginary part represents advantageous trait.
|
|
"""
|
|
|
|
def cleverParse(diff):
|
|
if float(diff) - int(diff) < 0.001:
|
|
return str(int(diff))
|
|
return str(f"{float(diff):.1f}")
|
|
|
|
isAdvantageous = diff.imag > 0
|
|
diff = diff.real
|
|
if diff != 0:
|
|
isChanged = True
|
|
else:
|
|
# do not change its value if one parameter is not changed (yet)
|
|
# some other parameter might be different
|
|
pass
|
|
|
|
if diff == 0:
|
|
rgb_str = "200,200,200"
|
|
elif isAdvantageous and diff > 0 or (not isAdvantageous) and diff < 0:
|
|
rgb_str = "180,0,0"
|
|
else:
|
|
rgb_str = "0,150,0"
|
|
|
|
file.write(
|
|
f"""<td><span style="color:rgb({rgb_str});">{cleverParse(diff)}</span></td>
|
|
"""
|
|
)
|
|
return isChanged
|
|
|
|
|
|
def computeUnitEfficiencyDiff(TemplatesByParent, Civs):
|
|
efficiency_table = {}
|
|
for parent in TemplatesByParent:
|
|
for template in [
|
|
template for template in TemplatesByParent[parent] if template[1]["Civ"] not in Civs
|
|
]:
|
|
print(template)
|
|
|
|
TemplatesByParent[parent] = [
|
|
template for template in TemplatesByParent[parent] if template[1]["Civ"] in Civs
|
|
]
|
|
TemplatesByParent[parent].sort(key=lambda x: Civs.index(x[1]["Civ"]))
|
|
|
|
for tp in TemplatesByParent[parent]:
|
|
# HP
|
|
diff = -1j + (int(tp[1]["HP"]) - int(templates[parent]["HP"]))
|
|
efficiency_table[(parent, tp[0], "HP")] = diff
|
|
efficiency_table[(parent, tp[0], "HP")] = diff
|
|
|
|
# Build Time
|
|
diff = +1j + (int(tp[1]["BuildTime"]) - int(templates[parent]["BuildTime"]))
|
|
efficiency_table[(parent, tp[0], "BuildTime")] = diff
|
|
|
|
# walk speed
|
|
diff = -1j + (float(tp[1]["WalkSpeed"]) - float(templates[parent]["WalkSpeed"]))
|
|
efficiency_table[(parent, tp[0], "WalkSpeed")] = diff
|
|
|
|
# Resistance
|
|
for atype in AttackTypes:
|
|
diff = -1j + (
|
|
float(tp[1]["Resistance"][atype])
|
|
- float(templates[parent]["Resistance"][atype])
|
|
)
|
|
efficiency_table[(parent, tp[0], "Resistance/" + atype)] = diff
|
|
|
|
# Attack types (DPS) and rate.
|
|
attType = "Ranged" if tp[1]["Ranged"] is True else "Melee"
|
|
if tp[1]["RepeatRate"][attType] != "0":
|
|
for atype in AttackTypes:
|
|
myDPS = float(tp[1]["Attack"][attType][atype]) / (
|
|
float(tp[1]["RepeatRate"][attType]) / 1000.0
|
|
)
|
|
parentDPS = float(templates[parent]["Attack"][attType][atype]) / (
|
|
float(templates[parent]["RepeatRate"][attType]) / 1000.0
|
|
)
|
|
diff = -1j + (myDPS - parentDPS)
|
|
efficiency_table[(parent, tp[0], "Attack/" + attType + "/" + atype)] = diff
|
|
diff = -1j + (
|
|
float(tp[1]["RepeatRate"][attType]) / 1000.0
|
|
- float(templates[parent]["RepeatRate"][attType]) / 1000.0
|
|
)
|
|
efficiency_table[
|
|
(parent, tp[0], "Attack/" + attType + "/" + atype + "/RepeatRate")
|
|
] = diff
|
|
# range and spread
|
|
if tp[1]["Ranged"] is True:
|
|
diff = -1j + (float(tp[1]["Range"]) - float(templates[parent]["Range"]))
|
|
efficiency_table[(parent, tp[0], "Attack/" + attType + "/Ranged/Range")] = diff
|
|
|
|
diff = float(tp[1]["Spread"]) - float(templates[parent]["Spread"])
|
|
efficiency_table[(parent, tp[0], "Attack/" + attType + "/Ranged/Spread")] = (
|
|
diff
|
|
)
|
|
|
|
for rtype in Resources:
|
|
diff = +1j + (
|
|
float(tp[1]["Cost"][rtype]) - float(templates[parent]["Cost"][rtype])
|
|
)
|
|
efficiency_table[(parent, tp[0], "Resources/" + rtype)] = diff
|
|
|
|
diff = +1j + (
|
|
float(tp[1]["Cost"]["population"]) - float(templates[parent]["Cost"]["population"])
|
|
)
|
|
efficiency_table[(parent, tp[0], "Population")] = diff
|
|
|
|
return efficiency_table
|
|
|
|
|
|
def computeTemplates(LoadTemplatesIfParent):
|
|
"""Loops over template XMLs and selectively insert into templates dict."""
|
|
pwd = os.getcwd()
|
|
os.chdir(basePath)
|
|
templates = {}
|
|
for template in list(glob.glob("template_*.xml")):
|
|
if os.path.isfile(template):
|
|
found = False
|
|
for possParent in LoadTemplatesIfParent:
|
|
if hasParentTemplate(template, possParent):
|
|
found = True
|
|
break
|
|
if found is True:
|
|
templates[template] = CalcUnit(template)
|
|
os.chdir(pwd)
|
|
return templates
|
|
|
|
|
|
def computeCivTemplates(Civs: list):
|
|
"""Load Civ specific templates.
|
|
|
|
NOTE: whether a Civ can train a certain unit is not recorded in the unit
|
|
.xml files, and hence we have to get that info elsewhere, e.g. from the
|
|
Civ tree. This should be delayed until this whole parser is based on the
|
|
Civ tree itself.
|
|
|
|
This function must always ensure that Civ unit parenthood works as
|
|
intended, i.e. a unit in a Civ indeed has a 'Civ' field recording its
|
|
loyalty to that Civ. Check this when upgrading this script to keep
|
|
up with the game engine.
|
|
"""
|
|
pwd = os.getcwd()
|
|
os.chdir(basePath)
|
|
|
|
CivTemplates = {}
|
|
|
|
for Civ in Civs:
|
|
CivTemplates[Civ] = {}
|
|
# Load all templates that start with that civ indicator
|
|
# TODO: consider adding mixin/civs here too
|
|
civ_list = list(glob.glob("units/" + Civ + "/*.xml"))
|
|
for template in civ_list:
|
|
if os.path.isfile(template):
|
|
# filter based on FilterOut
|
|
breakIt = False
|
|
for civ_filter in FilterOut:
|
|
if template.find(civ_filter) != -1:
|
|
breakIt = True
|
|
if breakIt:
|
|
continue
|
|
|
|
# filter based on loaded generic templates
|
|
breakIt = True
|
|
for possParent in LoadTemplatesIfParent:
|
|
if hasParentTemplate(template, possParent):
|
|
breakIt = False
|
|
break
|
|
if breakIt:
|
|
continue
|
|
|
|
unit = CalcUnit(template)
|
|
|
|
# Remove variants for now
|
|
if unit["Parent"].find("template_") == -1:
|
|
continue
|
|
|
|
# load template
|
|
CivTemplates[Civ][template] = unit
|
|
|
|
os.chdir(pwd)
|
|
return CivTemplates
|
|
|
|
|
|
def computeTemplatesByParent(templates: dict, Civs: list, CivTemplates: dict):
|
|
"""Get them in the array."""
|
|
# Civs:list -> CivTemplates:dict -> templates:dict -> TemplatesByParent
|
|
TemplatesByParent = {}
|
|
for Civ in Civs:
|
|
for CivUnitTemplate in CivTemplates[Civ]:
|
|
parent = CivTemplates[Civ][CivUnitTemplate]["Parent"]
|
|
|
|
# We have the following constant equality
|
|
# templates[*]["Civ"] === gaia
|
|
# if parent in templates and templates[parent]["Civ"] == None:
|
|
if parent in templates:
|
|
if parent not in TemplatesByParent:
|
|
TemplatesByParent[parent] = []
|
|
TemplatesByParent[parent].append(
|
|
(CivUnitTemplate, CivTemplates[Civ][CivUnitTemplate])
|
|
)
|
|
|
|
# debug after CivTemplates are non-empty
|
|
return TemplatesByParent
|
|
|
|
|
|
############################################################
|
|
## Pre-compute all tables
|
|
templates = computeTemplates(LoadTemplatesIfParent)
|
|
CivTemplates = computeCivTemplates(Civs)
|
|
TemplatesByParent = computeTemplatesByParent(templates, Civs, CivTemplates)
|
|
|
|
# Not used; use it for your own custom analysis
|
|
efficiencyTable = computeUnitEfficiencyDiff(TemplatesByParent, Civs)
|
|
|
|
|
|
############################################################
|
|
def writeHTML():
|
|
"""Create the HTML file."""
|
|
f = open(
|
|
os.path.realpath(__file__).replace("unitTables.py", "") + "unit_summary_table.html",
|
|
"w",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
f.write(
|
|
"""
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
|
|
<html>
|
|
<head>
|
|
<title>Unit Tables</title>
|
|
<link rel="stylesheet" href="style.css">
|
|
</head>
|
|
<body>
|
|
"""
|
|
)
|
|
htbout(f, "h1", "Unit Summary Table")
|
|
f.write("\n")
|
|
|
|
# Write generic templates
|
|
htbout(f, "h2", "Units")
|
|
f.write(
|
|
"""
|
|
<table id="genericTemplates">
|
|
<thead>
|
|
<tr>
|
|
<th> </th> <th>HP </th> <th>BuildTime </th> <th>Speed(walk) </th>
|
|
<th colspan="5">Resistance </th>
|
|
<th colspan="8">Attack (DPS) </th>
|
|
<th colspan="5">Costs </th>
|
|
<th>Efficient Against </th>
|
|
</tr>
|
|
<tr class="Label" style="border-bottom:1px black solid;">
|
|
<th> </th> <th> </th> <th> </th> <th> </th>
|
|
<th>H </th> <th>P </th> <th>C </th><th>P </th><th>F </th>
|
|
<th>H </th> <th>P </th> <th>C </th><th>P </th><th>F </th>
|
|
<th>Rate </th> <th>Range </th> <th>Spread (/100m) </th>
|
|
<th>F </th> <th>W </th> <th>S </th> <th>M </th> <th>P </th>
|
|
<th> </th>
|
|
</tr>
|
|
</thead>
|
|
"""
|
|
)
|
|
for template in templates:
|
|
f.write(WriteUnit(template, templates[template]))
|
|
f.write("</table>")
|
|
|
|
# Write unit specialization
|
|
# Sort them by civ and write them in a table.
|
|
#
|
|
# TODO: pre-compute the diffs then render, filtering out the non-interesting
|
|
# ones
|
|
#
|
|
f.write(
|
|
"""
|
|
<h2>Units Specializations
|
|
</h2>
|
|
|
|
<p class="desc">This table compares each template to its parent, showing the
|
|
differences between the two.
|
|
<br/>Note that like any table, you can copy/paste this in Excel (or Numbers or
|
|
...) and sort it.
|
|
</p>
|
|
|
|
<table id="TemplateParentComp">
|
|
<thead>
|
|
<tr>
|
|
<th> </th> <th> </th> <th>HP </th> <th>BuildTime </th>
|
|
<th>Speed (/100m) </th>
|
|
<th colspan="5">Resistance </th>
|
|
<th colspan="8">Attack </th>
|
|
<th colspan="5">Costs </th>
|
|
<th>Civ </th>
|
|
</tr>
|
|
<tr class="Label" style="border-bottom:1px black solid;">
|
|
<th> </th> <th> </th> <th> </th> <th> </th> <th> </th>
|
|
<th>H </th> <th>P </th> <th>C </th><th>P </th><th>F </th>
|
|
<th>H </th> <th>P </th> <th>C </th><th>P </th><th>F </th>
|
|
<th>Rate </th> <th>Range </th> <th>Spread </th>
|
|
<th>F </th> <th>W </th> <th>S </th> <th>M </th> <th>P </th>
|
|
<th> </th>
|
|
</tr>
|
|
</thead>
|
|
"""
|
|
)
|
|
for parent in TemplatesByParent:
|
|
TemplatesByParent[parent].sort(key=lambda x: Civs.index(x[1]["Civ"]))
|
|
for tp in TemplatesByParent[parent]:
|
|
isChanged = False
|
|
ff = open(
|
|
os.path.realpath(__file__).replace("unitTables.py", "") + ".cache",
|
|
"w",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
ff.write("<tr>")
|
|
ff.write(
|
|
"<th style='font-size:10px'>"
|
|
+ parent.replace(".xml", "").replace("template_", "")
|
|
+ "</th>"
|
|
)
|
|
ff.write(
|
|
'<td class="Sub">' + tp[0].replace(".xml", "").replace("units/", "") + "</td>"
|
|
)
|
|
|
|
# HP
|
|
diff = -1j + (int(tp[1]["HP"]) - int(templates[parent]["HP"]))
|
|
isChanged = WriteColouredDiff(ff, diff, isChanged)
|
|
|
|
# Build Time
|
|
diff = +1j + (int(tp[1]["BuildTime"]) - int(templates[parent]["BuildTime"]))
|
|
isChanged = WriteColouredDiff(ff, diff, isChanged)
|
|
|
|
# walk speed
|
|
diff = -1j + (float(tp[1]["WalkSpeed"]) - float(templates[parent]["WalkSpeed"]))
|
|
isChanged = WriteColouredDiff(ff, diff, isChanged)
|
|
|
|
# Resistance
|
|
for atype in AttackTypes:
|
|
diff = -1j + (
|
|
float(tp[1]["Resistance"][atype])
|
|
- float(templates[parent]["Resistance"][atype])
|
|
)
|
|
isChanged = WriteColouredDiff(ff, diff, isChanged)
|
|
|
|
# Attack types (DPS) and rate.
|
|
attType = "Ranged" if tp[1]["Ranged"] is True else "Melee"
|
|
if tp[1]["RepeatRate"][attType] != "0":
|
|
for atype in AttackTypes:
|
|
myDPS = float(tp[1]["Attack"][attType][atype]) / (
|
|
float(tp[1]["RepeatRate"][attType]) / 1000.0
|
|
)
|
|
parentDPS = float(templates[parent]["Attack"][attType][atype]) / (
|
|
float(templates[parent]["RepeatRate"][attType]) / 1000.0
|
|
)
|
|
isChanged = WriteColouredDiff(ff, -1j + (myDPS - parentDPS), isChanged)
|
|
isChanged = WriteColouredDiff(
|
|
ff,
|
|
-1j
|
|
+ (
|
|
float(tp[1]["RepeatRate"][attType]) / 1000.0
|
|
- float(templates[parent]["RepeatRate"][attType]) / 1000.0
|
|
),
|
|
isChanged,
|
|
)
|
|
# range and spread
|
|
if tp[1]["Ranged"] is True:
|
|
isChanged = WriteColouredDiff(
|
|
ff,
|
|
-1j + (float(tp[1]["Range"]) - float(templates[parent]["Range"])),
|
|
isChanged,
|
|
)
|
|
mySpread = float(tp[1]["Spread"])
|
|
parentSpread = float(templates[parent]["Spread"])
|
|
isChanged = WriteColouredDiff(ff, +1j + (mySpread - parentSpread), isChanged)
|
|
else:
|
|
ff.write(
|
|
"<td><span style='color:rgb(200,200,200);'>-</span></td><td>"
|
|
"<span style='color:rgb(200,200,200);'>-</span></td>"
|
|
)
|
|
else:
|
|
ff.write("<td></td><td></td><td></td><td></td><td></td><td></td>")
|
|
|
|
for rtype in Resources:
|
|
isChanged = WriteColouredDiff(
|
|
ff,
|
|
+1j + (float(tp[1]["Cost"][rtype]) - float(templates[parent]["Cost"][rtype])),
|
|
isChanged,
|
|
)
|
|
|
|
isChanged = WriteColouredDiff(
|
|
ff,
|
|
+1j
|
|
+ (
|
|
float(tp[1]["Cost"]["population"])
|
|
- float(templates[parent]["Cost"]["population"])
|
|
),
|
|
isChanged,
|
|
)
|
|
|
|
ff.write("<td>" + tp[1]["Civ"] + "</td>")
|
|
ff.write("</tr>\n")
|
|
|
|
ff.close() # to actually write into the file
|
|
with open(
|
|
os.path.realpath(__file__).replace("unitTables.py", "") + ".cache",
|
|
encoding="utf-8",
|
|
) as ff:
|
|
unitStr = ff.read()
|
|
|
|
if showChangedOnly:
|
|
if isChanged:
|
|
f.write(unitStr)
|
|
else:
|
|
# print the full table if showChangedOnly is false
|
|
f.write(unitStr)
|
|
|
|
f.write("<table/>")
|
|
|
|
# Table of unit having or not having some units.
|
|
f.write(
|
|
"""
|
|
<h2>Roster Variety
|
|
</h2>
|
|
|
|
<p class="desc">This table show which civilizations have units who derive from
|
|
each loaded generic template.
|
|
<br/>Grey means the civilization has no unit derived from a generic template;
|
|
<br/>dark green means 1 derived unit, mid-tone green means 2, bright green
|
|
means 3 or more.
|
|
<br/>The total is the total number of loaded units for this civ, which may be
|
|
more than the total of units inheriting from loaded templates.
|
|
</p>
|
|
<table class="CivRosterVariety">
|
|
<tr>
|
|
<th>Template </th>
|
|
"""
|
|
)
|
|
for civ in Civs:
|
|
f.write('<td class="vertical-text">' + civ + "</td>\n")
|
|
f.write("</tr>\n")
|
|
|
|
sortedDict = sorted(templates.items(), key=SortFn)
|
|
|
|
for tp in sortedDict:
|
|
if tp[0] not in TemplatesByParent:
|
|
continue
|
|
f.write("<tr><td>" + tp[0] + "</td>\n")
|
|
for civ in Civs:
|
|
found = 0
|
|
for temp in TemplatesByParent[tp[0]]:
|
|
if temp[1]["Civ"] == civ:
|
|
found += 1
|
|
if found == 1:
|
|
f.write('<td style="background-color:rgb(0,90,0);"></td>')
|
|
elif found == 2:
|
|
f.write('<td style="background-color:rgb(0,150,0);"></td>')
|
|
elif found >= 3:
|
|
f.write('<td style="background-color:rgb(0,255,0);"></td>')
|
|
else:
|
|
f.write('<td style="background-color:rgb(200,200,200);"></td>')
|
|
f.write("</tr>\n")
|
|
f.write(
|
|
'<tr style="margin-top:2px;border-top:2px #aaa solid;">\
|
|
<th style="text-align:right; padding-right:10px;">Total:</th>\n'
|
|
)
|
|
for civ in Civs:
|
|
count = 0
|
|
for _units in CivTemplates[civ]:
|
|
count += 1
|
|
f.write('<td style="text-align:center;">' + str(count) + "</td>\n")
|
|
|
|
f.write("</tr>\n")
|
|
|
|
f.write("<table/>")
|
|
|
|
# Add a simple script to allow filtering on sorting directly in the HTML
|
|
# page.
|
|
if AddSortingOverlay:
|
|
f.write(
|
|
"""
|
|
<script src="tablefilter/tablefilter.js"></script>
|
|
<script data-config>
|
|
var cast = function (val) {
|
|
console.log(val); if (+val != val)
|
|
return -999999999999;
|
|
return +val;
|
|
}
|
|
|
|
|
|
var filtersConfig = {
|
|
base_path: "tablefilter/",
|
|
col_0: "checklist",
|
|
alternate_rows: true,
|
|
rows_counter: true,
|
|
btn_reset: true,
|
|
loader: false,
|
|
status_bar: false,
|
|
mark_active_columns: true,
|
|
highlight_keywords: true,
|
|
col_number_format: Array(22).fill("US"),
|
|
filters_row_index: 2,
|
|
headers_row_index: 1,
|
|
extensions: [
|
|
{
|
|
name: "sort",
|
|
types: ["string",
|
|
...Array(6).fill("us"),
|
|
...Array(6).fill("mytype"),
|
|
...Array(5).fill("us"),
|
|
"string",
|
|
],
|
|
on_sort_loaded: function (o, sort) {
|
|
sort.addSortType("mytype", cast);
|
|
},
|
|
},
|
|
],
|
|
col_widths: [...Array(18).fill(null), "120px"],
|
|
};
|
|
|
|
var tf = new TableFilter('genericTemplates', filtersConfig,2);
|
|
tf.init();
|
|
|
|
var secondFiltersConfig = {
|
|
base_path: "tablefilter/",
|
|
col_0: "checklist",
|
|
col_19: "checklist",
|
|
alternate_rows: true,
|
|
rows_counter: true,
|
|
btn_reset: true,
|
|
loader: false,
|
|
status_bar: false,
|
|
mark_active_columns: true,
|
|
highlight_keywords: true,
|
|
col_number_format: [null, null, ...Array(17).fill("US"), null],
|
|
filters_row_index: 2,
|
|
headers_row_index: 1,
|
|
extensions: [
|
|
{
|
|
name: "sort",
|
|
types: ["string", "string",
|
|
...Array(6).fill("us"),
|
|
...Array(6).fill("typetwo"),
|
|
...Array(5).fill("us"),
|
|
"string",
|
|
],
|
|
on_sort_loaded: function (o, sort) {
|
|
sort.addSortType("typetwo", cast);
|
|
},
|
|
},
|
|
],
|
|
col_widths: Array(20).fill(null),
|
|
};
|
|
|
|
|
|
var tf2 = new TableFilter('TemplateParentComp', secondFiltersConfig,2);
|
|
tf2.init();
|
|
|
|
</script>
|
|
"""
|
|
)
|
|
|
|
f.write("</body>\n</html>")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
writeHTML()
|