public override void ConfirmTarget()
        {
            Type type = typeof(StimulatorAbility);
            StimulatorAbility stimulatorAbility = (StimulatorAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                stimulatorAbility.SetProperties("Stimulator",
                                                "Heal 25 hp. Applies \"Stimulator\"", 2, 0, 4, 4, true);
                stimulatorAbility.battleManager = battleManager;
                stimulatorAbility.targetBC      = targetForAttack;
                stimulatorAbility.attackerBC    = currentCharControl;
                stimulatorAbility.origin        = originForAttack;
                stimulatorAbility.destination   = destinationForAttcak;

                currentCharControl.SetCD(typeof(StimulatorTargetingController), 4);
                currentCharControl.DeltaAP(-2);

                stimulatorAbility.initiated = true;

                battleManager.eventQueue.Add(stimulatorAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
        public override void ConfirmTarget()
        {
            //Rewrite
            Type         type         = typeof(FlareAbility);
            FlareAbility flareAbility = (FlareAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                flareAbility.SetProperties("Flare",
                                           "Deals 25 damage and applies \"Burn\"", 2, 2, 4, 4, true);
                flareAbility.battleManager = battleManager;
                flareAbility.targetBC      = targetForAttack;
                flareAbility.attackerBC    = currentCharControl;
                flareAbility.origin        = originForAttack;
                flareAbility.destination   = destinationForAttcak;

                currentCharControl.SetCD(typeof(FlareTargetingController), 4);
                currentCharControl.DeltaAP(-2);
                currentCharControl.DeltaEP(-2);

                flareAbility.initiated = true;

                battleManager.eventQueue.Add(flareAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
Beispiel #3
0
        public override void ConfirmTarget()
        {
            Type            type            = typeof(OverloadAbility);
            OverloadAbility overloadAbility = (OverloadAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                overloadAbility.SetProperties("Overload",
                                              "Zapps target, dealing 20 damage and applying \"Shocked\" status for 2 turns", 2, 1, 2, 2, true);
                overloadAbility.battleManager = battleManager;
                overloadAbility.target        = targetForAttack;

                currentCharControl.SetCD(typeof(OverloadTargetingController), 3);
                currentCharControl.DeltaAP(-2);
                currentCharControl.DeltaEP(-1);

                overloadAbility.initiated = true;

                battleManager.eventQueue.Add(overloadAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
        public override void ConfirmTarget()
        {
            //Rewrite
            Type type = typeof(SniperShotAbility);
            SniperShotAbility sniperShotAbility = (SniperShotAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                sniperShotAbility.SetProperties("Sniper Shot",
                                                "Deals 20 damage and freezes target", 4, 0, 4, 4, true);
                sniperShotAbility.battleManager = battleManager;
                sniperShotAbility.targetBC      = targetForAttack;
                sniperShotAbility.attackerBC    = currentCharControl;
                sniperShotAbility.origin        = originForAttack;
                sniperShotAbility.destination   = destinationForAttcak;

                currentCharControl.SetCD(typeof(SniperShotTargetingController), 4);
                currentCharControl.DeltaAP(-4);

                sniperShotAbility.initiated = true;

                battleManager.eventQueue.Add(sniperShotAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
Beispiel #5
0
        public override void ConfirmTarget()
        {
            //Rewrite
            Type type = typeof(VulnerabilityScanAbility);
            VulnerabilityScanAbility vulnerabilityScanAbility = (VulnerabilityScanAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                vulnerabilityScanAbility.SetProperties("Vulnerability Scan",
                                                       "Scans target for weaknesses, lowering damage resistance by 25%", 2, 3, 4, 4, true);
                vulnerabilityScanAbility.battleManager = battleManager;
                vulnerabilityScanAbility.targetBC      = targetForAttack;
                vulnerabilityScanAbility.attackerBC    = currentCharControl;
                vulnerabilityScanAbility.origin        = originForAttack;
                vulnerabilityScanAbility.destination   = destinationForAttcak;

                currentCharControl.SetCD(typeof(VulnerabilityScanTargetingController), 4);
                currentCharControl.DeltaAP(-2);
                currentCharControl.DeltaEP(-3);

                vulnerabilityScanAbility.initiated = true;

                battleManager.eventQueue.Add(vulnerabilityScanAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
        public override void ConfirmTarget()
        {
            try
            {
                currentCharControl.DeltaAP(2);
                currentCharControl.SetCD(typeof(AdrenalineTargetingController), 3);
                AdrenalineEffect adrenalineEffect = new AdrenalineEffect(currentCharControl);

                currentCharControl.TryAddEffect(adrenalineEffect, currentCharControl.characterDataComponent.effects);
                // StartCoroutine(adrenalineEffect.ApplyEffect(_currentCharacterDataComponent.effects));
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }
        public override void ConfirmTarget()
        {
            //Rewrite
            Type             type             = typeof(SplitShotAbility);
            SplitShotAbility splitshotAbility = (SplitShotAbility)battleManager.gameObject.AddComponent(type);

            try
            {
                splitshotAbility.SetProperties("Splitshot",
                                               "Performs 3 basic attacks", 4, 0, 4, 4, true);
                splitshotAbility.battleManager = battleManager;
                splitshotAbility.targetBC      = targetForAttack;
                splitshotAbility.attackerBC    = currentCharControl;
                splitshotAbility.origin        = originForAttack;
                splitshotAbility.destination   = destinationForAttack;

                Debug.Log(originForAttack.Count);

                currentCharControl.SetCD(typeof(SplitshotTargetingController), 4);
                currentCharControl.DeltaAP(-4);

                splitshotAbility.initiated = true;

                battleManager.eventQueue.Add(splitshotAbility);

                // Some shit
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            // Deselect();
            currentCharControl.SwapTargeting(0);
        }