Cursos Empresas Blog Live Conf Eventos Precios

Permitiendo solo ciertos tipos de movimientos

Curso de Desarrollo de Videojuegos Móviles con Unity

Contenido del curso

Introducción

Empezando Nuestro Proyecto

Teoría de Gameplay

Mecánica Principal

Publicacion

Diseño del juego

Conclusiones

34
Juego Match 3 completo en tu teléfono
01:24 min

Tomar examen

Permitiendo solo ciertos tipos de movimientos

Resumen

¿Cómo podemos controlar el movimiento de las piezas en el tablero?

Para mejorar nuestro proyecto de juego, es esencial asegurarnos de que las piezas solo se muevan a espacios permitidos, es decir, a posiciones adyacentes y compatibles. Esto ayudará a mantener la lógica del juego y prevenir movimientos ilógicos que puedan romper las reglas establecidas. Para lograr esto, primero debemos entender lo que significa un "espacio permitido" tanto en el eje horizontal como en el vertical.

¿Cuál es la lógica detrás de los espacios permitidos?

La idea de "espacios permitidos" radica en moverse una sola unidad hacia un lado en el mismo eje o en cambiar una sola unidad de coordenadas, manteniendo constante la otra. Aquí profundizamos en cómo funciona:

Eje Horizontal:
- Las piezas deben compartir la misma coordenada en Y.
- La diferencia en la coordenada X debería ser exactamente 1.
Eje Vertical:
- Las piezas deben compartir la misma coordenada en X.
- La diferencia en la coordenada Y debería ser exactamente 1.

En suma, estos criterios aseguran que las piezas solo se muevan a espacios directamente adyacentes, ya sea horizontal o verticalmente.

¿Cómo implementamos esto en código?

Para poner en práctica esta lógica, crearemos una función que verifique si dos espacios están suficientemente cerca como para permitir un movimiento:

public bool isClosedTo(Tile start, Tile end) {
    // Verificación en el eje X
    if (Math.Abs(start.x - end.x) == 1 && start.y == end.y) {
        return true;
    }
    // Verificación en el eje Y
    if (Math.Abs(start.y - end.y) == 1 && start.x == end.x) {
        return true;
    }
    // Si no cumple ninguna condición, retorno falso
    return false;
}

Este fragmento de código introduce una función isClosedTo que evalúa si dos espacios (representados por Tile) son adyacentes. Utilizamos la función Math.Abs para calcular la diferencia absoluta entre las coordenadas y luego validamos las condiciones mencionadas anteriormente.

¿Cómo integramos la función en nuestro juego?

Una vez creada la función isClosedTo, es crucial integrarla con el resto de la lógica que maneja los movimientos del juego. Así, verificaremos que las piezas no solo tengan puntos de inicio y fin válidos, sino que también estén adecuadamente cerca.

public void TileUp(Tile startTile, Tile endTile) {
    if (startTile != null && endTile != null && isClosedTo(startTile, endTile)) {
        // Código para mover las piezas
    }
}

Al añadir este chequeo adicional, aseguramos que el movimiento solo se realice cuando los espacios son adyacentes. El resultado es una experiencia de juego más precisa y acorde a las reglas establecidas.

