Example #1
0
        private static void UseAbilityTempEffect(BattleGame game,GameCharacter character, Tile target, Ability ability)
        {

            foreach (var ae in ability.activeEffects)
            {
                switch (ae.effectType)
                {
                    case TempEffectType.Particle:
                        game.gameControllerScript.StartTempParticles(ae.effectName, new UnityEngine.Vector3(target.x, -target.y));
                        break;
                    case TempEffectType.Sprite:
                        var spriteVector = new UnityEngine.Vector3(target.x, -target.y);
                        game.gameControllerScript.StartTempSprite(spriteVector, spriteVector, ae.effectName, ae.effectIndex);
                        break;
                    case TempEffectType.Text:
                        game.gameControllerScript.StartTempText(new UnityEngine.Vector3(target.x, -target.y), UnityEngine.Color.grey, ability.name);
                        break;
                    case TempEffectType.ProjectileSprite:
                        var spriteVector1 = new UnityEngine.Vector3(game.ActiveCharacter.x, -game.ActiveCharacter.y);
                        var spriteVector2 = new UnityEngine.Vector3(target.x, -target.y);

                        game.gameControllerScript.StartTempSpriteProjectile(spriteVector1, spriteVector2, ae.effectName, ae.effectIndex);
                      
                         break;
                    default:
                         break;
                }
            }

        }
Example #2
0
        private static bool UseAbilityLOSEmpty(GameCharacter character, Ability ability, Tile target, BattleGame game)
        {
            if (target.empty)
            {
                return UseAbilityLOS(character, ability, target, game);
            }

            return false;

        }
Example #3
0
        public static Ability getAbilityFromAbilityData(AbilityData data, Dictionary<long, EffectData> effectDataDictionary)
        {
            Ability ability = new Ability(){
                ap = data.ap,
                description = data.description,
                ID = data.ID,
                name = data.name,
                range = data.range,
                sheetname = data.sheetname,
                spriteindex = data.spriteindex,
                targetType = data.targetType,
                tilePatternType = data.tilePatternType,
                cooldown = data.cooldown
            };

            if (data.activeEffects.Count > 0)
            {
                List<ActiveEffect> aeList = new List<ActiveEffect>(); 

                foreach (long l in data.activeEffects)
                {
                    if(effectDataDictionary.ContainsKey(l)){
                        aeList.Add(getActiveEffectFromEffectData(effectDataDictionary[l]));
                    }
                   
                }
                ability.activeEffects = aeList;
            }

            if (data.passiveEffects.Count > 0)
            {
                List<PassiveEffect> peList = new List<PassiveEffect>();

                foreach (long l in data.passiveEffects)
                {
                    if (effectDataDictionary.ContainsKey(l))
                    {
                        peList.Add(getPassiveEffectFromEffectData(effectDataDictionary[l]));
                    }

                }
                ability.passiveEffects = peList;
            }

            return ability;
        }
Example #4
0
        private static bool UseAbilityLOS(GameCharacter character, Ability ability, Tile target, BattleGame game)
        {
            Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);
            var tileLOSList = game.board.getBoardLOS(ActiveTile, target);

            if (tileLOSList.Count <= ability.range && tileLOSList[tileLOSList.Count - 1] == target)
            {
                if (character.SpendAP(ability.ap))
                {
                    return UseAbilityAOEHelper(character, ability, target, game);
                }
                return false;
            }
            else
            {
                return false;
            }

        }
Example #5
0
        private static bool UseAbilityAOEHelper(GameCharacter character, Ability ability, Tile target, BattleGame game)
        {

            var tileAOEList = game.board.getTileListFromPattern(target, ability.tilePatternType);

            //draw AOE effect
            foreach (var t in tileAOEList)
            {
                game.board.AddTempChar(t, '*');
                game.board.AddTempEffect(t, ability.sheetname, ability.spriteindex);


                UseAbilityTempEffect(game, character, t, ability);

            }

            var charAOEList = game.getCharactersFromTileList(tileAOEList);

            return UseAbilityOnCharList(character,target, ability, charAOEList, game);

        }
Example #6
0
        private static void UseAbilityTempEffect(BattleGame game, GameCharacter character, GameCharacter target, Ability ability)
        {
            Tile targetTile = game.board.getTileFromPoint(new Point(target.x, target.y));
            UseAbilityTempEffect(game, character, targetTile, ability);

        }
Example #7
0
 //JSON.NET not available in Unity by default
 //NEED TO FIND FIX, OR PAY FOR JSON.NET IN UNITY
 public static Ability cloneAbility(Ability a)
 {
     return a;
     //return JsonConvert.DeserializeObject<Ability>(JsonConvert.SerializeObject(a));
 }
Example #8
0
 public static bool UseAbility(GameCharacter character, Ability ability, Tile target, BattleGame game)
 {
     bool useValue = false;
     if (ability.cooldownTimer == 0)
     {
         switch (ability.targetType)
         {
             case AbilityTargetType.Self:
                 useValue= UseAbilitySelf(character, ability, target, game);
                 break;
             case AbilityTargetType.SingleFriend:
                 useValue= UseAbilitySingleFriend(character, ability, target, game);
                 break;
             case AbilityTargetType.SingleFoe:
                 useValue= UseAbilitySingleFoe(character, ability, target, game);
                 break;
             case AbilityTargetType.AllFriends:
                 useValue= UseAbilityAllFriends(character, ability, target, game);
                 break;
             case AbilityTargetType.AllFoes:
                 useValue = UseAbilityAllFoes(character, ability, target, game);
                 break;
             case AbilityTargetType.PointEmpty:
                 useValue = UseAbilityPointEmpty(character, ability, target, game);
                 break;
             case AbilityTargetType.PointTarget:
                 useValue = UseAbilityPoint(character, ability, target, game);
                 break;
             case AbilityTargetType.LOSEmpty:
                 useValue = UseAbilityLOSEmpty(character, ability, target, game);
                 break;
             case AbilityTargetType.LOSTarget:
                 useValue = UseAbilityLOS(character, ability, target, game);
                 break;
             default:
                 useValue = false;
                 break;
         }
     }
     if (useValue)
     {
         ability.cooldownTimer = ability.cooldown;
     }
     return useValue;
 }
