Ejemplo n.º 1
0
    public void cardToScreenPlayerOne(float xPosition, float yPosition)
    {
        GameObject  manager     = GameObject.Find("_Manager");
        DeckObjects deckobjects = manager.GetComponent <DeckObjects>();

        for (int i = 0; i <= playerOneCards.Count - 1; i++)
        {
            xPosition = i * 200;

            #region switch statement player one
            switch (playerOneCards[i])
            {
            case "twoH":
                objectsOnScreen.Add(Instantiate(deckobjects.twoH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "twoH";
                break;

            case "threeH":
                objectsOnScreen.Add(Instantiate(deckobjects.threeH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "threeH";
                break;

            case "fourH":
                objectsOnScreen.Add(Instantiate(deckobjects.fourH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fourH";
                break;

            case "fiveH":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fiveH";
                break;

            case "sixH":
                objectsOnScreen.Add(Instantiate(deckobjects.sixH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sixH";
                break;

            case "sevenH":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sevenH";
                break;

            case "eightH":
                objectsOnScreen.Add(Instantiate(deckobjects.eightH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "eightH";
                break;

            case "nineH":
                objectsOnScreen.Add(Instantiate(deckobjects.nineH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "nineH";
                break;

            case "tenH":
                objectsOnScreen.Add(Instantiate(deckobjects.tenH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "tenH";
                break;

            case "jackH":
                objectsOnScreen.Add(Instantiate(deckobjects.jackH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "jackH";
                break;

            case "queenH":
                objectsOnScreen.Add(Instantiate(deckobjects.queenH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "queenH";
                break;

            case "kingH":
                objectsOnScreen.Add(Instantiate(deckobjects.kingH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "kingH";
                break;

            case "aceH":
                objectsOnScreen.Add(Instantiate(deckobjects.aceH, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "aceH";
                break;

            //Diamonds
            case "twoD":
                objectsOnScreen.Add(Instantiate(deckobjects.twoD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "twoD";
                break;

            case "threeD":
                objectsOnScreen.Add(Instantiate(deckobjects.threeD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "threeD";
                break;

            case "fourD":
                objectsOnScreen.Add(Instantiate(deckobjects.fourD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fourD";
                break;

            case "fiveD":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fiveD";
                break;

            case "sixD":
                objectsOnScreen.Add(Instantiate(deckobjects.sixD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sixD";
                break;

            case "sevenD":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sevenD";
                break;

            case "eightD":
                objectsOnScreen.Add(Instantiate(deckobjects.eightD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "eightD";
                break;

            case "nineD":
                objectsOnScreen.Add(Instantiate(deckobjects.nineD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "nineD";
                break;

            case "tenD":
                objectsOnScreen.Add(Instantiate(deckobjects.tenD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "tenD";
                break;

            case "jackD":
                objectsOnScreen.Add(Instantiate(deckobjects.jackD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "jackD";
                break;

            case "queenD":
                objectsOnScreen.Add(Instantiate(deckobjects.queenD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "queenD";
                break;

            case "kingD":
                objectsOnScreen.Add(Instantiate(deckobjects.kingD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "kingD";
                break;

            case "aceD":
                objectsOnScreen.Add(Instantiate(deckobjects.aceD, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "aceD";
                break;

            //Clubs
            case "twoC":
                objectsOnScreen.Add(Instantiate(deckobjects.twoC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "twoC";
                break;

            case "threeC":
                objectsOnScreen.Add(Instantiate(deckobjects.threeC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "threeC";
                break;

            case "fourC":
                objectsOnScreen.Add(Instantiate(deckobjects.fourC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fourC";
                break;

            case "fiveC":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fiveC";
                break;

            case "sixC":
                objectsOnScreen.Add(Instantiate(deckobjects.sixC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sixC";
                break;

            case "sevenC":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sevenC";
                break;

            case "eightC":
                objectsOnScreen.Add(Instantiate(deckobjects.eightC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "eightC";
                break;

            case "nineC":
                objectsOnScreen.Add(Instantiate(deckobjects.nineC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "nineC";
                break;

            case "tenC":
                objectsOnScreen.Add(Instantiate(deckobjects.tenC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "tenC";
                break;

            case "jackC":
                objectsOnScreen.Add(Instantiate(deckobjects.jackC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "jackC";
                break;

            case "queenC":
                objectsOnScreen.Add(Instantiate(deckobjects.queenC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "queenC";
                break;

            case "kingC":
                objectsOnScreen.Add(Instantiate(deckobjects.kingC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "kingC";
                break;

            case "aceC":
                objectsOnScreen.Add(Instantiate(deckobjects.aceC, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "aceC";
                break;

            //Spades
            case "twoS":
                objectsOnScreen.Add(Instantiate(deckobjects.twoS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "twoS";
                break;

            case "threeS":
                objectsOnScreen.Add(Instantiate(deckobjects.threeS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "threeS";
                break;

            case "fourS":
                objectsOnScreen.Add(Instantiate(deckobjects.fourS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fourS";
                break;

            case "fiveS":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "fiveS";
                break;

            case "sixS":
                objectsOnScreen.Add(Instantiate(deckobjects.sixS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sixS";
                break;

            case "sevenS":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "sevenS";
                break;

            case "eightS":
                objectsOnScreen.Add(Instantiate(deckobjects.eightS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "eightS";
                break;

            case "nineS":
                objectsOnScreen.Add(Instantiate(deckobjects.nineS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "nineS";
                break;

            case "tenS":
                objectsOnScreen.Add(Instantiate(deckobjects.tenS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "tenS";
                break;

            case "jackS":
                objectsOnScreen.Add(Instantiate(deckobjects.jackS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "jackS";
                break;

            case "queenS":
                objectsOnScreen.Add(Instantiate(deckobjects.queenS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "queenS";
                break;

            case "kingS":
                objectsOnScreen.Add(Instantiate(deckobjects.kingS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "kingS";
                break;

            case "aceS":
                objectsOnScreen.Add(Instantiate(deckobjects.aceS, new Vector3(xPosition, yPosition, 0), Quaternion.identity) as GameObject);
                lastCardPlayedPlayerOne = "aceS";
                break;
            }
            #endregion
        }
    }
Ejemplo n.º 2
0
    public void cardToScreenOpponent(float xPosition, float yPosition)
    {
        GameObject  manager     = GameObject.Find("_Manager");
        DeckObjects deckobjects = manager.GetComponent <DeckObjects>();
        Quaternion  rotation;

        for (int i = 0; i <= opponentCards.Count - 1; i++)
        {
            xPosition = i * 200;

            //this makes sure first card of dealers hand is facedown
            if (i == 0)
            {
                rotation = deckobjects.twoH.transform.rotation;
            }
            else
            {
                rotation = Quaternion.identity;
            }

            #region switch statement opponent
            switch (opponentCards[i])
            {
            case "twoH":
                objectsOnScreen.Add(Instantiate(deckobjects.twoH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "twoH";
                break;

            case "threeH":
                objectsOnScreen.Add(Instantiate(deckobjects.threeH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "threeH";
                break;

            case "fourH":
                objectsOnScreen.Add(Instantiate(deckobjects.fourH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fourH";
                break;

            case "fiveH":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fiveH";
                break;

            case "sixH":
                objectsOnScreen.Add(Instantiate(deckobjects.sixH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sixH";
                break;

            case "sevenH":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sevenH";
                break;

            case "eightH":
                objectsOnScreen.Add(Instantiate(deckobjects.eightH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "eightH";
                break;

            case "nineH":
                objectsOnScreen.Add(Instantiate(deckobjects.nineH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "nineH";
                break;

            case "tenH":
                objectsOnScreen.Add(Instantiate(deckobjects.tenH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "tenH";
                break;

            case "jackH":
                objectsOnScreen.Add(Instantiate(deckobjects.jackH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "jackH";
                break;

            case "queenH":
                objectsOnScreen.Add(Instantiate(deckobjects.queenH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "queenH";
                break;

            case "kingH":
                objectsOnScreen.Add(Instantiate(deckobjects.kingH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "kingH";
                break;

            case "aceH":
                objectsOnScreen.Add(Instantiate(deckobjects.aceH, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "aceH";
                break;

            //Diamonds
            case "twoD":
                objectsOnScreen.Add(Instantiate(deckobjects.twoD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "twoD";
                break;

            case "threeD":
                objectsOnScreen.Add(Instantiate(deckobjects.threeD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "threeD";
                break;

            case "fourD":
                objectsOnScreen.Add(Instantiate(deckobjects.fourD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fourD";
                break;

            case "fiveD":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fiveD";
                break;

            case "sixD":
                objectsOnScreen.Add(Instantiate(deckobjects.sixD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sixD";
                break;

            case "sevenD":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sevenD";
                break;

            case "eightD":
                objectsOnScreen.Add(Instantiate(deckobjects.eightD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "eightD";
                break;

            case "nineD":
                objectsOnScreen.Add(Instantiate(deckobjects.nineD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "nineD";
                break;

            case "tenD":
                objectsOnScreen.Add(Instantiate(deckobjects.tenD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "tenD";
                break;

            case "jackD":
                objectsOnScreen.Add(Instantiate(deckobjects.jackD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "jackD";
                break;

            case "queenD":
                objectsOnScreen.Add(Instantiate(deckobjects.queenD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "queenD";
                break;

            case "kingD":
                objectsOnScreen.Add(Instantiate(deckobjects.kingD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "kingD";
                break;

            case "aceD":
                objectsOnScreen.Add(Instantiate(deckobjects.aceD, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "aceD";
                break;

            //Clubs
            case "twoC":
                objectsOnScreen.Add(Instantiate(deckobjects.twoC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "twoC";
                break;

            case "threeC":
                objectsOnScreen.Add(Instantiate(deckobjects.threeC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "threeC";
                break;

            case "fourC":
                objectsOnScreen.Add(Instantiate(deckobjects.fourC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fourC";
                break;

            case "fiveC":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fiveC";
                break;

            case "sixC":
                objectsOnScreen.Add(Instantiate(deckobjects.sixC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sixC";
                break;

            case "sevenC":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sevenC";
                break;

            case "eightC":
                objectsOnScreen.Add(Instantiate(deckobjects.eightC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "eightC";
                break;

            case "nineC":
                objectsOnScreen.Add(Instantiate(deckobjects.nineC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "nineC";
                break;

            case "tenC":
                objectsOnScreen.Add(Instantiate(deckobjects.tenC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "tenC";
                break;

            case "jackC":
                objectsOnScreen.Add(Instantiate(deckobjects.jackC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "jackC";
                break;

            case "queenC":
                objectsOnScreen.Add(Instantiate(deckobjects.queenC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "queenC";
                break;

            case "kingC":
                objectsOnScreen.Add(Instantiate(deckobjects.kingC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "kingC";
                break;

            case "aceC":
                objectsOnScreen.Add(Instantiate(deckobjects.aceC, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "aceC";
                break;

            //Spades
            case "twoS":
                objectsOnScreen.Add(Instantiate(deckobjects.twoS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "twoS";
                break;

            case "threeS":
                objectsOnScreen.Add(Instantiate(deckobjects.threeS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "threeS";
                break;

            case "fourS":
                objectsOnScreen.Add(Instantiate(deckobjects.fourS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fourS";
                break;

            case "fiveS":
                objectsOnScreen.Add(Instantiate(deckobjects.fiveS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "fiveS";
                break;

            case "sixS":
                objectsOnScreen.Add(Instantiate(deckobjects.sixS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sixS";
                break;

            case "sevenS":
                objectsOnScreen.Add(Instantiate(deckobjects.sevenS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "sevenS";
                break;

            case "eightS":
                objectsOnScreen.Add(Instantiate(deckobjects.eightS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "eightS";
                break;

            case "nineS":
                objectsOnScreen.Add(Instantiate(deckobjects.nineS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "nineS";
                break;

            case "tenS":
                objectsOnScreen.Add(Instantiate(deckobjects.tenS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "tenS";
                break;

            case "jackS":
                objectsOnScreen.Add(Instantiate(deckobjects.jackS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "jackS";
                break;

            case "queenS":
                objectsOnScreen.Add(Instantiate(deckobjects.queenS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "queenS";
                break;

            case "kingS":
                objectsOnScreen.Add(Instantiate(deckobjects.kingS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "kingS";
                break;

            case "aceS":
                objectsOnScreen.Add(Instantiate(deckobjects.aceS, new Vector3(xPosition, yPosition, 0), rotation) as GameObject);
                lastCardPlayedOpponent = "aceS";
                break;
            }
            #endregion
        }
    }
Ejemplo n.º 3
0
    public void cardToScreenOpponent()
    {
        GameObject  manager     = GameObject.Find("_Manager");
        DeckObjects deckobjects = manager.GetComponent <DeckObjects>();

        #region switch statement opponent
        switch (opponentCards[0])
        {
        case "twoH":
            Instantiate(deckobjects.twoH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "twoH";
            break;

        case "threeH":
            Instantiate(deckobjects.threeH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "threeH";
            break;

        case "fourH":
            Instantiate(deckobjects.fourH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fourH";
            break;

        case "fiveH":
            Instantiate(deckobjects.fiveH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fiveH";
            break;

        case "sixH":
            Instantiate(deckobjects.sixH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sixH";
            break;

        case "sevenH":
            Instantiate(deckobjects.sevenH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sevenH";
            break;

        case "eightH":
            Instantiate(deckobjects.eightH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "eightH";
            break;

        case "nineH":
            Instantiate(deckobjects.nineH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "nineH";
            break;

        case "tenH":
            Instantiate(deckobjects.tenH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "tenH";
            break;

        case "jackH":
            Instantiate(deckobjects.jackH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "jackH";
            break;

        case "queenH":
            Instantiate(deckobjects.queenH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "queenH";
            break;

        case "kingH":
            Instantiate(deckobjects.kingH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "kingH";
            break;

        case "aceH":
            Instantiate(deckobjects.aceH, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "aceH";
            break;

        //Diamonds
        case "twoD":
            Instantiate(deckobjects.twoD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "twoD";
            break;

        case "threeD":
            Instantiate(deckobjects.threeD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "threeD";
            break;

        case "fourD":
            Instantiate(deckobjects.fourD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fourD";
            break;

        case "fiveD":
            Instantiate(deckobjects.fiveD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fiveD";
            break;

        case "sixD":
            Instantiate(deckobjects.sixD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sixD";
            break;

        case "sevenD":
            Instantiate(deckobjects.sevenD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sevenD";
            break;

        case "eightD":
            Instantiate(deckobjects.eightD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "eightD";
            break;

        case "nineD":
            Instantiate(deckobjects.nineD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "nineD";
            break;

        case "tenD":
            Instantiate(deckobjects.tenD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "tenD";
            break;

        case "jackD":
            Instantiate(deckobjects.jackD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "jackD";
            break;

        case "queenD":
            Instantiate(deckobjects.queenD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "queenD";
            break;

        case "kingD":
            Instantiate(deckobjects.kingD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "kingD";
            break;

        case "aceD":
            Instantiate(deckobjects.aceD, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "aceD";
            break;

        //Clubs
        case "twoC":
            Instantiate(deckobjects.twoC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "twoC";
            break;

        case "threeC":
            Instantiate(deckobjects.threeC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "threeC";
            break;

        case "fourC":
            Instantiate(deckobjects.fourC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fourC";
            break;

        case "fiveC":
            Instantiate(deckobjects.fiveC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fiveC";
            break;

        case "sixC":
            Instantiate(deckobjects.sixC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sixC";
            break;

        case "sevenC":
            Instantiate(deckobjects.sevenC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sevenC";
            break;

        case "eightC":
            Instantiate(deckobjects.eightC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "eightC";
            break;

        case "nineC":
            Instantiate(deckobjects.nineC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "nineC";
            break;

        case "tenC":
            Instantiate(deckobjects.tenC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "tenC";
            break;

        case "jackC":
            Instantiate(deckobjects.jackC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "jackC";
            break;

        case "queenC":
            Instantiate(deckobjects.queenC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "queenC";
            break;

        case "kingC":
            Instantiate(deckobjects.kingC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "kingC";
            break;

        case "aceC":
            Instantiate(deckobjects.aceC, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "aceC";
            break;

        //Spades
        case "twoS":
            Instantiate(deckobjects.twoS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "twoS";
            break;

        case "threeS":
            Instantiate(deckobjects.threeS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "threeS";
            break;

        case "fourS":
            Instantiate(deckobjects.fourS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fourS";
            break;

        case "fiveS":
            Instantiate(deckobjects.fiveS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "fiveS";
            break;

        case "sixS":
            Instantiate(deckobjects.sixS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sixS";
            break;

        case "sevenS":
            Instantiate(deckobjects.sevenS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "sevenS";
            break;

        case "eightS":
            Instantiate(deckobjects.eightS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "eightS";
            break;

        case "nineS":
            Instantiate(deckobjects.nineS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "nineS";
            break;

        case "tenS":
            Instantiate(deckobjects.tenS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "tenS";
            break;

        case "jackS":
            Instantiate(deckobjects.jackS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "jackS";
            break;

        case "queenS":
            Instantiate(deckobjects.queenS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "queenS";
            break;

        case "kingS":
            Instantiate(deckobjects.kingS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "kingS";
            break;

        case "aceS":
            Instantiate(deckobjects.aceS, new Vector3(0, 2, 0), Quaternion.identity);
            lastCardPlayedOpponent = "aceS";
            break;
        }
        #endregion
    }