Example #1
0
        public static void InitializeTargeting(Character originatingChar, Ability castedAbility, PlayState playState)
        {
            //change playState mode to targeting
            playState.playMode = PlayState.Mode.targeting;
            playState.abilityBeingTargeted = castedAbility;

            if(castedAbility is CharAbility)
            {
                InitializeTargetingCharAbility(originatingChar, (CharAbility)castedAbility, playState);
            }
        }
Example #2
0
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();

            battleMap = Map.buildDefaultMap(20, 20); //build map

            playState = new PlayState(battleMap);
            playState.viewportWidth = graphics.GraphicsDevice.Viewport.Width;
            playState.viewportHeight = graphics.GraphicsDevice.Viewport.Height;

            /*allCover = Cover.createTestCover(battleMap);
            allies = Character.createTestAllies(5, battleMap);
            enemies = Character.createTestEnemies(5, battleMap); //create teams of characters

            allCharacters.AddRange(allies);
            allCharacters.AddRange(enemies);

            playerTurn = true;*/

            gameCamera = new Camera(); //create camera

            mapWidth = battleMap.mapWidthInTiles();
            mapHeight = battleMap.mapHeightInTiles();
        }
Example #3
0
        public static void InitializeTargetingCharAbility(Character originatingChar, CharAbility castedAbility, PlayState playstate)
        {
            List<Character> potentialTargets = new List<Character>();

            switch (castedAbility.abilityPossibleTargets)
            {
                case (AbilityPosibleTargets.singleAlly):
                    if (castedAbility.limitedByRange) {
                        potentialTargets = GetCharatersInAbilityRange(originatingChar, castedAbility, playstate);
                        if (potentialTargets.Count > 0)
                        {
                            playstate.charactersTargeted = new List<Character> { potentialTargets[0] };
                            playstate.potentialTargets = potentialTargets;
                        }
                    }else {
                        playstate.charactersTargeted = new List<Character> { playstate.allies[0] };
                        playstate.potentialTargets = playstate.allies;
                    }
                    break;

                case (AbilityPosibleTargets.singleEnemy):
                    if (castedAbility.limitedByRange)
                    {
                        potentialTargets = GetCharatersInAbilityRange(originatingChar, castedAbility, playstate);
                        if (potentialTargets.Count > 0)
                        {
                            playstate.charactersTargeted = new List<Character> { potentialTargets[0] };
                            playstate.potentialTargets = potentialTargets;
                        }
                    }
                    else
                    {
                        playstate.charactersTargeted = new List<Character> { playstate.enemies[0] };
                        playstate.potentialTargets = playstate.enemies;
                    }
                    break;
                case (AbilityPosibleTargets.allAllies):
                    playstate.charactersTargeted = playstate.allies;
                    playstate.potentialTargets = playstate.allies;
                    break;
                case (AbilityPosibleTargets.allEnemies):
                    playstate.charactersTargeted = playstate.enemies;
                    playstate.potentialTargets = playstate.enemies;
                    break;
                case (AbilityPosibleTargets.allInRange):
                    potentialTargets = GetCharatersInAbilityRange(originatingChar, castedAbility, playstate);
                        if (potentialTargets.Count > 0)
                        {
                            playstate.charactersTargeted = new List<Character> { potentialTargets[0] };
                            playstate.potentialTargets = potentialTargets;
                        }
                    break;
                case (AbilityPosibleTargets.global):
                    playstate.charactersTargeted = playstate.allCharacters;
                    playstate.potentialTargets = playstate.allCharacters;
                    break;
                case (AbilityPosibleTargets.singleChar):
                    if (castedAbility.limitedByRange)
                    {
                        potentialTargets = GetCharatersInAbilityRange(originatingChar, castedAbility, playstate);
                        if (potentialTargets.Count > 0)
                        {
                            playstate.charactersTargeted = new List<Character> { potentialTargets[0] };
                            playstate.potentialTargets = potentialTargets;
                        }
                    }
                    else
                    {
                        playstate.charactersTargeted = new List<Character> { playstate.allCharacters[0] };
                        playstate.potentialTargets = playstate.allCharacters;
                    }
                    break;
            }
        }
Example #4
0
        public static List<Character> GetCharatersInAbilityRange(Character originatingChar, CharAbility castedAbility, PlayState playstate)
        {
            //get subset of tiles in range of ability via the distance formula
            //boundaries of square to search defined by ability range

            int rangeToSearch = castedAbility.range;
            List<Tile> tilesInAbilityRange = new List<Tile>();
            List<Character> charactersInAbilityRange = new List<Character>();

            int castingCharacterPosX = (int)originatingChar.position.X;
            int castingCharacterPosY = (int)originatingChar.position.Y;

            int minimumXtoSearch = (int)originatingChar.position.X - rangeToSearch;
            int maximumXtoSearch = (int)originatingChar.position.X + rangeToSearch;
            int minimumYtoSearch = (int)originatingChar.position.Y - rangeToSearch;
            int maximumYtoSearch = (int)originatingChar.position.Y + rangeToSearch;

            if (minimumXtoSearch < 1)
                minimumXtoSearch = 1;

            if (minimumYtoSearch < 0)
                minimumYtoSearch = 1;

            if (maximumXtoSearch > playstate.currentMap.mapWidthInTiles()-1)
                maximumXtoSearch = playstate.currentMap.mapWidthInTiles()-1;

            if (maximumYtoSearch > playstate.currentMap.mapHeightInTiles()-1)
                maximumYtoSearch = playstate.currentMap.mapHeightInTiles()-1;

            for (int x = 0; x <= rangeToSearch; x++)
            {
                for (int y = 0; y <= rangeToSearch; y++)
                {
                    if (x >= minimumXtoSearch && x <= maximumXtoSearch && y >= minimumYtoSearch && y <= maximumYtoSearch)
                    {
                        int distanceFromSource = Math.Abs(castingCharacterPosX - x) + Math.Abs(castingCharacterPosY - y);
                        if (distanceFromSource <= rangeToSearch)
                        {
                            //this tile is in range - add it to the list. Also check to see if it has a character, and if so, add it as a viable target
                            Tile currentTile = playstate.currentMap.tiles[x, y];
                            tilesInAbilityRange.Add(currentTile);
                            Character currentChar = null;
                            if (castedAbility.abilityPossibleTargets == AbilityPosibleTargets.singleChar || castedAbility.abilityPossibleTargets == AbilityPosibleTargets.allInRange)
                            {
                                currentChar = playstate.allCharacters.Find(character => (int)character.position.X == x && (int)character.position.Y == y);
                            }
                            else if (castedAbility.abilityPossibleTargets == AbilityPosibleTargets.singleAlly)
                            {
                                currentChar = playstate.allies.Find(character => (int)character.position.X == x && (int)character.position.Y == y);
                            }
                            else if (castedAbility.abilityPossibleTargets == AbilityPosibleTargets.singleEnemy)
                            {
                                currentChar = playstate.enemies.Find(character => (int)character.position.X == x && (int)character.position.Y == y);
                            }

                            if (currentChar != null)
                            {
                                charactersInAbilityRange.Add(currentChar);
                            }
                        }
                    }
                }
            }

            if (charactersInAbilityRange.Count > 0)
            {
                //if characters can be targeted, we wil want to draw the targeting range
                playstate.tilesInAbilityRange = tilesInAbilityRange;
            }

            return charactersInAbilityRange;
        }