Beispiel #1
0
    public IEnumerator MoveDoble(GameObject nextTile, int a)
    {
        if (classMatch.PlayerInTurn == MatchDates.Instance.myPos + 1)
        {
            FichaVariosJugadoresOnline tile = nextTile.GetComponent <FichaVariosJugadoresOnline>();

            classMetodosOthers.PV.RPC("RPC_MoveDoble", RpcTarget.Others, tile.pointUp, tile.pointDown, pointUp, pointDown, a, colliderWall1, colliderWall2);

            tile.inverse = !tile.inverse;

            if (a == 180)
            {
                a = 0;
            }
            if (a == 0)
            {
                a = 180;
            }

            if (classMatch.tileLeft == nextTile && colliderWall1 || classMatch.tileRight == nextTile && colliderWall1)
            {
                pos = new Vector3(transform.position.x, transform.position.y, transform.position.z - 1.9f);
            }

            if (classMatch.tileLeft == nextTile && colliderWall2 || classMatch.tileRight == nextTile && colliderWall2)
            {
                pos = new Vector3(transform.position.x, transform.position.y, transform.position.z + 1.9f);
            }

            var angl = nextTile.transform.rotation.eulerAngles;
            angl.z = a;
            angl.x = 90;
            nextTile.transform.rotation = Quaternion.Euler(angl);

            float normalizedTime = 0.0f;
            classMatch.classGeneral.putTile.Play();

            while (normalizedTime < 1)
            {
                nextTile.transform.position = Vector3.Lerp(nextTile.transform.position, pos, normalizedTime);
                normalizedTime += Time.deltaTime / duration;
                yield return(null);
            }

            nextTile.transform.position = pos;
            classMatch.ChangeTilesToNormal();
            yield return(new WaitForSeconds(1f));

            classMatch.noPlay = false;
            MatchDates.Instance.selectedFicha = null;
            classMatch.ValidateEnd();
            classMatch.ChangeTurn();
        }
    }
Beispiel #2
0
    public void RPC_RotTile(int Up, int Down, int TableUp, int TableDown, int z, int x, float valueX, float valueZ)
    {
        FindTile(Up, Down, false);
        FindTile(TableUp, TableDown, true);

        FichaVariosJugadoresOnline tile = currentTile.GetComponent <FichaVariosJugadoresOnline>();

        if (!tile.doble)
        {
            var angles = currentTile.transform.rotation.eulerAngles;
            angles.x = x;
            angles.z = z;
            currentTile.transform.rotation = Quaternion.Euler(angles);
        }

        pos = new Vector3(tableTile.transform.position.x + valueX, tableTile.transform.position.y, tableTile.transform.position.z + valueZ);

        StartCoroutine(Movement(currentTile, false));
    }
Beispiel #3
0
    public void RPC_MoveDoble(int Up, int Down, int TableUp, int TableDown, int a, bool collider1, bool collider2)
    {
        FindTile(Up, Down, false);
        FindTile(TableUp, TableDown, true);

        FichaVariosJugadoresOnline tile        = currentTile.GetComponent <FichaVariosJugadoresOnline>();
        FichaVariosJugadoresOnline tileInTable = tableTile.GetComponent <FichaVariosJugadoresOnline>();

        tileInTable.colliderWall1 = collider1;
        tileInTable.colliderWall2 = collider2;

        tile.inverse = !tile.inverse;

        if (a == 180)
        {
            a = 0;
        }
        if (a == 0)
        {
            a = 180;
        }

        if (classMatch.tileLeft == currentTile && tileInTable.colliderWall1 || classMatch.tileRight == currentTile && tileInTable.colliderWall1)
        {
            pos = new Vector3(tableTile.transform.position.x, tableTile.transform.position.y, tableTile.transform.position.z - 1.9f);
        }

        if (classMatch.tileLeft == currentTile && tileInTable.colliderWall2 || classMatch.tileRight == currentTile && tileInTable.colliderWall2)
        {
            pos = new Vector3(tableTile.transform.position.x, tableTile.transform.position.y, tableTile.transform.position.z + 1.9f);
        }

        var angl = currentTile.transform.rotation.eulerAngles;

        angl.z = a;
        angl.x = 90;
        currentTile.transform.rotation = Quaternion.Euler(angl);

        StartCoroutine(Movement(currentTile, false));
    }
