Unity3D 2019.3开发的中国象棋的源代码

最新推荐文章于 2021-07-28 23:40:06 发布
最新推荐文章于 2021-07-28 23:40:06 发布
阅读量2k 收藏 19
点赞数 2
分类专栏： unity3D 文章标签： unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36382679/article/details/105806470
版权

Unity3D 2019.3开发的中国象棋的源代码

在这里插入图片描述

1 ChessEnum

public enum ChessSide
{
    RED,
    BLACK,
    Barrier
}
public enum ChessType
{
   Soldier=0,
   Cannon=1,
   Chariot=2,
   Elephant =3,
   Horse=4,
   Advisor=5,
   General = 6,
   Barrier =7
}
public class ChessKey {
    public ChessSide side;
    public ChessType type;
    public ChessKey(){}
    public ChessKey(ChessSide side, ChessType type) {
        this.side = side;
        this.type = type;
    }

}

2 ChessManger

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class ChessManger : MonoBehaviour
{
    public static ChessManger instance;
    public GameObject chessPrefab;
    public int xColumn = 9;
    public int yRow = 10;
    public int[,] chessArray = new int[,]
    {
/*      {3,4,5,6,7,6,5,4,3 },//1
        {0,0,0,0,0,0,0,0,0 },//2
        {0,2,0,0,0,0,0,2,0 },//3
        {1,0,1,0,1,0,1,0,1 },//4
        {0,0,0,0,0,0,0,0,0 },//5
        {0,0,0,0,0,0,0,0,0 },//6
        {1,0,1,0,1,0,1,0,1 },//7
        {0,2,0,0,0,0,0,2,0 },//8
        {0,0,0,0,0,0,0,0,0 },//9
        {3,4,5,6,7,6,5,4,3 },//10
*/    // 1 2 3 4 5 6 7 8 9 10
        {2,-1,-1,0, -1,-1, 0,-1,-1,2 },//1
        {4,-1, 1,-1,-1,-1,-1, 1,-1,4 },//2
        {3,-1,-1,0, -1,-1, 0,-1,-1,3 },//3
        {5,-1,-1,-1,-1,-1,-1,-1,-1,5 },//4
        {6,-1,-1,0, -1,-1, 0,-1,-1,6},//5
        {5,-1,-1,-1,-1,-1,-1,-1,-1,5},//6
        {3,-1,-1,0, -1,-1, 0,-1,-1,3},//7
        {4,-1, 1,-1,-1,-1,-1, 1,-1,4 },//8
        {2,-1,-1,0, -1,-1,0, -1,-1,2 },//9
    };
    public GameObject[,] gameObjectsArray;
    public LinkedList<GameObject> BarrierGameObject = new LinkedList<GameObject>();
    public Piece selectPiece = null;
    public Piece lastSelectPiece = null;
    private void Awake()
    {
        gameObjectsArray = new GameObject[xColumn, yRow];
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
                ChessSide tempside = new ChessSide();
                if (chessArray[x, y] != -1)
                {
                    if (y <= 5) { tempside = ChessSide.RED; } else { tempside = ChessSide.BLACK; }
                    ChessType tempType = (ChessType)chessArray[x, y];
                    GameObject tempGameObject = GameObject.Instantiate(chessPrefab, correctPosition(x, y, 1), Quaternion.identity);
                    Piece tempPiece = tempGameObject.GetComponent<Piece>();
                    tempGameObject.transform.parent = transform;
                    ChessKey tempChessKey = new ChessKey();
                    tempChessKey.side = tempside;
                    tempChessKey.type = tempType;
                    tempPiece.init(x, y, tempChessKey);
                    gameObjectsArray[x, y] = tempGameObject;
                }
            }
        }
        instance = this;
    }
    public ChessSide currentChessSide = ChessSide.BLACK;
    // Start is called before the first frame update
    void Start()
    {
        currentChessSide = SwitchSide.instance.chessSideMethon(currentChessSide);
    }
    Vector3 correctPosition(float x, float y, float z) {
        float tempX;
        float tempY;
        tempX = (x - xColumn / 2);
        tempY = (y - (yRow) / 2);
        return new Vector3(tempX, tempY, z);
    }
    // Update is called once per frame


    public List<Vector2> getMoveable(Piece piece) {
        int x0 = 3;
        int x1 = 5;
        int y2 = -1;
        int y3 = -1;

        List<Vector2> moveables = new List<Vector2>();
        switch (piece.chessKey.type)
        {
            case ChessType.Soldier:
                if (piece.chessKey.side == ChessSide.RED)
                {
                    if (piece.y <= 4)
                    {
                        if (gameObjectsArray[piece.x, piece.y + 1] != null &&
                             gameObjectsArray[piece.x, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x, piece.y + 1));
                        }
                        else if (gameObjectsArray[piece.x, piece.y + 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x, piece.y + 1));
                        }

                    } else if (piece.y < yRow) {
                        if (piece.y + 1 < yRow) {
                            if (gameObjectsArray[piece.x, piece.y + 1] != null &&
                                gameObjectsArray[piece.x, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x, piece.y + 1));
                            }
                            else if (gameObjectsArray[piece.x, piece.y + 1] == null)
                            {
                                moveables.Add(new Vector2(piece.x, piece.y + 1));
                            }
                        }
                        if (piece.x - 1 >= 0)
                        {
                            if (gameObjectsArray[piece.x - 1, piece.y] != null &&
                                gameObjectsArray[piece.x - 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x - 1, piece.y));
                            }
                            else if (gameObjectsArray[piece.x - 1, piece.y] == null)
                            {
                                moveables.Add(new Vector2(piece.x - 1, piece.y));
                            }
                        }

                        if (piece.x + 1 < xColumn)
                        {
                            if (gameObjectsArray[piece.x + 1, piece.y] != null &&
                                gameObjectsArray[piece.x + 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x + 1, piece.y));
                            }
                            else if (gameObjectsArray[piece.x + 1, piece.y] == null)
                            {
                                moveables.Add(new Vector2(piece.x + 1, piece.y));
                            }
                        }

                    }
                }
                else if (piece.chessKey.side == ChessSide.BLACK)
                {
                    if (piece.y >= 5)
                    {
                        if (gameObjectsArray[piece.x, piece.y - 1] != null &&
                            gameObjectsArray[piece.x, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x, piece.y - 1));
                        }
                        else if (gameObjectsArray[piece.x, piece.y - 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x, piece.y - 1));
                        }

                    }
                    else if (piece.y >= 0)
                    {
                        if (piece.y - 1 >= 0)
                        {
                            if (gameObjectsArray[piece.x, piece.y - 1] != null &&
                                gameObjectsArray[piece.x, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x, piece.y - 1));
                            }
                            else if (gameObjectsArray[piece.x, piece.y - 1] == null)
                            {
                                moveables.Add(new Vector2(piece.x, piece.y - 1));
                            }
                        }

                        if (piece.x - 1 >= 0)
                        {
                            if (gameObjectsArray[piece.x - 1, piece.y] != null &&
                                gameObjectsArray[piece.x - 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x - 1, piece.y));
                            }
                            else if (gameObjectsArray[piece.x - 1, piece.y] == null)
                            {
                                moveables.Add(new Vector2(piece.x - 1, piece.y));
                            }
                        }

                        if (piece.x + 1 < xColumn)
                        {
                            if (gameObjectsArray[piece.x + 1, piece.y] != null &&
                                gameObjectsArray[piece.x + 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                            {
                                moveables.Add(new Vector2(piece.x + 1, piece.y));
                            }
                            else if (gameObjectsArray[piece.x + 1, piece.y] == null)
                            {
                                moveables.Add(new Vector2(piece.x + 1, piece.y));
                            }
                        }

                    }

                }
                break;
            case ChessType.Cannon:
                for (int x = piece.x - 1; x >= 0; x--)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(x, piece.y));
                }
                for (int x = piece.x + 1; x < xColumn; x++)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(x, piece.y));
                }
                for (int y = piece.y + 1; y < yRow; y++)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(piece.x, y));
                }
                for (int y = piece.y - 1; y >= 0; y--)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(piece.x, y));
                }

                for (int x = piece.x - 1; x >= 0; x--)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        for (x = x - 1; x >= 0; x--)
                        {
                            if (gameObjectsArray[x, piece.y] != null)
                            {
                                Piece tempPiece = gameObjectsArray[x, piece.y].GetComponent<Piece>();
                                if (piece.chessKey.side != tempPiece.chessKey.side)
                                {
                                    moveables.Add(new Vector2(x, piece.y));

                                }
                                break;
                            }

                        }
                        break;
                    }
                }

                for (int x = piece.x + 1; x < xColumn; x++)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        for (x = x + 1; x < xColumn; x++)
                        {
                            if (gameObjectsArray[x, piece.y] != null)
                            {
                                Piece tempPiece = gameObjectsArray[x, piece.y].GetComponent<Piece>();
                                if (piece.chessKey.side != tempPiece.chessKey.side)
                                {
                                    moveables.Add(new Vector2(x, piece.y));

                                }
                                break;
                            }

                        }
                        break;
                    }
                }

                for (int y = piece.y - 1; y >= 0; y--)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        for (y = y - 1; y >= 0; y--)
                        {
                            if (gameObjectsArray[piece.x, y] != null)
                            {
                                Piece tempPiece = gameObjectsArray[piece.x, y].GetComponent<Piece>();
                                if (piece.chessKey.side != tempPiece.chessKey.side)
                                {
                                    moveables.Add(new Vector2(piece.x, y));

                                }
                                break;
                            }

                        }
                        break;
                    }
                }

                for (int y = piece.y + 1; y < yRow; y++)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        for (y = y + 1; y < yRow; y++)
                        {
                            if (gameObjectsArray[piece.x, y] != null)
                            {
                                Piece tempPiece = gameObjectsArray[piece.x, y].GetComponent<Piece>();
                                if (piece.chessKey.side != tempPiece.chessKey.side)
                                {
                                    moveables.Add(new Vector2(piece.x, y));

                                }
                                break;
                            }

                        }
                        break;
                    }
                }
                break;
            case ChessType.Chariot:
                for (int x = piece.x - 1; x >= 0; x--)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(x, piece.y));
                }
                for (int x = piece.x + 1; x < xColumn; x++)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(x, piece.y));
                }
                for (int y = piece.y + 1; y < yRow; y++)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(piece.x, y));
                }
                for (int y = piece.y - 1; y >= 0; y--)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        break;
                    }
                    moveables.Add(new Vector2(piece.x, y));
                }


                for (int x = piece.x - 1; x >= 0; x--)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        Piece tempPiece = gameObjectsArray[x, piece.y].GetComponent<Piece>();
                        if (piece.chessKey.side != tempPiece.chessKey.side)
                        {
                            moveables.Add(new Vector2(x, piece.y));

                        }
                        break;
                    }
                }//
                for (int x = piece.x + 1; x < xColumn; x++)
                {
                    if (gameObjectsArray[x, piece.y] != null)
                    {
                        Piece tempPiece = gameObjectsArray[x, piece.y].GetComponent<Piece>();
                        if (piece.chessKey.side != tempPiece.chessKey.side)
                        {
                            moveables.Add(new Vector2(x, piece.y));

                        }
                        break;
                    }
                }//

                for (int y = piece.y + 1; y < yRow; y++)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        Piece tempPiece = gameObjectsArray[piece.x, y].GetComponent<Piece>();
                        if (piece.chessKey.side != tempPiece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x, y));

                        }
                        break;
                    }
                }
                for (int y = piece.y - 1; y >= 0; y--)
                {
                    if (gameObjectsArray[piece.x, y] != null)
                    {
                        Piece tempPiece = gameObjectsArray[piece.x, y].GetComponent<Piece>();
                        if (piece.chessKey.side != tempPiece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x, y));

                        }
                        break;
                    }
                }
                break;
            case ChessType.Elephant:
                int y0 = -1;
                int y1 = -1;
                if (piece.chessKey.side == ChessSide.RED)
                {
                    y0 = 0;
                    y1 = 4;
                }
                else if (piece.chessKey.side == ChessSide.BLACK)
                {
                    y0 = 5;
                    y1 = 9;
                }
                if (piece.x - 2 >= 0 && piece.y + 2 <= y1)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y + 1] == null)
                    {
                        if (gameObjectsArray[piece.x - 2, piece.y + 2] != null &&
                            gameObjectsArray[piece.x - 2, piece.y + 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y + 2));
                        }
                        else if (gameObjectsArray[piece.x - 2, piece.y + 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y + 2));
                        }
                    }
                }
                if (piece.x - 2 >= 0 && piece.y - 2 >= y0)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y - 1] == null)
                    {
                        if (gameObjectsArray[piece.x - 2, piece.y - 2] != null &&
                             gameObjectsArray[piece.x - 2, piece.y - 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y - 2));
                        }
                        else if (gameObjectsArray[piece.x - 2, piece.y - 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y - 2));
                        }
                    }
                }
                if (piece.x + 2 < xColumn && piece.y + 2 <= y1)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y + 1] == null)
                    {
                        if (gameObjectsArray[piece.x + 2, piece.y + 2] != null &&
                        gameObjectsArray[piece.x + 2, piece.y + 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y + 2));
                        }
                        else if (gameObjectsArray[piece.x + 2, piece.y + 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y + 2));
                        }
                    }
                }
                if (piece.x + 2 < xColumn && piece.y - 2 >= y0)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y - 1] == null)
                    {
                        if (gameObjectsArray[piece.x + 2, piece.y - 2] != null &&
                            gameObjectsArray[piece.x + 2, piece.y - 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y - 2));
                        }
                        else if (gameObjectsArray[piece.x + 2, piece.y - 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y - 2));
                        }

                    }
                }
                break;
            case ChessType.Horse:
                if (piece.x - 1 >= 0 && piece.y + 2 < yRow)
                {
                    if (gameObjectsArray[piece.x, piece.y + 1] == null)
                    {
                        if (gameObjectsArray[piece.x - 1, piece.y + 2] != null &&
                            gameObjectsArray[piece.x - 1, piece.y + 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 1, piece.y + 2));
                        }
                        else if (gameObjectsArray[piece.x - 1, piece.y + 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 1, piece.y + 2));
                        }

                    }
                }
                if (piece.x - 2 >= 0 && piece.y + 1 < yRow)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y] == null)
                    {
                        if (gameObjectsArray[piece.x - 2, piece.y + 1] != null &&
                                gameObjectsArray[piece.x - 2, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y + 1));
                        }
                        else if (gameObjectsArray[piece.x - 2, piece.y + 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y + 1));
                        }

                    }
                }

                if (piece.x + 1 < xColumn && piece.y + 2 < yRow)
                {
                    if (gameObjectsArray[piece.x, piece.y + 1] == null)
                    {
                        if (gameObjectsArray[piece.x + 1, piece.y + 2] != null &&
                             gameObjectsArray[piece.x + 1, piece.y + 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 1, piece.y + 2));
                        }
                        else if (gameObjectsArray[piece.x + 1, piece.y + 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 1, piece.y + 2));
                        }
                    }
                }
                if (piece.x + 2 < xColumn && piece.y + 1 < yRow)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y] == null)
                    {
                        if (gameObjectsArray[piece.x + 2, piece.y + 1] != null &&
                                gameObjectsArray[piece.x + 2, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y + 1));
                        }
                        else if (gameObjectsArray[piece.x + 2, piece.y + 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y + 1));
                        }
                    }
                }


                if (piece.x - 1 >= 0 && piece.y - 2 >= 0)
                {
                    if (gameObjectsArray[piece.x, piece.y - 1] == null)
                    {
                        if (gameObjectsArray[piece.x - 1, piece.y - 2] != null &&
                             gameObjectsArray[piece.x - 1, piece.y - 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 1, piece.y - 2));
                        }
                        else if (gameObjectsArray[piece.x - 1, piece.y - 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 1, piece.y - 2));
                        }
                    }
                }
                if (piece.x - 2 >= 0 && piece.y - 1 >= 0)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y] == null)
                    {
                        if (gameObjectsArray[piece.x - 2, piece.y - 1] != null &&
                             gameObjectsArray[piece.x - 2, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y - 1));
                        }
                        else if (gameObjectsArray[piece.x - 2, piece.y - 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x - 2, piece.y - 1));
                        }
                    }
                }

                if (piece.x + 1 < xColumn && piece.y - 2 >= 0)
                {
                    if (gameObjectsArray[piece.x, piece.y - 1] == null)
                    {
                        if (gameObjectsArray[piece.x + 1, piece.y - 2] != null &&
                             gameObjectsArray[piece.x + 1, piece.y - 2].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 1, piece.y - 2));
                        }
                        else if (gameObjectsArray[piece.x + 1, piece.y - 2] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 1, piece.y - 2));
                        }
                    }
                }
                if (piece.x + 2 < xColumn && piece.y - 1 >= 0)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y] == null)
                    {
                        if (gameObjectsArray[piece.x + 2, piece.y - 1] != null &&
                             gameObjectsArray[piece.x + 2, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y - 1));
                        }
                        else if (gameObjectsArray[piece.x + 2, piece.y - 1] == null)
                        {
                            moveables.Add(new Vector2(piece.x + 2, piece.y - 1));
                        }
                    }
                }
                break;
            case ChessType.General:

                if (piece.chessKey.side == ChessSide.RED)
                {
                    y2 = 0;
                    y3 = 2;
                    for (int y = piece.y + 1; y < yRow; y++)
                    {
                        if (gameObjectsArray[piece.x, y] != null &&
                            gameObjectsArray[piece.x, y].GetComponent<Piece>().chessKey.type == ChessType.General)
                        {
                            moveables.Add(new Vector2(piece.x, y));
                        }
                        else if (gameObjectsArray[piece.x, y] != null &&
                          gameObjectsArray[piece.x, y].GetComponent<Piece>().chessKey.type != ChessType.General)
                        {
                            break;
                        }
                        else if (gameObjectsArray[piece.x, y] == null)
                        {
                            continue;
                        }
                    }
                }
                else if (piece.chessKey.side == ChessSide.BLACK)
                {
                    y2 = 7;
                    y3 = 9;
                    for (int y = piece.y - 1; y >= 0; y--)
                    {
                        if (gameObjectsArray[piece.x, y] != null &&
                            gameObjectsArray[piece.x, y].GetComponent<Piece>().chessKey.type == ChessType.General)
                        {
                            moveables.Add(new Vector2(piece.x, y));
                        }
                        else if (gameObjectsArray[piece.x, y] != null &&
                          gameObjectsArray[piece.x, y].GetComponent<Piece>().chessKey.type != ChessType.General)
                        {
                            break;
                        }
                        else if (gameObjectsArray[piece.x, y] == null)
                        {
                            continue;
                        }
                    }
                }
                if (piece.x - 1 >= x0)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y] != null &&
                        gameObjectsArray[piece.x - 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y));
                    }
                    else if (gameObjectsArray[piece.x - 1, piece.y] == null)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y));
                    }
                }
                if (piece.y - 1 >= y2)
                {
                    if (gameObjectsArray[piece.x, piece.y - 1] != null &&
                         gameObjectsArray[piece.x, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x, piece.y - 1));
                    }
                    else if (gameObjectsArray[piece.x, piece.y - 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x, piece.y - 1));
                    }
                }
                if (piece.x + 1 <= x1)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y] != null &&
                    gameObjectsArray[piece.x + 1, piece.y].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y));
                    }
                    else if (gameObjectsArray[piece.x + 1, piece.y] == null)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y));
                    }
                }
                if (piece.y + 1 <= y3)
                {
                    if (gameObjectsArray[piece.x, piece.y + 1] != null &&
                        gameObjectsArray[piece.x, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x, piece.y + 1));
                    }
                    else if (gameObjectsArray[piece.x, piece.y + 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x, piece.y + 1));
                    }
                }

                break;
            case ChessType.Advisor:

                // int x0 = 3;
                // int x1 = 5;
                // int y2 = -1;
                // int y3 = -1;
                if (piece.chessKey.side == ChessSide.RED)
                {
                    y2 = 0;
                    y3 = 2;
                }
                else if (piece.chessKey.side == ChessSide.BLACK)
                {
                    y2 = 7;
                    y3 = 9;
                }
                if (piece.x - 1 >= x0 && piece.y + 1 <= y3)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y + 1] != null &&
                        gameObjectsArray[piece.x - 1, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y + 1));
                    }
                    else if (gameObjectsArray[piece.x - 1, piece.y + 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y + 1));
                    }
                }
                if (piece.x - 1 >= x0 && piece.y - 1 >= y2)
                {
                    if (gameObjectsArray[piece.x - 1, piece.y - 1] != null &&
                         gameObjectsArray[piece.x - 1, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y - 1));
                    }
                    else if (gameObjectsArray[piece.x - 1, piece.y - 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x - 1, piece.y - 1));
                    }
                }
                if (piece.x + 1 <= x1 && piece.y + 1 <= y3)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y + 1] != null &&
                    gameObjectsArray[piece.x + 1, piece.y + 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y + 1));
                    }
                    else if (gameObjectsArray[piece.x + 1, piece.y + 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y + 1));
                    }
                }
                if (piece.x + 1 <= x1 && piece.y - 1 >= y2)
                {
                    if (gameObjectsArray[piece.x + 1, piece.y - 1] != null &&
                        gameObjectsArray[piece.x + 1, piece.y - 1].GetComponent<Piece>().chessKey.side != piece.chessKey.side)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y - 1));
                    }
                    else if (gameObjectsArray[piece.x + 1, piece.y - 1] == null)
                    {
                        moveables.Add(new Vector2(piece.x + 1, piece.y - 1));
                    }
                }
                break;
            case ChessType.Barrier:

                break;
            default:
                break;
        }

        return moveables;
    }
    public void onMousePressEvents(Piece piece) {


        if (selectPiece != null)
        {
            return;
        }
        selectPiece = piece;
        if (selectPiece.chessKey.side != currentChessSide)
        {
            selectPiece = null;
            return;
        }

        List<Vector2> moveablepiece = getMoveable(piece);
        if (moveablepiece.Count <= 0)
        {
            selectPiece = null;
            return;
        }
        foreach (Vector2 item in moveablepiece)
        {
            GameObject tempGameObject = Instantiate(chessPrefab, correctPosition(item.x, item.y, -3), Quaternion.identity);
            Piece tempPiece = tempGameObject.GetComponent<Piece>();
            ChessKey tempChessKey = new ChessKey();
            tempChessKey.side = ChessSide.Barrier;
            tempChessKey.type = ChessType.Barrier;
            tempPiece.init((int)(item.x), (int)item.y, tempChessKey);
            BarrierGameObject.AddFirst(tempGameObject);
        }
    }

    public void onMouseUpEvents() {


        if (lastSelectPiece == null)
        {
            return;
        }

        chessArray[selectPiece.x, selectPiece.y] = -1;
        gameObjectsArray[selectPiece.x, selectPiece.y] = null;
        chessArray[lastSelectPiece.x, lastSelectPiece.y] = (int)selectPiece.chessKey.type;
        selectPiece.x = lastSelectPiece.x;
        selectPiece.y = lastSelectPiece.y;
        selectPiece.transform.position = lastSelectPiece.transform.position;
        if (gameObjectsArray[lastSelectPiece.x, lastSelectPiece.y] != null)
        {
            DestroyImmediate(gameObjectsArray[lastSelectPiece.x, lastSelectPiece.y]);

        }
        gameObjectsArray[lastSelectPiece.x, lastSelectPiece.y] = selectPiece.transform.gameObject;

        foreach (GameObject item in BarrierGameObject)
        {
            DestroyImmediate(item);
        }
        //Debug.Log(currentChessSide);
        currentChessSide = SwitchSide.instance.chessSideMethon(currentChessSide);
        selectPiece = null;
        lastSelectPiece = null;

    }
    public void onMouseOverEvents(Piece piece)
    {
        if (piece.chessKey.type == ChessType.Barrier)
        {
            lastSelectPiece = piece;
            selectPiece.transform.position = piece.transform.position;
        }
    }
    void Update()
    {
        if (selectPiece != null && lastSelectPiece == null & Input.GetMouseButtonDown(1))
        {
            selectPiece = null;
            foreach (GameObject item in BarrierGameObject)
            {
                DestroyImmediate(item);
            }
        }
    }
    public void restart(){
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);   
  }
}

