예제 #1
0
 public override void useCard(Character actor)
 {
     List<GridNode> strikenNodes = new List<GridNode>();
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         strikenNodes.Add(actor.CurrentNode.Left);
         while (strikenNodes[strikenNodes.Count - 1].panelExists(Util.Enums.Direction.Left))
         {
             strikenNodes.Add(strikenNodes[strikenNodes.Count - 1].Left);
         }
         foreach (GridNode node in strikenNodes)
         {
             spawnObjectUsingPrefabAsModel(damage, 9, .4f, true, Util.Enums.Direction.None, 0, 0, true, node, actor);
         }
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         strikenNodes.Add(actor.CurrentNode.Right);
         while (strikenNodes[strikenNodes.Count - 1].panelExists(Util.Enums.Direction.Right))
         {
             strikenNodes.Add(strikenNodes[strikenNodes.Count - 1].Right);
         }
         foreach (GridNode node in strikenNodes)
         {
             spawnObjectUsingPrefabAsModel(damage, 9, .4f, true, Util.Enums.Direction.None, 0, 0, true, node, actor);
         }
     }
 }
예제 #2
0
 public override void useCard(Character actor)
 {
     if (actor.Direction == Enums.Direction.Left)
         spawnObjectUsingPrefabAsModel(damage, range, .2f, true, Util.Enums.Direction.Left, 10, 1, true, actor.CurrentNode.Left, actor);
     if (actor.Direction == Enums.Direction.Right)
         spawnObjectUsingPrefabAsModel(damage, range, .2f, true, Util.Enums.Direction.Right, 10, 1, true, actor.CurrentNode.Right, actor);
 }
예제 #3
0
        public override void useCard(Character actor)
        {
            Weapons.Projectiles.GroundDestroyer temp = MonoBehaviour.Instantiate(prefab).GetComponent<Weapons.Projectiles.GroundDestroyer>();
            temp.Damage = damage;
            temp.Distance = range;
            temp.Piercing = true;
            temp.Speed = 5;
            temp.TimesCanPierce = -1;
            temp.IsFlying = true;
            temp.Owner = actor.gameObject;
            Util.AddElement.AddElementByEnum(temp.gameObject, element, true);
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                temp.Direction = Util.Enums.Direction.Left;
                temp.transform.position = actor.CurrentNode.Left.transform.position;
                temp.CurrentNode = actor.CurrentNode.Left;
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                temp.Direction = Util.Enums.Direction.Right;
                temp.transform.position = actor.CurrentNode.Right.transform.position;
                temp.CurrentNode = actor.CurrentNode.Right;
            }
        }
예제 #4
0
 public override void useCard(Character actor)
 {
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Left))
         {
             if (!(actor.CurrentNode.Left.Left.Left.Occupied))
             {
                 actor.CurrentNode.Left.Left.Left.Type = Util.Enums.FieldType.Blue;
                 spawnObjectUsingPrefabAsModel(0, 0, 6f, true, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Left.Left.Left, actor);
             }
             else
             {
                 spawnObjectUsingPrefabAsModel(damage, 0, 6f, false, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Left.Left.Left, actor);
             }
         }
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Right))
         {
             if (!(actor.CurrentNode.Right.Right.Right.Occupied))
             {
                 actor.CurrentNode.Right.Right.Right.Type = Util.Enums.FieldType.Red;
                 spawnObjectUsingPrefabAsModel(0, 0, 6f, true, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Right.Right.Right, actor);
             }
             spawnObjectUsingPrefabAsModel(damage, 0, 6f, false, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Right.Right.Right, actor);
         }
     }
 }
예제 #5
0
        public override void useCard(Character actor)
        {
            if (actor.Direction == Util.Enums.Direction.Left)
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Left))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, true, Util.Enums.Direction.Left, 10, range, true, actor.CurrentNode.Left, actor, true);

            if (actor.Direction == Util.Enums.Direction.Right)
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Right))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, true, Util.Enums.Direction.Right, 10, range, true, actor.CurrentNode.Right, actor, true);
        }
예제 #6
0
        public override void useCard(Character actor)
        {
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Left))
                    spawnObjectUsingPrefabAsModel(0, 0, 5f, true, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Left, actor);
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Right))
                    spawnObjectUsingPrefabAsModel(0, 0, 5f, true, Util.Enums.Direction.None, 0, damage, true, actor.CurrentNode.Right, actor);
            }
        }
예제 #7
0
        public override void useCard(Character actor)
        {
            Weapons.Hitbox temp = MonoBehaviour.Instantiate(hitbox);
            temp.Damage = damage;
            temp.DeathTime = 3f;
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                temp.transform.position = actor.CurrentNode.Left.transform.position;

            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                temp.transform.position = actor.CurrentNode.Right.transform.position;

            }
        }
