Ejemplo n.º 1
0
 private bool ShouldAttack(Creature creature)
 {
     if (owner.Creature.Gauges.Hunger.Value < 100)
     {
         return(true);
     }
     return(ForceEvaluation.Ratio(owner, creature) >= 0.2f);
     //return true;
 }
Ejemplo n.º 2
0
    public override float CalculateDesirability(Agent agent, bool requested)
    {
        DesirabilitiesConfig desirabilitiesConfig = GameManager.Instance.DesirabilitiesConfig;

        IReadOnlyCollection <DataCreature> creatures = agent.Memory.Creatures.Read();
        float    minDistanceFromHostil = -1;
        Creature closestHostil         = null;

        foreach (DataCreature data in creatures)
        {
            Agent otherAgent = data.creature?.agentCreature;
            if (!otherAgent || !otherAgent.gameObject.activeSelf || data.RegistrationDate < Time.time - 1f)
            {
                continue;
            }

            //bool attackSpecies = otherAgent.Steering.Target && otherAgent.Steering.Target.Creature.SpecieID == agent.Creature.SpecieID;
            //if(!attackSpecies) continue;

            if (otherAgent.Thinking.ActiveGoal?.GetType() == typeof(GoalTired))
            {
                return(0);
            }

            float distance = Vector3.Distance(agent.transform.position, otherAgent.transform.position);

            bool isHostil = GoalEvade.CreatureIsHostil(agent, otherAgent.Creature);
            if (!isHostil)
            {
                continue;
            }

            if (minDistanceFromHostil == -1 || distance < minDistanceFromHostil)
            {
                minDistanceFromHostil = distance;
                closestHostil         = otherAgent.Creature;
            }
        }

        if (minDistanceFromHostil == -1)
        {
            return(0);
        }

        float desirability = desirabilitiesConfig.DefenseDesirabilityByAggressivity.Evaluate(agent.Creature.Traits.Aggressivity.Value)
                             * desirabilitiesConfig.DefenseDesirabilityTwicker
                             * ForceEvaluation.Evaluate(agent, closestHostil);

        if (agent.Thinking.ActiveGoal?.GetType() == typeof(GoalDefense))
        {
            desirability *= desirabilitiesConfig.DefenseConfirmationBias;
        }

        return(desirability);
    }
    public override float CalculateDesirability(Agent agent, bool requested)
    {
        //TODO TEMP
        if (agent.Creature.Traits.Carnivorous < 0.5f)
        {
            return(0);
        }
        if (agent.Steering.Behavior != eSteeringBehavior.Seek && agent.Steering.Behavior != eSteeringBehavior.Wander && agent.Thinking.ActiveGoal?.GetType() != typeof(GoalAvoidPrey))
        {
            return(0);
        }

        DesirabilitiesConfig desirabilitiesConfig = GameManager.Instance.DesirabilitiesConfig;

        List <int> preys = new List <int>(agent.Memory.Species.GetByKey(agent.Creature.SpecieID).CarnivorousFoods.Select(food => food.preyID));
        IReadOnlyCollection <DataCreature> creatures = agent.Memory.Creatures.Read();
        float    minDistanceFromPrey = -1;
        Creature closestPrey         = null;

        foreach (DataCreature data in creatures)
        {
            Agent otherAgent = data.creature?.agentCreature;
            if (!otherAgent || !agent.gameObject.activeSelf || data.RegistrationDate < Time.time - 2f)
            {
                continue;
            }

            float distance = Vector3.Distance(agent.transform.position, otherAgent.transform.position);

            bool isPrey = preys.Contains(otherAgent.Creature.SpecieID);
            if (isPrey && (minDistanceFromPrey == -1 || distance < minDistanceFromPrey))
            {
                minDistanceFromPrey = distance;
                closestPrey         = otherAgent.Creature;
            }
        }

        if (minDistanceFromPrey == -1)
        {
            return(0);
        }

        float desirability = desirabilitiesConfig.AvoidPreyDesirabilityByDistance.Evaluate(1 - minDistanceFromPrey / desirabilitiesConfig.AvoidPreyConsiderationMaxDistance)
                             * desirabilitiesConfig.AvoidPreyDesirabilityTwicker
                             * (1 / ForceEvaluation.Evaluate(agent, closestPrey));

        if (agent.Thinking.ActiveGoal?.GetType() == typeof(GoalAvoidPrey))
        {
            desirability *= desirabilitiesConfig.AvoidPreyConfirmationBias;
        }

        return(desirability);
    }