3 ChessMove

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

public class ChessMove : MonoBehaviour
{
    // Start is called before the first frame update
   public Piece piece;
    private void Awake()
    {
        piece = this.transform.GetComponent<Piece>();
    }
    private void OnMouseDown()
    {
        //Debug.Log(piece.ToString());
        ChessManger.instance.onMousePressEvents(this.piece);
    }
    private void OnMouseUp()
    {
        ChessManger.instance.onMouseUpEvents();
        //Debug.Log(piece.ToString());
    }
  
    private void OnMouseEnter()
    {
        ChessManger.instance.onMouseOverEvents(this.piece);
        //Debug.Log("last piece:" + piece.ToString());
    }
}

4 Piece

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

public class Piece : MonoBehaviour
{
    public int x;
    public int y;
    public ChessKey chessKey;
    SpriteRenderer spriteRenderer;
    // Start is called before the first frame update
    private void Awake()
    {
        spriteRenderer =this.transform.GetComponent<SpriteRenderer>();
    }
    public void init(int x, int y, ChessKey chessKey) {
        this.x = x;
        this.y = y;
        this.chessKey = chessKey;
        //Debug.Log("PieceDirect.getSprite(chessKey)" + PieceDirect.getSprite(chessKey).name);
        spriteRenderer.sprite = PieceDirect.getSprite(chessKey);
    
    }
    public override string ToString()
    {
        return "x:" + x + "y:" + y + "chessSide:" + chessKey.side + "chessType:" + chessKey.type;
    }
}

