Member Plus Headquarters: Mod Guide

Foreword​

Programs​

• Advanced Genie Editor. Or AGE. The main program, the one you use to access the data files and modify units and technologies. To use this program, you can download it from Age of Kings Heaven or, if you have Definitive Edition installed, access it inside the ``AoE2DE'' folder, in a folder called ``Tools\_Builds''.​
• Turtle Pack. A program to visualize .slp files (graphic files) and .drs files (compressed files with mostly .slp files inside).​
• SLX Studio. A program to create graphics, modify DE graphic files and create .slp files from them. It also includes some functionalities like color replace, resizing, format change…​
• SMX Workshop A program to port the new .sld graphics into .smx ones. It also requires installing Java Run Enviroment.
• DRS merger. A program created by katsuie to merge several .slp files into a .drs file. Useful to change lots of graphics at once.​
• Text Editor, like notepad, in order to modify language files, map scripts and AI files.​
• Image Editor, like Paint or GIMP. Graphics are all bit maps and you'll need one of these in case you need to modify some of the graphics.​

Mod structure​

• Data. Folder with the main data files:
  • empires2_x1_p1.dat: the master file with the code of the game that you access through AGE.​
  • gamedata_x1.drs: compressed file with the original (common in 1.6) map scripts and ids of the game elements for map scripts to know what to place. Access it with Turtle Pack.​
  • gamedata_x1_p1.drs: compressed file with graphics and sounds. Access it with Turtle Pack.​
• drs. Folder to store graphics and sounds without adding them to gamedata_x1_p1.drs. More on this in the next section.​
• History. Text files with historical information about the civilizations. Not relevant for the gameplay.​
• SaveGame. Where recordings of your single and multiplayer games are stored and where you should store the ones you download in order to replay them.​
• Scenario. Where custom scenario files are stored.​
• Screenshots. You can take full screenshots of the map by pressing Ctrl+F12 or by using the PrtScn key. Either way, the game stores them here.​
• Script.Ai. Folder with the Artificial Intelligence files. I’m no expert in AI but I can give you a basic idea of how AIs are implemented:
  • Every AI needs a .ai file with its name, that’s the file that allows the AI to be selected in game.​
  • The basic code of the AI is stored in a .per file with the same name as the .ai file. You can read this file with a text editor.​
  • Additionally, AIs can separate the code into smaller files and store it in a folder. This is done for convenience when working on it but has no impact in the game.​
  • Inside gamedata_x1.drs there is a file where you can control the AI that is loaded when selecting "computer". This way you can have a default AI for the mod.​
• Script.Rm. Folder with the map scripts that appear in the Custom maps section. Maps are stored in .rms files that you can open with a text editor.​
• Sound. Stores music files, mainly:
  • music.m3u. Soundtrack you hear while playing. You can open it with a text editorand will see the paths to the music files. These paths can point anywhere in the computer.​
  • stream. Civilization themes you hear when selecting one.​
  • Scenario. Dialog files from the campaings. They come with WololoKingdoms but are of no use outside scenarios.​
• Taunt. Audio taunts that you play in the game, such as 1 (yes), 2 (no) or 11 (laugh).​
• age2_x1.xml. File listing the civilizations with an id, their audio theme and their scout unit. There are some other relevant values in it that we’ll mention in a future section.​
• language.ini. Language file that you can read with a text editor. Every text string you see inthe game has a number attached to it. The language file lists all the number with the corresponding string. Having different versions of this file with translated text is all you need to play the game in a different language.​
• Player.nfz. File to have player profiles in the game and store the last configuration of thegame (map, population, size...).​
• player1.hki. Hotkeys file. If you have several profiles in the single player menu, you willhave several of these files but this one is the main one you use in multiplayer.​
• version.ini. A text file containing the version of the mod so that Voobly checks that all theplayers have the same one and prevents crashes. This file is mandatory so that Voobly lists the folder as a mod.​

Priorities when loading files​

1. Files inside a local mod. Within the local mods folder, Voobly loads them in alphabetical order.​
2. Files inside the "drs" folder of the data mod.​
3. Files inside the gamedata_x1_p1.drs folder of the data mod.​
4. Original files in the AoE2/Data folder of the game.​

Merging several local mods​

Open and load a data mod​

• Genie version. Which version of the game you are working on. The Community Patch uses The Conquerors+UserPatch but you may also use Age of Empires II: Definitive Edition if you are modding for that game.
• Compressed data set (*.dat). Path to the file “empires2_x1_p1.dat” in your mod folder.
• Language file locations. These are .dll language files that only help navigating the code. The one I use, that you can download here, has all the new units and techs, thanks to a program by katsuie.
• Path for DRS files. Path to the data folder in the root AoE 2 folder. In my case “\Age2HD\data”. Having this file allows to visualize some graphics but only if they are stored there.
• Recent paths. Saves the last used configurations.

Main buttons and tabs​

• SLP menu. Only relevant for graphics and icons and only if you added graphics files when opening AGE.
• +++ button. Allows to open another window of AGE. This is useful when copying stuff from one data file to another, as opening AGE twice doesn’t allow copy.
• List button. Useful to leave activated. This way, when you delete text in the search fields, you don’t loose the selected item. If you don’t understand what I’m talking about just trust me.
• SLP button. Links the graphics from the AoE2 root folder if you selected them when opening AGE. If activated, you won’t be able to open those .drs files with Turtlepack, you have to deactivate it for that.
• Techs tab. Technologies in the game, the ones you manually research and the ones that activate automatically. In this tab you can modify names, costs, icons, research time, research locations…
• Effects tab. When you research a technology, it triggers an effect. This tab lists all the effects.
• Tech tree tab. This creates the technology tree in the game but only the visual layout, it has no effect on the actual behavior of the game. In reality, everything is done through technologies. It can be useful to locate a unit you don't know the name of.
• Civilizations tab. Lists all the civilizations with their civilization bonus and team bonus (both effects). Also lists all the resources the game uses, from wood, food, etc to other more obscure ones.
• Units tab. All the units in the game: actual soldiers, buildings, animals, trees, decorative stuff…
• Graphics tab. Lists all the graphics in the game, with links to their corresponding slp files.
• Terrains tab. Lists all the terrains the game uses.
• Sounds tab. Lists all the sounds in the game, with links to their corresponding wav files.

The filter box​

• The first dialogue box is to write text that must appear in the object. To have several strings, separate them with the symbol “|”, which means “or”. You can change the behavior of “|” from “or” to “and” in the check box next to it.
• The second dialogue box is to write text that must not appear in the object. The symbol “|” works identically.
• The two drop-down menus are to activate some extra text in the object description such as “Train location”, “Research time”, etc.

Language information​

• Internal Name Identifier of the technology, usually overrided with the actual name of the tecnology, unless you enable the filter.
• Language File Name Entry in the language file for the name of the technology. AGE instructs you to set a value between 7000 and 7999 so that it doesn't conflict with other elements of the game.
• Language File Description Entry in the language file for the short description of the technology. It should be the value of the ``Language File Name plus'' 1,000.
• Language File Help Not used in the game but linked to the ``Help Converter'' next to it. It should be the value of the file name plus 100,000.
• Help Converter Linked to the ``Language File Help'' and no need to modify it. Entry in the language file for the long description of the technology. It should be the value of the file name plus 21,000.
• Lang File Tech Tree Not used in the game but linked to the ``Tech Tree Converter'' next to it. It should be the value of the file name plus 150,000.
• Tech Tree Converter Linked to the ``Lang File Tech Tree'' and no need to modify it. Entry in the language file for the name of the technology displayed in the technology tree. It should be the value of the file name plus 10,000.

• n. Corresponding to the ``Language File Name''. Name of the technology.
• n+1,000. Corresponding to the ``Language File Description''. Short description.
• n+21,000$. Corresponding to the ``Help Converter''. Long description.
• n+10,000$. Corresponding to the ``Tech Tree Converter''. Technology tree name.

Code fields​

