コード例 #1
0
ファイル: AIManager.cs プロジェクト: Epicepicness/GDV3---AI
    // Checks for each unit to see if it could potentially be reached, and if so adds to the lists.
    private void ScanForUnits()
    {
        //@todo Unit scan doesn't consider "faction" yet, in case you want to use it for player-friendly units as well
        Unit currentUnit = unitManager.currentTurnUnit;

        int maxDistance = currentUnit.unitStats.movementDistance + 6;           //@todo Replace the +6 with the longest-range ability the unit has

        // Getting Friendly units
        //@todo only do so if the current AI unit has beneficial spells that can be cast on allies; do so during the
        foreach (Unit attemptUnit in unitManager.tempEnemyUnitList)
        {
            if (currentUnit.Equals(attemptUnit))                // If the unit is itself
            {
                self = new OtherUnit(attemptUnit, 0, null, true);
                friendlyUnits.Add(self);
                continue;
            }

            int unitDistance = LandTileMap.instance.GetTileDistance(currentUnit.currentTile, attemptUnit.currentTile);
            if (maxDistance >= unitDistance)
            {
                OtherUnit otherUnit;

                LandTile [] pathTowards = LandTileMap.instance.RequestPath(currentUnit.currentTile, attemptUnit.currentTile, currentUnit.unitStats.canMoveDiagonally, false);
                if (pathTowards.Length != 0 && pathTowards.Length <= currentUnit.unitStats.movementDistance)
                {
                    otherUnit = new OtherUnit(attemptUnit, unitDistance, pathTowards, true);
                }
                else                        // No path or out of our movement range means there's no walkable path
                {
                    otherUnit = new OtherUnit(attemptUnit, unitDistance, pathTowards);
                }

                friendlyUnits.Add(otherUnit);
            }
        }

        // Getting Hostile units
        foreach (Unit attemptUnit in unitManager.tempFriendlyUnitList)
        {
            int unitDistance = LandTileMap.instance.GetTileDistance(currentUnit.currentTile, attemptUnit.currentTile);
            if (maxDistance >= unitDistance)
            {
                OtherUnit otherUnit;

                LandTile [] pathTowards = LandTileMap.instance.RequestPath(currentUnit.currentTile, attemptUnit.currentTile, currentUnit.unitStats.canMoveDiagonally, false);
                if (pathTowards.Length != 0 && pathTowards.Length <= currentUnit.unitStats.movementDistance)
                {
                    otherUnit = new OtherUnit(attemptUnit, unitDistance, pathTowards, true);
                }
                else                        // No path or out of our movement range means there's no walkable path
                {
                    otherUnit = new OtherUnit(attemptUnit, unitDistance, pathTowards);
                }

                enemyUnits.Add(otherUnit);
            }
        }
    }
コード例 #2
0
ファイル: AIAction.cs プロジェクト: Epicepicness/GDV3---AI
    public AIAttackAction(OtherUnit targetUnit, int score, LandTile tileToMoveTo = null)
    {
        this.targetUnit = targetUnit;
        this.score      = score;

        if (tileToMoveTo == null)
        {
            return;
        }
        this.tileToMoveTo = tileToMoveTo;
        requiresMovement  = true;
    }
コード例 #3
0
ファイル: AIAction.cs プロジェクト: Epicepicness/GDV3---AI
    public AIAbilityAction(OtherUnit targetUnit, Ability abilityToUse, int score, LandTile tileToMoveTo = null)
    {
        this.targetUnit   = targetUnit;
        this.abilityToUse = abilityToUse;
        this.score        = score;

        if (tileToMoveTo == null)
        {
            return;
        }
        this.tileToMoveTo = tileToMoveTo;
        requiresMovement  = true;
    }
