Ticket #52: Triggers.2.patch

binaries/data/mods/public/maps/scripts/test.js

@@ +1 @@
+var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+
+// Test rigger to log the kills and defeat a player if his/her hero dies
+function trigger1_Action(data)
+{
+    var cmpKilled = Engine.QueryInterface(data.killedEntity, IID_Identity);
+    var killedPlayerId = GetEntityOwner(data.killedEntity);
+    var killerPlayerId = GetEntityOwner(data.killerEntity);
+    var cmpKiller = Engine.QueryInterface(data.killerEntity, IID_Identity);
+    log("A player " + killerPlayerId + "'s " + GetEntityGenericName(data.killerEntity) + " killed a player " + killedPlayerId + "'s " + GetEntityGenericName(data.killedEntity) + ".");
+    
+    if (EntityHasClass(data.killedEntity, "Hero"))
+    {
+        var playerEnt = GetPlayerEntityByID(killedPlayerId);
+        Engine.PostMessage(playerEnt, MT_PlayerDefeated, { "playerId": killedPlayerId } );
+    }
+}
+
+// Test trigger to check the "OnUnitRangeFromEntity" event. If entity 473 (Cyrus) gets near the entity 273 (The enemy embassy), 5 swordsman are spawned. This is done only once
+function trigger2_Action(data)
+{
+    if (data.entity == 473)
+    {
+        BuildingSpawnUnits(273, "units/cart_infantry_swordsman_2_b", 5);
+        
+        log("Ok. Finish it.");
+        cmpTrigger.DisableTrigger("trigger2");
+    }
+}
+
+// Test trigger to check the orders given by the player. Only works for the hero and the elite archer
+function trigger3_Action(data)
+{
+    if (data.entity == 473)
+    {
+        PushGUINotificationInTopCenter(1, "Your hero is ordered: " + data.order);
+    }
+    else if (data.entity == 474)
+    {
+        PushGUINotificationInTopCenter(1, "Your archer is ordered: " + data.order);
+    }
+}
+
+// The set of global trigger actions. The name must always be "g_TriggerActions"
+var g_TriggerActions = {
+    "trigger1_Action": trigger1_Action,
+    "trigger2_Action": trigger2_Action,
+    "trigger3_Action": trigger3_Action
+};
+
+// Make the trigger actions global so that we can use it in the trigger component.
+Engine.RegisterGlobal("g_TriggerActions", g_TriggerActions);
+
+// Register the triggers
+cmpTrigger.RegisterTrigger("trigger1", "OnEntityKilled", "trigger1_Action");
+cmpTrigger.RegisterOnUnitRangeFromEntityTrigger("entered", "trigger2", 273, 40, "trigger2_Action", [0, 1, 2], IID_DamageReceiver);
+cmpTrigger.RegisterTrigger("trigger3", "OnUnitIssuedOrder", "trigger3_Action");
+ No newline at end of file

binaries/data/mods/public/simulation/components/BuildingAI.js

@@ -146 +146 @@
  */
 BuildingAI.prototype.OnRangeUpdate = function(msg)
 {
-
     var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
     if (!cmpAttack)
         return;

binaries/data/mods/public/simulation/components/Foundation.js

@@ -202 +202 @@
             // (via CCmpTemplateManager). Now we need to remove that temporary
             // blocker-disabling, so that we'll perform standard unit blocking instead.
             cmpObstruction.SetDisableBlockMovementPathfinding(false, false, -1);
+            
+            // Call the related trigger event 
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnConstructionStarted", {"foundation": this.entity, "template": this.finalTemplateName});
         }
 
         // Switch foundation to scaffold variant

binaries/data/mods/public/simulation/components/interfaces/Trigger.js

@@ +1 @@
+Engine.RegisterInterface("Trigger");

binaries/data/mods/public/simulation/components/ProductionQueue.js

@@ -288 +288 @@
                 "timeTotal": time*1000,
                 "timeRemaining": time*1000,
             });