Beispiel #4
0
    private void OnMouseUpAsButton()
    {
        if (PhotonNetwork.PlayerList.Length > 2)
        {
            if (!onTable && classMatch.PlayerInTurn == MatchDates.Instance.myPos + 1 && !classMatch.noPlay && !classMatch.pause && !classMatch.panelOpened)
            {
                if (classMatch.startPlayer)
                {
                    classMatch.noPlay      = true;
                    classMatch.startPlayer = false;

                    classMatch.ChangeTilesToNormal();
                    classMetodosOthers.PV.RPC("RPC_StartMov", RpcTarget.All, pointUp, pointDown, classMatch.PlayerInTurn);
                }
                else
                {
                    GameObject childTileRight = classMatch.tileRight.transform.GetChild(0).gameObject;
                    childTileRight.GetComponent <SpriteRenderer>().sprite = classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                    GameObject childTileLeft = classMatch.tileLeft.transform.GetChild(0).gameObject;
                    childTileLeft.GetComponent <SpriteRenderer>().sprite = classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                    bool left  = false;
                    bool right = false;

                    if (pointDown == classMatch.countLeft || pointUp == classMatch.countLeft)
                    {
                        GameObject tileLeft = classMatch.tileLeft.transform.GetChild(0).gameObject;
                        tileLeft.GetComponent <SpriteRenderer>().sprite = classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().backsTile[1];
                        left = true;
                    }

                    if (pointDown == classMatch.countRight || pointUp == classMatch.countRight)
                    {
                        GameObject tileRight = classMatch.tileRight.transform.GetChild(0).gameObject;
                        tileRight.GetComponent <SpriteRenderer>().sprite = classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().backsTile[1];
                        right = true;
                    }

                    if (!right && left || right && !left)
                    {
                        classMatch.noPlay  = true;
                        classMatch.capicua = false;

                        GameObject childTileRight1 = classMatch.tileRight.transform.GetChild(0).gameObject;
                        childTileRight1.GetComponent <SpriteRenderer>().sprite = classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                        GameObject childTileLeft2 = classMatch.tileLeft.transform.GetChild(0).gameObject;
                        childTileLeft2.GetComponent <SpriteRenderer>().sprite = classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                        MatchDates.Instance.selectedFicha = transform.gameObject;

                        if (left)
                        {
                            classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().MovNexTile(transform.gameObject);
                        }
                        else
                        {
                            classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().MovNexTile(transform.gameObject);
                        }
                    }

                    if (classMatch.countLeft == classMatch.countRight && left && right && classMatch.tileLeft != classMatch.tileRight)
                    {
                        classMatch.noPlay  = true;
                        classMatch.capicua = false;

                        GameObject childTileRight1 = classMatch.tileRight.transform.GetChild(0).gameObject;
                        childTileRight1.GetComponent <SpriteRenderer>().sprite = classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                        GameObject childTileLeft2 = classMatch.tileLeft.transform.GetChild(0).gameObject;
                        childTileLeft2.GetComponent <SpriteRenderer>().sprite = classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                        MatchDates.Instance.selectedFicha = transform.gameObject;

                        classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().MovNexTile(transform.gameObject);
                    }

                    if (left || right)
                    {
                        if (classMatch.tileLeft == classMatch.tileRight)
                        {
                            classMatch.noPlay  = true;
                            classMatch.capicua = false;

                            GameObject childFirstTile = classMatch.firstTile.transform.GetChild(0).gameObject;
                            childFirstTile.GetComponent <SpriteRenderer>().sprite = classMatch.firstTile.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                            MatchDates.Instance.selectedFicha = transform.gameObject;

                            classMatch.firstTile.GetComponent <FichaVariosJugadoresOnline>().MovNexTile(transform.gameObject);
                        }
                    }

                    if (MatchDates.Instance.selectedFicha == null && left && right)
                    {
                        MatchDates.Instance.selectedFicha = transform.gameObject;
                    }
                }
            }
            else if (onTable && classMatch.PlayerInTurn == MatchDates.Instance.myPos + 1 && MatchDates.Instance.selectedFicha != null)
            {
                if (transform.gameObject == classMatch.tileLeft || transform.gameObject == classMatch.tileRight)
                {
                    classMatch.classGeneral.putTile.Play();
                    classMatch.noPlay = true;
                    GameObject childTileRight = classMatch.tileRight.transform.GetChild(0).gameObject;
                    childTileRight.GetComponent <SpriteRenderer>().sprite = classMatch.tileRight.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                    GameObject childTileLeft = classMatch.tileLeft.transform.GetChild(0).gameObject;
                    childTileLeft.GetComponent <SpriteRenderer>().sprite = classMatch.tileLeft.GetComponent <FichaVariosJugadoresOnline>().backsTile[0];

                    FichaVariosJugadoresOnline selectedFicha = MatchDates.Instance.selectedFicha.GetComponent <FichaVariosJugadoresOnline>();

                    classMatch.capicua = false;

                    if (selectedFicha.pointDown == classMatch.countLeft && selectedFicha.pointUp == classMatch.countRight ||
                        selectedFicha.pointDown == classMatch.countRight && selectedFicha.pointUp == classMatch.countLeft)
                    {
                        classMatch.capicua = true;
                    }

                    MovNexTile(MatchDates.Instance.selectedFicha);
                }
            }
        }
    }
