binaries/data/mods/public/maps/random/survivalofthefittest_triggers.js

   1 var treasures =
   2 [
   3         "gaia/special_treasure_food_barrel",
   4         "gaia/special_treasure_food_bin",
   5         "gaia/special_treasure_food_crate",
   6         "gaia/special_treasure_food_jars",
   7         "gaia/special_treasure_metal",
   8         "gaia/special_treasure_stone",
   9         "gaia/special_treasure_wood",
  10         "gaia/special_treasure_wood",
  11         "gaia/special_treasure_wood"
  12 ];
  13 var attackerEntityTemplates =
  14 [
  15         [
  16                 "units/athen_champion_infantry",
  17                 "units/athen_champion_marine",
  18                 "units/athen_champion_ranged",
  19                 "units/athen_mechanical_siege_lithobolos_packed",
  20                 "units/athen_mechanical_siege_oxybeles_packed",
  21         ],
  22         [
  23                 "units/brit_champion_cavalry",
  24                 "units/brit_champion_infantry",
  25                 "units/brit_mechanical_siege_ram",
  26         ],
  27         [
  28                 "units/cart_champion_cavalry",
  29                 "units/cart_champion_elephant",
  30                 "units/cart_champion_infantry",
  31                 "units/cart_champion_pikeman",
  32         ],
  33         [
  34                 "units/gaul_champion_cavalry",
  35                 "units/gaul_champion_fanatic",
  36                 "units/gaul_champion_infantry",
  37                 "units/gaul_mechanical_siege_ram",
  38         ],
  39         [
  40                 "units/iber_champion_cavalry",
  41                 "units/iber_champion_infantry",
  42                 "units/iber_mechanical_siege_ram",
  43         ],
  44         [
  45                 "units/mace_champion_cavalry",
  46                 "units/mace_champion_infantry_a",
  47                 "units/mace_champion_infantry_e",
  48                 "units/mace_mechanical_siege_lithobolos_packed",
  49                 "units/mace_mechanical_siege_oxybeles_packed",
  50         ],
  51         [
  52                 "units/maur_champion_chariot",
  53                 "units/maur_champion_elephant",
  54                 "units/maur_champion_infantry",
  55                 "units/maur_champion_maiden",
  56                 "units/maur_champion_maiden_archer",
  57         ],
  58         [
  59                 "units/pers_champion_cavalry",
  60                 "units/pers_champion_infantry",
  61                 "units/pers_champion_elephant",
  62         ],
  63         [
  64                 "units/ptol_champion_cavalry",
  65                 "units/ptol_champion_elephant",
  66         ],
  67         [
  68                 "units/rome_champion_cavalry",
  69                 "units/rome_champion_infantry",
  70                 "units/rome_mechanical_siege_ballista_packed",
  71                 "units/rome_mechanical_siege_scorpio_packed",
  72         ],
  73         [
  74                 "units/sele_champion_cavalry",
  75                 "units/sele_champion_chariot",
  76                 "units/sele_champion_elephant",
  77                 "units/sele_champion_infantry_pikeman",
  78                 "units/sele_champion_infantry_swordsman",
  79         ],
  80         [
  81                 "units/spart_champion_infantry_pike",
  82                 "units/spart_champion_infantry_spear",
  83                 "units/spart_champion_infantry_sword",
  84                 "units/spart_mechanical_siege_ram",
  85         ],
  86 ];
  87
  88 Trigger.prototype.StartAnEnemyWave = function()
  89 {
  90         let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
  91         let attackerTemplates = attackerEntityTemplates[Math.floor(Math.random() * attackerEntityTemplates.length)];
  92         // A soldier for each 2-3 minutes of the game. Should be waves of 20 soldiers after an hour
  93         let nextTime = Math.round(120000 + Math.random() * 60000);
  94         let attackersPerTemplate = Math.round(cmpTimer.GetTime() / nextTime / attackerTemplates.length);
  95         let spawned = false;
  96
  97         for (let point of this.GetTriggerPoints("A"))
  98         {
  99                 let cmpPlayer = QueryOwnerInterface(point, IID_Player);
 100                 if (cmpPlayer.GetPlayerID() == 0 || cmpPlayer.GetState() != "active")
 101                         continue;
 102
 103                 let cmpPosition =  Engine.QueryInterface(this.playerCivicCenter[cmpPlayer.GetPlayerID()], IID_Position);
 104                 if (!cmpPosition || !cmpPosition.IsInWorld)
 105                         continue;
 106                 let targetPos = cmpPosition.GetPosition();
 107
 108                 for (let template of attackerTemplates)
 109                 {
 110                         let entities = TriggerHelper.SpawnUnits(point, template, attackersPerTemplate, 0);
 111
 112                         ProcessCommand(0, {
 113                                 "type": "attack-walk",
 114                                 "entities": entities,
 115                                 "x": targetPos.x,
 116                                 "z": targetPos.z,
 117                                 "queued": true,
 118                                 "targetClasses": undefined
 119                         });
 120                 }
 121                 spawned = true;
 122         }
 123
 124         if (!spawned)
 125                 return;
 126
 127         let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 128         cmpGUIInterface.PushNotification({
 129                 "message": markForTranslation("An enemy wave is attacking!"),
 130                 "translateMessage": true
 131         });
 132         this.DoAfterDelay(nextTime, "StartAnEnemyWave", {}); // The next wave will come in 3 minutes
 133 };
 134
 135 Trigger.prototype.InitGame = function()
 136 {
 137         let numberOfPlayers = TriggerHelper.GetNumberOfPlayers();
 138         // Find all of the civic centers, disable some structures
 139         for (let i = 1; i < numberOfPlayers; ++i)
 140         {
 141                 let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 142                 let playerEntities = cmpRangeManager.GetEntitiesByPlayer(i); // Get all of each player's entities
 143
 144                 for (let entity of playerEntities)
 145                 {
 146                         if (TriggerHelper.EntityHasClass(entity, "CivilCentre"))
 147                                 this.playerCivicCenter[i] = entity;
 148                         else if (TriggerHelper.EntityHasClass(entity, "Female"))
 149                         {
 150                                 let cmpDamageReceiver = Engine.QueryInterface(entity, IID_DamageReceiver);
 151                                 cmpDamageReceiver.SetInvulnerability(true);
 152
 153                                 let cmpHealth = Engine.QueryInterface(entity, IID_Health);
 154                                 cmpHealth.SetUndeletable(true);
 155                         }
 156                 }
 157         }
 158
 159         this.PlaceTreasures();
 160
 161         // Disable farms, civic centers and walls for all players
 162         for (let i = 1; i < numberOfPlayers; ++i)
 163         {
 164                 let cmpPlayer = QueryPlayerIDInterface(i);
 165                 let civ = cmpPlayer.GetCiv();
 166                 cmpPlayer.SetDisabledTemplates([
 167                         "structures/" + civ + "_field",
 168                         "structures/" + civ + "_corral",
 169                         "structures/" + civ + "_civil_centre",
 170                         "structures/" + civ + "_military_colony",
 171                         "structures/" + civ + "_wallset_stone",
 172                         "other/wallset_palisade"
 173                 ]);
 174         }
 175 };
 176
 177 Trigger.prototype.PlaceTreasures = function()
 178 {
 179         let point = ["B", "C", "D"][Math.floor(Math.random() * 3)];
 180         let triggerPoints = this.GetTriggerPoints(point);
 181         for (let point of triggerPoints)
 182         {
 183                 let template = treasures[Math.floor(Math.random() * treasures.length)];
 184                 TriggerHelper.SpawnUnits(point, template, 1, 0);
 185         }
 186         this.DoAfterDelay(4*60*1000, "PlaceTreasures", {}); // Place more treasures after 4 minutes
 187 };
 188
 189 Trigger.prototype.InitializeEnemyWaves = function()
 190 {
 191         let time = (5 + Math.round(Math.random() * 10)) * 60 * 1000;
 192         let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 193         cmpGUIInterface.AddTimeNotification({
 194                 "message": markForTranslation("The first wave will start in %(time)s!"),
 195                 "translateMessage": true
 196         }, time);
 197         this.DoAfterDelay(time, "StartAnEnemyWave", {});
 198 };
 199
 200 Trigger.prototype.DefeatPlayerOnceCCIsDestroyed = function(data)
 201 {
 202         if (data.entity == this.playerCivicCenter[data.from])
 203                 TriggerHelper.DefeatPlayer(data.from);
 204 };
 205
 206
 207 {
 208         let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 209         cmpTrigger.playerCivicCenter = {};
 210         cmpTrigger.DoAfterDelay(0, "InitGame", {});
 211         cmpTrigger.DoAfterDelay(1000, "InitializeEnemyWaves", {});
 212         cmpTrigger.RegisterTrigger("OnOwnershipChanged", "DefeatPlayerOnceCCIsDestroyed", { "enabled": true });
 213 }