+            
+            // Call the related trigger event 
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnTrainingQueued", {"playerid": cmpPlayer.GetPlayerID(), "unitTemplate": templateName, "count": count, "metadata": metadata, "trainerEntity": this.entity});
         }
         else if (type == "technology")
         {
@@ -324 +328 @@
                 "timeTotal": time*1000,
                 "timeRemaining": time*1000,
             });
+            
+            // Call the related trigger event 
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnResearchQueued", {"playerid": cmpPlayer.GetPlayerID(), "technologyTemplate": templateName, "researcherEntity": this.entity});
         }
         else
         {

binaries/data/mods/public/simulation/components/ResourceTrickle.js

@@ -57 +57 @@
     if (cmpPlayer)
         for (var resource in rates)
             cmpPlayer.AddResource(resource, rates[resource]);
-    
 };
 
 Engine.RegisterComponentType(IID_ResourceTrickle, "ResourceTrickle", ResourceTrickle);

binaries/data/mods/public/simulation/components/TechnologyManager.js

@@ -283 +283 @@
         return;
     }
     
+    // Call the related trigger event 
+    var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+    cmpTrigger.CallEvent("OnResearchFinished", {"researcher": this.entity, "tech": tech});
+    
     var modifiedComponents = {};
     this.researchedTechs[tech] = template;
     // store the modifications in an easy to access structure

binaries/data/mods/public/simulation/components/Trigger.js