• Required Techs Six fields to enter technologies that must be researched in order to enable the current technology.
• Min Req Techs Ammount of the required technologies needed to enable the current technology. Used to allow different ways of enabling a technology. For example, Double-Bit Axe, technology 202, has two required technologies but only requires one of them. This way, it is enabled by reaching Feudal Age or by researching technology 758 that is related to the Burgundian bonus.
• Type Whether the progress should show in the bar at the top of the screen or not. Set to 0 for everything except for the ages.
• Research Time in seconds.
• Icon From the file 50729.slp.
• Button Position in the interface. 1 to 5 are first row, 6 to 10 the second row, 11 to 15 the third one and extra values create a second page.
• Effect What to do when the technology is researched. Can be empty if the technology is used as a trigger for others.
• Research Location Where to show the button. Can be empty if the technology researches automatically.
• Civilization Who that can research it. Value -1 means every civilization can research it (and later can be disabled with the ``Tech tree'' effect). Any other value enables the technology only for that civilization.
• Full Tech Mode Controls if the tech appears in that mode of the game. Only relevant for technologies that are researched by only one civilization and is mostly set to 0 (unavailable) for all of them.
• Costs Requirements to research the technology. In ``Type'' one can put the four normal resources or anything else. ``Amount'' is the quantity needed and ``Deduct'' controls whether the amount has to be paid or not. For technologies there are no examples of this mechanic but units use it.

Types of technologies​

• Technologies with zero research time. You research these technologies automatically when you meet their “Required techs” conditions, without considering the cost. For example, technology 25, “STBL (make avail)” allows you to create stables. It requires two technologies: “Feudal Age” and “Shadow Node Barracks + Khmer”, a technology that is researched when you build a Barracks or are Khmer (since they don’t need pre-requisite buildings).
• Technologies with positive research time. You research these technologies by clicking the icon and paying its cost. They are only available once their “Required Techs” are met. For example, technology 200, “Bodkin Arrow”, can only be researched if you are in Castle Age and have already researched Fletching.

• Attribute Modifier (Set). For setting a new value for an attribute for a unit or a class of units.
• Resource Modifier (Set/+/-). For changing a resource by increasing or decreasing it or directly setting a new value.
• Enable/Disable Unit.
• Upgrade Unit. Change existing and future versions of a unit into another one. The upgrade implementation is a bit counter intuitive, see the section on upgrading units.
• Attribute Modifier (+/-). For changing the value of an attribute for a unit or a class of units.
• Attribute Modifier (Multiply). For multiplying the value of an attribute for a unit or a class of units.
• Resource Modifier (Multiply). For multiplying the value of a resource.
• Enable/Disable Technology.
• Modify Technology. Not used in favor of the 101 and 103 effects.
• Set Player Civ Name. Used in some mods but not common.

• Team Attribute Modifier (Set).
• Team Resource Modifier (Set/+/-).
• Team Enable/Disable Unit.
• Team Upgrade Unit.
• Team Attribute Modifier (+/-).
• Team Attribute Modifier (Multiply).
• Team Resource Modifier (Multiply).
• Team Enable/Disable Technology.

• Enemy Attribute Modifier (Set).
• Enemy Resource Modifier (Set/+/-).
• Enemy Enable/Disable Unit.
• Enemy Upgrade Unit.
• Enemy Attribute Modifier (+/-).
• Enemy Attribute Modifier (Multiply).
• Enemy Resource Modifier (Multiply).
• Enemy Enable/Disable Technology.

• Tech Cost Modifier (Set/+/-). For changing the cost of a technology.
• Tech Time Modifier (Set/+/-). For changing the research time of a technology.

• Technology Tree Here each civilization has an effect that mostly disables the common technologies they don't have access to. It can also be used to add some civilization bonuses like discounts, free technologies, etc.
• Team bonus This is the effect of the civilization team bonus that will be applied to the allies.

Resources​

Edits per civilization​

• Buildings have different graphics depending on the civilization, this makes architectures possible.
• Some units may have different values depending on the civilization, this is usually done for simplicity. The most notable example are units 1345, 1346, 1347, that handle the unique technologies and unit upgrades.

Type and Class of unit​

Descriptive fields​

• Internal Name Used if the Language File Name is empty or doesn't have a string in the language file.
• Language File Name Entry in the language file for the name of the unit. AGE instructs you to set a value between 5000 and 5999 so that it doesn't conflict with other elements of the game.
• Language File Description Entry in the language file for the short description of the unit. It should be the value of the "Language File Name plus'' 1,000.
• Hotkey
• Language File Help Not used in the game but linked to the "Help Converter'' next to it. It should be the value of the file name plus 100,000.
• Help Converter Linked to the "Language File Help'' and no need to modify it. Entry in the language file for the long description of the unit. It should be the value of the file name plus 21,000.
• Lang File Tech Tree Not used in the game but linked to the "Tech Tree Converter'' next to it. It should be the value of the file name plus 150,000.
• Tech Tree Converter Linked to the "Lang File Tech Tree'' and no need to modify it. Entry in the language file for the name of the unit displayed in the technology tree. It should be the value of the file name plus 10,000.

• n. Corresponding to the "Language File Name''. Name of the unit.
• n+1,000. Corresponding to the "Language File Description''. Short description.
• n+21,000. Corresponding to the "Help Converter''. Long description.
• n+9,000. Corresponding to the "Tech Tree Converter''. Technology tree name.

Graphics​

• Icon From the file 5730.slp.
• Special Graphic Related to the special abilities, unused.
• Standing Graphics Those of the unit when it's idle. There are two fields, to have them switch between animations if desired.
• Dying Graphics Death and collapsing animation of units.
• Undead Graphics Unused.
• Walking Graphics For when the unit is moving.
• Running Graphics For when units have two speeds, used for deers.
• Snow Graphics Usually only the snow to be placed on top of the building.
• Construction Graphics Foundation graphics.
• Attack Graphic For when the unit is attacking.
• Garrison Graphic Flags to be placed on the unit.

Damage Graphics​

Statistics​

• A "Rotation Speed'' of zero means that the unit turns instantaneously. It's mostly zero for all units except for some ships.
• The "`Line of Sight'' is the amount of tiles the unit uncovers in a straight line. The "Search Radius'' is the distance the units look for enemies. For units, both numbers usually coincide but things like the Castle or the Krepost have search radius smaller than the line of sight.
• "Max Range'' is the maximum distance a unit can shoot and "Shown Range'' is the value displayed in the screen. Both values are the same but, when you research range upgrades, only "Max Range'' is modified, which makes the "4+1'' values appear.

Attacks and armors​

• The "Shown'' attack, melee and pierce armor are the values displayed in the screen for the unit and display "+1'' when upgrades are researched. "Shown Attack'' will check for the melee or pierce armor class in the attacks list.
• "Frame Delay'' affects only units that shoot projectiles. It is the amount of frames in the attack animation that have to pass before the projectile unit is created. This is what makes Manguadai easier to micromanage than Cavalry Archers.
• "Accuracy Percent'' is the probability (in percentage) of a projectile going for the intended target. For each projectile shot, a random number is generated to see if the unit misses. For missed shots, the "Attack Dispersion'' value comes into play and measures how much do the missed shots actually deviate.
  
  This means that you could have a unit with 0 accuracy and 0 attack dispersion and still it would hit its targets all the time.
• "Reload Time'' is the time in seconds that must pass before another projectile is shot or a new attack is computed. "Shown Reload Time'' has no effect.
  
  This creates a distinction between melee and projectile units. When melee units go into combat, they cycle through their attack animation over and over but that doesn't mean that every hit of the sword is an attack, it's just visual. The reload time is what controls the attacks.
  
  For projectile units this is a bit different. Once they finish the attack animation and have shot the projectile, they go into idle mode until the reload time has passed, when they shoot again.
• "Blast Width'' is the radius in tiles where the blast damage is computed.
• "Blast Attack'' control what type of blast damage units deal. "Blast Defense'' is not taken into account. For more information, read Section 2.7.2.
• "Base Armor'' is a default armor value used when an attack class is not present in the armors. It is set to 1,000 for everyone so as to ensure that no damage is produced.
• "Terrain Defense Bonus'' affects buildings and controls extra damage dealt when standing the unit is on a specific terrain. As far as I know, the only example is Cracked Dirt.

Resources and Garrison​

• Resource Capacity Amount of resource the unit can hold or store. Used mainly for villagers. Mines, farms and other animals use the "Resource Storages'' section.
• Resource Decay Speed at which units loose resources. Used on rotting animals and on corpses to make them disappear.
• Work Rate General purpose value used for farms to produce food, villagers to collect resources, buildings to produce units or monks to heal. Resource collection uses some extra values in the tasks section.
• Garrsion Capacity For transports and buildings.
• Garrison Type This fields uses a binary code, meaning that each box bellow controls a bit of the number and the value above is the decimal translation. This allows different units to enter buildings.
• Garrison Heal Rate Health gained per second while garrisoned. The higher the value, the faster the regeneration. This contrasts with the regeneration speed (attribute 45) used by regenerating units. There, the value is the amount of seconds that pass to get a single health point.

