Example #1
0
    public DecisionMaker.AIDecision AICalculateSkillScoreAndApplication(ItemSkill SourceItemSkill, Character Owner)
    {
        DecisionMaker.AIDecision SkillApp;

        if (!CheckIfSkillCouldBeActivated(SourceItemSkill, Owner))
        {
            SkillApp = new DecisionMaker.AIDecision
            {
                Score = -1
            };

            return(SkillApp);
        }

        SkillApp = AIDecisionMaker.CalculateTotalScore(Owner, SourceItemSkill);

        return(SkillApp);
    }
Example #2
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);
    }
Example #3
0
    public void DecideMovePattern()
    {
        /*       if (MovePatternEvaluationCycleTimer > 0)
         *     {
         *         MovePatternEvaluationCycleTimer -= Time.deltaTime;
         *         return;
         *     }*/
/*
 *      if (IdleMoveTimer > 0)
 *      {
 *          IdleMoveTimer -= Time.deltaTime;
 *          return;
 *      }*/

        DecisionMaker.AIDecision BestMovePatternDecision = new DecisionMaker.AIDecision
        {
            Score = IdleSkillScore
        };

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

        // Go through basic move patterns:
        for (int mp = 0; mp < MovePatterns.Length; mp++)
        {
            TempMovePatternDecision = MovePatterns[mp].AICalculateMovePatternScore(this);

            if (TempMovePatternDecision.Score > BestMovePatternDecision.Score)
            {
                BestMovePatternDecision = TempMovePatternDecision;
                ActiveMovePattern       = MovePatterns[mp];
                TargetCharacter         = BestMovePatternDecision.TargetCharacter;
            }
        }

        // Go through weapon move patterns:
        MovePattern[] WeaponMovePatterns;

        for (int i = 0; i < WeaponSlots.Length; i++)
        {
            if (WeaponSlots[i])
            {
                WeaponMovePatterns = WeaponSlots[i].GetMovePatterns();

                for (int j = 0; j < WeaponMovePatterns.Length; j++)
                {
                    TempMovePatternDecision = WeaponMovePatterns[j].AICalculateMovePatternScore(this);

                    if (TempMovePatternDecision.Score > BestMovePatternDecision.Score)
                    {
                        BestMovePatternDecision = TempMovePatternDecision;
                        ActiveMovePattern       = WeaponMovePatterns[j];
                        TargetCharacter         = BestMovePatternDecision.TargetCharacter;
                    }
                }
            }
        }

        // Go through skill move patterns:
        MovePattern[] SkillMovePatterns;

        for (int i = 0; i < SkillCurrentlyActivating.Length; i++)
        {
            if (SkillCurrentlyActivating[i] >= 0)
            {
                SkillMovePatterns = ItemSkillSlots[SkillCurrentlyActivating[i]].AIGetSkillMovePatterns();

                for (int mp = 0; mp < SkillMovePatterns.Length; mp++)
                {
                    TempMovePatternDecision = SkillMovePatterns[mp].AICalculateMovePatternScore(this);

                    if (TempMovePatternDecision.Score > BestMovePatternDecision.Score)
                    {
                        BestMovePatternDecision = TempMovePatternDecision;
                        ActiveMovePattern       = SkillMovePatterns[mp];
                        TargetCharacter         = BestMovePatternDecision.TargetCharacter;
                    }
                }
            }
        }

        MovePatternEvaluationCycleTimer = MovePatternEvaluationCycle;
    }