Beispiel #5
0
    public IEnumerator Move(GameObject nextTile, int a, float mov)
    {
        if (classMatch.PlayerInTurn == MatchDates.Instance.myPos + 1)

        {
            FichaVariosJugadoresOnline tile = nextTile.GetComponent <FichaVariosJugadoresOnline>();

            classMetodosOthers.PV.RPC("RPC_Move", RpcTarget.Others, tile.pointUp, tile.pointDown, pointUp, pointDown, a, mov, colliderWall1, colliderWall2);

            classMatch.CountTile(nextTile);

            if (a == 180)
            {
                tile.inverse = true;
            }

            tile.onTable         = true;
            classMatch.countPase = 0;

            nextTile.transform.SetParent(classMatch.table.transform);
            nextTile.transform.localScale = new Vector3(0.7f, 0.7f, 1);

            var angles = nextTile.transform.rotation.eulerAngles;
            angles.y = a;
            angles.x = 90;
            nextTile.transform.rotation = Quaternion.Euler(angles);

            pos = new Vector3(transform.position.x, transform.position.y, transform.position.z + mov);

            if (colliderWall1 && nocollider == false || colliderWall2 && nocollider == false)
            {
                tile.nocollider = true;
                tile.moved      = true;

                if (colliderWall1)
                {
                    tile.colliderWall1 = true;
                }
                if (colliderWall2)
                {
                    tile.colliderWall2 = true;
                }

                MovedTile(nextTile);
                yield break;
            }

            if (moved)
            {
                if (colliderWall1)
                {
                    tile.colliderWall1 = true;
                }
                if (colliderWall2)
                {
                    tile.colliderWall2 = true;
                }

                tile.nocollider = true;

                if (tile.doble)
                {
                    tile.movedDoble = true;
                }

                StartCoroutine(TurnTile(nextTile, a));
                yield break;
            }

            if (movedDoble)
            {
                if (colliderWall1)
                {
                    tile.colliderWall1 = true;
                }
                if (colliderWall2)
                {
                    tile.colliderWall2 = true;
                }

                tile.nocollider = true;

                StartCoroutine(MoveDoble(nextTile, a));
                yield break;
            }

            float normalizedTime = 0.0f;
            classMatch.classGeneral.putTile.Play();

            while (normalizedTime < 1)
            {
                nextTile.transform.position = Vector3.Lerp(nextTile.transform.position, pos, normalizedTime);
                normalizedTime += Time.deltaTime / duration;
                yield return(null);
            }

            nextTile.transform.position = pos;
            classMatch.ChangeTilesToNormal();

            yield return(new WaitForSeconds(1f));

            classMatch.noPlay = false;
            MatchDates.Instance.selectedFicha = null;
            classMatch.ValidateEnd();
            classMatch.ChangeTurn();
        }
    }