Projectiles attributes​

• Projectile Type Always has value zero. Other values could be used for lasers in the Star Wars game.
• Smart Mode Ballistics behavior. All projectiles have it to zero and the technology changes it to one.
• Hit mode How the projectile behaves when hitting units different from the intended one or how to behave when hitting units in a line.
• Vanish Mode What happens when the projectile hits a target. It may disappear or pass through.
• Area Effects Zero for arrows, one for bullets.
• Projectile Arc How much does the projectile curve.

Attributes​

• Available Whether the unit is available from the start of the game or requires a technology.
• Can be Built on Used to make corpses disappear when you build on top of them.
• Hide in Editor Whether the unit should appear in the Scenario Editor. Used to hide annex units or corpses.
• Fly mode To display the shadow properly.
• Can be Gathered To let the game identify resources and not apply the fog of war rules.
• Adjacent Mode Mainly used by walls to change shape.
• Built: Vanishes Used for buildings that have a different foundation unit from the standing one, to make the first one disappear. The most notable example is the Town Center.

• Sort Number Relevant for scenarios, this field doesn't make corpses or farms walkable.
• Hill Mode What makes buildings require flat surfaces. This controls whether you need a fully flat surface or allow for some slope.
• Fog Visibility Whether the unit is visible in the fog of war. The game only uses value zero for normal units and one for animals or corpses.
• Combat Level Used by units to prioritize enemies. This is what makes wolves prefer villagers to military or rams buildings.
• Interaction Mode What makes units selectable and movable. Doesn't control the interface units show.
• Minimap Mode How the unit shows in the map. The game mostly uses zero for non-visible units and 1 for visible ones.
• Minimap Color Set to zero when the unit belongs to a player and a color for resources.
• Doppelganger I believe this makes fallen trees still not count as dead, and thus walkable, units.
• Gather Group Probably not used anymore.
• Task Swap Group This is what makes villagers switch tasks. Whenever a villager is tasked to something, the game looks at units in the same group for a unit that knows what to do with it, based on the tasks at the bottom of the tab.
• Special Ability Not used but implemented. This has a charge mechanic, for example.
• Unit Trait This fields uses a binary code, meaning that each box bellow controls a bit of the number and the value above is the decimal translation. This is what allows units to garrison others.
• Civilization Not used as far as I know.
• Trait Piece Not used.
• Dead Unit Into what unit does the unit turn into when it dies. Can be empty for the unit to disappear.
• Placement Terrains Two fields. Only relevant for docks.
• Placement Side Terrains Two fields. Only relevant for docks. Also makes shore fish appear in the shore.
• Terrain Table The actual guide for where a unit can be. Values don't represent single terrains but collections of them, see the "Terrain Tables'' tab.
• Foundation Terrain For changing a terrain when a building is placed there.
• Initiates Technology A technology to be researched automatically when the building is finished. Used for age requirements and queuable technologies.
• Defaut Task Used by animals to be move around the map.
• Drop Sites Two fields for the buildings villagers use to drop resources. Note that fishermen using the dock is not implemented through here but through the patch. You could do it at the expense of loosing another building.
• Collision Size Physical space occupied by the unit, specially relevant for missed shots and for bunching units together.
• Selection Outline X and Y values determine the size of the circle or square around the unit. Z value controls the position of the health bar.
• Clearance Size As far as I know, the same values as the collision one.
• Occlusion Mode This fields uses a binary code, but doesn't have check boxes so you need to do the binary translation yourself. This makes units display their outline when passing behind buildings.
• Obstruction Type This makes buildings have square selection and controls whether units can pass over others.
• Blockage Class One thing this fields controls is whether buildings can be placed over units, counting that they will move away.
• Selection Effect Whether to display the health bar or the outline when selecting the unit.
• Trailing Unit Used by projectiles to leave behind a trail of smoke. "Trail Mode'' is usually set to 2 and "Trail Density'' is usually 0.4.
• Interface Kind What controls the buttons you see in when selecting the unit, for example the formation buttons for military. Bear in mind that the buttons for units to create or buildings to build are controlled with the following fields.
• Train Time Also construction time for buildings.
• Train Location Set to the builder for buildings.
• Train Button Where in the interface does the button appear. 1 to 5 are first row, 6 to 10 the second row, 11 to 15 the third one and extra values create a second page.

Resources and Costs​

• The resource can be stored in the unit and has to be gathered.
• The resource can be given when the unit is created and never lost.
• The resource can be given when the unit is created and returned when the unit dies.

Looting Table​

Annex units and alike​

• Stack Unit The unit that appears after completion. Usually paired with the ``Built: Vanishes'' option.
• Head Unit As far as I know, it has no effect but informs of the unit an annex one is connected to.
• Transform Unit Used by trebuchets and gates.
• Pile Unit Not used.

Sounds​

Tasks​

Healing units​

• Attribute 40 seems to control wether the regeneration is active or not. Putting it to 4 is the simplest option. Other values also convert the unit into a hero, thus making it impossible to convert.
• Attribute 45 controls the regeneration speed. The number is the time in seconds to get a new health point. The smaller the number, the faster the regeneration.

Generating extra resources​

1. The villager extracts a unit of ``Resource In'' from the mine. If we check the actual mine, unit 66, we see that it has 800 units of ``Gold Storage''.
2. The unit of gold is multiplied by the ``Productivity Resource''.
3. The amount resulting from the multiplication is added to the player's ``Resource Out'' bank.

• Internal Name and Sprite Name are used to identify graphics but not by the game, in favor of the "Sprite'' number.
• Sprite Number of the .slp file that stores the graphic. This file can be in a .drs file, the drs folder of the mod or a local mod folder.
• Layer Order in which graphics are drawn, the higher the value, the more on top of other things. This makes units show the outline when going behind a building but not its shadow.
• Transparent Pick Whether the graphic should respond to clicks. This makes buildings clickable only by clicking the actual building, not the shadow or the range indicator lines.
• Replay Delay The time between repeating an animation. Mostly used for idle units so they are not constantly moving.
• Frames per Angle Every angle in the .slp file should have the same amount of frames, reflected here.
• Animation Duration In seconds.
• Sequence Type Whether the game should use different angles or loop the animation.
• Mirroring Mode Whether the game should mirror frames to make the other angles. For eight angles, this field should be 6.
• Sound A sound to be played with the animation. Used for dying units or flames. weapon hits are done below.
• Forced Player Color Only used for birds.
• Unit Speed Multiplier Set to 1 for all moving units and 0 for buildings.

Deltas​

Angles and sounds​

2.7.1 Armor classes​

1. Infantry units.
2. Turtle Ships. Turtle Ships and Thirisadais have the armor. Fire ships have the attack.
3. Base pierce damage of non mounted units.
4. Base melee damage of non mounted units.
5. Elephants.
6. Extra cavalry class to combine the Bohemian bonus damage and Sicilian and Bengali bonus resistance.
7. Extra elephant class for damage against Bengali elephants.
8. Cavalry.
9. Extra cavalry class to combine the Gurjara bonus damage and Sicilian and Bengali bonus resistance.
10. Unused.
11. All Buildings, including stone walls.
12. Unused.
13. Stone Wals and gates, excluding palisades.
14. Animals have the armor, villagers the attack. For implementing the Magyar bonus.
15. Archers.
16. Ships.
17. Rams, Trebuchets and Siege towers.
18. Trees. Lumberjacks and Ballista elephants have the attack but no unit has the armor. Probably used to be able to damage trees.
19. Unique units.
20. Siege weapons.
21. Standard Buildings, excluding stone walls.
22. Walls and gates, including palisades.
23. Gunpowder units. For the Condottiero bonus.
24. Boars and alikes. For the Goth bonus.
25. Monks.
26. Castle and Krepost.
27. Spearmen.
28. Cavalry Archers.
29. Eagle Warriors.
30. Camels.
31. Ignoring armor class. Units have zero armor on this class, buildings have their melee armor. Used by Leitis and Dravidian units after their unique technology.
32. Condottiero. Used by units with bonus damage against infantry (Cataphract, Slinger) to bypass the Condottiero resistance against Hand Canoneers.
33. Composite Bowman class to accomodate their ability.
34. Fishing ships. Ships and fortified buildigs have this attack.
35. Mamelukes. Pikemen and camels have this attack.
36. Archers except skirmishers. For implementing the Japanese bonus.
37. Heavy Siege. Hussite Wagons and Ballista Elephants have the armor, Mangonels and Bombard cannons have the attack.
38. Skirmishers and Genitours. For implementing the Bengali bonus.
39. Pierce damage of mounted units.
40. Melee damage of mounted units.
41. Unused.
42. Unused.
43. Unused.
44. Unused.
45. Unused.
46. Unused.
47. Unused.
48. Extra cavalry class for damage against Sicilian units.
49. Unused.
50. Extra damage of Arambais.

