GameObject GetClickedObject()
    {
        GameObject touched = null;

        if (Input.GetMouseButtonDown(0))
        {
            Camera camera = Camera.main;

            if (camera == null)
            {
                print("camera not found");
                return(null);
            }
            Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit, 100))
            {
                touched = hit.transform.gameObject;

                SkeletonGameObject clickedTarget = touched.GetComponent <SkeletonGameObject>();

                if (clickedTarget != null)
                {
                    bool isAlly = false;

                    if (touched.tag == turnHolder.tag)
                    {
                        isAlly = true;
                    }

                    switch (turnHolder.skeleton.skillToExecute.type)
                    {
                    case SkeletonSkill.SkillType.TYPE_DAMAGE:

                        if (!isAlly)
                        {
                            turnHolder.playOnAttackAnimation();

                            int damageToDeal = turnHolder.skeleton.GetDirectDamage(turnHolder.skeleton.skillToExecute);
                            clickedTarget.skeleton.TakeDamageAndApplyDebuff(damageToDeal, turnHolder.skeleton.skillToExecute);

                            clickedTarget.playOnHitAnimation();
                            clickedTarget.UpdateStats();

                            if (clickedTarget.skeleton.hp <= 0)
                            {
                                clickedTarget.Die();
                            }
                        }
                        else
                        {
                            Debug.Log("cannot deal damage to allies!");
                            return(null);
                        }
                        break;

                    case SkeletonSkill.SkillType.TYPE_SPECIAL_DAMAGE:

                        if (!isAlly)
                        {
                            turnHolder.playOnAttackAnimation();

                            int damageToDeal = turnHolder.skeleton.GetDirectDamage(turnHolder.skeleton.skillToExecute);

                            Debug.Log(clickedTarget.skeleton.name + " took " + damageToDeal +
                                      " of damage. Skill used has multiplier : " + turnHolder.skeleton.skillToExecute.multiplier);
                            clickedTarget.skeleton.TakeDamageAndApplyDebuff(damageToDeal, turnHolder.skeleton.skillToExecute);

                            clickedTarget.playOnHitAnimation();
                            clickedTarget.UpdateStats();

                            if (clickedTarget.skeleton.hp <= 0)
                            {
                                clickedTarget.Die();
                            }
                        }
                        else
                        {
                            Debug.Log("cannot deal damage to allies!");
                            return(null);
                        }
                        break;

                    case SkeletonSkill.SkillType.TYPE_HEAL:

                        if (isAlly)
                        {
                            int damageToHeal = turnHolder.skeleton.GetDirectHealing(turnHolder.skeleton.skillToExecute);

                            /*switch (turnHolder.skeleton.skillToExecute.multiplyFactor)
                             * {
                             *  case SkeletonSkill.MultiplyFactor.FACTOR_ATTACK:
                             *      damageToHeal = turnHolder.skeleton.attack * turnHolder.skeleton.skillToExecute.multiplier;
                             *      break;
                             *  case SkeletonSkill.MultiplyFactor.FACTOR_SPECIAL_ATTACK:
                             *      damageToHeal = turnHolder.skeleton.specialAttack * turnHolder.skeleton.skillToExecute.multiplier;
                             *      break;
                             *  case SkeletonSkill.MultiplyFactor.FACTOR_HP:
                             *      damageToHeal = turnHolder.skeleton.maxHp * turnHolder.skeleton.skillToExecute.multiplier;
                             *      break;
                             *  case SkeletonSkill.MultiplyFactor.FACTOR_DEFENSE:
                             *      damageToHeal = turnHolder.skeleton.defense * turnHolder.skeleton.skillToExecute.multiplier;
                             *      break;
                             *  case SkeletonSkill.MultiplyFactor.FACTOR_SPECIAL_DEFENSE:
                             *      damageToHeal = turnHolder.skeleton.specialDefense * turnHolder.skeleton.skillToExecute.multiplier;
                             *      break;
                             * }*/

                            Debug.Log(clickedTarget.skeleton.name + " healed " + damageToHeal +
                                      " of damage. Skill used has multiplier : " + turnHolder.skeleton.skillToExecute.multiplier);
                            clickedTarget.skeleton.HealDamage(damageToHeal);
                            clickedTarget.UpdateStats();
                        }
                        else
                        {
                            Debug.Log("cannot heal enemies!");
                            return(null);
                        }

                        break;
                    }

                    switch (state)
                    {
                    case BattleState.BATTLE_STATE_ALLY_TURN_DECIDING:
                        state = BattleState.BATTLE_STATE_ALLY_TURN_ENDING;
                        break;

                    case BattleState.BATTLE_STATE_ENEMY_TURN_DECIDING:
                        state = BattleState.BATTLE_STATE_ENEMY_TURN_ENDING;
                        break;
                    }
                }
                else
                {
                    Debug.Log("no viable target found");
                }
            }
        }

        return(gameObject);
    }
    // Update is called once per frame
    void Update()
    {
        switch (state)
        {
        case BattleState.BATTLE_STATE_IDDLE:
            print("State : iddle");

            if (Input.GetKeyDown("space"))
            {
                info.text = "Battle Started!";

                turnHolder = turnList[currentTurnPointer];

                if (turnHolder.tag.Equals("Ally"))
                {
                    state = BattleState.BATTLE_STATE_ALLY_TURN_STARTED;
                }
                else
                {
                    state = BattleState.BATTLE_STATE_ENEMY_TURN_STARTED;
                }

                print("Its " + turnHolder.name + "[" + turnHolder.tag + "] turn");
            }

            break;

        case BattleState.BATTLE_STATE_CHECKING_NEXT_TURN_HOLDER:

            currentTurnPointer++;

            print("pointer is :" + currentTurnPointer);

            if (currentTurnPointer > maxTurnPointer)
            {
                print("everyone have move, reseting turn order");
                currentTurnPointer = 0;
            }

            turnHolder = turnList[currentTurnPointer];

            if (turnHolder.skeleton.status == Skeleton.SkeletonStatus.DEATH)
            {
                print("characters is death, skipping. Current index is " + currentTurnPointer + "and owner is : " + turnHolder.name);
                state = BattleState.BATTLE_STATE_CHECKING_NEXT_TURN_HOLDER;
                break;
            }

            if (turnHolder.tag.Equals("Ally"))
            {
                state = BattleState.BATTLE_STATE_ALLY_TURN_STARTED;
            }
            else
            {
                state = BattleState.BATTLE_STATE_ENEMY_TURN_STARTED;
            }

            print("Its " + turnHolder.name + "[" + turnHolder.tag + "] turn");

            break;

        case BattleState.BATTLE_STATE_ALLY_TURN_STARTED:
            //init values or activate effects if necesary
            info.text += "\nAlly Turn Started";
            state      = BattleState.BATTLE_STATE_ALLY_TURN_DECIDING;
            turnHolder.transform.GetChild(0).GetComponent <MeshRenderer>().enabled = true;
            break;

        case BattleState.BATTLE_STATE_ALLY_TURN_DECIDING:
            print("State : ALLY TURN");
            whosTurn.text = "Ally Turn";

            if (Input.GetKeyDown("a"))
            {
                print("ALLY Skill 1 Selected");
                info.text += "\nALLY Skill 1 Selected";

                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.firstSkill;
            }

            if (Input.GetKeyDown("s"))
            {
                print("ALLY Skill 2 Selected");
                info.text += "\nALLY Skill 2 Selected";
                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.secondSkill;
            }

            if (Input.GetKeyDown("d"))
            {
                print("ALLY Skill 3 Selected");
                info.text += "\nALLY Skill 3 Selected";
                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.thirdSkill;
            }

            break;

        case BattleState.BATTLE_STATE_ALLY_TURN_ENDING:
            turnHolder.skeleton.reduceBuffsDuration();
            updateTurnList();
            info.text += "\nAlly Turn Ending";
            //use this to set values at the end of the turn (ex, buff or heal ally,
            //deal damage to enemies, etc)
            state = BattleState.BATTLE_STATE_CHECKING_NEXT_TURN_HOLDER;
            turnHolder.transform.GetChild(0).GetComponent <MeshRenderer>().enabled = false;
            break;


        case BattleState.BATTLE_STATE_ENEMY_TURN_STARTED:
            //init values or activate effects if necesary
            turnHolder.transform.GetChild(0).GetComponent <MeshRenderer>().enabled = true;
            info.text += "\nENEMY Turn Started";
            state      = BattleState.BATTLE_STATE_ENEMY_TURN_DECIDING;
            break;

        case BattleState.BATTLE_STATE_ENEMY_TURN_DECIDING:
            print("State : ENEMY TURN");
            whosTurn.text = "Enemy Turn";

            if (Input.GetKeyDown("a"))
            {
                print("ENEMY Skill 1 Selected");
                info.text += "\nENEMY Skill 1 Selected";
                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.firstSkill;
            }

            if (Input.GetKeyDown("s"))
            {
                print("ENEMY Skill 2 Selected");
                info.text += "\nENEMY Skill 2 Selected";
                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.secondSkill;
            }

            if (Input.GetKeyDown("d"))
            {
                print("ENEMY Skill 3 Selected");
                info.text += "\nENEMY Skill 3 Selected";
                turnHolder.skeleton.skillToExecute = turnHolder.skeleton.thirdSkill;
            }

            break;

        case BattleState.BATTLE_STATE_ENEMY_TURN_ENDING:
            turnHolder.skeleton.reduceBuffsDuration();
            updateTurnList();

            info.text += "\nENEMY Turn Ending";

            //use this to set values at the end of the turn (ex, buff or heal ally,
            //deal damage to enemies, etc)
            state = BattleState.BATTLE_STATE_CHECKING_NEXT_TURN_HOLDER;
            turnHolder.transform.GetChild(0).GetComponent <MeshRenderer>().enabled = false;

            break;
        }
        GetClickedObject();
    }