Ahora, ve a Unity y comprueba el funcionamiento. Reinicia y observa cómo las piezas se mueven únicamente a espacios vecinos, reforzando así la lógica y jugabilidad deseadas. ¡Todo un avance para nuestra mecánica del juego!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class Board : MonoBehaviour
{
    public int width;
    public int height;
    public GameObject tileObject;
    public float cameraSizeOffset;
    public float cameraVerticalOffset;
    public GameObject[] availablePieces;
    Tile[,] Tiles;
    Piece[,] Pieces;
    Tile startTile;
    Tile endTile;

    bool swappingPieces = false;

    // Start is called before the first frame update
    void Start()
    {
        Tiles = new Tile[width, height];
        Pieces = new Piece[width, height];
        SetupBoard();
        PositionCamera();
        SetupPieces();
    }

    private void SetupPieces()
    {
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                var selectedPiece = availablePieces[UnityEngine.Random.Range(0, availablePieces.Length)];
                var o = Instantiate(selectedPiece, new Vector3(x, y, -5), Quaternion.identity);
                o.transform.parent = transform;
                Pieces[x, y] = o.GetComponent<Piece>();
                Pieces[x, y].Setup(x, y, this);
            }
        }
    }

    private void PositionCamera()
    {
        float newPosX = (float)width / 2f;
        float newPosY = (float)height / 2f;

        Camera.main.transform.position = new Vector3(newPosX - 0.5f, newPosY - 0.5f + cameraVerticalOffset, -10f);

        float horizontal = width + 1;
        float vertical = (height / 2) + 1;

        Camera.main.orthographicSize = horizontal > vertical ? horizontal + cameraSizeOffset : vertical + cameraSizeOffset;
    }

    private void SetupBoard()
    {
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                var o = Instantiate(tileObject, new Vector3(x, y, -5), Quaternion.identity);
                o.transform.parent = transform;
                Tiles[x, y] = o.GetComponent<Tile>();
                Tiles[x, y]?.Setup(x, y, this); // Removed duplicate call
            }
        }
    }

    public void TileDown(Tile tile_)
    {
        startTile = tile_;
    }

    public void TileOver(Tile tile_)
    {
        endTile = tile_;
    }

    public void TileUp(Tile tile_)
    {
        if (startTile != null && endTile != null && IsCloseTo(startTile, endTile) && !swappingPieces)
        {
            swappingPieces = true;
            StartCoroutine(SwapTiles());
        }
        startTile = null;
        endTile = null;
    }

    IEnumerator SwapTiles()
    {
        var startPiece = Pieces[startTile.x, startTile.y];
        var endPiece = Pieces[endTile.x, endTile.y];

        if (startPiece == null || endPiece == null)
        {
            swappingPieces = false;
            yield break;
        }

        startPiece.Move(endTile.x, endTile.y);
        endPiece.Move(startTile.x, startTile.y);

        Pieces[startTile.x, startTile.y] = endPiece;
        Pieces[endTile.x, endTile.y] = startPiece;

        yield return new WaitForSeconds(0.3f);

        bool foundMatch = false;
        var startMatches = GetMatchByPiece(startTile.x, startTile.y, 3);
        var endMatches = GetMatchByPiece(endTile.x, endTile.y, 3);

        startMatches?.ForEach(piece =>
        {
            foundMatch = true;
            Pieces[piece.x, piece.y] = null;
            Destroy(piece.gameObject);
        });

        endMatches?.ForEach(piece =>
        {
            foundMatch = true;
            Pieces[piece.x, piece.y] = null;
            Destroy(piece.gameObject);
        });

        if (!foundMatch)
        {
            // Swap back if no matches found
            startPiece.Move(startTile.x, startTile.y);
            endPiece.Move(endTile.x, endTile.y);
            Pieces[startTile.x, startTile.y] = startPiece;
            Pieces[endTile.x, endTile.y] = endPiece;
        }

        startTile = null;
        endTile = null;
        swappingPieces = false;

        yield return null;
    }

    public bool IsCloseTo(Tile start, Tile end)
    {
        return (Math.Abs(start.x - end.x) == 1 && start.y == end.y) || 
               (Math.Abs(start.y - end.y) == 1 && start.x == end.x);
    }

    public List<Piece> GetMatchByDirection(int xpos, int ypos, Vector2 direction, int minPieces = 3)
    {
        List<Piece> matches = new List<Piece>();
        Piece startPiece = Pieces[xpos, ypos];
        matches.Add(startPiece);
        int nextX;
        int nextY;
        int maxVal = width > height ? width : height;

        for (int i = 1; i < maxVal; i++)
        {
            nextX = xpos + ((int)direction.x * i);
            nextY = ypos + ((int)direction.y * i);

            if (nextX >= 0 && nextX < width && nextY >= 0 && nextY < height)
            {
                var nextPiece = Pieces[nextX, nextY];
                if (nextPiece != null && nextPiece.pieceType == startPiece.pieceType)
                {
                    matches.Add(nextPiece);
                }
                else
                {
                    break;
                }
            }
        }

        return matches.Count >= minPieces ? matches : null;
    }

    public List<Piece> GetMatchByPiece(int xpos, int ypos, int minPieces = 3)
    {
        var upMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, 1), 2);
        var downMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, -1), 2);
        var rightMatches = GetMatchByDirection(xpos, ypos, new Vector2(1, 0), 2);
        var leftMatches = GetMatchByDirection(xpos, ypos, new Vector2(-1, 0), 2);

        upMatches = upMatches ?? new List<Piece>();
        downMatches = downMatches ?? new List<Piece>();
        rightMatches = rightMatches ?? new List<Piece>();
        leftMatches = leftMatches ?? new List<Piece>();

        var verticalMatches = upMatches.Union(downMatches).ToList();
        var horizontalMatches = leftMatches.Union(rightMatches).ToList();
        var foundMatches = new List<Piece>();

        if (verticalMatches.Count >= minPieces)
        {
            foundMatches = foundMatches.Union(verticalMatches).ToList();
        }
        if (horizontalMatches.Count >= minPieces)
        {
            foundMatches = foundMatches.Union(horizontalMatches).ToList();
        }

        return foundMatches;
    }
}
```using System;using System.Collections;using System.Collections.Generic;using System.Linq;using UnityEngine;
public class Board : MonoBehaviour{    public int width;    public int height;    public GameObject tileObject;    public float cameraSizeOffset;    public float cameraVerticalOffset;    public GameObject\[] availablePieces;    Tile\[,] Tiles;    Piece\[,] Pieces;    Tile startTile;    Tile endTile;
    bool swappingPieces = false;
    // Start is called before the first frame update    void Start()    {        Tiles = new Tile\[width, height];        Pieces = new Piece\[width, height];        SetupBoard();        PositionCamera();        SetupPieces();    }
    private void SetupPieces()    {        for (int x = 0; x < width; x++)        {            for (int y = 0; y < height; y++)            {                var selectedPiece = availablePieces\[UnityEngine.Random.Range(0, availablePieces.Length)];                var o = Instantiate(selectedPiece, new Vector3(x, y, -5), Quaternion.identity);                o.transform.parent = transform;                Pieces\[x, y] = o.GetComponent\<Piece>();                Pieces\[x, y].Setup(x, y, this);            }        }    }
    private void PositionCamera()    {        float newPosX = (float)width / 2f;        float newPosY = (float)height / 2f;
        Camera.main.transform.position = new Vector3(newPosX - 0.5f, newPosY - 0.5f + cameraVerticalOffset, -10f);
        float horizontal = width + 1;        float vertical = (height / 2) + 1;
        Camera.main.orthographicSize = horizontal > vertical ? horizontal + cameraSizeOffset : vertical + cameraSizeOffset;    }
    private void SetupBoard()    {        for (int x = 0; x < width; x++)        {            for (int y = 0; y < height; y++)            {                var o = Instantiate(tileObject, new Vector3(x, y, -5), Quaternion.identity);                o.transform.parent = transform;                Tiles\[x, y] = o.GetComponent\<Tile>();                Tiles\[x, y]?.Setup(x, y, this); // Removed duplicate call            }        }    }
    public void TileDown(Tile tile\_)    {        startTile = tile\_;    }
    public void TileOver(Tile tile\_)    {        endTile = tile\_;    }
    public void TileUp(Tile tile\_)    {        if (startTile != null && endTile != null && IsCloseTo(startTile, endTile) && !swappingPieces)        {            swappingPieces = true;            StartCoroutine(SwapTiles());        }        startTile = null;        endTile = null;    }
    IEnumerator SwapTiles()    {        var startPiece = Pieces\[startTile.x, startTile.y];        var endPiece = Pieces\[endTile.x, endTile.y];
        if (startPiece == null || endPiece == null)        {            swappingPieces = false;            yield break;        }
        startPiece.Move(endTile.x, endTile.y);        endPiece.Move(startTile.x, startTile.y);
        Pieces\[startTile.x, startTile.y] = endPiece;        Pieces\[endTile.x, endTile.y] = startPiece;
        yield return new WaitForSeconds(0.3f);
        bool foundMatch = false;        var startMatches = GetMatchByPiece(startTile.x, startTile.y, 3);        var endMatches = GetMatchByPiece(endTile.x, endTile.y, 3);
        startMatches?.ForEach(piece =>        {            foundMatch = true;            Pieces\[piece.x, piece.y] = null;            Destroy(piece.gameObject);        });
        endMatches?.ForEach(piece =>        {            foundMatch = true;            Pieces\[piece.x, piece.y] = null;            Destroy(piece.gameObject);        });
        if (!foundMatch)        {            // Swap back if no matches found            startPiece.Move(startTile.x, startTile.y);            endPiece.Move(endTile.x, endTile.y);            Pieces\[startTile.x, startTile.y] = startPiece;            Pieces\[endTile.x, endTile.y] = endPiece;        }
        startTile = null;        endTile = null;        swappingPieces = false;
        yield return null;    }
    public bool IsCloseTo(Tile start, Tile end)    {        return (Math.Abs(start.x - end.x) == 1 && start.y == end.y) ||                (Math.Abs(start.y - end.y) == 1 && start.x == end.x);    }
    public List\<Piece> GetMatchByDirection(int xpos, int ypos, Vector2 direction, int minPieces = 3)    {        List\<Piece> matches = new List\<Piece>();        Piece startPiece = Pieces\[xpos, ypos];        matches.Add(startPiece);        int nextX;        int nextY;        int maxVal = width > height ? width : height;
        for (int i = 1; i < maxVal; i++)        {            nextX = xpos + ((int)direction.x \* i);            nextY = ypos + ((int)direction.y \* i);
            if (nextX >= 0 && nextX < width && nextY >= 0 && nextY < height)            {                var nextPiece = Pieces\[nextX, nextY];                if (nextPiece != null && nextPiece.pieceType == startPiece.pieceType)                {                    matches.Add(nextPiece);                }                else                {                    break;                }            }        }
        return matches.Count >= minPieces ? matches : null;    }
    public List\<Piece> GetMatchByPiece(int xpos, int ypos, int minPieces = 3)    {        var upMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, 1), 2);        var downMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, -1), 2);        var rightMatches = GetMatchByDirection(xpos, ypos, new Vector2(1, 0), 2);        var leftMatches = GetMatchByDirection(xpos, ypos, new Vector2(-1, 0), 2);
        upMatches = upMatches ?? new List\<Piece>();        downMatches = downMatches ?? new List\<Piece>();        rightMatches = rightMatches ?? new List\<Piece>();        leftMatches = leftMatches ?? new List\<Piece>();
        var verticalMatches = upMatches.Union(downMatches).ToList();        var horizontalMatches = leftMatches.Union(rightMatches).ToList();        var foundMatches = new List\<Piece>();
        if (verticalMatches.Count >= minPieces)        {            foundMatches = foundMatches.Union(verticalMatches).ToList();        }        if (horizontalMatches.Count >= minPieces)        {            foundMatches = foundMatches.Union(horizontalMatches).ToList();        }
        return foundMatches;    }}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class Board : MonoBehaviour
{
    public int width;
    public int height;
    public GameObject tileObject;
    public float cameraSizeOffset;
    public float cameraVerticalOffset;
    public GameObject[] availablePieces;
    Tile[,] Tiles;
    Piece[,] Pieces;
    Tile startTile;
    Tile endTile;

    bool swappingPieces = false;

    // Start is called before the first frame update
    void Start()
    {
        Tiles = new Tile[width, height];
        Pieces = new Piece[width, height];
        SetupBoard();
        PositionCamera();
        SetupPieces();
    }

    private void SetupPieces()
    {
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                var selectedPiece = availablePieces[UnityEngine.Random.Range(0, availablePieces.Length)];
                var o = Instantiate(selectedPiece, new Vector3(x, y, -5), Quaternion.identity);
                o.transform.parent = transform;
                Pieces[x, y] = o.GetComponent<Piece>();
                Pieces[x, y].Setup(x, y, this);
            }
        }
    }

    private void PositionCamera()
    {
        float newPosX = (float)width / 2f;
        float newPosY = (float)height / 2f;

        Camera.main.transform.position = new Vector3(newPosX - 0.5f, newPosY - 0.5f + cameraVerticalOffset, -10f);

        float horizontal = width + 1;
        float vertical = (height / 2) + 1;

        Camera.main.orthographicSize = horizontal > vertical ? horizontal + cameraSizeOffset : vertical + cameraSizeOffset;
    }

    private void SetupBoard()
    {
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                var o = Instantiate(tileObject, new Vector3(x, y, -5), Quaternion.identity);
                o.transform.parent = transform;
                Tiles[x, y] = o.GetComponent<Tile>();
                Tiles[x, y]?.Setup(x, y, this); // Removed duplicate call
            }
        }
    }

    public void TileDown(Tile tile_)
    {
        startTile = tile_;
    }

    public void TileOver(Tile tile_)
    {
        endTile = tile_;
    }

    public void TileUp(Tile tile_)
    {
        if (startTile != null && endTile != null && IsCloseTo(startTile, endTile) && !swappingPieces)
        {
            swappingPieces = true;
            StartCoroutine(SwapTiles());
        }
        startTile = null;
        endTile = null;
    }

    IEnumerator SwapTiles()
    {
        var startPiece = Pieces[startTile.x, startTile.y];
        var endPiece = Pieces[endTile.x, endTile.y];

        if (startPiece == null || endPiece == null)
        {
            swappingPieces = false;
            yield break;
        }

        startPiece.Move(endTile.x, endTile.y);
        endPiece.Move(startTile.x, startTile.y);

        Pieces[startTile.x, startTile.y] = endPiece;
        Pieces[endTile.x, endTile.y] = startPiece;

        yield return new WaitForSeconds(0.3f);

        bool foundMatch = false;
        var startMatches = GetMatchByPiece(startTile.x, startTile.y, 3);
        var endMatches = GetMatchByPiece(endTile.x, endTile.y, 3);

        startMatches?.ForEach(piece =>
        {
            foundMatch = true;
            Pieces[piece.x, piece.y] = null;
            Destroy(piece.gameObject);
        });

        endMatches?.ForEach(piece =>
        {
            foundMatch = true;
            Pieces[piece.x, piece.y] = null;
            Destroy(piece.gameObject);
        });

        if (!foundMatch)
        {
            // Swap back if no matches found
            startPiece.Move(startTile.x, startTile.y);
            endPiece.Move(endTile.x, endTile.y);
            Pieces[startTile.x, startTile.y] = startPiece;
            Pieces[endTile.x, endTile.y] = endPiece;
        }

        startTile = null;
        endTile = null;
        swappingPieces = false;

        yield return null;
    }

    public bool IsCloseTo(Tile start, Tile end)
    {
        return (Math.Abs(start.x - end.x) == 1 && start.y == end.y) || 
               (Math.Abs(start.y - end.y) == 1 && start.x == end.x);
    }

    public List<Piece> GetMatchByDirection(int xpos, int ypos, Vector2 direction, int minPieces = 3)
    {
        List<Piece> matches = new List<Piece>();
        Piece startPiece = Pieces[xpos, ypos];
        matches.Add(startPiece);
        int nextX;
        int nextY;
        int maxVal = width > height ? width : height;

        for (int i = 1; i < maxVal; i++)
        {
            nextX = xpos + ((int)direction.x * i);
            nextY = ypos + ((int)direction.y * i);

            if (nextX >= 0 && nextX < width && nextY >= 0 && nextY < height)
            {
                var nextPiece = Pieces[nextX, nextY];
                if (nextPiece != null && nextPiece.pieceType == startPiece.pieceType)
                {
                    matches.Add(nextPiece);
                }
                else
                {
                    break;
                }
            }
        }

        return matches.Count >= minPieces ? matches : null;
    }

    public List<Piece> GetMatchByPiece(int xpos, int ypos, int minPieces = 3)
    {
        var upMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, 1), 2);
        var downMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, -1), 2);
        var rightMatches = GetMatchByDirection(xpos, ypos, new Vector2(1, 0), 2);
        var leftMatches = GetMatchByDirection(xpos, ypos, new Vector2(-1, 0), 2);

        upMatches = upMatches ?? new List<Piece>();
        downMatches = downMatches ?? new List<Piece>();
        rightMatches = rightMatches ?? new List<Piece>();
        leftMatches = leftMatches ?? new List<Piece>();

        var verticalMatches = upMatches.Union(downMatches).ToList();
        var horizontalMatches = leftMatches.Union(rightMatches).ToList();
        var foundMatches = new List<Piece>();

        if (verticalMatches.Count >= minPieces)
        {
            foundMatches = foundMatches.Union(verticalMatches).ToList();
        }
        if (horizontalMatches.Count >= minPieces)
        {
            foundMatches = foundMatches.Union(horizontalMatches).ToList();
        }

        return foundMatches;
    }
}
```using System;using System.Collections;using System.Collections.Generic;using System.Linq;using UnityEngine;
public class Board : MonoBehaviour{    public int width;    public int height;    public GameObject tileObject;    public float cameraSizeOffset;    public float cameraVerticalOffset;    public GameObject\[] availablePieces;    Tile\[,] Tiles;    Piece\[,] Pieces;    Tile startTile;    Tile endTile;
    bool swappingPieces = false;
    // Start is called before the first frame update    void Start()    {        Tiles = new Tile\[width, height];        Pieces = new Piece\[width, height];        SetupBoard();        PositionCamera();        SetupPieces();    }
    private void SetupPieces()    {        for (int x = 0; x < width; x++)        {            for (int y = 0; y < height; y++)            {                var selectedPiece = availablePieces\[UnityEngine.Random.Range(0, availablePieces.Length)];                var o = Instantiate(selectedPiece, new Vector3(x, y, -5), Quaternion.identity);                o.transform.parent = transform;                Pieces\[x, y] = o.GetComponent\<Piece>();                Pieces\[x, y].Setup(x, y, this);            }        }    }
    private void PositionCamera()    {        float newPosX = (float)width / 2f;        float newPosY = (float)height / 2f;
        Camera.main.transform.position = new Vector3(newPosX - 0.5f, newPosY - 0.5f + cameraVerticalOffset, -10f);
        float horizontal = width + 1;        float vertical = (height / 2) + 1;
        Camera.main.orthographicSize = horizontal > vertical ? horizontal + cameraSizeOffset : vertical + cameraSizeOffset;    }
    private void SetupBoard()    {        for (int x = 0; x < width; x++)        {            for (int y = 0; y < height; y++)            {                var o = Instantiate(tileObject, new Vector3(x, y, -5), Quaternion.identity);                o.transform.parent = transform;                Tiles\[x, y] = o.GetComponent\<Tile>();                Tiles\[x, y]?.Setup(x, y, this); // Removed duplicate call            }        }    }
    public void TileDown(Tile tile\_)    {        startTile = tile\_;    }
    public void TileOver(Tile tile\_)    {        endTile = tile\_;    }
    public void TileUp(Tile tile\_)    {        if (startTile != null && endTile != null && IsCloseTo(startTile, endTile) && !swappingPieces)        {            swappingPieces = true;            StartCoroutine(SwapTiles());        }        startTile = null;        endTile = null;    }
    IEnumerator SwapTiles()    {        var startPiece = Pieces\[startTile.x, startTile.y];        var endPiece = Pieces\[endTile.x, endTile.y];
        if (startPiece == null || endPiece == null)        {            swappingPieces = false;            yield break;        }
        startPiece.Move(endTile.x, endTile.y);        endPiece.Move(startTile.x, startTile.y);
        Pieces\[startTile.x, startTile.y] = endPiece;        Pieces\[endTile.x, endTile.y] = startPiece;
        yield return new WaitForSeconds(0.3f);
        bool foundMatch = false;        var startMatches = GetMatchByPiece(startTile.x, startTile.y, 3);        var endMatches = GetMatchByPiece(endTile.x, endTile.y, 3);
        startMatches?.ForEach(piece =>        {            foundMatch = true;            Pieces\[piece.x, piece.y] = null;            Destroy(piece.gameObject);        });
        endMatches?.ForEach(piece =>        {            foundMatch = true;            Pieces\[piece.x, piece.y] = null;            Destroy(piece.gameObject);        });
        if (!foundMatch)        {            // Swap back if no matches found            startPiece.Move(startTile.x, startTile.y);            endPiece.Move(endTile.x, endTile.y);            Pieces\[startTile.x, startTile.y] = startPiece;            Pieces\[endTile.x, endTile.y] = endPiece;        }
        startTile = null;        endTile = null;        swappingPieces = false;
        yield return null;    }
    public bool IsCloseTo(Tile start, Tile end)    {        return (Math.Abs(start.x - end.x) == 1 && start.y == end.y) ||                (Math.Abs(start.y - end.y) == 1 && start.x == end.x);    }
    public List\<Piece> GetMatchByDirection(int xpos, int ypos, Vector2 direction, int minPieces = 3)    {        List\<Piece> matches = new List\<Piece>();        Piece startPiece = Pieces\[xpos, ypos];        matches.Add(startPiece);        int nextX;        int nextY;        int maxVal = width > height ? width : height;
        for (int i = 1; i < maxVal; i++)        {            nextX = xpos + ((int)direction.x \* i);            nextY = ypos + ((int)direction.y \* i);
            if (nextX >= 0 && nextX < width && nextY >= 0 && nextY < height)            {                var nextPiece = Pieces\[nextX, nextY];                if (nextPiece != null && nextPiece.pieceType == startPiece.pieceType)                {                    matches.Add(nextPiece);                }                else                {                    break;                }            }        }
        return matches.Count >= minPieces ? matches : null;    }
    public List\<Piece> GetMatchByPiece(int xpos, int ypos, int minPieces = 3)    {        var upMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, 1), 2);        var downMatches = GetMatchByDirection(xpos, ypos, new Vector2(0, -1), 2);        var rightMatches = GetMatchByDirection(xpos, ypos, new Vector2(1, 0), 2);        var leftMatches = GetMatchByDirection(xpos, ypos, new Vector2(-1, 0), 2);
        upMatches = upMatches ?? new List\<Piece>();        downMatches = downMatches ?? new List\<Piece>();        rightMatches = rightMatches ?? new List\<Piece>();        leftMatches = leftMatches ?? new List\<Piece>();
        var verticalMatches = upMatches.Union(downMatches).ToList();        var horizontalMatches = leftMatches.Union(rightMatches).ToList();        var foundMatches = new List\<Piece>();
        if (verticalMatches.Count >= minPieces)        {            foundMatches = foundMatches.Union(verticalMatches).ToList();        }        if (horizontalMatches.Count >= minPieces)        {            foundMatches = foundMatches.Union(horizontalMatches).ToList();        }
        return foundMatches;    }}

Adolfo Sebastián Jara Gavilanes

Estudiante

Hace 3 años

En caso de que les ocurra el siguiente error:

Assets\Scripts\Board.cs(132,18): error CS0103: The name 'Math' does not exist in the current context

deben importar el módulo de System al principio del script:

using System;

EDISON ALEXANDER GOMEZ TOLOZA

Hace 2 años

Gabriel Souki

Tengo la costumbre de intentar siempre escribir el código necesario para resolvr el problema antes que el profe lo haga, y lo termine haciendo de una manera ligeramente diferente 🙂

public void TileUp()

{

if(startTile != null && endTile != null)

if(CanPiecesBeSwapped())

SwapTiles();

}

else

Debug.Log("Pieces can't be swapped");

startTile = null;

endTile = null;

private bool CanPiecesBeSwapped()

if((startTile.GetPositionX() == endTile.GetPositionX()) && (Mathf.Abs(endTile.GetPositionY() - startTile.GetPositionY()) == 1))

return true;

else if((startTile.GetPositionY() == endTile.GetPositionY()) && (Mathf.Abs(endTile.GetPositionX() - startTile.GetPositionX()) == 1))

return false;

Ambas son funcionales para lo que necesitamos. Recuerden que en la programación siempre hay diferentes maneras de resolver un mismo problema! 😋🧡

Permitiendo solo ciertos tipos de movimientos

Introducción

Bienvenida y presentación del proyecto

Instala Unity con módulos Android e iOS

Empezando Nuestro Proyecto

Cómo iniciar un proyecto 2D URP en Unity

Control de versiones

Importando nuestros assets

Teoría de Gameplay

Cómo analizar gameplay antes de programarlo

Elementos clave de un Match 3 antes de programar

Mecánica Principal

Crea la cuadrícula del juego en Unity

Cámara ortográfica automática en Unity

Sistema de coordenadas para piezas en Unity

Piezas aleatorias en la cuadrícula Unity

Mover piezas en Unity con DOTween

Intercambio de piezas con arrays 2D en Unity

Permitiendo solo ciertos tipos de movimientos

Lógica de Match 3 en cuatro direcciones

Detectar Match 3 con corrutinas en Unity

Evitar matches por defecto en Match 3

Colapso de columnas en un Match 3

Combos automáticos en Match 3 con corrutinas

Corrutinas para animar piezas en Match 3

Mejorando la animación de las piezas

Publicacion

Momento del primer build para Android

Momento del primer build para iOS

Diseño del juego

Hablemos de diseño

Agregando un sistema de puntos

Sistema de tiempo

Interfaz para el sistema de tiempo

Creando sistema de UI

Sistema de UI reactivo al estado del juego

Agregando funcionalidad a la pantalla de game over

Cómo reiniciar board y puntos en Unity

Agregando audio

Terminando el juego

Conclusiones

Juego Match 3 completo en tu teléfono

Resumen