Ticket #3919: UnitAIAnimal.js

// function piggyback example
// AnimalAI.protoype.SetNextState = UnitAI.prototype.SetNextState;

function UnitAIAnimal() {}

UnitAIAnimal.prototype.Schema =
    "<element name='Behaviour' a:help='Behaviour of the animal'>" +
        "<choice>" +
            "<value a:help='Will actively attack any unit it encounters, even if not threatened'>violent</value>" +
            "<value a:help='Will attack nearby units if it feels threatened (if they linger within LOS for too long)'>aggressive</value>" +
            "<value a:help='Will attack nearby units if attacked'>defensive</value>" +
            "<value a:help='Will never attack units but will attempt to flee when attacked'>passive</value>" +
            "<value a:help='Will never attack units. Will typically attempt to flee for short distances when units approach'>skittish</value>" +
            "<value a:help='Will never attack units and will not attempt to flee when attacked'>domestic</value>" +
        "</choice>" +
    "</element>" +
    "<element name='RoamDistance'>" +
        "<ref name='positiveDecimal'/>" +
    "</element>" +
    "<element name='RoamTimeMin'>" +
        "<ref name='positiveDecimal'/>" +
    "</element>" +
    "<element name='RoamTimeMax'>" +
        "<ref name='positiveDecimal'/>" +
    "</element>" +
    "<element name='FeedTimeMin'>" +
        "<ref name='positiveDecimal'/>" +
    "</element>" +
    "<element name='FeedTimeMax'>" +
        "<ref name='positiveDecimal'/>" +
    "</element>";

// See ../helpers/FSM.js for some documentation of this FSM specification syntax
UnitAIAnimal.prototype.UnitFsmSpec = {

    "ANIMAL": {
        "Attacked": function(msg) {
            if (this.template.Behaviour == "skittish" ||
                this.template.Behaviour == "passive")
            {
                this.Flee(msg.data.attacker, false);
            }
            else if (this.IsDangerousAnimal() || this.template.Behaviour == "defensive")
            {
                if (this.CanAttack(msg.data.attacker))
                    this.Attack(msg.data.attacker, false);
            }
            else if (this.template.Behaviour == "domestic")
            {
                // Never flee, stop what we were doing
                this.SetNextState("IDLE");
            }
        },

        "Order.LeaveFoundation": function(msg) {
            // Move a tile outside the building
            var range = 4;
            if (this.MoveToTargetRangeExplicit(msg.data.target, range, range))
            {
                // We've started walking to the given point
                this.SetNextState("WALKING");
            }
            else
            {
                // We are already at the target, or can't move at all
                this.FinishOrder();
            }
        },

        "IDLE": {
            // (We need an IDLE state so that FinishOrder works)

            "enter": function() {
                // Start feeding immediately
                this.SetNextState("FEEDING");
                return true;
            },
        },

        "ROAMING": {
            "enter": function() {
                // Walk in a random direction
                this.SelectAnimation("walk", false, this.GetWalkSpeed());
                this.MoveRandomly(+this.template.RoamDistance);
                // Set a random timer to switch to feeding state
                this.StartTimer(RandomInt(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
                this.SetFacePointAfterMove(false);
            },

            "leave": function() {
                this.StopTimer();
                this.SetFacePointAfterMove(true);
            },

            "LosRangeUpdate": function(msg) {
                if (this.template.Behaviour == "skittish")
                {
                    if (msg.data.added.length > 0)
                    {
                        this.Flee(msg.data.added[0], false);
                        return;
                    }
                }
                // Start attacking one of the newly-seen enemy (if any)
                else if (this.IsDangerousAnimal())
                {
                    this.AttackVisibleEntity(msg.data.added);
                }

                // TODO: if two units enter our range together, we'll attack the
                // first and then the second won't trigger another LosRangeUpdate
                // so we won't notice it. Probably we should do something with
                // ResetActiveQuery in ROAMING.enter/FEEDING.enter in order to
                // find any units that are already in range.
            },

            "Timer": function(msg) {
                this.SetNextState("FEEDING");
            },

            "MoveCompleted": function() {
                this.MoveRandomly(+this.template.RoamDistance);
            },
        },

        "FEEDING": {
            "enter": function() {
                // Stop and eat for a while
                this.SelectAnimation("feeding");
                this.StopMoving();
                this.StartTimer(RandomInt(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
            },

            "leave": function() {
                this.StopTimer();
            },

            "LosRangeUpdate": function(msg) {
                if (this.template.Behaviour == "skittish")
                {
                    if (msg.data.added.length > 0)
                    {
                        this.Flee(msg.data.added[0], false);
                        return;
                    }
                }
                // Start attacking one of the newly-seen enemy (if any)
                else if (this.template.Behaviour == "violent")
                {
                    this.AttackVisibleEntity(msg.data.added);
                }
            },

            "MoveCompleted": function() { },

            "Timer": function(msg) {
                this.SetNextState("ROAMING");
            },
        },

        "FLEEING": "INDIVIDUAL.FLEEING", // reuse the same fleeing behaviour for animals

        "COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals

        "WALKING": "INDIVIDUAL.WALKING",    // reuse the same walking behaviour for animals
                            // only used for domestic animals
    }
}

UnitAIAnimal.prototype.Init = UnitAI.prototype.Init;

UnitAIAnimal.prototype.Flee = UnitAI.prototype.Flee;
UnitAIAnimal.prototype.AddOrder = UnitAI.prototype.AddOrder;
UnitAIAnimal.prototype.PushOrder = UnitAI.prototype.PushOrder;
UnitAIAnimal.prototype.UnitFsm = UnitAI.prototype.UnitFsm;

UnitAIAnimal.prototype.CanAttack = UnitAI.prototype.CanAttack;
UnitAIAnimal.prototype.Attack = UnitAI.prototype.Attack;
UnitAIAnimal.prototype.SetNextState = UnitAI.prototype.SetNextState;
UnitAIAnimal.prototype.MoveToTargetRangeExplicit = UnitAI.prototype.MoveToTargetRangeExplicit;
UnitAIAnimal.prototype.FinishOrder = UnitAI.prototype.FinishOrder;
UnitAIAnimal.prototype.SelectAnimation = UnitAI.prototype.SelectAnimation;
UnitAIAnimal.prototype.GetWalkSpeed = UnitAI.prototype.GetWalkSpeed;
UnitAIAnimal.prototype.MoveRandomly = UnitAI.prototype.MoveRandomly;
UnitAIAnimal.prototype.StartTimer = UnitAI.prototype.StartTimer;
UnitAIAnimal.prototype.SetFacePointAfterMove = UnitAI.prototype.SetFacePointAfterMove;
UnitAIAnimal.prototype.StopTimer = UnitAI.prototype.StopTimer;
UnitAIAnimal.prototype.IsDangerousAnimal = UnitAI.prototype.IsDangerousAnimal;
UnitAIAnimal.prototype.AttackVisibleEntity = UnitAI.prototype.AttackVisibleEntity;
UnitAIAnimal.prototype.StopMoving = UnitAI.prototype.StopMoving;