public void selectEffect(string id, string code)
 {
     if (code == "DRAW")
     {
         scr_playerInGame.deck.Remove(id);
         scr_playerInGame.hand.Add(id);
     }
     else if (code == "GETHAND")
     {
         scr_playerInGame.hand.Add(id);
     }
     else if (code == "DISCARDHAND")
     {
         scr_playerInGame.hand.Remove(id);
         scr_playerInGame.tomb.Add(id);
     }
     else if (code == "DISCARDHANDTOSACRIFICE")
     {
         scr_playerInGame.hand.Remove(id);
         scr_playerInGame.tomb.Add(id);
         sacrificeCnt += (int)DB_card.getIdentity(id)[0];
     }
     else if (code == "DRAWPANELTY_COSTDAMAGE")
     {
         scr_playerInGame.deck.Remove(id);
         scr_playerInGame.hand.Add(id);
         health -= (int)DB_card.getIdentity(id)[0];
     }
     else if (code == "RECALL")
     {
         scr_playerInGame.tomb.Remove(id);
         scr_playerInGame.hand.Add(id);
     }
     else if (code == "SERIATODECK")
     {
         scr_playerInGame.hand.Remove(id);
         scr_playerInGame.deck.Add("Seria");
     }
     else if (code == "REMOVE_CAMOUFLAGE")
     {
         scr_playerInGame.tomb.Remove(id);
         foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
         {
             scr_unit curData = cur.GetComponent <scr_unit>();
             if (curData.id == "pyren_zombie")
             {
                 curData.CmdCamouflage(id);
             }
         }
     }
     else if (code == "CHANGETAG")
     {
         string tempTag = (string)DB_card.getIdentity(id)[6];
         foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
         {
             scr_unit curData = cur.GetComponent <scr_unit>();
             if (curData.hosts == GetComponent <scr_playerController>().isHost)
             {
                 curData.CmdsetTag(tempTag);
             }
         }
     }
     else if (code == "ELEMENTALFIELD")
     {
         string tempTag = (string)DB_card.getIdentity(id)[6];
         CmdSetEnvironment("$" + tempTag);
     }
     gameObject.GetComponent <scr_playerInGame>().displayHand();
 }
    public void OnEndDrag(PointerEventData eventData)
    {
        foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Player"))
        {
            gameObject.transform.SetParent(GameObject.Find("Canvas").transform);

            if (gameObject.GetComponent <SpriteRenderer>().sprite == attack)
            {
                if (!cur.GetComponent <scr_playerController>().isPlayer&& canDirectAttack() &&
                    transform.localPosition.y >= 360)
                {
                    scr_unit data = sav_parent.GetComponent <scr_unit>();
                    data.CmdDirectattack_health_calculation(cur);

                    if (data.id == "Falcifer")
                    {
                        data.CmdDamage(sav_parent, 2);
                        data.Cmdcharge();
                        break;
                    }
                    break;
                }
            }
        }

        foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
        {
            gameObject.transform.SetParent(GameObject.Find("Canvas").transform);

            if (gameObject.GetComponent <SpriteRenderer>().sprite == attack)
            {
                string checkRange = (string)DB_card.getIdentity(sav_parent.GetComponent <scr_unit>().id)[5];
                if (cur.GetComponent <scr_unit>().isEnemy&& (checkRange.Contains("[원격") || canAttack(cur)) &&
                    Vector3.Distance(gameObject.transform.localPosition, cur.transform.localPosition) <= 60f)
                {
                    scr_unit data = sav_parent.GetComponent <scr_unit>();
                    data.Cmdchange_spawn_turn();

                    string checkAttack = (string)DB_card.getIdentity(data.id)[5];
                    if (checkAttack.Contains("[공격"))
                    {
                        switch (data.id)
                        {
                        case "moon_slayer":
                            data.CmdgetSelfStatus(1, 0);
                            break;

                        case "Revilla":
                            data.CmdgetSelfStatus(cur.GetComponent <scr_unit>().health, 0);
                            break;

                        case "dollmaker":
                            if (data.isMyturn())
                            {
                                scr_playerInGame.hand.Add("doll");
                            }
                            break;

                        case "sacrifice_summoner":
                            if (getPlayer())
                            {
                                player.GetComponent <scr_playerIdentity>().CmdSetSacrificeCnt(data.hosts, 2);
                            }
                            break;

                        case "wind_rider":
                            if (cur.GetComponent <scr_unit>().attack >= 7)
                            {
                                data.CmdDamage(cur, cur.GetComponent <scr_unit>().health);
                            }
                            break;

                        case "Volcanic_twindragon":
                            if (cur.GetComponent <scr_unit>().health <= data.attack)
                            {
                                data.CmdgetSelfStatus(1, 1);
                                data.Cmdcharge();
                            }
                            break;

                        case "mancy":
                            data.CmdgetSelfStatus(2, 0);
                            break;

                        case "axe_zealot":
                            if (getPlayer())
                            {
                                if (player.GetComponent <scr_playerController>().myturn)
                                {
                                    foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Unit"))
                                    {
                                        if (obj != gameObject)
                                        {
                                            data.CmdDamage(obj, 1);
                                        }
                                    }
                                }
                            }
                            break;

                        case "Falcifer":
                            data.CmdDamage(sav_parent, 2);
                            data.Cmdcharge();
                            break;

                        case "mirat":
                            if (getPlayer())
                            {
                                if (player.GetComponent <scr_playerController>().myturn)
                                {
                                    foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Unit"))
                                    {
                                        if (obj.GetComponent <scr_unit>().hosts == data.hosts &&
                                            obj.GetComponent <scr_unit>().id == "doll")
                                        {
                                            data.CmdgetStatus(obj, 1, 1);
                                        }
                                    }
                                }
                            }
                            break;

                        case "Keiro":
                            if (getPlayer())
                            {
                                if (data.isMyturn())
                                {
                                    if (cur.GetComponent <scr_unit>().health <= data.attack)
                                    {
                                        foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Player"))
                                        {
                                            if (!obj.GetComponent <scr_playerController>().isPlayer)
                                            {
                                                data.CmdDamage(obj, cur.GetComponent <scr_unit>().attack);
                                            }
                                        }
                                    }
                                }
                            }
                            break;

                        default:
                            break;
                        }
                    }

                    data.Cmdattack_health_calculation(cur);
                    break;
                }
            }

            else if (gameObject.GetComponent <SpriteRenderer>().sprite == magic)
            {
                if ((Vector3.Distance(gameObject.transform.localPosition, cur.transform.localPosition) <= 60f) && cur != gameObject)
                {
                    scr_unit data = sav_parent.GetComponent <scr_unit>();
                    requestParticle(3, sav_parent, -1);

                    switch (data.id)
                    {
                    case "little_healer":
                        data.CmdDamage(cur, -2);
                        emerge_flag = false;
                        break;

                    case "student_swordman":
                        data.CmdDamage(cur, 1);
                        emerge_flag = false;
                        break;

                    case "shasha":
                        data.CmdsetTerial(cur.GetComponent <scr_unit>().terial);
                        emerge_flag = false;
                        break;

                    case "hero_helper":
                        data.CmdgetStatus(cur, 1, 1);
                        emerge_flag = false;
                        break;

                    case "corpse_raven":
                        scr_unit curData = cur.GetComponent <scr_unit>();
                        if (data.hosts == curData.hosts &&
                            curData.card_tag.Contains("Beast"))
                        {
                            data.CmdDamage(cur, curData.health);
                            if (getPlayer())
                            {
                                player.GetComponent <scr_playerIdentity>().CmdGainCard(data.hosts, "draw");
                            }
                            emerge_flag = false;
                        }
                        break;

                    case "admired_bishop":
                        curData = cur.GetComponent <scr_unit>();
                        if (data.hosts != curData.hosts)
                        {
                            if (data.isMyturn())
                            {
                                scr_playerInGame.hand.Add(curData.id);
                            }
                            emerge_flag = false;
                        }
                        break;

                    case "waterdragon_priest":
                        curData = cur.GetComponent <scr_unit>();
                        if (data.hosts == curData.hosts &&
                            curData.card_tag.Contains("Water"))
                        {
                            data.CmdDamage(cur, curData.health);
                            if (getPlayer())
                            {
                                player.GetComponent <scr_playerIdentity>().CmdGainCard(data.hosts, "draw");
                                player.GetComponent <scr_playerIdentity>().CmdGainCard(data.hosts, "draw");
                            }
                            emerge_flag = false;
                        }
                        break;

                    case "little_mermaid":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.card_tag.Contains("Water"))
                        {
                            data.CmdgetStatus(cur, 1, 1);
                            emerge_flag = false;
                        }
                        break;

                    case "slum_dancer":
                        data.CmdgetStatus(cur, -2, 0);
                        emerge_flag = false;
                        break;

                    case "attack_eater":
                        curData = cur.GetComponent <scr_unit>();
                        bool temp_flag = false;
                        foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Unit"))
                        {
                            if (obj != gameObject && obj.GetComponent <scr_unit>().card_tag.Contains("Wind"))
                            {
                                temp_flag = true;
                                break;
                            }
                        }
                        if (temp_flag)
                        {
                            int temp_curAttack = curData.attack;
                            int temp_attack    = data.attack;
                            data.CmdgetSelfStatus(temp_curAttack - temp_attack, 0);
                            data.CmdgetStatus(cur, temp_attack - temp_curAttack, 0);
                            emerge_flag = false;
                        }
                        break;

                    case "ground_follower":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.hosts == data.hosts && curData.card_tag.Contains("Earth"))
                        {
                            curData.CmdgetSelfStatus(curData.health - curData.attack, 0);
                            emerge_flag = false;
                        }
                        break;

                    case "whitefur_fox":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.hosts == data.hosts && curData.card_tag.Contains("Beast"))
                        {
                            data.CmdgetStatus(cur, 1, 1);
                            emerge_flag = false;
                        }
                        break;

                    case "juen":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.hosts == data.hosts && curData.card_tag.Contains("Beast"))
                        {
                            curData.Cmdcharge();
                            emerge_flag = false;
                        }
                        break;

                    case "Toxie":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.health <= 2)
                        {
                            curData.CmdCamouflage("Devil-T_host");
                            emerge_flag = false;
                        }
                        break;

                    case "steel_sworder":
                        data.CmdDamage(cur, 2);
                        emerge_flag = false;
                        break;

                    case "rein":
                        data.CmdgetStatus(cur, 1 - cur.GetComponent <scr_unit>().attack, 0);
                        emerge_flag = false;
                        break;

                    case "dark_baron":
                        if (getPlayer())
                        {
                            int temp_health = cur.GetComponent <scr_unit>().health;
                            data.CmdDamage(player, temp_health);
                            data.CmdDamage(cur, temp_health);
                        }
                        emerge_flag = false;
                        break;

                    case "mitero":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.hosts == data.hosts && curData.card_tag.Contains("Wind"))
                        {
                            data.CmdDamage(cur, curData.health);
                            emerge_flag = false;
                        }
                        if (!emerge_flag)
                        {
                            foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Unit"))
                            {
                                scr_unit objData = obj.GetComponent <scr_unit>();
                                if (data.hosts != objData.hosts && objData.attack >= 5)
                                {
                                    data.CmdDamage(obj, objData.health);
                                }
                            }
                        }
                        break;

                    case "Sein":
                        getPlayer();
                        curData = cur.GetComponent <scr_unit>();
                        if (data.isMyturn())
                        {
                            if (scr_playerInGame.hand.Contains("doll"))
                            {
                                scr_playerInGame.hand.Remove("doll");
                                scr_playerInGame.deck.Add("doll");
                                data.CmdDamage(cur, 2);
                            }
                        }
                        break;

                    case "Tenebera":
                        data.CmdrequestParticleByVector(7, cur.transform.localPosition, -1);
                        data.CmdDestroyUnit(cur);
                        emerge_flag = false;
                        break;

                    case "dark_mage":
                        data.CmdDamage(cur, 4);
                        emerge_flag = false;
                        break;

                    case "burying_socerer":
                        curData = cur.GetComponent <scr_unit>();
                        if (data.isMyturn())
                        {
                            scr_playerInGame.hand.Add(curData.id);
                        }
                        data.CmdrequestParticleByVector(7, cur.transform.localPosition, -1);
                        data.CmdDestroyUnit(cur);
                        emerge_flag = false;
                        break;

                    case "tigor":
                        curData = cur.GetComponent <scr_unit>();
                        if (curData.hosts == data.hosts && curData.card_tag.Contains("Beast"))
                        {
                            data.CmdgetStatus(cur, 3, 3);
                            emerge_flag = false;
                        }
                        break;

                    case "SENA":
                        if (data.isMyturn())
                        {
                            if (scr_playerInGame.hand.Count != 0)
                            {
                                data.CmdDamage(cur, 2);
                                getPlayer();
                                player.GetComponent <scr_playerIdentity>().CmdSelectCard(data.hosts, data.id);
                            }
                        }
                        break;

                    case "BT":
                        if (cur.GetComponent <scr_unit>().attack <= 5)
                        {
                            cur.GetComponent <scr_unit>().Cmdcharge();
                        }
                        emerge_flag = false;
                        break;

                    default:
                        break;
                    }
                    break;
                }
            }
        }

        gameObject.transform.position = savePos;
        drag = false;
    }
    public void CmdforAllSpell(bool hosts, string id, int cost)
    {
        bool used = true;

        switch (id)
        {
        case "#vitality":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit data = cur.GetComponent <scr_unit>();
                if (data.hosts == hosts && data.card_tag.Contains("Earth"))
                {
                    data.CmdgetSelfStatus(0, 2);
                }
            }
            break;

        case "#luminous_grail":
            CmdGainStatusExtended(hosts, 0, 3, 3);
            break;

        case "#dark_token":
            RpcGaincard(hosts, "daki");
            RpcGaincard(hosts, "daki");
            break;

        case "#blood_storm":
            int temp_cnt = 0;
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit data = cur.GetComponent <scr_unit>();
                if (data.hosts != hosts)
                {
                    temp_cnt++;
                }
            }
            if (temp_cnt >= 4)
            {
                foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
                {
                    scr_unit data = cur.GetComponent <scr_unit>();
                    data.CmdDamage(cur, 3);
                }
            }
            else
            {
                foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
                {
                    scr_unit data = cur.GetComponent <scr_unit>();
                    data.CmdDamage(cur, 1);
                }
            }
            break;

        case "#volcano":
            CmdSetEnvironment("volcano");
            break;

        case "#dimension_summon":
            ArrayList temp_table = new ArrayList();
            foreach (string cardId in DB_card.collectible)
            {
                if (!cardId.Contains("#"))
                {
                    temp_table.Add(cardId);
                }
            }
            int drawIndex = Random.Range(0, temp_table.Count);
            CmdGainCard(hosts, (string)temp_table[drawIndex]);
            break;

        case "#tales_river":
            CmdSetEnvironment("tales_1");
            break;

        case "#salvage":
            RpcSelectCard(hosts, id);
            break;

        case "#evolve:SaintResia":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts == hosts && curData.id == "Resia")
                {
                    curData.CmdCamouflage("Angel_resia");
                }
            }
            break;

        case "#evolve:DarkResia":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts == hosts && curData.id == "Resia")
                {
                    curData.CmdCamouflage("Dark_resia");
                }
            }
            break;

        case "#nas_breath":
            RpcGaincard(hosts, "nas");
            CmdGainStatus(hosts, 0, 4);
            break;

        case "#assembly":
            RpcSelectCard(hosts, id);
            break;

        case "#initial_shine":
            RpcGaincard(hosts, "draw");
            break;

        case "#dangerous_contact":
            scr_meditator med         = GameObject.FindGameObjectWithTag("Meditator").GetComponent <scr_meditator>();
            int           sav_handCnt = (hosts)? med.serverHandcnt : med.clientHandcnt;
            for (int i = 0; i < 3; i++)
            {
                RpcGaincardExtended(hosts, "draw", "NotDarkRemove");
            }
            if (sav_handCnt != -1)
            {
                if (hosts)
                {
                    if (sav_handCnt == med.serverHandcnt)
                    {
                        RpcGaincardExtended(hosts, "draw", "RemoveAll");
                    }
                }
                else
                {
                    if (sav_handCnt == med.clientHandcnt)
                    {
                        RpcGaincardExtended(hosts, "draw", "RemoveAll");
                    }
                }
            }
            break;

        case "#doll_gathering":
            for (int i = 0; i < 3; i++)
            {
                RpcGaincardExtended(hosts, "doll", "IFINDECK");
            }
            break;

        case "#doll_regression":
            for (int i = 0; i < 3; i++)
            {
                RpcGaincardExtended(hosts, "doll", "TOMBTOHAND");
            }
            RpcGaincard(hosts, "draw");
            break;

        case "#doll_sacrifice":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts == hosts && (curData.id == "doll" || curData.id == "tetra"))
                {
                    curData.CmdgetSelfStatus(1, 1);
                }
            }
            break;

        case "#wisdom_eye":
            RpcGaincard(hosts, "draw");
            RpcGaincard(hosts, "draw");
            break;

        case "#heal_leaf":
            CmdGainStatus(hosts, 0, 8);
            break;

        case "#earthquake":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit data = cur.GetComponent <scr_unit>();
                if (!data.card_tag.Contains("Earth"))
                {
                    data.CmdDamage(cur, 2);
                }
            }
            break;

        case "#luminous_badge":
            CmdSetEnvironment("luminous_badge");
            break;

        case "#Archmage_rune":
            CmduseTerial(cost);
            CmdSetEnvironment("archmage_rune");
            break;

        case "#union_roar":
            CmdSelectCard(hosts, id);
            break;

        case "#ren_wakeup":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                cur.GetComponent <scr_unit>().CmdDamage(cur, 5);
            }
            break;

        case "#halfmoon_strike":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts != hosts)
                {
                    curData.CmdDamage(cur, 6);
                }
            }
            RpcGaincard(hosts, "draw");
            RpcGaincard(hosts, "draw");
            break;

        case "#latien_prelude":
            RpcGaincard(hosts, "draw");
            RpcGaincard(hosts, "draw");
            break;

        case "#latien_choir":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts == hosts)
                {
                    curData.CmdgetSelfStatus(2, 2);
                }
            }
            break;

        case "#latien_fantasia":
            RpcSelectCard(hosts, id);
            break;

        case "#latien_lyrics":
            foreach (GameObject cur in GameObject.FindGameObjectsWithTag("Unit"))
            {
                scr_unit curData = cur.GetComponent <scr_unit>();
                if (curData.hosts != hosts)
                {
                    curData.CmdDamage(cur, 3);
                }
            }
            break;

        default:
            break;
        }
        CmduseTerial(cost);
        if (used)
        {
            RpcUseSpell(hosts, id);
        }
    }