Index: ps/trunk/binaries/data/mods/public/simulation/components/Identity.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Identity.js	(revision 21884)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Identity.js	(revision 21885)
@@ -1,169 +1,169 @@
 function Identity() {}
 
 Identity.prototype.Schema =
 	"<a:help>Specifies various names and values associated with the unit type, typically for GUI display to users.</a:help>" +
 	"<a:example>" +
 		"<Civ>athen</Civ>" +
 		"<GenericName>Athenian Hoplite</GenericName>" +
 		"<SpecificName>Hoplī́tēs Athēnaïkós</SpecificName>" +
 		"<Icon>units/athen_infantry_spearman.png</Icon>" +
 	"</a:example>" +
-	"<element name='Civ' a:help='Civilisation that this unit is primarily associated with, typically a 4-letter code. Choices include: gaia (world objects), athen (Athenians), brit (Britons), cart (Carthaginians), gaul (Gauls), iber (Iberians), mace (Macedonians), maur (Mauryans), pers (Persians), ptol (Ptolemies), rome (Romans), sele (Seleucids), spart (Spartans)'>" +
+	"<element name='Civ' a:help='Civilisation that this unit is primarily associated with, typically a 4-letter code. Choices include: gaia (world objects), athen (Athenians), brit (Britons), cart (Carthaginians), gaul (Gauls), iber (Iberians), kush (Kushites), mace (Macedonians), maur (Mauryans), pers (Persians), ptol (Ptolemies), rome (Romans), sele (Seleucids), spart (Spartans)'>" +
 		"<text/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='Lang' a:help='Unit language for voices'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Gender' a:help='Unit gender for voices. Choices includes male or female.'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<element name='GenericName' a:help='Generic English-language name for this class of unit.'>" +
 		"<text/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='SpecificName' a:help='Specific native-language name for this unit type.'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='SelectionGroupName' a:help='Name used to group ranked entities.'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Tooltip'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='History'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Rank'>" +
 			"<choice>" +
 				"<value>Basic</value>" +
 				"<value>Advanced</value>" +
 				"<value>Elite</value>" +
 			"</choice>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Classes' a:help='Optional list of space-separated classes applying to this entity. Choices include: Animal, Apadana, ArmyCamp, Ashoka, BarterMarket, Celt, CitizenSoldier, CivCentre, Colony, ConquestCritical, Defensive, Domestic, DropsiteFood, DropsiteMetal, DropsiteStone, DropsiteWood, FemaleCitizen, FishingBoat, ForestPlant, Fortress, GarrisonFortress, GarrisonTower, Gates, Human, Iberian, Immortal, Italian, Juggernaut, Kennel, Lighthouse, LongWall, MercenaryCamp, Naval, NavalMarket, Organic, Palace, Palisade, Player, PtolemyIV, SeaCreature, SiegeWall, SpecialBuilding, StoneWall, Structure, Syssiton, Theater, Tower, Unit'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='VisibleClasses' a:help='Optional list of space-separated classes applying to this entity. These classes will also be visible in various GUI elements. If the classes need spaces, underscores will be replaced with spaces. Choices include: Archer, Barracks, Blacksmith, BoltShooter, Camel, Catapult, Cavalry, Champion, Chariot, Citizen, City, Civic, CivilCentre, Corral, DefenseTower, Dock, Dog, Economic, Elephant, ElephantStables, Embassy, Farmstead, Field, Fireship, Healer, Hero, House, Infantry, Javelin, Maceman, Market, Mechanical, Melee, Mercenary, Military, Outpost, Pike, Ram, Ranged, Relic, Resource, SentryTower, Ship, Shipyard, Siege, SiegeTower, Slave, Sling, Soldier, Spear, Stables, Storehouse, Support, Sword, Temple, Town, Trader, Village, Warship, Wonder, Worker, Workshop'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Formations' a:help='Optional list of space-separated formations this unit is allowed to use. Choices include: Scatter, Box, ColumnClosed, LineClosed, ColumnOpen, LineOpen, Flank, Skirmish, Wedge, Testudo, Phalanx, Syntagma, BattleLine'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Icon'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='RequiredTechnology' a:help='Optional name of a technology which must be researched before the entity can be produced.'>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<element name='Undeletable' a:help='Prevent players from deleting this entity.'>" +
 		"<data type='boolean'/>" +
 	"</element>";
 
 Identity.prototype.Init = function()
 {
 	this.classesList = GetIdentityClasses(this.template);
 	this.visibleClassesList = GetVisibleIdentityClasses(this.template);
 };
 
 Identity.prototype.Deserialize = function ()
 {
 	this.Init();
 };
 
 Identity.prototype.Serialize = null; // we have no dynamic state to save
 
 Identity.prototype.GetCiv = function()
 {
 	return this.template.Civ;
 };
 
 Identity.prototype.GetLang = function()
 {
 	return this.template.Lang || "greek"; // ugly default
 };
 
 Identity.prototype.GetGender = function()
 {
 	return this.template.Gender || "male"; // ugly default
 };
 
 Identity.prototype.GetRank = function()
 {
 	return this.template.Rank || "";
 };
 
 Identity.prototype.GetClassesList = function()
 {
 	return this.classesList;
 };
 
 Identity.prototype.GetVisibleClassesList = function()
 {
 	return this.visibleClassesList;
 };
 
 Identity.prototype.HasClass = function(name)
 {
 	return this.GetClassesList().indexOf(name) != -1;
 };
 
 Identity.prototype.GetFormationsList = function()
 {
 	if (this.template.Formations && this.template.Formations._string)
 		return this.template.Formations._string.split(/\s+/);
 	return [];
 };
 
 Identity.prototype.CanUseFormation = function(template)
 {
 	return this.GetFormationsList().indexOf(template) != -1;
 };
 
 Identity.prototype.GetSelectionGroupName = function()
 {
 	return this.template.SelectionGroupName || "";
 };
 
 Identity.prototype.GetGenericName = function()
 {
 	return this.template.GenericName;
 };
 
 Identity.prototype.IsUndeletable = function()
 {
 	return this.template.Undeletable == "true";
 };
 
 Engine.RegisterComponentType(IID_Identity, "Identity", Identity);