예제 #8
0
        public override void useCard(Character actor)
        {
            Weapons.Hitbox temp = MonoBehaviour.Instantiate(hitbox);
            temp.Damage = damage;
            temp.DeathTime = .2f;
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                temp.transform.position = actor.CurrentNode.Left.transform.position;
                if (range > 1 && actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Down))
                {
                    temp = MonoBehaviour.Instantiate(hitbox);
                    temp.Damage = damage;
                    temp.DeathTime = .2f;
                    temp.transform.position = actor.CurrentNode.Left.Down.transform.position;
                }
                if (range > 2 && actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Up))
                {
                    temp = MonoBehaviour.Instantiate(hitbox);
                    temp.Damage = damage;
                    temp.DeathTime = .2f;
                    temp.transform.position = actor.CurrentNode.Left.Up.transform.position;
                }
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                temp.transform.position = actor.CurrentNode.Right.transform.position;
                if (range > 1 && actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Down))
                {
                    temp = MonoBehaviour.Instantiate(hitbox);
                    temp.Damage = damage;
                    temp.DeathTime = .2f;
                    temp.transform.position = actor.CurrentNode.Right.Down.transform.position;
                }
                if (range > 2 && actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Up))
                {
                    temp = MonoBehaviour.Instantiate(hitbox);
                    temp.Damage = damage;
                    temp.DeathTime = .2f;
                    temp.transform.position = actor.CurrentNode.Right.Up.transform.position;
                }
            }
        }
예제 #9
0
 public override void useCard(Character actor)
 {
     List<GridNode> strikenNodes = new List<GridNode>();
     int randHolder;
     bool repeater = false;
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         GameObject[] enemyNodes = GameObject.FindGameObjectsWithTag("Red");
         while (strikenNodes.Count < range)
         {
             randHolder = (int)Random.Range(0, enemyNodes.Length);
             foreach(GridNode node in strikenNodes)
                 repeater = repeater||(node == (enemyNodes[randHolder].GetComponent<GridNode>()));
             if (repeater == false)
                 strikenNodes.Add(enemyNodes[randHolder].GetComponent<GridNode>());
             else
                 repeater = false;
         }
         foreach(GridNode node in strikenNodes)
         {
             spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.None, 10, 0, true, node, actor);
         }
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         GameObject[] enemyNodes = GameObject.FindGameObjectsWithTag("Blue");
         while (strikenNodes.Count < range)
         {
             randHolder = (int)Random.Range(0, enemyNodes.Length);
             foreach (GridNode node in strikenNodes)
                 repeater = repeater||(node == enemyNodes[randHolder]);
             if (repeater == false)
                 strikenNodes.Add(enemyNodes[randHolder].GetComponent<GridNode>());
             else
                 repeater = false;
         }
         foreach (GridNode node in strikenNodes)
         {
             spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.None, 10, 0, true, node, actor);
         }
     }
 }
예제 #10
0
 public override void useCard(Character actor)
 {
     GridNode currentNode = actor.CurrentNode;
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         while (currentNode.panelExists(Util.Enums.Direction.Left))
         {
             currentNode = currentNode.Left;
         }
         spawnObjectUsingPrefabAsModel(damage, 9, .5f, false, Util.Enums.Direction.None, 10, 0, true, currentNode, actor);
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         while (currentNode.panelExists(Util.Enums.Direction.Right))
         {
             currentNode = currentNode.Right;
         }
         spawnObjectUsingPrefabAsModel(damage, 9, .5f, false, Util.Enums.Direction.None, 10, 0, true, currentNode, actor);
     }
 }
예제 #11
0
        public override void useCard(Character actor)
        {
            //Create a reference to the node we're trying to destroy. Since we do not know the
            //entire grid map, we will start at the actor origin and work from there.
            Grid.GridNode targetNode = actor.CurrentNode;

            //Keep track of the hitbox in case we want to do damage when we destroy a tile.
            Weapons.Hitbox temp = MonoBehaviour.Instantiate(hitbox);
            temp.Damage = damage;
            temp.DeathTime = .2f;
            temp.transform.position = targetNode.transform.position;

            if (actor.Direction == Util.Enums.Direction.Left)
            {
                for (int i = 0; i < range; i++)
                {
                    if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Left))
                    {
                        temp.transform.position = targetNode.Left.transform.position;
                        targetNode = targetNode.Left;
                    }
                }
                //Destroy the furthest tile within range.
                targetNode.Type = Assets.Scripts.Util.Enums.FieldType.Destroyed;

            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                for (int i = 0; i < range; i++)
                {
                    if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Right))
                    {
                        temp.transform.position = targetNode.Right.transform.position;
                        targetNode = targetNode.Right;
                    }
                }
                //Destroy the furthest tile within range.
                targetNode.Type = Assets.Scripts.Util.Enums.FieldType.Destroyed;
            }
        }