コード例 #4
0
ファイル: AIManager.cs プロジェクト: Epicepicness/GDV3---AI
    private LandTile FindPointToMoveTo()
    {
        //@todo Does adding a "is being threatened" tag to tiles improve this performance-wise?
        //@todo Has the option of returning its current position

        Unit currentUnit = unitManager.currentTurnUnit;

        LandTile [] possibleTiles = LandTileMap.instance.RequestRange(currentUnit.transform.position, currentUnit.unitStats.movementDistance, currentUnit.unitStats.canMoveDiagonally, true, false, false);
        if (possibleTiles.Length == 0)
        {
            return(null);
        }

        LandTile tileToMoveTo = null;

        if (enemyUnits.Count != 0)
        {
            // Am I ranged/wizard? Move away from closest target
            //@todo Find way of recognizing spellcasters/healers etc. Could be class-based, but not preferable. If Intelligence>Attack?
            if (currentUnit.unitStats.attackRange > 1 || currentUnit.unitStats.intelligence > currentUnit.unitStats.attackPower)
            {
                int [] tileScores  = new int [possibleTiles.Length];
                int    lowestValue = 9999;
                int    lowestIndex = 0;

                for (int i = 0; i < possibleTiles.Length; i++)                      // Calculates the 'safest' spot by adding up the tile's distance to each enemy and picking the lowest
                {
                    foreach (OtherUnit enemy in enemyUnits)                         //@todo Better ways to do this?
                    {
                        tileScores [i] += LandTileMap.instance.GetTileDistance(currentUnit.currentTile, enemy.unit.currentTile);
                        if (tileScores [i] < lowestValue)
                        {
                            lowestValue = tileScores [i];
                            lowestIndex = i;
                        }
                    }
                }

                return(tileToMoveTo = possibleTiles [lowestIndex]);
            }

            int       lowestHealth      = 9999;
            OtherUnit lowestHealthEnemy = null;
            // Scan for lowest health enemy, move towards that one
            foreach (OtherUnit enemy in enemyUnits)
            {
                if (enemy.canReach && enemy.unit.unitStats.currentHealth < lowestHealth)
                {
                    LandTile testingTile = enemy.pathToTarget [Mathf.Clamp(enemy.pathToTarget.Length - 2, 0, enemy.pathToTarget.Length - 1)];
                    if ((possibleTiles.Contains <LandTile> (testingTile) || currentUnit.currentTile == testingTile) && testingTile.unitOnTile == null)
                    {
                        lowestHealthEnemy = enemy;
                        lowestHealth      = enemy.unit.unitStats.currentHealth;
                    }
                }
            }
            if (lowestHealthEnemy != null)
            {
                if (LandTileMap.instance.GetTileDistance(currentUnit.currentTile, lowestHealthEnemy.unit.currentTile) < currentUnit.unitStats.attackRange)
                {
                    return(null);                       // if we're already in range of the lowest health unit; we don't have to move.
                }
                else
                {
                    return(tileToMoveTo = lowestHealthEnemy.pathToTarget [Mathf.Clamp(lowestHealthEnemy.pathToTarget.Length - 2, 0, lowestHealthEnemy.pathToTarget.Length)]);
                }
            }

            // If there were no possible enemies to path to, move in the general direction of one
            //@todo doesn't consider movement costs yet
            if (tileToMoveTo == null)
            {
                for (int i = 0; i < enemyUnits.Count - 1; i++)
                {
                    int random = Random.Range(i, enemyUnits.Count);
                    if (enemyUnits [random].pathToTarget != null && enemyUnits[random].pathToTarget.Length != 0)
                    {
                        tileToMoveTo = enemyUnits [random].pathToTarget [Mathf.Clamp(currentUnit.unitStats.movementDistance, 0, enemyUnits [random].pathToTarget.Length - 1)];

                        break;
                    }
                }
            }
        }

        // If all else fails, pick a random tile within movement range
        if (tileToMoveTo == null)
        {
            tileToMoveTo = possibleTiles [Random.Range(0, possibleTiles.Length - 1)];
        }

        return(tileToMoveTo);
    }