5 PieceDirect

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

public class PieceDirect : MonoBehaviour
{
    [System.Serializable]
    public struct ChessSideStruct
    {
        public ChessSide side;
        public Sprite sprite;
    }
    [System.Serializable]
    public struct ChessTypeStruct
    {
        public ChessType type;
        public ChessSideStruct sideStruct;
    }
    public ChessTypeStruct[] chessStructs;
    // Start is called before the first frame update
  
    public static   Dictionary<ChessKey,Sprite> chessDirct;

    void Awake()
    {
        chessDirct = new Dictionary<ChessKey, Sprite>();
        for (int i = 0; i < chessStructs.Length; i++)
        {
            ChessType chessType = chessStructs[i].type;
            ChessSideStruct chessSideStruct = chessStructs[i].sideStruct;
            ChessSide chessSide = chessSideStruct.side;
            Sprite sprite = chessSideStruct.sprite;
            ChessKey tempchessKey = new ChessKey();
            tempchessKey.side = chessSide;
            tempchessKey.type = chessType;            
            chessDirct.Add(tempchessKey, sprite);
            //Debug.Log(chessDirct.Keys.Count);
        }
    }

    public static Sprite getSprite(ChessKey chessKey)
    {
        Sprite tempSprite =null;
        foreach (ChessKey temp in chessDirct.Keys)
        {
            //Debug.Log(temp.side+":"+temp.type);
            if (temp.side == chessKey.side && temp.type == chessKey.type) {
                tempSprite= chessDirct[temp];
               // Debug.Log("tempSprite" + tempSprite.name);
                break;
            }
        }
        return tempSprite;
    }
}