예제 #12
0
        public override void useCard(Character actor)
        {
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Left))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Left, 10, 1, true, actor.CurrentNode.Left, actor);
                if (range > 1 && actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Down))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Left, 10, 1, true, actor.CurrentNode.Left.Down, actor);
                if (range > 2 && actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Up))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Left, 10, 1, true, actor.CurrentNode.Left.Up, actor);
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                if (actor.CurrentNode.panelExists(Util.Enums.Direction.Right))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Right, 10, 1, true, actor.CurrentNode.Right, actor);
                if (range > 1 && actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Down))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Right, 10, 1, true, actor.CurrentNode.Right.Down, actor);
                if (range > 2 && actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Up))
                    spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.Right, 10, 1, true, actor.CurrentNode.Right.Up, actor);
            }
        }
예제 #13
0
        public override void useCard(Character actor)
        {
            Weapons.Projectiles.ZigZag temp = MonoBehaviour.Instantiate(prefab).GetComponent<Weapons.Projectiles.ZigZag>();
            temp.Damage = damage;
            temp.TimesCanPierce = range - 1;
            temp.Owner = actor.gameObject;
            Util.AddElement.AddElementByEnum(temp.gameObject, element, true);
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                temp.Direction = Util.Enums.Direction.Left;
                temp.transform.position = actor.CurrentNode.Left.transform.position;
                temp.CurrentNode = actor.CurrentNode.Left;
                Transform model = temp.GetComponentInChildren<Transform>();
                model.localScale = new Vector3(model.localScale.x, -model.localScale.y, model.localScale.z);
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                temp.Direction = Util.Enums.Direction.Right;
                temp.transform.position = actor.CurrentNode.Right.transform.position;
                temp.CurrentNode = actor.CurrentNode.Right;
            }
        }
예제 #14
0
 public override void useCard(Character actor)
 {
     actor.AddHealth(damage);
 }
예제 #15
0
 public override void useCard(Character actor)
 {
     GridNode currentNode = actor.CurrentNode;
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         if (range == 1)
         {
             while (currentNode.Left.Type == Util.Enums.FieldType.Blue)
             {
                 currentNode = currentNode.Left;
             }
             if (!(currentNode.Occupied))
             {
                 currentNode.Left.Type = Util.Enums.FieldType.Blue;
             }
         }
         if (range == 3)
         {
             if (!(currentNode.panelExists(Util.Enums.Direction.Up)))
             {
                 currentNode = currentNode.Down;
             }
             if (!(currentNode.panelExists(Util.Enums.Direction.Down)))
             {
                 currentNode = currentNode.Up;
             }
             GridNode[] stolenPanels = new GridNode[3];
             while (currentNode.Left.Type == Util.Enums.FieldType.Blue && currentNode.Left.Up.Type == Util.Enums.FieldType.Blue && currentNode.Left.Down.Type == Util.Enums.FieldType.Blue)
             {
                 currentNode = currentNode.Left;
             }
             stolenPanels[0] = currentNode.Left;
             stolenPanels[1] = currentNode.Left.Up;
             stolenPanels[2] = currentNode.Left.Down;
             foreach (GridNode node in stolenPanels)
             {
                 if (!(node.Occupied))
                 {
                     node.Type = Util.Enums.FieldType.Blue;
                 }
             }
         }
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         if (range == 1)
         {
             while (currentNode.Right.Type == Util.Enums.FieldType.Red)
             {
                 currentNode = currentNode.Right;
             }
             if (!(currentNode.Occupied))
             {
                 currentNode.Right.Type = Util.Enums.FieldType.Red;
             }
         }
         if (range == 3)
         {
             if (!(currentNode.panelExists(Util.Enums.Direction.Up)))
             {
                 currentNode = currentNode.Down;
             }
             if (!(currentNode.panelExists(Util.Enums.Direction.Down)))
             {
                 currentNode = currentNode.Up;
             }
             GridNode[] stolenPanels = new GridNode[3];
             while (currentNode.Right.Type == Util.Enums.FieldType.Red && currentNode.Right.Up.Type == Util.Enums.FieldType.Red && currentNode.Right.Down.Type == Util.Enums.FieldType.Red)
             {
                 currentNode = currentNode.Right;
             }
             stolenPanels[0] = currentNode.Right;
             stolenPanels[1] = currentNode.Right.Up;
             stolenPanels[2] = currentNode.Right.Down;
             foreach (GridNode node in stolenPanels)
             {
                 if (!(node.Occupied))
                 {
                     node.Type = Util.Enums.FieldType.Red;
                 }
             }
         }
     }
 }
