Esempio n. 1
0
    private BestSkill EvaluateBestSkillToUse(int WeaponSlotID)
    {
        DecisionMaker.AIDecision BestSkillDecision = new DecisionMaker.AIDecision
        {
            Score = IdleSkillScore
        };

        DecisionMaker.AIDecision TempSkillDecision = new DecisionMaker.AIDecision();

        BestSkill BestSkillID = new BestSkill();

        BestSkillID.SkillID = -1;

        int TwoHandedModifier = 0;

        if (TwoHandedWeaponEquipped)
        {
            TwoHandedModifier = 1;
        }

        for (int sk = WeaponSlotID * SkillsPerWeapon; sk < (WeaponSlotID + 1 + TwoHandedModifier) * SkillsPerWeapon; sk++)
        {
            if (ItemSkillSlots[sk])
            {
                TempSkillDecision = ItemSkillSlots[sk].AICalculateSkillScoreAndApplication();

                if (TempSkillDecision.Score > BestSkillDecision.Score)
                {
                    BestSkillDecision   = TempSkillDecision;
                    BestSkillID.SkillID = sk;
                    BestSkillID.Score   = BestSkillDecision.Score;
                }
            }
        }

        return(BestSkillID);
    }
Esempio n. 2
0
    // ========================================= AI =========================================

    public void DecideSkillUse()
    {
        if (SkillCurrentlyActivating[0] >= 0 || !WeaponSlots[0])
        {
            if (SkillCurrentlyActivating[1] < 0)
            {
                DecideSkillUse(1);
                return;
            }
            return;
        }
        else if (SkillCurrentlyActivating[1] >= 0 || !WeaponSlots[1])
        {
            if (SkillCurrentlyActivating[0] < 0)
            {
                DecideSkillUse(0);
                return;
            }
            return;
        }

        if (IdleTimer[0] > 0)
        {
            IdleTimer[0] -= Time.deltaTime;
        }
        if (IdleTimer[1] > 0)
        {
            IdleTimer[1] -= Time.deltaTime;
        }
        if (IdleTimer[0] > 0 || IdleTimer[1] > 0)
        {
            return;
        }

        BestSkill[] BestSkills       = new BestSkill[2];
        BestSkill   CurrentBestSkill = new BestSkill
        {
            Score = -1
        };

        int WeaponSlotID = -1;

        for (int i = 0; i < BestSkills.Length; i++)
        {
            BestSkills[i] = EvaluateBestSkillToUse(i);
        }

        for (int i = 0; i < BestSkills.Length; i++)
        {
            if (BestSkills[i].Score > CurrentBestSkill.Score)
            {
                CurrentBestSkill = BestSkills[i];
                WeaponSlotID     = i;
            }
        }

        if (CurrentBestSkill.SkillID >= 0)
        {
            SkillEvaluationCycleTimers[WeaponSlotID] = ItemSkillSlots[CurrentBestSkill.SkillID].AIGetSkillEvaluationCycle();
            SkillContinueActivation[WeaponSlotID]    = true;

            SensibleSkillActivationTimes[WeaponSlotID] = ItemSkillSlots[CurrentBestSkill.SkillID].AIGetSensibleActivationTime();
            StartSkillActivation(CurrentBestSkill.SkillID);
        }
        else
        {
            IdleTimer[0] = IdleDuration;
            IdleTimer[1] = IdleDuration;
        }
    }