2.7.2 Blast damage options​

• 00: Units, buildings, trees and other resources receive damage. This destroys stone and gold mines.
• 01: Units, buildings and trees receive damage but not other resources.
• 10: Units and buildings receive damage. This is the usual configuration for non-siege units.
• 11: Only units receive damage.

• Third bit set to 1: units receive 5 damage, regardless of armor.
• Fourth bit set to 1: units receive half damage, accounting for armor.

Full list of values​

2.7.3 Projectiles​

• Arrows have Hit and Vanish mode zero, meaning that, if they don't miss, they hit only the intended objective.
• Bullets from Organ Guns have Hit mode one and Vanish Mode zero, meaning that they hit the first enemy in the way. If it wasn't the intended one, they deal half damage.
• Scorpion bolts have Hit mode and Vanish mode one, meaning that they damage all units in the way to the objective.

2.7.4 New resources​

• Resource 214. Control free Kipchaks with Cuman mercenaries.
• Resource 215. Controls Fishermen and Fishing ships productivity.
• Resource 216. Controls Sheperds productivity.
• Resource 218. Controls Feudal Cuman Town Centers.
• Resources 219 to 285. Controls queuable technologies.
• Resource 286. Controls Poles stone miners and Vietnamese lumberjacks.
• Resources 287 and 288. Controls First Crusade Serjeants.
• Resource 289 and 290. Controls queuable ages, not implemented right now.
• Resource 291. For detecting Strongholds and Chieftains and apply the new effects.
• Resource 292. Controls Hunters productivity.
• Resource 293. For detecting Comitatenses and enable charged units
• Resources 294 to 336. For controlling the charge speed of various units.
• Resource 337. For keeping track of the roman militia line, in combination with the Centurion effect.
• Resources 340 to 342. Controls mining and lumber quable technologies.
• Resources 343 to 377. Used to store game statistics and display them during recordings.
• Resources 378 to 477. Controls queuable technologies in the Triple Tech Mode.

Civilization interfaces​

Civilization descriptions​

Artificial intelligence names​

• Every civilization has 20 fields reserved for names.
• The first field of those 20 is actually a number that determines how many of the remaining 19 fields are actually used.
• The original Age of Kings civilizations (the first 13) have their names starting at id 4400. This means 4400 is the first id of Britons, 4420 is the first one for French and so on until Celts.
• Starting with the Age of Conquerors civilizations, the ids are shifted by the value of aiNameOffset. This means that the Spanish first id, that should be 4400+20 x 13=4660 is actually 4660+7480=12140, with 7480 being the current value of aiNameOffset.

3.1.1 Turtle Pack​

• The Anchor, that control where the graphic is displayed, to ensure that a unit’s graphic coincides with its phisical position in the game.
• The Selection mask, the overlay that appears when a unit goes behind a building.
• You can change the player color of the unit.

3.1.2 SLX Studio​

• The background, in pink, that codes which pixels should not be shown in game.
• The shadow, in red, that codes which pixels should be painted gray in game, regardless, of what appears in the actual graphic.
• The outline, in blue, identical to the selection mask.
• The player color, in green, that codes which pixels change color with the player.

3.1.3 The Color Palette​

1. Obtaining the graphics as bmp files.​

2. Loading graphics directly with Turtle Pack doesn’t work​

• Player color asks wether or not this graphic is painted with some player color, so that it detects the pixels that should change color, in this case we want it empty, as this icon doesn’t change color with players.
• Transparent palette reffers to the background color. The ones that are relevant are Null (no background color), and Auto (whatever looks like the background color), I’ve had troubles using the third option. In our case, we put the background as Null as we want the game to display the black background behind the icon.

3. Doing the graphics with SLX Studio​

4. Adding the frames to the slp file​

1. Locating graphic files from Definitive Edition.​

2. Angles and frame count​

1. Definitive Edition graphics use 16 angles, that is, 16 directions the unit faces. On the other hand, AoC uses 5 angles and the mirror mode to mimic all directions. This means that two thirds of the frames are not needed.
2. Definitive Edition uses way more frames to ensure smoother animations. Of the valid angles, we will delete several of them to accomodate the number of frames programmed in AGE.

2.1 Angles​

2.2 Frames per angle​

2.3 Save the .slx file​

3. Color and shadow correction.​

• AA2F9B to FF0000, 20% tolerance.
• 850C79 to FF0000, 20% tolerance.
• 4F004B to FF0000, 20% tolerance.
• D33AC9 to FF00FF, 20% tolerance.

4. Creating data graphics.​

1. Save the data graphics under a different name so that SLX Studio doesn’t replace them. Then, when you create new data graphics and erase the player color, you still have the original ones to copy those pixels back to the newly generated data graphic. This method requires a way of copying only green pixels and do it automatically for all the frames but preserves the exact same pixels.
2. Have SLX Studio detect the “blue” pixels and treat them as player color pixels. This option is subjected to the actual colors in the image and the tolerance, and is unlikely that you will get the same result as the original version. However is simpler to do and will cover all frames.

• The Mask section detects the pink pixels as background and will omit them from the graphic. Set the tolernce to 20%.
• The Shadow section detects the red pixels as shadow and will paint them gray. Set the tolernce to 20%. Note that there is also the option of “Split Shadows”; this creates the shadow in a different file and is uses for buildings like castles and walls.
• The Player section detects all the pixels that should change color with the owner. Here do the following:
  • Set the tolerance to 30 %.
  • Load the preset [Blue] AoE1.
  • Add two more colors to the preset: 0000FF and 004ABB.
• The Outlines section will draw the outline around the unit. It should not be used for buildings and for corpse units. Mark the option “Draw outlines” and “Player only”.

5. Exporting the graphics.​

Batch processing​

1. “Graphics/Batch Extract SMX to SLX” will convert all the .smx files in a folder into .slx ones, creating a folder for each one. You’ll have to manually go over them and delete extra frames if necessary but it’s useful for buildings.
2. “Tools/Batch Image Color Replace” will replace the color of all the graphics. It works exactly as the “Color Replace Graphics” tool.
3. “Tools/Batch Generate Data Graphics” will create the data graphics. This one is more tricky as it’s bugged. You need to set the options in the single “Generate Data Graphics” tool and then move to the batch version, the configuration will remain. Once the process finishes and you close the tool, SLX studio will freeze so you need to close it through the Task Manager.
4. “Graphics/Batch Convert SLX to SLP/Standard 2.0N SLP” will export to .slp files all the .slx files in a folder.

Handling the color pixels​

Color pixels with Paint​

1. Open both the original and new data graphics with Paint.
2. Select the whole new data graphic, copy it and paste it into the original data graphic. This will momentarily hide the original data graphic completly.
3. On the “Select” option, select “Transparent Selection”. This will make Paint ignore white pixels from the new data graphic and the green pixels from the image bellow will appear.

Color pixels with a script​

#This module lets Python handle images
from PIL import Image

#Function to copy the color pixels (green in the data file) to the new data file
#As inputs, it receives the two file paths
def data_graphics(original_name,new_name):
    #open both files
    original = Image.open(original_name)
    new = Image.open(new_name)
    #get the size of the image
    (w,h) = original.size
    #go over all pixels in the image
    for i in range(w):
        for j in range(h):
            #if the pixel in the original one is green, change it in the new one
            if original.getpixel((i,j)) == (0,255,0):
                new.putpixel((i,j),(0,255,0))
    #save the modified image
    new.save(new_name)

Brighter images​

Locating the interface data​

Using palettes in Turtle Pack​

Using palettes in SLX Studio​

Known palettes​

Mayan bonus​