@@ +1 @@
+function Trigger() {}
+
+Trigger.prototype.Schema =
+    "<a:component type='system'/><empty/>";
+
+Trigger.prototype.Init = function()
+{
+    // Each event has its own set of actions determined by the map maker.
+    this.eventOnEntityTookDamageActions = {};
+    this.eventOnEntityKilledActions = {};
+    this.eventOnStructureBuiltActions = {};
+    this.eventOnConstructionStartedActions = {};
+    this.eventOnTrainingFinishedActions = {};
+    this.eventOnTrainingQueuedActions = {};
+    this.eventOnResearchFinishedActions = {};
+    this.eventOnResearchQueuedActions = {};
+    this.eventAlwaysActions = {};
+    this.eventOnUnitRangeFromEntityData = {};
+    this.eventOnUnitIssuedOrderActions = {};
+    
+    // We are going to have all of the triggers here to be able to enable/disbale them in runtime.
+    this.triggerEnabled = {};
+    
+    // Queries for OnUnitFromEntity events
+    this.activeRangeQueries = {};
+};
+
+Trigger.prototype.StartUpdateTimer = function(interval, delay)
+{
+    delay = (delay === undefined ? 0 : delay);
+    
+    // Stop the last timer before starting a new one
+    if (this.timer !== undefined)
+        this.StopUpdateTimer();
+
+    // Start the update timer
+    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    this.timer = cmpTimer.SetInterval(this.entity, IID_Trigger, "TimerUpdate", delay, interval, undefined);
+}
+
+Trigger.prototype.StopUpdateTimer = function()
+{
+    // Call the update timer
+    if (this.timer !== undefined)
+    {
+        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+        cmpTimer.CancelTimer(this.timer);
+        this.timer = undefined;
+    }
+}
+
+// Binds the "action" function to one of the implemented events. "name" is a string for further access
+// to the trigger for enabling/disabling.
+Trigger.prototype.RegisterTrigger = function(name, event, action, enabled)
+{
+    enabled = (enabled !== undefined ? enabled : true);
+    var validEvent = true;
+    switch (event)
+    {
+    case "OnEntityTookDamage":
+        this.eventOnEntityTookDamageActions[name] = action;
+        break;
+    case "OnEntityKilled":
+        this.eventOnEntityKilledActions[name] = action;
+        break;
+    case "OnUnitIssuedOrder":
+        this.eventOnUnitIssuedOrderActions[name] = action;
+        break;
+    case "OnStructureBuilt":
+        this.eventOnStructureBuiltActions[name] = action;
+        break;
+    case "OnConstructionStarted":
+        this.eventOnConstructionStartedActions[name] = action;
+        break;
+    case "OnTrainingFinished":
+        this.eventOnTrainingFinishedActions[name] = action;
+        break;
+    case "OnTrainingQueued":
+        this.eventOnTrainingQueuedActions[name] = action;
+        break;
+    case "OnResearchFinished":
+        this.eventOnResearchFinishedActions[name] = action;
+        break;
+    case "OnResearchQueued":
+        this.eventOnResearchQueuedActions[name] = action;
+        break;
+    case "Always":
+        this.eventAlwaysActions[name] = action;
+        break;
+    default:
+        validEvent = false;
+        break;
+    }
+    if (validEvent)
+        this.triggerEnabled[name] = enabled
+    else
+        error("Invalid trigger event \"" + event + "\".");
+};
+
+// This is an event with more than just the name argument, so we should have a special register function for it.
+Trigger.prototype.RegisterOnUnitRangeFromEntityTrigger = function(event, name, entity, radius, action, players, component_id, enabled)
+{
+    enabled = (enabled !== undefined ? enabled : true);
+    component_id = (component_id !== undefined ? component_id : 0);
+    
+    // If the players parameter is not specified use all players.
+    if (!players)
+    {
+        var playerEntities = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayerEntities();
+        players = [];
+        for each (var pentity in playerEntities)
+            players.push(Engine.QueryInterface(pentity, IID_Player).GetPlayerID());
+    }
+    
+    // To determine if a unit has "moved" or "was inside" the range, we should know if it was in the range before. We have "currentCollection" for this purpose.
+    // For the purpose of finding out the intersection of the previous and the current rangeQuery faster, we are sorting the current one.
+    this.eventOnUnitRangeFromEntityData[name] = {"event": event, "action": action, "entity": entity, "radius": radius, "currentCollection": [], "players": players};
+    this.triggerEnabled[name] = enabled;
+    
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    
+    this.activeRangeQueries[name] = cmpRangeManager.CreateActiveQuery(entity, 0, radius, players, component_id, cmpRangeManager.GetEntityFlagMask("normal"));
+    cmpRangeManager.EnableActiveQuery(this.activeRangeQueries[name]);
+}
+
+// Disable trigger
+Trigger.prototype.DisableTrigger = function(name)
+{
+    if (this.triggerEnabled[name] !== undefined)
+        this.triggerEnabled[name] = false;
+    else
+        warn("Trigger doesn't exist:" + name);
+}
+
+// Enable trigger
+Trigger.prototype.EnableTrigger = function(name)
+{
+    if (this.triggerEnabled[name] !== undefined)
+        this.triggerEnabled[name] = true;
+    else
+        warn("Trigger doesn't exist:" + name);
+}
+
+// To handle the events that cannot be tracked by messages, this function should be called in the simulation code.
+Trigger.prototype.CallEvent = function(event, data)
+{
+    if (event == "OnEntityKilled")
+    {
+        for (var i in this.eventOnEntityKilledActions)
+        {
+            if (this.triggerEnabled[i])    // Check if it is enabled
+                g_TriggerActions[this.eventOnEntityKilledActions[i]](data); // The data for this one is {"killerEntity": killerEntity, "killedEntity": targetEntity}
+        
+            // Remove the "OnUnitFromRangeEntity" triggers which have this entity as their argument
+            for (var j in this.eventOnUnitRangeFromEntityData)
+            {
+                if (this.eventOnUnitRangeFromEntityData[j].entity == data.killedEntity)
+                {
+                    delete this.eventOnUnitRangeFromEntityData[j];
+                    delete this.triggerEnabled[j];
+                }
+            }
+        }
+        
+        return;
+    }
+    
+    if (this["event" + event + "Actions"] === undefined)
+    {
+        warn("Invalid trigger event \"" + event + "\" called.");
+        return;
+    }
+    
+    for (var i in this["event" + event + "Actions"])
+        if (this.triggerEnabled[i])
+            g_TriggerActions[this["event" + event + "Actions"][i]](data);
+}
+
+// Handles "OnStructureBuilt" event.
+Trigger.prototype.OnGlobalConstructionFinished = function(msg)
+{
+    for (var i in this.eventOnStructureBuiltActions)
+        if (this.triggerEnabled[i])    // Check if it is enabled
+            g_TriggerActions[this.eventOnStructureBuiltActions[i]]({"building": msg.newentity}); // The data for this one is {"building": constructedBuilding}
+}
+
+// Handles "OnTrainingFinished" event.
+Trigger.prototype.OnGlobalTrainingFinished = function(msg)
+{
+    for (var i in this.eventOnTrainingFinishedActions)
+        if (this.triggerEnabled[i])    // Check if it is enabled
+            g_TriggerActions[this.eventOnTrainingFinishedActions[i]](msg); // The data for this one is {"entities": createdEnts,
+                                                                     // "owner": cmpOwnership.GetOwner(),
+                                                                     // "metadata": metadata,}
+                                                                     // See function "SpawnUnits" in ProductionQueue for more details
+}
+
+// Handles an event that occurs by the interval the map designer specifies
+Trigger.prototype.TimerUpdate = function(data, lateness)
+{
+    // Handle "Always" event.
+    for (var i in this.eventAlwaysActions)
+        if (this.triggerEnabled[i])    // Check if it is enabled
+            g_TriggerActions[this.eventAlwaysActions[i]](); // This function event has no data
+}
+
+// Handles "OnUnitRangeFromEntity"
+Trigger.prototype.OnGlobalRangeUpdate = function(msg)
+{
+    var updatedRange = undefined;
+    for (var name in this.activeRangeQueries)
+    {
+        if (msg.tag == this.activeRangeQueries[name])
+        {
+            updatedRange = name;
+            break;
+        }
+    }
+    
+    if (updatedRange === undefined)
+        return;
+
+    for each (var entity in msg.removed)
+    {
+        var index = this.eventOnUnitRangeFromEntityData[name].currentCollection.indexOf(entity);
+            if (index > -1)
+                this.eventOnUnitRangeFromEntityData[name].currentCollection.splice(index, 1);
+        this.eventOnUnitRangeFromEntityData[name].currentCollection.push(entity);
+    }
+        
+    for each (var entity in msg.added)
+        this.eventOnUnitRangeFromEntityData[name].currentCollection.push(entity);
+        
+    if (this.triggerEnabled[name])    // Check if it is enabled
+    {
+        if (this.eventOnUnitRangeFromEntityData[name].event == "moved")
+        {
+            for each (var entity in this.eventOnUnitRangeFromEntityData[name].currentCollection)
+            {
+                var cmpUnitMotion = Engine.QueryInterface(entity, IID_UnitMotion);
+                if (cmpUnitMotion && cmpUnitMotion.IsMoving())
+                    g_TriggerActions[this.eventOnUnitRangeFromEntityData[name].action]({"entity": entity});
+            }
+        }
+        else if (this.eventOnUnitRangeFromEntityData[name].event == "entered")
+        {
+            for each (var entity in msg.added)
+            {
+                g_TriggerActions[this.eventOnUnitRangeFromEntityData[name].action]({"entity": entity});
+            }
+        }
+        else if (this.eventOnUnitRangeFromEntityData[name].event == "left")
+        {
+            for each (var entity in msg.removed)
+            {
+                g_TriggerActions[this.eventOnUnitRangeFromEntityData[name].action]({"entity": entity});
+            }
+        }
+        else if (this.eventOnUnitRangeFromEntityData[name].event == "was inside")
+        {
+            for each (var entity in this.eventOnUnitRangeFromEntityData[name].currentCollection)
+            {
+                g_TriggerActions[this.eventOnUnitRangeFromEntityData[name].action]({"entity": entity});
+            }
+        }
+    }
+}
+
+// These two functions are for handling one time timers in the triggers.
+Trigger.prototype.DoAfterDelay = function(miliseconds, action, data)
+{
+    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    return cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_Trigger, "DoAction", miliseconds, {"action": action, "data": data});
+}
+
+Trigger.prototype.DoAction = function(data)
+{
+    g_TriggerActions[data.action](data);
+}
+
+Engine.RegisterComponentType(IID_Trigger, "Trigger", Trigger);