Beispiel #6
0
    public void MovNexTile(GameObject nextTile) // Este método lo hace la ficha de la mesa
    {
        if (classMatch.PlayerInTurn == MatchDates.Instance.myPos + 1)
        {
            FichaVariosJugadoresOnline tile = nextTile.GetComponent <FichaVariosJugadoresOnline>();

            classMetodosOthers.PV.RPC("RPC_MovNexTile", RpcTarget.Others, tile.pointUp, tile.pointDown, pointUp, pointDown);

            if (transform.gameObject == classMatch.firstTile)
            {
                if (!closedUp && pointUp == tile.pointDown)
                {
                    closedUp             = true;
                    tile.closedDown      = true;
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = nextTile;

                    if (tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    if (!tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 0, 1.9f));
                    }
                    if (!tile.doble && doble)
                    {
                        StartCoroutine(Move(nextTile, 0, 1.45f));
                    }

                    return;
                }

                if (!closedUp && pointUp == tile.pointUp)
                {
                    closedUp             = true;
                    tile.closedUp        = true;
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = nextTile;

                    if (tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    if (!tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 180, 1.9f));
                    }
                    if (!tile.doble && doble)
                    {
                        StartCoroutine(Move(nextTile, 180, 1.45f));
                    }
                    return;
                }

                if (!closedDown && pointDown == tile.pointUp)
                {
                    closedDown            = true;
                    tile.closedUp         = true;
                    classMatch.tileRight  = nextTile;
                    classMatch.countRight = tile.pointDown;

                    if (tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    if (!tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 0, -1.9f));
                    }
                    if (!tile.doble && doble)
                    {
                        StartCoroutine(Move(nextTile, 0, -1.45f));
                    }
                    return;
                }

                if (!closedDown && pointDown == tile.pointDown)
                {
                    closedDown            = true;
                    tile.closedDown       = true;
                    classMatch.tileRight  = nextTile;
                    classMatch.countRight = tile.pointUp;

                    if (tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    if (!tile.doble && !doble)
                    {
                        StartCoroutine(Move(nextTile, 180, -1.9f));
                    }
                    if (!tile.doble && doble)
                    {
                        StartCoroutine(Move(nextTile, 180, -1.45f));
                    }
                }
            }
            else
            {
                if (!closedUp && !inverse && !doble && pointUp == tile.pointDown)
                {
                    closedUp        = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 0, 1.9f));
                    }

                    return;
                }

                if (!closedDown && inverse && !doble && pointDown == tile.pointDown)
                {
                    closedDown      = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 0, 1.9f));
                    }
                    return;
                }

                if (!closedDown && !inverse && !doble && pointDown == tile.pointUp)
                {
                    closedDown    = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 0, -1.9f));
                    }
                    return;
                }

                if (!closedUp && inverse && !doble && pointUp == tile.pointUp)
                {
                    closedUp      = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 0, -1.9f));
                    }
                    return;
                }

                if (!closedUp && !inverse && !doble && pointUp == tile.pointUp)
                {
                    closedUp      = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 180, 1.9f));
                    }
                    return;
                }

                if (!closedDown && inverse && !doble && pointDown == tile.pointUp)
                {
                    closedDown    = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, 1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 180, 1.9f));
                    }
                    return;
                }

                if (!closedDown && !inverse && !doble && pointDown == tile.pointDown)
                {
                    closedDown      = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 180, -1.9f));
                    }
                    return;
                }

                if (!closedUp && inverse && !doble && pointUp == tile.pointDown)
                {
                    closedUp        = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    if (tile.doble)
                    {
                        StartCoroutine(Move(nextTile, 90, -1.45f));
                    }
                    else
                    {
                        StartCoroutine(Move(nextTile, 180, -1.9f));
                    }
                    return;
                }

                if (!closedUp && doble && pointUp == tile.pointDown)
                {
                    closedUp        = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    StartCoroutine(Move(nextTile, 0, 1.45f));
                    return;
                }

                if (!closedDown && doble && pointDown == tile.pointUp)
                {
                    closedDown    = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    StartCoroutine(Move(nextTile, 0, -1.45f));
                    return;
                }

                if (!closedUp && doble && pointUp == tile.pointUp)
                {
                    closedUp      = true;
                    tile.closedUp = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointDown;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointDown;
                    }

                    StartCoroutine(Move(nextTile, 180, 1.45f));
                    return;
                }

                if (!closedDown && doble && pointDown == tile.pointDown)
                {
                    closedDown      = true;
                    tile.closedDown = true;

                    if (classMatch.tileLeft == transform.gameObject)
                    {
                        classMatch.countLeft = tile.pointUp;
                        classMatch.tileLeft  = nextTile;
                    }
                    else
                    {
                        classMatch.tileRight  = nextTile;
                        classMatch.countRight = tile.pointUp;
                    }

                    StartCoroutine(Move(nextTile, 180, -1.45f));
                }
            }
        }
    }