• It initiates technology 552, “Disable TC spawn extra”.
• It has another annex unit attached to it, 1394, “Villager building”.
• Its “Dead unit” is still -1.

• It creates unit 1394 attached to it and triggers tech 552.
• Unit 1394 dies instantly and turns into unit 1397.
• Unit 1397 dies instantly and turns into a villager.

Chinese bonus​

"Disable TC spawn" techs​

Tatar’s extra sheep​

Actual implementation​

• We need new technologies that “make available” the queuabe version when the requirements of the technology are met. For example, technology 816 researches automatically once you reach Feudal Age and its only effect is to activate the queuabe version of Bloodlines.
• Thechnologies are programmed into the Technology Tree of civilizations by simply disabling the tech. For the queuable technologies, we also need to disable the techs that make the queuable version available. Effect 258, the Frank Technology Tree, has technology 816 disabled.
• The queuable technology is actually a unit that should disappear as soon as it has triggered the tech. This is easy to do by setting the hit points of all the queuable techs to -1.
• Since for all intends and purposes, the queuable techs are units, it is perfectly possible to queue more than one or to shift-click them in a group of buildings. With this you are paying the cost of several techs but only getting the effect once. To solve this we introduce another resource into the cost, a hidden resource of which the player only has one unit. This way, once the player clicks once in the tech, it consumes the single unit of the resource and prevents from researching a technology more than once. We have to create a new resource per technology in order to have this.
• Once the technology has been researched, the icon doesn’t disapear, as the game treats it like a unit. Therefore, we have to program the effect of every technology to also disable the unit that created it.
• Additionally, we instruct the technology to move the button to position 255. This effectively hides the button and is implemented as a security measure for scenarios that may want to research technologies using triggers.
• We need also to disable the button field in the Techs Tab so it doesn’t show in game. This is the only part of the original technology we should modify as the AI still researches technollogies in this fashion. Leaving the research time and cost intact allows to competitively play against AI.

Issues​

A more obscure issue​

In game behavior​

1. When the requisites of the technology are met (age, previous technology) the actual technology is enabled and the "make available" version is activated. Humans don't see the actual technology, as the button is hidden, but AIs do. In the corresponding building, a trebuchet-like unit appears in the position of the technology.
2. When the unit is created, it dies instantly but triggers the actual technology. Appart from it's effects, this technology hides and disables the unit.
3. If needed, a dummy version of the technology is triggered to enable future technologies.

Scenario Editor use​

• If you want to research a technolgy using triggers, research the actual one. It will take care of hidding the button of the unit.
• If you want to enable a technology for the player to research, use a trigger to research the "make available" version.
• If you want to disable a technology for a civilization, disable the "make available" version. The section of the editor where you can disable technologies only uses the actual ones, which may be useful if you expect to use AI players.
• Unique technologiess and unique units upgrades use all the same three technologies.
• The effect to research technologies allows to input a number. Some of the useful values you can use with queuable techs are the following. For more information, see here.
  • 0. Research the technology.
  • 2. Disable technology.
  • 3. Enable a technology for researching through triggers.

Basic Age of Mandala​

Adaptative Age of Mandala​

Easy version​

Hard version​

• Unit 79 is the unit you see in game but it has no Train location (which should be the villager) and has unit 1461 as Head unit.
  
  
• Unit 1461 does have the villager as the Train location, has a different range unit from unit 79, 1404, and has unit 79 as Stack unit. The description of Stack unit reads ''Second building to be placed directly on top of this building''. Moreover, one of its attributes is ''Built: Vanishes''.

Final problem​

Code for generating the mandalas​

Adaptative Age of Mandala code​

from PIL import Image
import math
import numpy as np

'''
This program creates mandalas given the size of the building and its reach
It differentiates between straight lines paralel to the sides of the building and
arcs around the corners, following an ellipse.

To get the distances, the program assumes that the tiles measure 96x96 pixels and that
the perspective shrinks them only vertically, by a factor of 0.5.
'''

global ang,side,horizon
#A tile measures 96 pixels horizontaly and 48 vertically
ang = math.atan(0.5) #angle of the grid lines from the horizontal, 30 degrees.
side = math.sqrt(96**2+48**2)/2 #length of a tile side in pixels
horizon = math.sqrt(2)*48 #length of a tile side when horizontal

def aprox(x):
    return list(map(round,x))

#Create empty image
def empty(base,reach):
    #base: number of tiles of the side of the building
    #reach: in tiles of the building
    global ang, side, horizon
    l = math.ceil(base*96+reach*2*horizon)+4 #length of the picture plus 4 extra pixels
    h = math.ceil(base*48+reach*2*horizon*0.5)+4 #height of the picture plus 4 extra pixels
    return Image.new("RGB", (l,h), (255,0,255)) #blank image in pink

#Paint a pixel and the 8 surounding it
def paint(img,x,color):
    i = [-1, 0, 1,-1,0,1,-1,0,1]
    j = [-1,-1,-1, 0,0,0, 1,1,1]
    for k in range(9):
        img.putpixel((x[0]+i[k],x[1]+j[k]),color)

#Draw straingt lines from point x following vector v in length long(given in tiles)
def straight_line(x,v,long,img):
    global side,trace
    step = 0.01
    for _ in np.arange(0,long+step,step):
        x=x+v*step
        if int(trace)%2==0: #to make discontinuous line
            paint(img,aprox(x),(255,0,0)) #paint in red
        trace += step*4

#Paint arcs at distance reach from x0 starting in angle a0
#The function draws an ellipse
def arc(x0,a0,reach,img):
    global ang,trace,horizon
    step = 0.001
    #Start a bit before a0 and finish a bit after rotating ang, to ensure it connects to the straight lines
    for thet in np.arange(a0-ang*0.7,a0+2.7*ang+step,step):
        x=x0+np.array([reach*horizon*math.cos(thet),reach*horizon*0.5*math.sin(thet)])
        if int(trace)%3==0: #to make discontinuous line
            paint(img,aprox(x),(255,0,0))
        trace += step*(3*horizon/4) #increment: angle in radians times the mean radius of the ellipse

#function to create the whole mandala
def mandala(base,reach):
    #base: number of tiles of the side of the building
    #reach: in tiles of the building
    global ang,side,trace
    img = empty(base,reach)

    #vectors following the lines in the grid
    v1 = np.array([side*math.cos(ang),side*math.sin(ang),])
    v2 = np.array([-side*math.cos(ang),side*math.sin(ang),])
    (l,h) = img.size

    center = np.array([l/2-1,h/2-1])
 
    trace = 0
    #straight side NW
    x=center-v2*base/2-v1*(base/2+reach)
    straight_line(x,v2,base,img)
 
    #arc W
    x=center+v2*base/2-v1*(base/2)
    arc(x,math.pi-ang,reach,img)
 
    #straight side SW
    x=center-v1*base/2+v2*(base/2+reach)
    straight_line(x,v1,base,img)

    #arc N
    x=center-v2*base/2-v1*(base/2)
    arc(x,3*math.pi/2-ang,reach,img)

    #straight side SE
    x=center+v2*base/2+v1*(base/2+reach)
    straight_line(x,-v2,base,img)

    #arc E
    x=center-v2*base/2+v1*(base/2)
    arc(x,-ang,reach,img)

    #straight side NE
    x=center+v1*base/2-v2*(base/2+reach)
    straight_line(x,-v1,base,img)

    #arc S
    x=center+v2*base/2+v1*(base/2)
    arc(x,math.pi/2-ang,reach,img)
        
    return img

#Tower
for i in range(8,14):
    mandala(1,i).save('tower'+str(i)+'.bmp')

#Donjon
for i in range(8,12):
    mandala(2,i).save('donjon'+str(i)+'.bmp')

#Krepost/Harbor
for i in range(7,11):
    mandala(3,i).save('krepost'+str(i)+'.bmp')

#Castle
for i in range(8,15):
    mandala(4,i).save('castle'+str(i)+'.bmp')

Allied vision​

No onager cutting​

Longer lasting resources​

effect_amount SET_ATTRIBUTE BAMBOO_TREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE OAKTREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE PINETREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE PALMTREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE TREE_A ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_B ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_C ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_D ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_E ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_F ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_G ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_H ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_I ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_J ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_K ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE TREE_L ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE FOREST_TREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE SNOWPINETREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE JUNGLETREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE DRAGONTREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE BAOBABTREE ATTR_STORAGE_VALUE 2000
effect_amount SET_ATTRIBUTE ACACIA_TREE ATTR_STORAGE_VALUE 1500
effect_amount SET_ATTRIBUTE DLC_MANGROVE_TREE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE DLC_RAINTREE ATTR_STORAGE_VALUE 1000