binaries/data/mods/public/simulation/components/UnitAI.js

@@ -199 +199 @@
         cmpUnitMotion.MoveToFormationOffset(msg.data.target, msg.data.x, msg.data.z);
 
         this.SetNextStateAlwaysEntering("FORMATIONMEMBER.WALKING");
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.FormationWalk", "metadata": msg});
     },
 
     // Special orders:
@@ -225 +228 @@
             // We are already at the target, or can't move at all
             this.FinishOrder();
         }
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.LeaveFoundation", "metadata": msg});
     },
 
     // Individual orders:
@@ -247 +253 @@
             this.SetNextState("ANIMAL.IDLE");
         else
             this.SetNextState("INDIVIDUAL.IDLE");
-
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Stop", "metadata": msg});
     },
 
     "Order.Walk": function(msg) {
@@ -258 +266 @@
             return;
         }
 
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Walk", "metadata": msg});
+        
         // For packable units:
         // 1. If packed, we can move.
         // 2. If unpacked, we first need to pack, then follow case 1.
@@ -284 +295 @@
             return;
         }
 
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.WalkAndFight", "metadata": msg});
+        
         // For packable units:
         // 1. If packed, we can move.
         // 2. If unpacked, we first need to pack, then follow case 1.
@@ -310 +324 @@
             this.FinishOrder();
             return;
         }