Index: ps/trunk/source/tools/templatesanalyzer/unitTables.py
===================================================================
--- ps/trunk/source/tools/templatesanalyzer/unitTables.py	(revision 21884)
+++ ps/trunk/source/tools/templatesanalyzer/unitTables.py	(revision 21885)
@@ -1,566 +1,566 @@
 # Copyright (C) 2015 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.
 
 import xml.etree.ElementTree as ET
 import os
 import glob
 
 AttackTypes = ["Hack","Pierce","Crush"]
 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", "mace", "maur", "pers", "ptol", "rome", "sele", "spart"]
+Civs = ["athen", "brit", "cart", "gaul", "iber", "kush", "mace", "maur", "pers", "ptol", "rome", "sele", "spart"]
 
 # Remote Civ templates with those strings in their name.
 FilterOut = ["marian", "thureophoros", "thorakites", "kardakes"]
 
 # Sorting parameters for the "roster variety" table
 ComparativeSortByCav = True
 ComparativeSortByChamp = True
 SortTypes = ["Support", "Pike", "Spear", "Sword", "Archer", "Javelin", "Sling", "Elephant"]	# Classes
 
 # 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.
 basePath = os.path.realpath(__file__).replace("unitTables.py","") + "../../../binaries/data/mods/public/simulation/templates/"
 
 # For performance purposes, cache opened templates files.
 globalTemplatesList = {}
 
 def htbout(file, balise, value):
 	file.write("<" + balise + ">" + value + "</" + balise + ">\n" )
 def htout(file, value):
 	file.write("<p>" + value + "</p>\n" )
 
 def fastParse(templateName):
 	if templateName in globalTemplatesList:
 		return globalTemplatesList[templateName]
 	globalTemplatesList[templateName] = ET.parse(templateName)
 	return globalTemplatesList[templateName]
 
 # This function checks that a template has the given parent.
 def hasParentTemplate(UnitName, parentName):
 	Template = fastParse(UnitName)
 
 	found = False
 	Name = UnitName
 	while found != True and Template.getroot().get("parent") != None:
 		Name = Template.getroot().get("parent") + ".xml"
 		if Name == parentName:
 			return True
 		Template = ET.parse(Name)
 
 	return False
 
 def NumericStatProcess(unitValue, templateValue):
 	if not "op" in templateValue.attrib:
 		return float(templateValue.text)
 	if (templateValue.attrib["op"] == "add"):
 		unitValue += float(templateValue.text)
 	elif (templateValue.attrib["op"] == "sub"):
 		unitValue -= float(templateValue.text)
 	elif (templateValue.attrib["op"] == "mul"):
 		unitValue *= float(templateValue.text)
 	elif (templateValue.attrib["op"] == "div"):
 		unitValue /= float(templateValue.text)
 	return unitValue
 
 
 # This function parses the entity values manually.
 def CalcUnit(UnitName, existingUnit = None):
 	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"}, "Armour" : { "Hack" : 0, "Pierce" : 0, "Crush" : 0},
 	"Ranged" : False, "Classes" : [], "AttackBonuses" : {}, "Restricted" : [], "WalkSpeed" : 0, "Range" : 0, "Spread" : 0,
 	"Civ" : None }
 	
 	if (existingUnit != None):
 		unit = existingUnit
 
 	Template = fastParse(UnitName)
 	
 	# Recursively get data from our parent which we'll override.
 	if (Template.getroot().get("parent") != None):
 		unit = CalcUnit(Template.getroot().get("parent") + ".xml", unit)
 		unit["Parent"] = Template.getroot().get("parent") + ".xml"
 
 	if (Template.find("./Identity/Civ") != None):
 		unit['Civ'] = Template.find("./Identity/Civ").text
 
 	if (Template.find("./Health/Max") != None):
 		unit['HP'] = NumericStatProcess(unit['HP'], Template.find("./Health/Max"))
 
 	if (Template.find("./Cost/BuildTime") != None):
 		unit['BuildTime'] = NumericStatProcess(unit['BuildTime'], Template.find("./Cost/BuildTime"))
 	
 	if (Template.find("./Cost/Resources") != None):
 		for type in list(Template.find("./Cost/Resources")):
 			unit['Cost'][type.tag] = NumericStatProcess(unit['Cost'][type.tag], type)
 
 	if (Template.find("./Cost/Population") != None):
 		unit['Cost']["population"] = NumericStatProcess(unit['Cost']["population"], Template.find("./Cost/Population"))
 
 	if (Template.find("./Attack/Melee") != None):
 		if (Template.find("./Attack/Melee/RepeatTime") != None):
 			unit['RepeatRate']["Melee"] = NumericStatProcess(unit['RepeatRate']["Melee"], Template.find("./Attack/Melee/RepeatTime"))
 		if (Template.find("./Attack/Melee/PrepareTime") != None):
 			unit['PrepRate']["Melee"] = NumericStatProcess(unit['PrepRate']["Melee"], Template.find("./Attack/Melee/PrepareTime"))
 		for atttype in AttackTypes:
 			if (Template.find("./Attack/Melee/"+atttype) != None):
 				unit['Attack']['Melee'][atttype] = NumericStatProcess(unit['Attack']['Melee'][atttype], Template.find("./Attack/Melee/"+atttype))
 		if (Template.find("./Attack/Melee/Bonuses") != None):
 			for Bonus in Template.find("./Attack/Melee/Bonuses"):
 				Against = []
 				CivAg = []
 				if (Bonus.find("Classes") != None and Bonus.find("Classes").text != None):
 					Against = Bonus.find("Classes").text.split(" ")
 				if (Bonus.find("Civ") != None and Bonus.find("Civ").text != 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") != 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("./Attack/Ranged") != None):
 		unit['Ranged'] = True
 		if (Template.find("./Attack/Ranged/MaxRange") != None):
 			unit['Range'] = NumericStatProcess(unit['Range'], Template.find("./Attack/Ranged/MaxRange"))
 		if (Template.find("./Attack/Ranged/Spread") != None):
 			unit['Spread'] = NumericStatProcess(unit['Spread'], Template.find("./Attack/Ranged/Spread"))
 		if (Template.find("./Attack/Ranged/RepeatTime") != None):
 			unit['RepeatRate']["Ranged"] = NumericStatProcess(unit['RepeatRate']["Ranged"], Template.find("./Attack/Ranged/RepeatTime"))
 		if (Template.find("./Attack/Ranged/PrepareTime") != None):
 			unit['PrepRate']["Ranged"] = NumericStatProcess(unit['PrepRate']["Ranged"], Template.find("./Attack/Ranged/PrepareTime"))
 		for atttype in AttackTypes:
 			if (Template.find("./Attack/Ranged/"+atttype) != None):
 				unit['Attack']['Ranged'][atttype] = NumericStatProcess(unit['Attack']['Ranged'][atttype], Template.find("./Attack/Ranged/"+atttype))
 		if (Template.find("./Attack/Ranged/Bonuses") != None):
 			for Bonus in Template.find("./Attack/Ranged/Bonuses"):
 				Against = []
 				CivAg = []
 				if (Bonus.find("Classes") != None and Bonus.find("Classes").text != None):
 					Against = Bonus.find("Classes").text.split(" ")
 				if (Bonus.find("Civ") != None and Bonus.find("Civ").text != 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") != 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("./Armour") != None):
 		for atttype in AttackTypes:
 			if (Template.find("./Armour/"+atttype) != None):
 				unit['Armour'][atttype] = NumericStatProcess(unit['Armour'][atttype], Template.find("./Armour/"+atttype))
 
 	if (Template.find("./UnitMotion") != None):
 		if (Template.find("./UnitMotion/WalkSpeed") != None):
 				unit['WalkSpeed'] = NumericStatProcess(unit['WalkSpeed'], Template.find("./UnitMotion/WalkSpeed"))
 
 	if (Template.find("./Identity/VisibleClasses") != 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") != 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(int(UnitDict["HP"])) + "</td>"
 	
 	ret += "<td>" +str("%.0f" % float(UnitDict["BuildTime"])) + "</td>"
 
 	ret += "<td>" + str("%.1f" % float(UnitDict["WalkSpeed"])) + "</td>"
 
 	for atype in AttackTypes:
 		PercentValue = 1.0 - (0.9 ** float(UnitDict["Armour"][atype]))
 		ret += "<td>" + str("%.0f" % float(UnitDict["Armour"][atype])) + " / " + str("%.0f" % (PercentValue*100.0)) + "%</td>"
 
 	attType = ("Ranged" if UnitDict["Ranged"] == 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 atype in AttackTypes:
 			ret += "<td> - </td>"
 		ret += "<td> - </td>"
 
 	if UnitDict["Ranged"] == True and UnitDict["Range"] > 0:
 		ret += "<td>" + str("%.1f" % float(UnitDict["Range"])) + "</td>"
 		spread = float(UnitDict["Spread"])
 		ret += "<td>" + str("%.1f" % spread) + "</td>"
 	else:
 		ret += "<td> - </td><td> - </td>"
 
 	for rtype in Resources:
 		ret += "<td>" + str("%.0f" % float(UnitDict["Cost"][rtype])) + "</td>"
 	
 	ret += "<td>" + str("%.0f" % 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 += ': ' + str(UnitDict["AttackBonuses"][Bonus]["Multiplier"]) + "]  "
 	ret += "</td>"
 
 	ret += "</tr>\n"
 	return ret
 
 # Sort the templates dictionary.
 def SortFn(A):
 	sortVal = 0
 	for classe in SortTypes:
 		sortVal += 1
 		if classe in A[1]["Classes"]:
 			break
 	if ComparativeSortByChamp == True and A[0].find("champion") == -1:
 		sortVal -= 20
 	if ComparativeSortByCav == True and A[0].find("cavalry") == -1:
 		sortVal -= 10
 	if A[1]["Civ"] != None and A[1]["Civ"] in Civs:
 		sortVal += 100 * Civs.index(A[1]["Civ"])
 	return sortVal
 
 # helper to write coloured text.
 def WriteColouredDiff(file, diff, PositOrNegat):
 
 	def cleverParse(diff):
 		if float(diff) - int(diff) < 0.001:
 			return str(int(diff))
 		else:
 			return str("%.1f" % float(diff))
 
 	if (PositOrNegat == "positive"):
 		file.write("<td><span style=\"color:rgb(" +("200,200,200" if diff == 0 else ("180,0,0" if diff > 0 else "0,150,0")) + ");\">" + cleverParse(diff) + "</span></td>")
 	elif (PositOrNegat == "negative"):
 		file.write("<td><span style=\"color:rgb(" +("200,200,200" if diff == 0 else ("180,0,0" if diff < 0 else "0,150,0")) + ");\">" + cleverParse(diff) + "</span></td>")
 	else:
 		complain
 
 
 ############################################################
 ############################################################
 # Create the HTML file
 
 f = open(os.path.realpath(__file__).replace("unitTables.py","") + 'unit_summary_table.html', 'w')
 
 f.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n<html>\n<head>\n	<title>Unit Tables</title>\n	<link rel=\"stylesheet\" href=\"style.css\">\n</head>\n<body>")
 htbout(f,"h1","Unit Summary Table")
 f.write("\n")
 
 os.chdir(basePath)
 
 ############################################################
 # Load generic templates
 
 templates = {}
 
 htbout(f,"h2", "Units")
 
 f.write("<table id=\"genericTemplates\">\n")
 f.write("<thead><tr>")
 f.write("<th></th><th>HP</th>	<th>BuildTime</th>	<th>Speed(walk)</th>	<th colspan=\"3\">Armour</th>	<th colspan=\"6\">Attack (DPS)</th>													<th colspan=\"5\">Costs</th>						<th>Efficient Against</th> 	</tr>\n")
 f.write("<tr class=\"Label\" style=\"border-bottom:1px black solid;\">")
 f.write("<th></th><th></th>		<th></th>			<th></th>				<th>H</th><th>P</th><th>C</th>	<th>H</th><th>P</th><th>C</th><th>Rate</th><th>Range</th><th>Spread\n(/100m)</th>	<th>F</th><th>W</th><th>S</th><th>M</th><th>P</th>	<th></th>		</tr>\n</thead>\n")
 
 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 == True:
 			templates[template] = CalcUnit(template)
 			f.write(WriteUnit(template, templates[template]))
 
 f.write("</table>")
 
 ############################################################
 # Load Civ specific templates
 
 CivTemplates = {}
 
 for Civ in Civs:
 	CivTemplates[Civ] = {}
 	# Load all templates that start with that civ indicator
 	for template in list(glob.glob('units/' + Civ + '_*.xml')):
 		if os.path.isfile(template):
 
 			# filter based on FilterOut
 			breakIt = False
 			for filter in FilterOut:
 				if template.find(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
 
 ############################################################
 f.write("\n\n<h2>Units Specializations</h2>\n")
 f.write("<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>")
 
 TemplatesByParent = {}
 
 #Get them in the array
 for Civ in Civs:
 	for CivUnitTemplate in CivTemplates[Civ]:
 		parent = CivTemplates[Civ][CivUnitTemplate]["Parent"]
 		if parent in templates and templates[parent]["Civ"] == None:
 			if parent not in TemplatesByParent:
 				TemplatesByParent[parent] = []
 			TemplatesByParent[parent].append( (CivUnitTemplate,CivTemplates[Civ][CivUnitTemplate]))
 
 #Sort them by civ and write them in a table.
 f.write("<table id=\"TemplateParentComp\">\n")
 f.write("<thead><tr>")
 f.write("<th></th><th></th><th>HP</th>	<th>BuildTime</th>	<th>Speed</th>	<th colspan=\"3\">Armour</th>	<th colspan=\"6\">Attack</th>												<th colspan=\"5\">Costs</th>						<th>Civ</th>	</tr>\n")
 f.write("<tr class=\"Label\" style=\"border-bottom:1px black solid;\">")
 f.write("<th></th><th></th><th></th>	<th></th>			<th></th>		<th>H</th><th>P</th><th>C</th>	<th>H</th><th>P</th><th>C</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>\n<tr></thead>")
 for parent in TemplatesByParent:
 	TemplatesByParent[parent].sort(key=lambda x : Civs.index(x[1]["Civ"]))
 	for tp in TemplatesByParent[parent]:
 		f.write("<th style='font-size:10px'>" + parent.replace(".xml","").replace("template_","") + "</th>")
 
 		f.write("<td class=\"Sub\">" + tp[0].replace(".xml","").replace("units/","") + "</td>")
 		
 		# HP
 		diff = int(tp[1]["HP"]) - int(templates[parent]["HP"])
 		WriteColouredDiff(f, diff, "negative")
 		
 		# Build Time
 		diff = int(tp[1]["BuildTime"]) - int(templates[parent]["BuildTime"])
 		WriteColouredDiff(f, diff, "positive")
 		
 		# walk speed
 		diff = float(tp[1]["WalkSpeed"]) - float(templates[parent]["WalkSpeed"])
 		WriteColouredDiff(f, diff, "negative")
 		
 		# Armor
 		for atype in AttackTypes:
 			diff = float(tp[1]["Armour"][atype]) - float(templates[parent]["Armour"][atype])
 			WriteColouredDiff(f, diff, "negative")
 
 		# Attack types (DPS) and rate.
 		attType = ("Ranged" if tp[1]["Ranged"] == 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)
 				WriteColouredDiff(f, myDPS - parentDPS, "negative")
 			WriteColouredDiff(f, float(tp[1]["RepeatRate"][attType])/1000.0 - float(templates[parent]["RepeatRate"][attType])/1000.0, "negative")
 			# range and spread
 			if tp[1]["Ranged"] == True:
 				WriteColouredDiff(f, float(tp[1]["Range"]) - float(templates[parent]["Range"]), "negative")
 				mySpread = float(tp[1]["Spread"])
 				parentSpread = float(templates[parent]["Spread"])
 				WriteColouredDiff(f,  mySpread - parentSpread, "positive")
 			else:
 				f.write("<td></td><td></td>")
 		else:
 				f.write("<td></td><td></td><td></td><td></td><td></td><td></td>")
 
 		for rtype in Resources:
 			WriteColouredDiff(f, float(tp[1]["Cost"][rtype]) - float(templates[parent]["Cost"][rtype]), "positive")
 		
 		WriteColouredDiff(f, float(tp[1]["Cost"]["population"]) - float(templates[parent]["Cost"]["population"]), "positive")
 
 		f.write("<td>" + tp[1]["Civ"] + "</td>")
 
 		f.write("</tr>\n<tr>")
 f.write("<table/>")
 
 # Table of unit having or not having some units.
 f.write("\n\n<h2>Roster Variety</h2>\n")
 f.write("<p class=\"desc\">This table show which civilizations have units who derive from each loaded generic template.<br/>Green means 1 deriving unit, blue means 2, black 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>")
 f.write("<table class=\"CivRosterVariety\">\n")
 f.write("<tr><th>Template</th>\n")
 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,230,0);\"></td>")
 		elif found == 2:
 			f.write("<td style=\"background-color:rgb(0,0,200);\"></td>")
 		elif found >= 3:
 			f.write("<td style=\"background-color:rgb(0,0,0);\"></td>")
 		else:
 			f.write("<td style=\"background-color:rgb(235,0,0);\"></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>\n\
 	\n\
 	<script data-config>\n\
 	\
 		var cast = function (val) {\n\
 		console.log(val);\
 			if (+val != val)\n\
 				return -999999999999;\n\
 			return +val;\n\
 		}\n\
 	\n\n\
 		var filtersConfig = {\n\
 			base_path: 'tablefilter/',\n\
 			col_0: 'checklist',\n\
 			alternate_rows: true,\n\
 			rows_counter: true,\n\
 			btn_reset: true,\n\
 			loader: false,\n\
 			status_bar: false,\n\
 			mark_active_columns: true,\n\
 			highlight_keywords: true,\n\
 			col_number_format: [\n\
 				'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US'\n\
 			],\n\
 			filters_row_index: 2,\n\
 			headers_row_index: 1,\n\
 			extensions:[{\
 				name: 'sort',\
 				types: [\
 					'string', 'us', 'us', 'us', 'us', 'us', 'us', 'mytype', 'mytype', 'mytype', 'mytype', 'mytype', 'mytype', 'us', 'us', 'us', 'us', 'us', 'string'\
 				],\
 				on_sort_loaded: function(o, sort) {\
 					sort.addSortType('mytype',cast);\
 				},\
 			}],\n\
 			col_widths: [\n\
 				null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,'120px'\n\
 			],\n\
 		};\n\
 		var tf = new TableFilter('genericTemplates', filtersConfig,2);\n\
 		tf.init();\n\
 	\n\
 	   \
 		var secondFiltersConfig = {\n\
 			base_path: 'tablefilter/',\n\
 			col_0: 'checklist',\n\
 			col_19: 'checklist',\n\
 			alternate_rows: true,\n\
 			rows_counter: true,\n\
 			btn_reset: true,\n\
 			loader: false,\n\
 			status_bar: false,\n\
 			mark_active_columns: true,\n\
 			highlight_keywords: true,\n\
 			col_number_format: [\n\
 				null, null, 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', 'US', null\n\
 			],\n\
 			filters_row_index: 2,\n\
 			headers_row_index: 1,\n\
 			extensions:[{\
 				name: 'sort',\
 				types: [\
 					'string', 'string', 'us', 'us', 'us', 'us', 'us', 'us', 'typetwo', 'typetwo', 'typetwo', 'typetwo', 'typetwo', 'typetwo', 'us', 'us', 'us', 'us', 'us', 'string'\
 				],\
 				on_sort_loaded: function(o, sort) {\
 					sort.addSortType('typetwo',cast);\
 				},\
 			}],\n\
 			col_widths: [\n\
 				null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null\n\
 			],\n\
 		};\n\
 		\
 		var tf2 = new TableFilter('TemplateParentComp', secondFiltersConfig,2);\n\
 		tf2.init();\n\
 	\n\
 	</script>\n")
 
 
 f.write("</body>\n</html>")