#const GURJARA_BUSH 1628
effect_amount SET_ATTRIBUTE FORAGE_BUSH ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE DLC_ORANGEBUSH ATTR_STORAGE_VALUE 1250
effect_amount SET_ATTRIBUTE GURJARA_BUSH ATTR_STORAGE_VALUE 1250

effect_amount SET_ATTRIBUTE GOLD_MINE ATTR_STORAGE_VALUE 8000
effect_amount SET_ATTRIBUTE STONE_MINE ATTR_STORAGE_VALUE 3500

effect_amount SET_ATTRIBUTE FISH ATTR_STORAGE_VALUE 2000
effect_amount SET_ATTRIBUTE SHORE_FISH ATTR_STORAGE_VALUE 2000
effect_amount SET_ATTRIBUTE GREAT_FISH_MARLIN ATTR_STORAGE_VALUE 3500
effect_amount SET_ATTRIBUTE GREAT_FISH_MARLIN2 ATTR_STORAGE_VALUE 3500
effect_amount SET_ATTRIBUTE DORADO ATTR_STORAGE_VALUE 2250
effect_amount SET_ATTRIBUTE SALMON ATTR_STORAGE_VALUE 2250
effect_amount SET_ATTRIBUTE TUNA ATTR_STORAGE_VALUE 2250
effect_amount SET_ATTRIBUTE 458 ATTR_STORAGE_VALUE 2250

#const GOOSE 382
#const PIG 997
effect_amount SET_ATTRIBUTE DLC_LLAMA ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE GOOSE ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE SHEEP ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE DLC_COW ATTR_STORAGE_VALUE 1500
effect_amount SET_ATTRIBUTE TURKEY ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE PIG ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE DLC_GOAT ATTR_STORAGE_VALUE 1000
effect_amount SET_ATTRIBUTE DLC_WATERBUFFALO ATTR_STORAGE_VALUE 1500

#const IBEX 1472
effect_amount SET_ATTRIBUTE DEER ATTR_STORAGE_VALUE 1400
effect_amount SET_ATTRIBUTE DLC_ZEBRA ATTR_STORAGE_VALUE 1400
effect_amount SET_ATTRIBUTE DLC_OSTRICH ATTR_STORAGE_VALUE 1400
effect_amount SET_ATTRIBUTE IBEX ATTR_STORAGE_VALUE 1400

effect_amount SET_ATTRIBUTE WILD_BOAR ATTR_STORAGE_VALUE 3400
effect_amount SET_ATTRIBUTE JAVELINA ATTR_STORAGE_VALUE 3400
effect_amount SET_ATTRIBUTE ELEPHANT ATTR_STORAGE_VALUE 4000
effect_amount SET_ATTRIBUTE DLC_RHINO ATTR_STORAGE_VALUE 4000

Triple tech mode​

Empire wars​

Enabling the mode​

Adding initial units and buildings​

create_object FARM
{
number_of_objects 2
set_place_for_every_player
min_distance_to_players 4
max_distance_to_players 4
}

create_object VILLAGER
{
number_of_objects 6
set_place_for_every_player
min_distance_to_players 2
max_distance_to_players 2
}

create_object VILLAGER
{
number_of_objects 2
group_placement_radius  1
set_place_for_every_player
min_distance_to_players 4
max_distance_to_players 4
}

create_object VILLAGER
{
number_of_objects 4
number_of_groups  5
temp_min_distance_group_placement 6
set_place_for_every_player
group_placement_radius  1
min_distance_to_players 10
max_distance_to_players 12
}
#const EW_OUTPOST 2801
create_object EW_OUTPOST
{
number_of_objects 1
number_of_groups  8
temp_min_distance_group_placement 6
set_place_for_every_player
group_placement_radius  1
min_distance_to_players 13
max_distance_to_players 15
}

create_object HERDABLE_A
{
  set_place_for_every_player
  min_distance_to_players 1
  max_distance_to_players 1
  }

create_object HOUSE
{
number_of_objects 6
group_placement_radius  5
set_place_for_every_player
min_distance_to_players 7
max_distance_to_players 7
min_distance_group_placement  1
}

create_object BARRACKS
{
set_place_for_every_player
min_distance_to_players 8
max_distance_to_players 9
min_distance_group_placement  1
}

create_object BLACKSMITH
{
set_place_for_every_player
min_distance_to_players 8
max_distance_to_players 9
min_distance_group_placement  1
}

Re-setting building cost​

1. \item Lumber camps have an annex unit, 2793, called ''EW lumber camp annex 1a''.
2. ''EW lumber camp annex 1a'' dies instantly and turns into unit 2794, ''EW lumber camp annex 1b''.
3. ''EW lumber camp annex 1b'' triggers technology 2009, ''EW lumber camp 1''.
4. The effect of ''EW lumber camp 1'' is to upgrade ''EW lumber camp annex 1a'' to ''EW lumber camp annex 2a'' and ''EW lumber camp annex 1b'' to ''EW lumber camp annex 2b''.

Circle and fixed placement​

Circle placement​

• You have to set the placement to “direct_placement” in the section. Normal random maps have “random_placement” instead.
• This code is meant to be placed in the section, where the “create_land” of the players should be.
• When using it, you need to modify the variable constants with the lines of code that should go in all “create_land” entries, such as terrain_type, land_percent, base size, etc.
• You can set the radius of the circle for each number of players.
• This code will add a bit of deviation in the circle when having 4 or less players and put players equidistantly when having 5 or more, so as not to have bases intersecting.

import math
'''
function to generate all the team distributions of a given number of players
taking care that teams have at least 2 players and only the first teams are filled
n: number of players to assign
distrib: list with the number of players in each team. Initially all zeros
    indexes: 0: unassigned players, 1,2,3,4: teams
t: team to asign, initially 1
'''
def team_variations(n,distrib,t):
    #list with all the variations to be retrieved after all team_variations executions finish
    global variations
 
    #case of unassigned players, team 5
    if t == 5:
        distrib[0]=n #add players to the unasigned players team
        variations.append(distrib)#add distribution to the list of variations
        return
 
    #don't assign less than 2 players to a team
    elif n < 2: #if you have less than two players to assign
        team_variations(n,distrib,t+1) #step team counter until reaching 5, unassigned case
        return
 
    #don't leave teams empty
    elif t >= 2 and distrib[t-1] == 0: #if the team to assign is 2 or more but the previous is empty
        team_variations(n,distrib,t+1) #step team counter until reaching 5, unassigned case
        return
 
    #fill the team with every possible variation of number of players
    #for number of players between 2 and n
    for i in range(2,n+1):
        #create a copy of the current distribution and set the number of players
        #on the current team to assign to i
        distrib_aux = distrib[:]
        distrib_aux[t] = i
        #recursive call with less available players and for the next team
        team_variations(n-i,distrib_aux,t+1)

    #recursive call with all the players in the next team, used to get to the unassigned case
    team_variations(n,distrib,t+1)

'''
function that computes the number of teams with positive number of players
variation: list with the number of players in each team.
    indexes: 0: unassigned players, 1,2,3,4: teams
'''
def number_of_teams(variation):
    k = 0
    for i in range(1,5):
        if variation[i] > 0:
            k += 1
    return k

'''
function that returns a string with the team and the number of players in it
variation: list with the number of players in each team.
    indexes: 0: unassigned players, 1,2,3,4: teams
i: team to display
'''
def team_size(variations,i):
    return 'TEAM'+str(i)+'_SIZE'+str(variations[i])