Ejemplo n.º 4
0
    public override float CalculateDesirability(Agent agent, bool requested)
    {
        //TODO TEMP
        if (agent.Creature.Traits.Carnivorous >= 0.5f)
        {
            return(0);
        }

        DesirabilitiesConfig desirabilitiesConfig = GameManager.Instance.DesirabilitiesConfig;

        IReadOnlyCollection <DataCreature> creatures = agent.Memory.Creatures.Read();
        float    minDistanceFromHostil = -1;
        Creature closestHostil         = null;

        foreach (DataCreature data in creatures)
        {
            Agent otherAgent = data.creature?.agentCreature;
            if (!otherAgent || !agent.gameObject.activeSelf || data.RegistrationDate < Time.time - 2f)
            {
                continue;
            }

            float distance = Vector3.Distance(agent.transform.position, otherAgent.transform.position);

            bool isHostil = GoalEvade.CreatureIsHostil(agent, otherAgent.Creature);
            if (isHostil && (minDistanceFromHostil == -1 || distance < minDistanceFromHostil))
            {
                minDistanceFromHostil = distance;
                closestHostil         = otherAgent.Creature;
            }
        }

        if (minDistanceFromHostil == -1)
        {
            return(0);
        }

        float desirability = desirabilitiesConfig.EvadeDesirabilityByDistance.Evaluate(1 - minDistanceFromHostil / desirabilitiesConfig.EvadeConsiderationMaxDistance)
                             * desirabilitiesConfig.EvadeDesirabilityByAggressivity.Evaluate(agent.Creature.Traits.Aggressivity.Value)
                             * desirabilitiesConfig.EvadeDesirabilityTwicker
                             * (1 / ForceEvaluation.Evaluate(agent, closestHostil));

        if (agent.Thinking.ActiveGoal?.GetType() == typeof(GoalEvade))
        {
            desirability *= desirabilitiesConfig.EvadeConfirmationBias;
        }

        return(desirability);
    }
    public override float CalculateDesirability(Agent agent, bool requested)
    {
        if (Player.Instance.IsDie)
        {
            return(0);
        }

        DesirabilitiesConfig desirabilitiesConfig = GameManager.Instance.DesirabilitiesConfig;

        if (agent.Creature.Traits.Vigilance.Value < desirabilitiesConfig.DefensePlayerConsiderationMinVigilance)
        {
            return(0);
        }

        bool playerDetected = agent.Memory.Player.lastSeeTime > Time.time - 2f;

        if (!playerDetected)
        {
            return(0);
        }

        if (agent.Thinking.ActiveGoal?.GetType() != typeof(GoalDefensePlayer) &&
            agent.Memory.Player.lastObserved > Time.time - desirabilitiesConfig.DefensePlayerMinTimeRepeat)
        {
            return(0);
        }

        float distanceWithPlayer = Vector3.Distance(agent.transform.position, Player.Instance.transform.position);

        float desirability = desirabilitiesConfig.DefensePlayerDesirabilityByAggressivity.Evaluate(agent.Creature.Traits.Aggressivity.Value)
                             * desirabilitiesConfig.DefensePlayerDesirabilityByVigilance.Evaluate(agent.Creature.Traits.Vigilance.Value)
                             * desirabilitiesConfig.DefensePlayerDesirabilityTwicker
                             * ForceEvaluation.EvaluateAgainstPlayer(agent);

        if (agent.Thinking.ActiveGoal?.GetType() == typeof(GoalDefensePlayer))
        {
            desirability *= desirabilitiesConfig.DefensePlayerConfirmationBias;
        }

        if (GoalEatInPlayerHand_Evaluator.Instance.IsPlayerWantGiveFood())
        {
            desirability *= desirabilitiesConfig.DefensePlayerDesirabilityTwickerWithFoodHolder;
        }

        return(desirability);
    }
    public override float CalculateDesirability(Agent agent, bool requested)
    {
        if (Player.Instance.IsDie)
        {
            return(0);
        }

        DesirabilitiesConfig desirabilitiesConfig = GameManager.Instance.DesirabilitiesConfig;

        if (agent.Creature.Traits.Vigilance.Value > desirabilitiesConfig.ProtectPlayerConsiderationMaxVigilance)
        {
            return(0);
        }

        bool playerDetected = agent.Memory.Player.lastSeeTime > Time.time - 1f;

        if (!playerDetected)
        {
            return(0);
        }

        IReadOnlyCollection <DataCreature> creatures = agent.Memory.Creatures.Read();
        float    minDistanceFromHostil = -1;
        Creature closestHostil         = null;

        foreach (DataCreature data in creatures)
        {
            Agent otherAgent = data.creature?.agentCreature;
            if (!otherAgent || !otherAgent.gameObject.activeSelf || data.RegistrationDate < Time.time - 1f)
            {
                continue;
            }

            if (otherAgent.Creature.SpecieID == agent.Creature.SpecieID)
            {
                continue;
            }

            if (otherAgent.Thinking.ActiveGoal?.GetType() == typeof(GoalTired))
            {
                continue;
            }

            Goal goal = otherAgent.Thinking.ActiveGoal;
            if (!(goal is GoalDefensePlayer))
            {
                continue;
            }

            Goal subGoal = (goal as GoalComposite).GetActiveGoal();
            if (subGoal == null || (!(subGoal is GoalPursuitPlayer) && !(subGoal is GoalAttackPlayer)))
            {
                continue;
            }

            float distance = Vector3.Distance(agent.transform.position, otherAgent.transform.position);

            if (minDistanceFromHostil == -1 || distance < minDistanceFromHostil)
            {
                minDistanceFromHostil = distance;
                closestHostil         = otherAgent.Creature;
            }
        }

        if (minDistanceFromHostil == -1)
        {
            return(0);
        }

        float desirability = desirabilitiesConfig.ProtectPlayerDesirabilityByAggressivity.Evaluate(agent.Creature.Traits.Aggressivity.Value)
                             * desirabilitiesConfig.ProtectPlayerDesirabilityByVigilance.Evaluate(agent.Creature.Traits.Vigilance.Value)
                             * desirabilitiesConfig.ProtectPlayerDesirabilityTwicker
                             * ForceEvaluation.Evaluate(agent, closestHostil);

        if (agent.Thinking.ActiveGoal?.GetType() == typeof(GoalProtectPlayer))
        {
            desirability *= desirabilitiesConfig.ProtectPlayerConfirmationBias;
        }

        return(desirability);
    }