6 SwitchSide

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class SwitchSide : MonoBehaviour
{
    public static SwitchSide instance; 
    public Text sideDes;
    public Image sideSprite;
    public ChessKey tempKey;
     void Awake()
    {
        instance = this;
    }
    public  ChessSide chessSideMethon(ChessSide chessSide) {

        tempKey = new ChessKey();
        tempKey.type = ChessType.General;
        switch (chessSide)
        {
            case ChessSide.RED:
                //sideDes.text = "黑方".ToString();

                tempKey.side = ChessSide.BLACK;
                //sideSprite.sprite = PieceDirect.getSprite(tempKey);
                Debug.Log(tempKey.side);
                break;
            case ChessSide.BLACK:
               // sideDes.text = "红方".ToString();
                tempKey.side = ChessSide.RED;
                //sideSprite.sprite = PieceDirect.getSprite(tempKey);
                Debug.Log(tempKey.side);
                break;
            case ChessSide.Barrier:
                break;
            default:
                break;
        }
        Debug.Log(tempKey.side);
        return tempKey.side;
    }
     void Update()
    {
        if (tempKey==null)
        {
            return;
        }
        switch (tempKey.side)
        {
            case ChessSide.BLACK:
                sideDes.text = "黑方".ToString();

                //tempKey.side = ChessSide.BLACK;
                sideSprite.sprite = PieceDirect.getSprite(tempKey);
                Debug.Log(tempKey.side);
                break;
            case ChessSide.RED:
                sideDes.text = "红方".ToString();
                //tempKey.side = ChessSide.RED;
                sideSprite.sprite = PieceDirect.getSprite(tempKey);
                //Debug.Log(tempKey.side);
                break;
        }
    }
}
青眼酷白龙
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用C#开发Unity围棋游戏源码分享及提子算法实现详解
qq_38334677的博客
06-23 852
Unity是一款强大的游戏开发引擎，支持多平台发布，广泛应用于各种游戏开发中。它提供了强大的编辑器、丰富的资源和插件库，使得开发者可以高效地进行游戏开发。C#是一种由微软开发的现代、通用、面向对象的编程语言。它语法简洁、功能强大，是Unity开发的主要编程语言。使用C#开发Unity游戏，可以充分利用其面向对象编程的优势，编写出结构清晰、功能完善的游戏代码。本文详细介绍了如何使用C#在Unity中开发一款围棋游戏。从创建项目。
中国象棋源码 unity亲测
09-21
unity小游戏合集主页很多，内容太大 ，分批上传，多多理解；Unity游戏合集；小游戏源码；水果机；益智游戏；马里奥；斗地主；卡牌游戏；滑雪游戏skiing；跑酷游戏；三消类游戏；闯关游戏；
中国象棋，源码
09-30
中国象棋程序，功能比较简单。包含联网对战，悔棋等功能，必要的注释，重命名类、函数、变量的名字，提高了可读性。 特别说明：这个版本的功能比较弱，用户体验也很差，bug也不少。 主要用来学习用，如果有兴趣，可以自行完善。
Unity游戏源码分享-中国象棋Unity5.6版本
08-14
Unity游戏源码分享-中国象棋Unity5.6版本
unity2018.4.3f1实现中国象棋游戏（一）
在Redhat7.2环境下用C语言写小游戏
12-12 1084
目录一、创建项目和导入资源二、工欲善其事，必先利其器象棋学习资料： 一、创建项目和导入资源 有了之前五子棋游戏的经验，在此不再细说了哈 二、工欲善其事，必先利其器 我们不管做策划还是做程序员，或者说做其他任何工作，我们在开始动手之前，我们应该先明白我们要做什么，做这个东西需要哪些技术和准备，应该如何去设计，做的过程中那个地方是难点，那个地方容易出bug，多想一下再动手。而不是一上手就去拼UI，都没搞明白怎么玩，技术拼蛮力无用的。 象棋学习资料： 中国象棋的基本规则： https://jingyan.
Unity和C#开发 - 中国象棋+源代码工程
谁为拨动染血的时空苍穹
07-28 608
Unity和C#开发 - 中国象棋+高清视频指导+源代码工程#中国象棋 #游戏 #一起玩游戏 #抖音游戏 https://item.taobao.com/item.htm?ft=t&id=650971483074
Unity3D 2019.3开发的中国象棋的源代码.zip
04-28
总之，这个Unity3D 2019.3的中国象棋源代码项目涵盖了2D游戏开发的多个重要方面，无论是对Unity新手还是有一定经验的开发者，都能从中学习到宝贵的知识和实践经验。通过分析和改进这个项目，可以提升自己的游戏开发...
Python中国象棋源代码（下载即用）.zip
04-29
Python中国象棋源代码（下载即用）.zipPython中国象棋源代码（下载即用）.zipPython中国象棋源代码（下载即用）.zipPython中国象棋源代码（下载即用）.zipPython中国象棋源代码（下载即用）.zipPython中国象棋源代码...
中国象棋游戏源代码.zip
06-19
【标题】: "中国象棋游戏源代码" 是一个压缩包文件，其中包含了开发一款中国象棋游戏的全部源代码。这种源代码是程序员用编程语言编写的，用于实现中国象棋游戏的各种功能，包括棋盘布局、棋子移动规则、胜负判断等...
unity开发的象棋游戏
12-31
unity写的象棋程序，全ugui并运用象棋ucci协议加载象棋引擎，用的是象棋旋风5层引擎，棋力非常强大。请用unity5.5以后版本打开。
基于Java的中国象棋对弈游戏系统开发（代码版本）
05-22
基于Java的中国象棋对弈游戏系统开发代码。适用场景：课程设计、大作业、毕业设计、项目设计等。适用人群：本科、专科、高职等。 代码量：3000行左右。可以直接运行，一键导入Idea、Eclipse即可。 支持JavaJDK所有版本。内含高级算法：剪枝算法、博弈树算法、Zobrist算法等。 可以实现人机对战、人人对战、悔棋、重新开始、智能对战存储、残局等功能。 主要开发语言：Java。适合新手和小白进阶！！~ 界面美观丰富、并且人机对战有难度之分（小白、高手、无敌三种模式任选），通过智能算法实现人机对战！
中国象棋 后端C++源代码
06-16
中国象棋C++源代码，适合做游戏的朋友学习与参考。
unity象棋 源码.txt
08-12
unity象棋 源码
Python中国象棋源代码资料合集.zip
05-06
Python中国象棋源代码资料合集.zipPython中国象棋源代码资料合集.zipPython中国象棋源代码资料合集.zipPython中国象棋源代码资料合集.zipPython中国象棋源代码资料合集.zipPython中国象棋源代码资料合集.zipPython...
高分项目，基于Unity3D开发实现的中国象棋，内含完整源码+资源
最新发布
06-12
高分项目，基于Unity3D开发实现的中国象棋，内含完整源码+资源 象棋是一种智力游戏,古今中外不少人痴迷,有深厚的群众基础和广泛的参与度;象棋还是一种体育运动,每年有各种专业的象棋比赛吸人眼球,也有正规的象棋...
unity2018.4.3f1实现中国象棋游戏（二）
在Redhat7.2环境下用C语言写小游戏
12-12 443
目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值