'''
Function that computes the coordinates of a player base along a circle
radius: of the circle from the center of the map, measured in percent of total length
players: number of  players to fit in the circle
per_player: number of positions available to every player.
    this controls that, when computing for 2 players, one can create more than 2 positions
    but still have the players opposed.
'''
def circle(radius, players, per_player=1, add_deviations=True):
    '''
    rotations and events handle the probability distribution.
    rotations decide the overall position of players, there are as many as the value of per-player
    events decide which of the positions belong to which player, there are as many as the value of players
    '''
    #rotations, given by per_player
    rotations = [100//per_player]*per_player #probabilities have to be an integer number
    #events, given by players
    events = [100//players]*players #probabilities have to be an integer number

    #distribute the remining probability up to 100
    #per_player
    rem = 100 - rotations[0]*per_player
    while rem > 0:
        for i in range(per_player):
            rotations[i] += 1
            rem -= 1
            if rem == 0:
                break
    #players
    rem = 100 - events[0]*players
    while rem > 0:
        for p in range(players):
            events[p] += 1
            rem -= 1
            if rem == 0:
                break

    #angle to generate as many rotations as given in per_player
    pp_angle = 2*math.pi/(players*per_player)
    #angle between players
    angle = 2*math.pi/(players)

    '''
    output string will hold all the text that nedds to be added to the rms file
    '''
    output = ''
    #write the random sample that generates the cases:
    #rotations
    if per_player > 1:
        output+='  start_random\n'
        for i in range(per_player):
            output+='    percent_chance '+str(rotations[i])
            output+=' #define ROTATION_'+str(i+1)+'\n'
        output+='  end_random\n\n'

    #events
    output+='  start_random\n'
    for p in range(players):
        output+='    percent_chance '+str(events[p])
        output+=' #define PLACE_'+str(p+1)+'\n'
    output+='  end_random\n\n\n'


    #write the coordinates of the positions
    global variations, constants
    '''
    variations will hold all the valid combinations of players and teams
    constants holds the text that has to go in all the create_land entries
    '''
    variations = []
    team_variations(players,[0]*5,1)
    #now variations holds all the possible variations of players per team

    #Create as many lands as players, adding the random cases given by rotation
    for p in range(players):
        '''
        create the player land
        '''
        output += '  create_land {\n'
        output += constants #text that has to be written always
 
        if per_player > 1: #if there is more than one rotation
            first_rotation = True #flag to write "if" or "elseif"
            for i in range(per_player):
                if first_rotation:
                    output += '    if '
                    first_rotation = False
                else:
                    output += '    elseif '
                output += 'ROTATION_'+str(i+1)+'\n'
                #include a random deviation in the angle
                if add_deviations:
                    output += '      start_random\n'
                    for j in range(-1,2):
                        output+='        percent_chance '+str(40-10*abs(j))
                        coord_x = round(50 + radius*math.cos(angle*p+pp_angle*i+angle/4*j))
                        coord_y = round(50 + radius*math.sin(angle*p+pp_angle*i+angle/4*j))
                        output+=' land_position '+str(coord_x)+' '+str(coord_y)+'\n'
                    output += '      end_random\n'
                else:
                    coord_x = round(50 + radius*math.cos(angle*p+pp_angle*i))
                    coord_y = round(50 + radius*math.sin(angle*p+pp_angle*i))
                    output+='      land_position '+str(coord_x)+' '+str(coord_y)+'\n'
            output += '    endif\n\n'
        else: #per_player == 1
            #include a random deviation in the angle
            if add_deviations:
                output += '    start_random\n'
                for j in range(-1,2):
                    output+='      percent_chance '+str(40-10*abs(j))
                    coord_x = round(50 + radius*math.cos(angle*p+angle/4*j))
                    coord_y = round(50 + radius*math.sin(angle*p+angle/4*j))
                    output+=' land_position '+str(coord_x)+' '+str(coord_y)+'\n'
                output += '    end_random\n'
            else:
                coord_x = round(50 + radius*math.cos(angle*p))
                coord_y = round(50 + radius*math.sin(angle*p))
                output+='    land_position '+str(coord_x)+' '+str(coord_y)+'\n\n'

        '''
        assign the player land
        '''
        #for each variation of teams
        for v in variations:
            if v[0] == 0 and v[1] == players:#ignore the case where all players are in team 1
                continue
            output += '    if '
            output += str(number_of_teams(v))+'_TEAM_GAME\n'
   
            #write all the sizes of each team in the variation (with actual players)
            #this creates several nested "if" clauses to act as "and"
            for t in range(1,5): #skip team 0, unassigned
                if v[t] == 0: #if the team is empty, the others will be too
                    break
                output += '      if '+team_size(v,t)+'\n'

            #Distribute land for teams
            #if there are no teams
            if number_of_teams(v) == 0:
                output += '      assign_to AT_TEAM 0 0 0\n'
                output += '    endif\n\n' #this closes the "if" of variation v
                continue #the rest of the loop is needed in case of teams
   
            #if there are teams
            #list with as many elements as the number of players
            #with as many 0s as unassigned players, as many 1s as players in team 1, etc
            teams = [0]*v[0]+[1]*v[1]+[2]*v[2]+[3]*v[3]+[4]*v[4]
            first_players = True #flag to write "if" or "elseif"
            #for each player
            for l in range(players):
                string = 'PLACE_'+str(l+1)#random sample given by the events list, one per player
                if first_players:
                    output+='        if '
                    first_players = False
                else:
                    output+='        elseif '
                output += string+'\n'
                #in each iteration of the l loop, the index (p+l)%players will increase by one
                #the value p is placed so that each land is assigned to consecutive teams
                output += '          assign_to AT_TEAM '+str(teams[(p+l)%players])+' 0 0\n'
            output += '        endif\n'

            #endif for team sizes, this closes the nested "if" from above
            for t in range(1,5): #skip team 0, unassigned
                if v[t] == 0: #if the team is empty, the others will be too
                    break
                output += '      endif\n'
            #endif of variation v
            output += '    endif\n\n'

        output += '  }\n\n' #end of the create_land
    return output


global constants #text that has to be written in every create_land
'''
EDIT THIS with the constants of the particular map
'''
constants='    terrain_type LAYER_A\n    number_of_tiles 300\n    base_size 12\n    clumping_factor 15\n    other_zone_avoidance_distance 8\n'

file=open('circles.txt','w')
per_players = [4,2,2,1,1,1,1] #number of rotations for each number of players
radius = [34,34,35,36,37,38,38] #radius of the circles for each number of players
for p in range(2,9):
    if p == 2:
        file.write('if ')
    else:
        file.write('elseif ')
    file.write(str(p)+'_PLAYER_GAME\n')
    #generate the code for the circle of the given number of players and write it in the file
    if p <=4:
        file.write(circle(radius[p-2],p,per_players[p-2],True))
    else:
        file.write(circle(radius[p-2],p,per_players[p-2],False))
file.write('endif')
file.close()

Fixed Positions​

import math
'''
function to generate all the team distributions of a given number of players
taking care that teams have at least 2 players and only the first teams are filled
n: number of players to assign
distrib: list with the number of players in each team. Initially all zeros
    indexes: 0: unassigned players, 1,2,3,4: teams
t: team to asign, initially 1
'''
def team_variations(n,distrib,t):
    #list with all the variations to be retrieved after all team_variations executions finish
    global variations
 
    #case of unassigned players, team 5
    if t == 5:
        distrib[0]=n #add players to the unasigned players team
        variations.append(distrib)#add distribution to the list of variations
        return
 
    #don't assign less than 2 players to a team
    elif n < 2: #if you have less than two players to assign
        team_variations(n,distrib,t+1) #step team counter until reaching 5, unassigned case
        return
 
    #don't leave teams empty
    elif t >= 2 and distrib[t-1] == 0: #if the team to assign is 2 or more but the previous is empty
        team_variations(n,distrib,t+1) #step team counter until reaching 5, unassigned case
        return
 
    #fill the team with every possible variation of number of players
    #for number of players between 2 and n
    for i in range(2,n+1):
        #create a copy of the current distribution and set the number of players
        #on the current team to assign to i
        distrib_aux = distrib[:]
        distrib_aux[t] = i
        #recursive call with less available players and for the next team
        team_variations(n-i,distrib_aux,t+1)

    #recursive call with all the players in the next team, used to get to the unassigned case
    team_variations(n,distrib,t+1)

'''
function that computes the number of teams with positive number of players
variation: list with the number of players in each team.
    indexes: 0: unassigned players, 1,2,3,4: teams
'''
def number_of_teams(variation):
    k = 0
    for i in range(1,5):
        if variation[i] > 0:
            k += 1
    return k

'''
function that returns a string with the team and the number of players in it
variation: list with the number of players in each team.
    indexes: 0: unassigned players, 1,2,3,4: teams
i: team to display
'''
def team_size(variations,i):
    return 'TEAM'+str(i)+'_SIZE'+str(variations[i])

'''
Function that computes the coordinates of a player base along a circle
radius: of the circle from the center of the map, measured in percent of total length
players: number of  players to fit in the circle
per_player: number of positions available to every player.
    this controls that, when computing for 2 players, one can create more than 2 positions
    but still have the players opposed.
'''
def circle(radius, players, per_player=1):
    '''
    rotations and events handle the probability distribution.
    rotations decide the overall position of players, there are as many as the value of per-player
    events decide which of the positions belong to which player, there are as many as the value of players
    '''
    #rotations, given by per_player
    rotations = [100//per_player]*per_player #probabilities have to be an integer number
    #events, given by players
    events = [100//players]*players #probabilities have to be an integer number

    #distribute the remining probability up to 100
    #per_player
    rem = 100 - rotations[0]*per_player
    while rem > 0:
        for i in range(per_player):
            rotations[i] += 1
            rem -= 1
            if rem == 0:
                break
    #players
    rem = 100 - events[0]*players
    while rem > 0:
        for p in range(players):
            events[p] += 1
            rem -= 1
            if rem == 0:
                break

    #angle to generate as many rotations as given in per_player
    pp_angle = 2*math.pi/(players*per_player)
    #angle between players
    angle = 2*math.pi/(players)

    '''
    output string will hold all the text that nedds to be added to the rms file
    '''
    output = ''
    #write the random sample that generates the cases:
    #rotations
    if per_player > 1:
        output+='  start_random\n'
        for i in range(per_player):
            output+='    percent_chance '+str(rotations[i])
            output+=' #define ROTATION_'+str(i+1)+'\n'
        output+='  end_random\n\n'

    #events
    output+='  start_random\n'
    for p in range(players):
        output+='    percent_chance '+str(events[p])
        output+=' #define PLACE_'+str(p+1)+'\n'
    output+='  end_random\n\n\n'


    #write the coordinates of the positions
    global variations, constants
    '''
    variations will hold all the valid combinations of players and teams
    constants holds the text that has to go in all the create_land entries
    '''
    variations = []
    team_variations(players,[0]*5,1)
    #now variations holds all the possible variations of players per team

    #Create as many lands as players, adding the random cases given by rotation
    for p in range(players):
        '''
        create the player land
        '''
        output += '  create_land {\n'
        output += constants #text that has to be written always
 
        if per_player > 1: #if there is more than one rotation
            first_rotation = True #flag to write "if" or "elseif"
            for i in range(per_player):
                if first_rotation:
                    output += '    if '
                    first_rotation = False
                else:
                    output += '    elseif '
                output += 'ROTATION_'+str(i+1)+'\n'
                coord_x = round(50 + radius*math.cos(angle*p+pp_angle*i))
                coord_y = round(50 + radius*math.sin(angle*p+pp_angle*i))
                output+='      land_position '+str(coord_x)+' '+str(coord_y)+'\n'
            output += '    endif\n\n'
        else: #per_player == 1
            coord_x = round(50 + radius*math.cos(angle*p))
            coord_y = round(50 + radius*math.sin(angle*p))
            output+='    land_position '+str(coord_x)+' '+str(coord_y)+'\n\n'

        '''
        assign the player land
        '''
        #for each variation of teams
        for v in variations:
            if v[1]==v[2] and v[1]+v[2]==players and v[1]>=3: #if there are two even teams
                output += '    if '
                output += str(number_of_teams(v))+'_TEAM_GAME\n'
    
                #write all the sizes of each team in the variation (with actual players)
                #this creates several nested "if" clauses to act as "and"
                for t in range(1,5): #skip team 0, unassigned
                    if v[t] == 0: #if the team is empty, the others will be too
                        break
                    output += '      if '+team_size(v,t)+'\n'

                #Distribute land for teams
                #list with as many elements as the number of players, sorted by team (odds, evens)
                colors =list(range(1,players+1,2))+list(range(2,players+1,2))
                first_players = True #flag to write "if" or "elseif"
                #for each player
                for l in range(players):
                    string = 'PLACE_'+str(l+1)#random sample given by the events list, one per player
                    if first_players:
                        output+='        if '
                        first_players = False
                    else:
                        output+='        elseif '
                    output += string+'\n'
                    #in each iteration of the l loop, the index (p+l)%players will increase by one
                    #the value p is placed so that each land is assigned to consecutive players
                    output += '          assign_to AT_COLOR '+str(colors[(p+l)%players])+' 0 0\n'
                output += '        endif\n'

                #endif for team sizes, this closes the nested "if" from above
                for t in range(1,5): #skip team 0, unassigned
                    if v[t] == 0: #if the team is empty, the others will be too
                        break
                    output += '      endif\n'
                #endif of variation v
                output += '    endif\n\n'

        output += '  }\n\n' #end of the create_land
    return output


global constants #text that has to be written in every create_land
'''
EDIT THIS with the constants of the particular map
'''
constants = '    terrain_type LAYER_A\n    land_percent 4\n    base_size 9\n'

file=open('fixed_positions.txt','w')

file.write('if ')
file.write('6'+'_PLAYER_GAME\n')
#generate the code for the circle of the given number of players and write it in the file
file.write(circle(37,6,1))

file.write('elseif ')
file.write('8'+'_PLAYER_GAME\n')
#generate the code for the circle of the given number of players and write it in the file
file.write(circle(38,8,1))

file.write('endif')
file.close()

Handicap mode​

• Faster gather rate for villagers.
• Higher carry capacity.
• More starting resources.
• Higher Villager HP.
• Faster build speed.
• More HP on all buildings.
• More bonus damage for counter units.
• Faster work rate for military buildings.

Basic implementation of handicap​

Handicap mode in a random map​

• Players have to be created with the “direct_placement” command.
• We create lands and assign them for specific player numbers with the “ASSING_TO_AT COLOR” command.
• Additionally, we need to identify those lands with the command “land_id”.
• When creating objects, we can control which players receive them by using the command “place_on_specific_land_id”.

Creating maps with specific handicap​

1. The unit may die from splash damage if not provided with enough health.
2. Although the unit is invisible, it can be detected by enemy units, thus distracting them.
3. The unit belongs to the player and therefore has to die in order to eliminate a player. Finding and killing an invisible unit should not be a requirement.

Extra villagers per age​

Elephant units bonus resistance​

Elephant archers​

• Feudal age: elephant archers gain +1 cavalry archer armor for a total of -3.
• Feudal age: elephant archers gain +4 elephant armor for a total of 4.
• Feudal age: elephant archers gain +4 cavalry armor for a total of 4.
• Leather archer armor (castle age): elephant archers gain +1 archer armor, for a total of 1.
• Leather archer armor (castle age): elephant archers gain +2 elephant armor, for a total of 6.
• Leather archer armor (castle age): elephant archers gain +1 cavalry armor, for a total of 5.
• Ring archer armor (imperial age): elephant archers gain +1 cavalry archer armor, for a total of -2.
• Ring archer armor (imperial age): elephant archers gain +1 archer armor, for a total of 2.
• Ring archer armor (imperial age): elephant archers gain +1 elephant armor, for a total of 7.
• Ring archer Armor (imperial age): elephant archers gain +3 cavalry armor, for a total of 8.

Battle Elephants​

• Feudal age: elephants gain +4 elephant armor for a total of 4.
• Feudal age: elephants gain +4 cavalry armor for a total of 4.
• Chain barding armor (castle age): elephants gain +2 elephant armor, for a total of 6.
• Chain barding armor (castle age): elephants gain +1 cavalry armor, for a total of 5.
• Plate barding armor (imperial age): elephants gain +1 elephant armor, for a total of 7.
• Plate barding armor (imperial age): elephants gain +3 cavalry armor, for a total of 8.

• Camel scout (3), camel rider (3), heavy camel rider (4) and imperial camel rider (4).
• Eagle scout (2), eagle warrior (3) and elite eagle warrior (3).
• Genoese crossbow (2) and elite genoese crossbow (3).
• Kamayuk (4) and elite kamayuk (7).
• Mameluke (3) and elite mameluke (5).
• Flemish militia (4).
• Infantry (1) when researching viking’s chieftains.

Armored Elephant​

• Chain barding armor (castle age): armored elephants gain +6 elephant armor, for a total of 23.
• Plate barding armor (imperial age): siege elephants gain +2 elephant armor, for a total of 28.

Bohemian and gurjara bonus damage​

Mahayana​

Feudal Town Center​

Cuman mercenaries​

Madrasah​

Adaptation to Keshiks​