예제 #16
0
 public override void useCard(Character actor)
 {
     List<GridNode> strikenNodes = new List<GridNode>();
     if (actor.Direction == Util.Enums.Direction.Left)
     {
         if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Left))
         {
             strikenNodes.Add(actor.CurrentNode.Left.Left);
         }
         if (range == 4)
         {
             if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Left.Up);
             }
             if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Left.Down);
             }
             if (actor.CurrentNode.panelExists(Util.Enums.Direction.Left))
             {
                 strikenNodes.Add(actor.CurrentNode.Left);
             }
             if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Left))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Left.Left);
             }
         }
         if (range == 5)
         {
             if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Up);
             }
             if (actor.CurrentNode.Left.Left.Left.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Left.Left.Down);
             }
             if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Down);
             }
             if (actor.CurrentNode.Left.Left.Left.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Left.Left.Left.Up);
             }
         }
     }
     if (actor.Direction == Util.Enums.Direction.Right)
     {
         if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Right))
         {
             strikenNodes.Add(actor.CurrentNode.Right.Right);
         }
         if (range == 4)
         {
             if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Right.Up);
             }
             if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Right.Down);
             }
             if (actor.CurrentNode.panelExists(Util.Enums.Direction.Right))
             {
                 strikenNodes.Add(actor.CurrentNode.Right);
             }
             if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Right))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Right.Right);
             }
         }
         if (range == 5)
         {
             if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Up);
             }
             if (actor.CurrentNode.Right.Right.Right.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Right.Right.Down);
             }
             if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Down))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Down);
             }
             if (actor.CurrentNode.Right.Right.Right.panelExists(Util.Enums.Direction.Up))
             {
                 strikenNodes.Add(actor.CurrentNode.Right.Right.Right.Up);
             }
         }
     }
     foreach (GridNode node in strikenNodes)
     {
         spawnObjectUsingPrefabAsModel(damage, 9, .2f, false, Util.Enums.Direction.None, 10, 0, true, node, actor);
     }
 }
예제 #17
0
 public void clearOccupied()
 {
     occupied = false;
     panelOwner = null;
 }
예제 #18
0
        public override void useCard(Character actor)
        {
            int randHolder;
            bool repeater = false;
            List<GridNode> strikenNodes = new List<GridNode>();
            if (actor.Direction == Util.Enums.Direction.Left)
            {
                if (range != 4)
                    spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left, actor);
                if (range == 2)
                {
                    if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Left))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left.Left, actor);
                    if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Up))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left.Left.Up, actor);
                    if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Down))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left.Left.Down, actor);
                }
                else if (range == 3)
                {
                    if (actor.CurrentNode.Left.panelExists(Util.Enums.Direction.Left))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left.Left, actor);
                    if (actor.CurrentNode.Left.Left.panelExists(Util.Enums.Direction.Left))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Left.Left.Left, actor);
                }
                else if (range == 4)
                {
                    GameObject[] enemyNodes = GameObject.FindGameObjectsWithTag("Red");
                    while (strikenNodes.Count < enemyNodes.Length/2)
                    {
                        randHolder = (int)Random.Range(0, enemyNodes.Length);
                        foreach (GridNode node in strikenNodes)
                            repeater = repeater || (node == (enemyNodes[randHolder].GetComponent<GridNode>()));
                        if (repeater == false)
                            strikenNodes.Add(enemyNodes[randHolder].GetComponent<GridNode>());
                        else
                            repeater = false;
                    }
                    foreach(GridNode node in strikenNodes)
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, node , actor);
                }
            }

            if (actor.Direction == Util.Enums.Direction.Right)
            {
                if (range != 4)
                    spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right, actor);
                if (range == 2)
                {
                    if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Right))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right.Right, actor);
                    if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Up))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right.Right.Up, actor);
                    if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Down))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right.Right.Down, actor);
                }
                else if (range == 3)
                {
                    if (actor.CurrentNode.Right.panelExists(Util.Enums.Direction.Right))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right.Right, actor);
                    if (actor.CurrentNode.Right.Right.panelExists(Util.Enums.Direction.Right))
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, actor.CurrentNode.Right.Right.Right, actor);
                }
                else if (range == 4)
                {
                    GameObject[] enemyNodes = GameObject.FindGameObjectsWithTag("Blue");
                    while (strikenNodes.Count < enemyNodes.Length / 2)
                    {
                        randHolder = (int)Random.Range(0, enemyNodes.Length);
                        foreach (GridNode node in strikenNodes)
                            repeater = repeater || (node == (enemyNodes[randHolder].GetComponent<GridNode>()));
                        if (repeater == false)
                            strikenNodes.Add(enemyNodes[randHolder].GetComponent<GridNode>());
                        else
                            repeater = false;
                    }
                    foreach (GridNode node in strikenNodes)
                        spawnObjectUsingPrefabAsModel(damage, 9, 5f, false, Util.Enums.Direction.None, 0, 0, false, node, actor);
                }
            }
        }