Ticket #4066: GarrisonHolder_Mod.js

GarrisonHolder.prototype.Schema +=
    "<optional>" +
        "<element name='StartingGarrison' a:help='Units that are garrisoned in this unit / structure after its creation'>" +
            "<zeroOrMore>" +
                "<element a:help='Element containing the offset coordinates'>" +
                    "<anyName/>" +
                    "<interleave>" +
                        "<element name='Template'>" +
                            "<text/>" +
                        "</element>" +
                        "<element name='Count'>" +
                            "<data type='nonNegativeInteger'/>" +
                        "</element>" +
                    "</interleave>" +
                "</element>" +
            "</zeroOrMore>" +
        "</element>" +
    "</optional>";

/**
 * Initialize GarrisonHolder Component
 *
 * Garrisoning when loading a map is set in the script of the map, by setting initGarrison
 * which should contain the array of garrisoned entities
 */
GarrisonHolder.prototype.Init = function()
{
    // Garrisoned Units
    this.entities = [];
    this.timer = undefined;
    this.allowGarrisoning = {};
    this.visibleGarrisonPoints = [];
    this.startingGarrison = [];
    this.startingGarrisonCount = 0;
    this.startingGarrisonObtained = false;
    if (this.template.VisibleGarrisonPoints)
    {
        for (let key in this.template.VisibleGarrisonPoints)
        {
            let offset = this.template.VisibleGarrisonPoints[key];
            let o = {};
            o.x = +offset.X;
            o.y = +offset.Y;
            o.z = +offset.Z;
            this.visibleGarrisonPoints.push({"offset":o, "entity": null});
        }
    }
    if (this.template.StartingGarrison)
    {
        for (let key in this.template.StartingGarrison)
        {
            if (this.startingGarrisonCount < this.template.Max)
            {
                let group = this.template.StartingGarrison[key];
                let template = group.Template;
                let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
                if (!cmpTemplateManager.TemplateExists(template))
                    warn("Specified StartingGarrison template '" +template+ "' in group '" +key+ "' does not exist");
                else
                {
                    let count;
                    count = group.Count;
                    if (Number(count) > Number(this.template.Max))
                        count = this.template.Max;
                    if ((Number(this.startingGarrisonCount) + Number(count)) > Number(this.template.Max))
                    {
                        count = Number(this.template.Max) - Number(count);
                        warn("Tried adding too many units. "+key+"'s count has been reduced to " +count+ ".");
                    }
                    this.startingGarrison.push({"template":template, "count": count});
                    this.startingGarrisonCount = Number(this.startingGarrisonCount) + Number(count);
                }
            }
            else
                warn(key+ ": The maximum garrison capacity of the entity has been reached already.");
        }
    }
};

/**
 * Execute some magic when the ownership of an entity is given to a player for the first time
 */
GarrisonHolder.prototype.OnOwnershipChanged = function(msg)
{
    if (msg.from == -1)
    {
        if (this.startingGarrisonObtained == false)
        {
            this.SpawnStartingGarrison();
            this.startingGarrisonObtained = true;
        }
    }
};

GarrisonHolder.prototype.PerformGarrison = function(entity, enforce)
{
    if (enforce == 0 && !this.HasEnoughHealth())
        return false;

    // Check if the unit is allowed to be garrisoned inside the building
    if(!this.AllowedToGarrison(entity))
        return false;

    // check the capacity
    var extraCount = 0;
    var cmpGarrisonHolder = Engine.QueryInterface(entity, IID_GarrisonHolder);
    if (cmpGarrisonHolder)
        extraCount += cmpGarrisonHolder.GetGarrisonedEntitiesCount();
    if (this.GetGarrisonedEntitiesCount() + extraCount >= this.GetCapacity())
        return false;

    if (!this.timer && this.GetHealRate() > 0)
    {
        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
        this.timer = cmpTimer.SetTimeout(this.entity, IID_GarrisonHolder, "HealTimeout", 1000, {});
    }

    // Actual garrisoning happens here
    this.entities.push(entity);
    this.UpdateGarrisonFlag();
    var cmpProductionQueue = Engine.QueryInterface(entity, IID_ProductionQueue);
    if (cmpProductionQueue)
        cmpProductionQueue.PauseProduction();

    var cmpAura = Engine.QueryInterface(entity, IID_Auras);
    if (cmpAura && cmpAura.HasGarrisonAura())
        cmpAura.ApplyGarrisonBonus(this.entity);

    Engine.PostMessage(this.entity, MT_GarrisonedUnitsChanged, { "added" : [entity], "removed": [] });

    var cmpUnitAI = Engine.QueryInterface(entity, IID_UnitAI);
    if (cmpUnitAI && cmpUnitAI.IsUnderAlert())
        Engine.PostMessage(cmpUnitAI.GetAlertRaiser(), MT_UnitGarrisonedAfterAlert, {"holder": this.entity, "unit": entity});

    return true;
};

GarrisonHolder.prototype.SpawnStartingGarrison = function()
{
    if (this.template.StartingGarrison)
    {
        for (let key in this.startingGarrison)
        {
            for (let i = 0; i < this.startingGarrison[key].count; ++i)
            {
                var newEnt = Engine.AddEntity(this.startingGarrison[key].template);
                var cmpOwnership = Engine.QueryInterface(newEnt, IID_Ownership);
                var cmpOwnership2 = Engine.QueryInterface(this.entity, IID_Ownership);
                if (!cmpOwnership)
                {
                    Engine.DestroyEntity(newEnt);
                    continue;
                }
                cmpOwnership.SetOwner(cmpOwnership2.GetOwner());
                this.PerformGarrison(newEnt, 1);
            }
        }
    }
};

Engine.ReRegisterComponentType(IID_GarrisonHolder, "GarrisonHolder", GarrisonHolder);