Beispiel #7
0
    public void RPC_Move(int Up, int Down, int TableUp, int TableDown, int a, float mov, bool collider1, bool collider2)
    {
        FindTile(Up, Down, false);
        FindTile(TableUp, TableDown, true);

        FichaVariosJugadoresOnline tile        = currentTile.GetComponent <FichaVariosJugadoresOnline>();
        FichaVariosJugadoresOnline tileInTable = tableTile.GetComponent <FichaVariosJugadoresOnline>();

        tileInTable.colliderWall1 = collider1;
        tileInTable.colliderWall2 = collider2;

        if (a == 180)
        {
            tile.inverse = true;
        }

        tile.onTable         = true;
        classMatch.countPase = 0;

        currentTile.transform.SetParent(classMatch.table.transform);
        currentTile.transform.localScale = new Vector3(0.7f, 0.7f, 1);

        var angles = currentTile.transform.rotation.eulerAngles;

        angles.y = a;
        angles.x = 90;
        currentTile.transform.rotation = Quaternion.Euler(angles);

        pos = new Vector3(tableTile.transform.position.x, tableTile.transform.position.y, tableTile.transform.position.z + mov);

        if (collider1 && tileInTable.nocollider == false || collider2 && tileInTable.nocollider == false)
        {
            tile.nocollider = true;
            tile.moved      = true;

            if (collider1)
            {
                tile.colliderWall1 = true;
            }
            if (collider2)
            {
                tile.colliderWall2 = true;
            }

            return;
        }

        if (tileInTable.moved)
        {
            if (collider1)
            {
                tile.colliderWall1 = true;
            }
            if (collider2)
            {
                tile.colliderWall2 = true;
            }

            tile.nocollider = true;

            if (tile.doble)
            {
                tile.movedDoble = true;
            }

            return;
        }

        if (tileInTable.movedDoble)
        {
            if (collider1)
            {
                tile.colliderWall1 = true;
            }
            if (collider2)
            {
                tile.colliderWall2 = true;
            }

            tile.nocollider = true;

            return;
        }

        StartCoroutine(Movement(currentTile, false));
    }