-
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.WalkToTarget", "metadata": msg, "target": this.order.data.target});
+        
         // For packable units:
         // 1. If packed, we can move.
         // 2. If unpacked, we first need to pack, then follow case 1.
@@ -358 +375 @@
             this.StopMoving();
             this.SetNextState("INDIVIDUAL.PICKUP.LOADING");
         }
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.PickupUnit", "metadata": msg, "target": this.order.data.target});
     },
 
     "Order.Guard": function(msg) {
@@ -371 +391 @@
             this.SetNextState("INDIVIDUAL.GUARD.ESCORTING");
         else
             this.SetNextState("INDIVIDUAL.GUARD.GUARDING");
+        
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Guard", "metadata": msg, "target": this.order.data.target});
     },
 
     "Order.Flee": function(msg) {
@@ -379 +402 @@
         var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
         if (cmpUnitMotion.MoveToTargetRange(this.order.data.target, distance, -1))
         {
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Flee", "metadata": msg, "target": this.order.data.target});
+        
             // We've started fleeing from the given target
             if (this.IsAnimal())
                 this.SetNextState("ANIMAL.FLEEING");
@@ -391 +417 @@
             this.StopMoving();
             this.FinishOrder();
         }
+        
+
     },
 
     "Order.Attack": function(msg) {
@@ -411 +439 @@
         }
         this.order.data.attackType = type;
 
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Attack", "metadata": msg, "target": this.order.data.target});
+        
         // If we are already at the target, try attacking it from here
         if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
         {
@@ -495 +527 @@
         // We can't reach the target, and can't move towards it,
         // so abandon this attack order
         this.FinishOrder();
+        
     },
 
     "Order.Heal": function(msg) {
@@ -515 +548 @@
         // Check if the target is in range
         if (this.CheckTargetRange(this.order.data.target, IID_Heal))
         {
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Heal", "metadata": msg, "target": this.order.data.target});
+        
             this.StopMoving();
             this.SetNextState("INDIVIDUAL.HEAL.HEALING");
             return;
@@ -531 +568 @@
         // Try to move within heal range
         if (this.MoveToTargetRange(this.order.data.target, IID_Heal))
         {
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Heal", "metadata": msg, "target": this.order.data.target});
+        
             // We've started walking to the given point
             this.SetNextState("INDIVIDUAL.HEAL.APPROACHING");
             return;
@@ -588 +629 @@
             this.StopMoving();
             this.SetNextStateAlwaysEntering("INDIVIDUAL.GATHER.GATHERING");
         }
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Gather", "metadata": msg, "target": this.order.data.target});
     },
 
     "Order.GatherNearPosition": function(msg) {
         // Move the unit to the position to gather from.
         this.MoveToPoint(this.order.data.x, this.order.data.z);
         this.SetNextState("INDIVIDUAL.GATHER.WALKING");
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.GatherNearPosition", "metadata": msg, "target": this.order.data.target});
     },
 
     "Order.ReturnResource": function(msg) {
@@ -617 +666 @@
         // Try to move to the dropsite
         if (this.MoveToTargetRange(this.order.data.target, IID_ResourceGatherer))
         {
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.ReturnResource", "metadata": msg, "target": this.order.data.target});
+        
             // We've started walking to the target
             this.SetNextState("INDIVIDUAL.RETURNRESOURCE.APPROACHING");
             return;
@@ -649 +702 @@
         this.waypoints = undefined;
         if (this.MoveToMarket(nextMarket))
         {
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Trade", "metadata": msg, "target": this.order.data.target});
+        
             // We've started walking to the next market
             this.SetNextState(state);
         }
@@ -671 +728 @@
             this.StopMoving();
             this.SetNextState("INDIVIDUAL.REPAIR.REPAIRING");
         }
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Repair", "metadata": msg, "target": this.order.data.target});
     },
 
     "Order.Garrison": function(msg) {
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Garrison", "metadata": msg, "target": this.order.data.target});
+    
         // For packable units:
         // 1. If packed, we can move to the garrison target.
         // 2. If unpacked, we first need to pack, then follow case 1.
@@ -698 +763 @@
 
     "Order.Autogarrison": function(msg) {
         this.SetNextState("INDIVIDUAL.AUTOGARRISON");
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Autogarrison", "metadata": msg});
     },
 
     "Order.Alert": function(msg) {
@@ -711 +780 @@
             this.ReplaceOrder("Garrison", {"target": this.alertGarrisoningTarget});
         else
             this.FinishOrder();
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Alert", "metadata": msg});
     },  
 
     "Order.Cheering": function(msg) {
         this.SetNextState("INDIVIDUAL.CHEERING");
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Cheering", "metadata": msg});
     },
 
     "Order.Pack": function(msg) {
@@ -722 +799 @@
         {
             this.StopMoving();
             this.SetNextState("INDIVIDUAL.PACKING");
+            
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Pack", "metadata": msg});
         }
     },
 
@@ -730 +811 @@
         {
             this.StopMoving();
             this.SetNextState("INDIVIDUAL.UNPACKING");
+            
+            // Call "OnUnitIssuedOrder" event of the triggers.
+            var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+            cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.Unpack", "metadata": msg});
         }
     },
 
@@ -738 +823 @@
         if (cmpPack && cmpPack.IsPacking() && !cmpPack.IsPacked())
             cmpPack.CancelPack();
         this.FinishOrder();
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.CancelPack", "metadata": msg});
     },
 
     "Order.CancelUnpack": function(msg) {
@@ -745 +834 @@
         if (cmpPack && cmpPack.IsPacking() && cmpPack.IsPacked())
             cmpPack.CancelPack();
         this.FinishOrder();
+        
+        // Call "OnUnitIssuedOrder" event of the triggers.
+        var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+        cmpTrigger.CallEvent("OnUnitIssuedOrder", {"entity": this.entity, "order": "Order.CancelUnpack", "metadata": msg});
     },
 
     // States for the special entity representing a group of units moving in formation:
@@ -809 +902 @@
             var cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
             if (cmpTargetUnitAI && cmpTargetUnitAI.IsFormationMember())
                 target = cmpTargetUnitAI.GetFormationController();
-
+            
             var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
             // Check if we are already in range, otherwise walk there
             if (!this.CheckTargetAttackRange(target, target))
@@ -838 +931 @@
                 this.FinishOrder();
                 return;
             }
+            
             // Check if we are already in range, otherwise walk there
             if (!this.CheckGarrisonRange(msg.data.target))
             {
@@ -915 +1009 @@
             }
 
             this.CallMemberFunction("GatherNearPosition", [msg.data.x, msg.data.z, msg.data.type, msg.data.template, false]);
-
+            
             this.SetNextStateAlwaysEntering("MEMBER");
         },
 
@@ -934 +1028 @@
             }
 
             this.CallMemberFunction("Heal", [msg.data.target, false]);
-
+            
             this.SetNextStateAlwaysEntering("MEMBER");
         },
 
@@ -1188 +1282 @@
 
             // Stop moving as soon as the formation disbands
             this.StopMoving();
-
+            
             // If the controller handled an order but some members rejected it,
             // they will have no orders and be in the FORMATIONMEMBER.IDLE state.
             if (this.orderQueue.length)

binaries/data/mods/public/simulation/helpers/Damage.js