Example #9
0
 private static bool UseAbilitySelf(GameCharacter character, Ability ability, Tile target, BattleGame game)
 {
     if (character.SpendAP(ability.ap))
     {
         return UseAbilityOnCharList(character,target, ability, new List<GameCharacter>() { character }, game);
     }
     else
     {
         return false;
     }
 }
Example #10
0
 private static bool UseAbilitySingleFoe(GameCharacter character, Ability ability, Tile target, BattleGame game)
 {
     if (character.SpendAP(ability.ap))
     {
         GameCharacter targetChar = game.getCharacterFromTile(target);
         if (targetChar != null & targetChar.type != character.type)
         {
             return UseAbilityOnCharList(character,target, ability, new List<GameCharacter>() { targetChar }, game);
         }
     }
     return false;
 }
Example #11
0
        private static bool UseAbilityAllFoes(GameCharacter character, Ability ability, Tile target, BattleGame game)
        {
            if (character.SpendAP(ability.ap))
            {
                var foeList = from data in game.characterList
                              where data.type != character.type
                              select data;

                return UseAbilityOnCharList(character,target, ability, foeList.ToList(), game);
            }
            else
            {
                return false;
            }
        }
Example #12
0
        private static bool UseAbilityPoint(GameCharacter character, Ability ability, Tile target, BattleGame game)
        {
            Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);

            int dist = PlotLine.GetPointsOnLine(character.x, character.y, target.x, target.y).Count()-1;

            if(dist <= ability.range)
            {
                if (character.SpendAP(ability.ap))
                {
                    return UseAbilityAOEHelper(character, ability, target, game);
                }
            }
            return false;
        }
Example #13
0
        private static bool UseAbilityOnCharList(GameCharacter sourceCharacter, Tile target, Ability ability, List<GameCharacter> characterList, BattleGame game)
        {

            //Draw Temp Character
             game.board.AddTempChar(target, 'X');
             game.board.AddTempEffect(target, ability.sheetname, ability.spriteindex);



            foreach(var c in characterList)
            {
                UseAbilityTempEffect(game, sourceCharacter, c, ability);
            }
             


            //special conditions if we're doing something on sourceCharacter
            if(characterList.Count ==0)
            {
                foreach (var ae in ability.activeEffects)
                {
                    if (ae.statType == StatType.Teleport)
                    {
                        game.board.MoveCharacterFree(sourceCharacter, target);
                    }
                }
            }

            foreach (var character in characterList)
            {
                foreach (var ae in ability.activeEffects)
                {
                    if (ae.statType == StatType.Teleport)
                    {
                        game.board.MoveCharacterFree(sourceCharacter, target); //for now, can only teleport self.
                    }
                    else if (ae.statType == StatType.Knockback) //move away from sourceCharacter
                    {
                        Tile sourceTile = game.board.getTileFromLocation(sourceCharacter.x, sourceCharacter.y);
                        Tile charTile = game.board.getTileFromLocation(character.x, character.y);
                        List<Tile> moveTargetList = game.board.getMoveTargetTileList(sourceTile, charTile, ae.minAmount);

                        if (moveTargetList.Count > 0)
                        {
                            Tile moveTile = moveTargetList[moveTargetList.Count - 1];
                            game.board.MoveCharacterFree(character, moveTile);
                        }
                    }
                    else if(ae.statType == StatType.Explode) //move away from target
                    {
                        Tile charTile = game.board.getTileFromLocation(character.x, character.y);
                        List<Tile> moveTargetList = game.board.getMoveTargetTileList(target, charTile, ae.minAmount);
                        if (moveTargetList.Count > 0)
                        {
                            Tile moveTile = moveTargetList[moveTargetList.Count - 1];
                            game.board.MoveCharacterFree(character, moveTile);
                        }
                    }
                    else
                    {
                        character.AddActiveEffect(cloneActiveEffect(ae), game);
                    }
                }
            }

            return true;
        }
Example #14
0
        public bool UseAbility(GameCharacter character, Ability ability, Tile target)
        {
            if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
            {
                if (character.abilityList.Contains(ability))
                {
                    if (AbilityHelper.UseAbility(character, ability, target, this))
                    {
                        battleLog.AddEntry(string.Format("{0} used {1}", character.name, ability.name));
                        return true;
                    }
                    else
                    {
                        battleLog.AddEntry(string.Format("{0} failed to use {1}", character.name, ability.name));
                    }
                }
            }
            else
            {
                battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, ability.name));
            }

            return false;
        }
Example #15
0
        public List<BattleAction> getAbilityActionList(Ability a, int x, int y)
        {
            List<BattleAction> actionList = new List<BattleAction>();
            actionList.Add(new BattleAction() { character = ActiveCharacter, actionType = BattleActionType.UseAbility, ability = a, targetTile = board.getTileFromLocation(x, y) });

            return actionList;
        }