Beispiel #8
0
    public void RPC_MovNexTile(int Up, int Down, int TableUp, int TableDown)
    {
        FindTile(Up, Down, false);
        FindTile(TableUp, TableDown, true);

        FichaVariosJugadoresOnline tile        = currentTile.GetComponent <FichaVariosJugadoresOnline>();
        FichaVariosJugadoresOnline tileInTable = tableTile.GetComponent <FichaVariosJugadoresOnline>();

        if (tableTile.transform.gameObject == classMatch.firstTile)
        {
            if (!tileInTable.closedUp && tileInTable.pointUp == tile.pointDown)
            {
                tileInTable.closedUp = true;
                tile.closedDown      = true;
                classMatch.countLeft = tile.pointUp;
                classMatch.tileLeft  = currentTile;

                return;
            }

            if (!tileInTable.closedUp && tileInTable.pointUp == tile.pointUp)
            {
                tileInTable.closedUp = true;
                tile.closedUp        = true;
                classMatch.countLeft = tile.pointDown;
                classMatch.tileLeft  = currentTile;

                return;
            }

            if (!tileInTable.closedDown && tileInTable.pointDown == tile.pointUp)
            {
                tileInTable.closedDown = true;
                tile.closedUp          = true;
                classMatch.tileRight   = currentTile;
                classMatch.countRight  = tile.pointDown;

                return;
            }

            if (!tileInTable.closedDown && tileInTable.pointDown == tile.pointDown)
            {
                tileInTable.closedDown = true;
                tile.closedDown        = true;
                classMatch.tileRight   = currentTile;
                classMatch.countRight  = tile.pointUp;
            }
        }
        else
        {
            if (!tileInTable.closedUp && !tileInTable.inverse && !tileInTable.doble && tileInTable.pointUp == tile.pointDown)
            {
                tileInTable.closedUp = true;
                tile.closedDown      = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }

                return;
            }

            if (!tileInTable.closedDown && tileInTable.inverse && !tileInTable.doble && tileInTable.pointDown == tile.pointDown)
            {
                tileInTable.closedDown = true;
                tile.closedDown        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }

                return;
            }

            if (!tileInTable.closedDown && !tileInTable.inverse && !tileInTable.doble && tileInTable.pointDown == tile.pointUp)
            {
                tileInTable.closedDown = true;
                tile.closedUp          = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedUp && tileInTable.inverse && !tileInTable.doble && tileInTable.pointUp == tile.pointUp)
            {
                tileInTable.closedUp = true;
                tile.closedUp        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedUp && !tileInTable.inverse && !tileInTable.doble && tileInTable.pointUp == tile.pointUp)
            {
                tileInTable.closedUp = true;
                tile.closedUp        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedDown && tileInTable.inverse && !tileInTable.doble && tileInTable.pointDown == tile.pointUp)
            {
                tileInTable.closedDown = true;
                tile.closedUp          = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedDown && !tileInTable.inverse && !tileInTable.doble && tileInTable.pointDown == tile.pointDown)
            {
                tileInTable.closedDown = true;
                tile.closedDown        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }

                return;
            }

            if (!tileInTable.closedUp && tileInTable.inverse && !tileInTable.doble && tileInTable.pointUp == tile.pointDown)
            {
                tileInTable.closedUp = true;
                tile.closedDown      = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }

                return;
            }

            if (!tileInTable.closedUp && tileInTable.doble && tileInTable.pointUp == tile.pointDown)
            {
                tileInTable.closedUp = true;
                tile.closedDown      = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }

                return;
            }

            if (!tileInTable.closedDown && tileInTable.doble && tileInTable.pointDown == tile.pointUp)
            {
                tileInTable.closedDown = true;
                tile.closedUp          = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedUp && tileInTable.doble && tileInTable.pointUp == tile.pointUp)
            {
                tileInTable.closedUp = true;
                tile.closedUp        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointDown;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointDown;
                }

                return;
            }

            if (!tileInTable.closedDown && tileInTable.doble && tileInTable.pointDown == tile.pointDown)
            {
                tileInTable.closedDown = true;
                tile.closedDown        = true;

                if (classMatch.tileLeft == tableTile)
                {
                    classMatch.countLeft = tile.pointUp;
                    classMatch.tileLeft  = currentTile;
                }
                else
                {
                    classMatch.tileRight  = currentTile;
                    classMatch.countRight = tile.pointUp;
                }
            }
        }
    }