@@ -74 +74 @@
     // Damage the target
     var targetState = cmpDamageReceiver.TakeDamage(data.strengths.hack * data.multiplier, data.strengths.pierce * data.multiplier, data.strengths.crush * data.multiplier, data.attacker);
 
+    // Call the related trigger event
+    // We have to call the event instead of listening to it by messages because the message is sent
+    // after the target gets killed, which is not our intended case
+    var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+    cmpTrigger.CallEvent("OnEntityTookDamage", {"attackerEntity": data.attacker, "attackedEntity": data.target, "type":data.type, "ammount":-targetState.change});
+    
     // If the target was killed run some cleanup
     if (targetState.killed)
         Damage.TargetKilled(data.attacker, data.target);
@@ -110 +116 @@
     // Call RangeManager with dummy entity and return the result.
     var rangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     var rangeQuery = rangeManager.ExecuteQueryAroundPos(origin, 0, radius, players, IID_DamageReceiver);
+    
     return rangeQuery;
 };
 
@@ -133 +140 @@
     var cmpLooter = Engine.QueryInterface(killerEntity, IID_Looter);
     if (cmpLooter)
         cmpLooter.Collect(targetEntity);
+        
+    // Call the related trigger event 
+    var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
+    cmpTrigger.CallEvent("OnEntityKilled", {"killerEntity": killerEntity, "killedEntity": targetEntity});
 };
 
 Engine.RegisterGlobal("Damage", Damage);

binaries/data/mods/public/simulation/helpers/TriggerHelpers.js

@@ +1 @@
+// Contains standardized functions suitable for using in trigger scripts.
+// Do not use them in any other simulation script.
+
+/**
+ * A function to get the owner of an entity. 
+ * Returns the ID of a player. Returns 0 if the owner is Gaia.
+ */
+function GetEntityOwner(entity)
+{
+    return Engine.QueryInterface(entity, IID_Ownership).GetOwner()
+}
+
+/**
+ * A function to get the generic name of an entity
+ */
+function GetEntityGenericName(entity)
+{
+    var cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
+    return cmpIdentity.GetGenericName();
+}
+
+/**
+ * A function to get a list of the classes of an entity
+ */
+function GetEntityClassesList(entity)
+{
+    var cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
+    return cmpIdentity.GetClassesList();
+}
+
+/**
+ * A function to determine if an entity has a specific class
+ */
+function EntityHasClass(entity, classname)
+{
+    var classes = GetEntityClassesList(entity);
+    return (classes && classes.indexOf(classname) != -1);
+}
+
+/**
+ * Returns the entity id of a player based on the id of the player
+ * Useful when one wants to change a player's properties.
+ */
+function GetPlayerEntityByID(id)
+{
+    var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    return cmpPlayerMan.GetPlayerByID(id);
+}
+
+/**
+ * Can be used to "force" a building to spawn a group of entities.
+ * Only works for buildings that can already train units.
+ */
+function BuildingSpawnUnits(entity, template, count)
+{
+    var cmpProductionQueue = Engine.QueryInterface(entity, IID_ProductionQueue);
+    cmpProductionQueue.SpawnUnits(template, count, null);
+} 
+
+/**
+ * Shows a message in the top center of the screen
+ */
+function PushGUINotificationInTopCenter(player, message)
+{
+    var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+    cmpGUIInterface.PushNotification({"player": player, "message": message});
+} 
+
+/**
+ * Returns the resource type that can be gathered from an entity
+ */
+function GetEntityResourceType(entity)
+{
+    var cmpResourceSupply = Engine.QueryInterface(entity, IID_ResourceSupply);
+    if (!cmpResourceSupply)
+        return undefined;
+    return cmpResourceSupply.GetType();
+} 
+
+/**
+ * Returns a list of entities owned by the player
+ */
+function GetEntitiesByPlayer(playerID)
+{
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    return cmpRangeManager.GetEntitiesByPlayer(playerID);
+}
+
+/**
+ * Wins the game for a player
+ */
+function SetPlayerWon(playerID)
+{
+    var playerEnt = GetPlayerEntityByID(playerID);
+    var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
+    cmpPlayer.SetState("won")
+}
+
+/**
+ * Defeats a player
+ */
+function DefeatPlayer(playerID)
+{
+    var playerEnt = GetPlayerEntityByID(playerID);
+    Engine.PostMessage(playerEnt, MT_PlayerDefeated, { "playerId": playerID } );
+}
+
+Engine.RegisterGlobal("GetEntityOwner", GetEntityOwner);
+Engine.RegisterGlobal("GetEntityGenericName", GetEntityGenericName);
+Engine.RegisterGlobal("GetEntityClassesList", GetEntityClassesList);
+Engine.RegisterGlobal("EntityHasClass", EntityHasClass);
+Engine.RegisterGlobal("GetPlayerEntityByID", GetPlayerEntityByID);
+Engine.RegisterGlobal("BuildingSpawnUnits", BuildingSpawnUnits);
+Engine.RegisterGlobal("PushGUINotificationInTopCenter", PushGUINotificationInTopCenter);
+Engine.RegisterGlobal("GetEntityResourceType", GetEntityResourceType);
+Engine.RegisterGlobal("GetEntitiesByPlayer", GetEntitiesByPlayer);
+Engine.RegisterGlobal("SetPlayerWon", SetPlayerWon);
+Engine.RegisterGlobal("DefeatPlayer", DefeatPlayer);
+ No newline at end of file

source/simulation2/Simulation2.cpp

@@ -133 +133 @@
             LOAD_SCRIPTED_COMPONENT("PlayerManager");
             LOAD_SCRIPTED_COMPONENT("TechnologyTemplateManager");
             LOAD_SCRIPTED_COMPONENT("Timer");
+            LOAD_SCRIPTED_COMPONENT("Trigger");
             LOAD_SCRIPTED_COMPONENT("ValueModificationManager");
 
 #undef LOAD_SCRIPTED_COMPONENT
@@ -748 +749 @@
 
     if (!m->m_StartupScript.empty())
         GetScriptInterface().LoadScript(L"map startup script", m->m_StartupScript);
+    
+    // Load the trigger script after we have loaded the simulation and the map.
+    if (GetScriptInterface().HasProperty(m->m_MapSettings.get(), "TriggerScript"))
+    {
+        std::string script_name;
+        GetScriptInterface().GetProperty(m->m_MapSettings.get(), "TriggerScript", script_name);
+
+        script_name = "maps/scripts/" + script_name;
+        m->m_ComponentManager.LoadScript(script_name.data());
+    }
 }
 
 int CSimulation2::ProgressiveLoad()