【Unity】简单象棋项目开发

于 2025-02-19 17:43:46 发布
阅读量1.1k 收藏 9
点赞数 11
文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Explorer0314/article/details/145734047
版权

象棋

中国象棋是一项策略型棋类游戏，具有深厚历史和文化背景。游戏双方通过布局、运筹帷幄展开对抗，遵循完整的规则体系以保证比赛公平和规范。中国象棋的规则包括盘和棋子的设置、走棋方式、胜负条件、记录、计时和违规与处罚等规定。中国象棋的历史可以追溯到春秋战国时期，象棋不仅仅是一种游戏，更是一种文化符号和智慧的象征。理解和遵守规则能帮助棋手发挥战略和技巧，享受比赛乐趣，同时确保比赛的公正性和顺利进行。

开发准备

1.首先你需要有一个Unity游戏引擎

Unity [1]是实时3D互动内容创作和运营平台 [2]。包括游戏开发、美术、建筑、汽车设计、影视在内的所有创作者，借助Unity将创意变成现实。 [3]Unity平台提供一整套完善的软件解决方案 [3]，可用于创作、运营和变现任何实时互动的2D和3D内容，支持平台包括手机、平板电脑、PC、游戏主机、增强现实和虚拟现实设备。 [3]

网上类似的教程有很多我这里就不过多赘述了。

https://blog.csdn.net/Dugege007/article/details/128472571

这里有一个网上的教程可以放心使用。

2.创建项目

打开Unity 你会出现如下界面 这里先别急编辑器的版本无所谓
在这里插入图片描述接着点击右上角的“新项目” 然后接着你会出现如下界面

在这里插入图片描述

选择2D 核心模板 ，取一名字选择你的项目要存放在哪里，我一般习惯放在D盘，你只需放在自己喜欢的位置就行了

你们可以移动那些格子拖动来找到你们最舒服的位置，好接下来我们正式开始开发

正式开发

接下来我们要了解一些基本组件，这次开发我使用的的是纯UI开发虽然利用非UI也能开发，但是我们需要学习一些组件其次才能进行开发

组件：Button
组件：Canvas

接着我们创建一个画布，并在画布上创建一个空物体挂上组件：Image （以此来添加棋盘图片），你可以为你的新物体创建一个新的名字，并创建一个脚本命名为ChessManager 挂在空物体上，并添加一个管理子物体的组件如下图在这里插入图片描述
接着我们常见一个小物体挂照着我的组件挂上，并创建一个 Square 脚本挂上自己的Slots
在这里插入图片描述
在这里插入图片描述

接着我们预先在棋盘上摆出想起的样子：
在这里插入图片描述

开始写代码
ChessManager 这个最后再看 先看下面两个

using System;
using UnityEngine.UI;
using UnityEngine;

public class ChessManager : MonoBehaviour
{
    // 得到空照片
    [SerializeField] private Sprite Nonephoto;
    // 实例化格子
    [SerializeField] private Square[] slots;
    // 当前阵营 
    public Camp currentCamp;
    private Vector2Int curPos;
    private bool isSelectChess;
    /* 单例模式 */
    private static ChessManager instance;
    private ChessManager() {}
    public static ChessManager Instance()
    {
        if(instance == null) instance = new ChessManager();
        return instance;
    }
    /* 单例模式 */

    private void Awake()
    {
        isSelectChess = false;
        curPos = new Vector2Int(-1, -1);
        currentCamp = Camp.Red;
        InitIndex();
    }
    // 坐标 位置转换
    public Vector2Int GetIndex(int index)
    {
        return new Vector2Int(index % 9, index / 9);
    }
    public int GetNum(Vector2Int pos)
    {
        return pos.y * 9 + pos.x;
    }
    // 初始化
    public void InitIndex()
    {
        for(int i = 0; i < slots.Length; i ++)
        {
            slots[i].index = GetIndex(i);
        }
    }
    // 事件呼叫
    private void OnEnable()
    {
        EventHandler.SlotClicked += OnSlotClicked;
    }
    private void OnDisable()
    {
        EventHandler.SlotClicked -= OnSlotClicked;
    }
    private void OnSlotClicked(Vector2Int pos) // 选择后触发事件
    {
        if (isSelectChess)
        {
            if (pos == curPos)
            {
                Debug.Log(slots[GetNum(curPos)].chessType +"该棋子已经选中！");
                return;
            }
            if (slots[GetNum(pos)].camp == currentCamp)
            {
                Debug.Log("无法移动到己方棋子上！");
            }
            Debug.Log(curPos);
            MoveChess(pos);
        }
        else
        {

            if (slots[GetNum(pos)].camp == currentCamp)
            {
                curPos = pos;
                isSelectChess = true;
            }
            else
            {
                return;
            }
        }
    }
    private void MoveChess(Vector2Int pos) // 判断当前位置棋子类型并执行移动
    {
        switch (slots[GetNum(curPos)].chessType)
        {
            case ChessType.Check: // 将军
                CheckMove(pos);
                break;
            case ChessType.Soldier: // 兵
                SoldierMove(pos);
                break;
            case ChessType.Satute: // 炮
                SatuteMove(pos);
                break;
            case ChessType.Elephant: // 象
                ElephantMove(pos);
                break;
            case ChessType.Horse: // 马
                HorseMove(pos);
                break;
            case ChessType.Car: // 车
                CarMove(pos);
                break;
            case ChessType.Bachelor: // 士
                BachelorMove(pos);
                break;
        }
    }
    private void MoveTheChess(Vector2Int movePos) // 将格子移动
    {
        slots[GetNum(movePos)].camp = slots[GetNum(curPos)].camp;
        slots[GetNum(movePos)].chessType = slots[GetNum(curPos)].chessType;
        slots[GetNum(curPos)].camp = Camp.None;
        slots[GetNum(curPos)].chessType = ChessType.None;
        slots[GetNum(movePos)].icon.GetComponent<Image>().sprite = slots[GetNum(curPos)].icon.GetComponent<Image>().sprite;
        slots[GetNum(curPos)].icon.GetComponent<Image>().sprite = Nonephoto;
    }
    // 各类棋子移动
    private void CheckMove(Vector2Int pos) // 将军移动
    {
        if (currentCamp == Camp.Red)
        {
            Debug.Log("当前为红方");
            if (pos.x < 3 || pos.x > 5)
            {
                Debug.Log("帅并不能走出方格！");
                return;
            }
            else if (pos.y > 9 || pos.y < 7)
            {
                Debug.Log("帅并不能走出方格！");
                return;
            }
            else if (pos.x != curPos.x && pos.y != curPos.y)
            {
                Debug.Log("帅不能斜侧移动！");
                return;
            }
            else
            {
                if (pos.x == curPos.x)
                {
                    if (pos.y == curPos.y + 1 || pos.y == curPos.y - 1)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Black;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("一次只能移动一个");
                    return;
                }
                else if (curPos.y == pos.y)
                {
                    if (pos.x == curPos.x + 1 || pos.x == curPos.x - 1)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Black;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("一次只能移动一个");
                    return;
                }
            }
        }
        else if (currentCamp == Camp.Black)
        {
            Debug.Log("当前为黑色！");
            if (pos.x < 3 || pos.x > 5)
            {
                Debug.Log("将并不能走出方格！");
                return;
            }
            else if (pos.y > 2 || pos.y < 0)
            {
                Debug.Log("将并不能走出方格！");
                return;
            }
            else if (pos.x != curPos.x && pos.y != curPos.y)
            {
                Debug.Log("将不能斜侧移动！");
                return;
            }
            else
            {
                if (pos.x == curPos.x)
                {
                    if (pos.y == curPos.y + 1 || pos.y == curPos.y - 1)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Red;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("一次只能移动一个");
                    return;
                }
                else if (curPos.y == pos.y)
                {
                    if (pos.x == curPos.x + 1 || pos.x == curPos.x - 1)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Red;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("一次只能移动一个");
                    return;
                }
            }
        }
    }
    private void SoldierMove(Vector2Int pos) // 小兵移动
    {
        if (currentCamp == Camp.Red)
        {
            if (curPos.y > 4)
            {
                if (pos.x == curPos.x && pos.y == curPos.y - 1)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Black;
                }
                Debug.Log("兵在过河前只能前进");
                return;
            }
            else
            {
                if (pos.y < curPos.y)
                {
                    Debug.Log("兵无法向后移动");
                    return;
                }
                else if (pos.x != curPos.x && pos.y != curPos.y)
                {
                    Debug.Log("兵无法斜侧移动");
                    return;
                }
                else
                {
                    if (pos.x == curPos.x)
                    {
                        if (pos.y == curPos.y + 1)
                        {
                            MoveTheChess(pos);
                            isSelectChess = false;
                            currentCamp = Camp.Black;
                            return;
                        }
                    }
                    else if (pos.y == curPos.y)
                    {
                        if (pos.x == curPos.x + 1 || pos.x == curPos.x - 1)
                        {
                            MoveTheChess(pos);
                            isSelectChess = false;
                            currentCamp = Camp.Black;
                            return;
                        }
                    }
                }
            }
        }
        else if (currentCamp == Camp.Black)
        {
            if (curPos.y > 6)
            {
                if (pos.x == curPos.x && pos.y == curPos.y + 1)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Red;
                }
                Debug.Log("卒在过河前只能前进");
                return;
            }
            else
            {
                if (pos.y < curPos.y)
                {
                    Debug.Log("卒无法向后移动");
                    return;
                }
                else if (pos.x != curPos.x && pos.y != curPos.y)
                {
                    Debug.Log("卒无法斜侧移动");
                    return;
                }
                else
                {
                    if (pos.x == curPos.x)
                    {
                        if (pos.y == curPos.y + 1)
                        {
                            MoveTheChess(pos);
                            isSelectChess = false;
                            currentCamp = Camp.Red;
                            return;
                        }
                    }
                    else if (pos.y == curPos.y)
                    {
                        if (pos.x == curPos.x + 1 || pos.x == curPos.x - 1)
                        {
                            MoveTheChess(pos);
                            isSelectChess = false;
                            currentCamp = Camp.Red;
                            return;
                        }
                    }
                }
            }
        }
    }
    private void SatuteMove(Vector2Int pos) // 炮移动
    {
        if (pos.x != curPos.x && pos.y != curPos.y)
        {
            Debug.Log("炮不能斜侧移动");
            return;
        }
        else if (pos.x == curPos.x)
        {
            int ma = Math.Max(pos.y, curPos.y);
            int mi = Math.Min(pos.y, curPos.y);
            Debug.Log(ma + " " + mi);
            int num = 0;
            for (int i = mi + 1; i < ma; i ++)
            {
                Vector2Int temp = new Vector2Int(curPos.x, i);
                if (slots[GetNum(temp)].camp != Camp.None)
                {
                    num ++;
                }
            }
            if (num > 1)
            {
                Debug.Log("炮不能跳过两个以上棋子");
                return;
            }
            if (num == 1)
            {
                if (currentCamp == Camp.Red)
                {
                    if (slots[GetNum(pos)].camp == Camp.Black)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Black;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("无法移动到当前位置");
                }
                if (currentCamp == Camp.Black)
                {
                    if (slots[GetNum(pos)].camp == Camp.Red)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Red;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("无法移动到当前位置");
                }
            }
            if (num == 0 && slots[GetNum(pos)].camp == Camp.None)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
        }
        else if (curPos.y == pos.y)
        {
            int ma = Math.Max(pos.x, curPos.x);
            int mi = Math.Min(pos.x, curPos.x);
            Debug.Log(ma + " " + mi);
            int num = 0;
            for (int i = mi + 1; i < ma; i ++)
            {
                Vector2Int temp = new Vector2Int(i, curPos.y);
                if (slots[GetNum(temp)].camp != Camp.None)
                {
                    num ++;
                }
            }
            Debug.Log("炮跳过" + num);
            if (num > 1)
            {
                Debug.Log("炮不能跳过两个以上棋子");
                return;
            }
            if (num == 1)
            {
                if (currentCamp == Camp.Red)
                {
                    if (slots[GetNum(pos)].camp == Camp.Black)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Black;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("无法移动到当前位置");
                }
                if (currentCamp == Camp.Black)
                {
                    if (slots[GetNum(pos)].camp == Camp.Red)
                    {
                        MoveTheChess(pos);
                        currentCamp = Camp.Red;
                        isSelectChess = false;
                        return;
                    }
                    Debug.Log("无法移动到当前位置");
                }
            }
            if (num == 0 && slots[GetNum(pos)].camp == Camp.None)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
        }
    }
    private void CarMove(Vector2Int pos) // 车移动
    {
        if (pos.x != curPos.x && pos.y != curPos.y)
        {
            Debug.Log("车不能斜向移动");
            return;
        }
        else if (pos.x == curPos.x)
        {
            int ma = Math.Max(pos.y, curPos.y);
            int mi = Math.Min(pos.y, curPos.y);
            int num = 0;
            for (int i = mi + 1; i < ma; i ++)
            {
                Vector2Int temp = new Vector2Int(curPos.x, i);
                if (slots[GetNum(temp)].camp != Camp.None)
                {
                    num ++;
                }
            }
            if (num == 0)
            {
                if (currentCamp == Camp.Red && slots[GetNum(pos)].camp != currentCamp)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Black;
                    return;
                }
                if (currentCamp == Camp.Black && slots[GetNum(pos)].camp != currentCamp)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Red;
                    return;
                }
                return;
            }
            return;
        }
        else if (pos.y == curPos.y)
        {
            int ma = Math.Max(pos.x, curPos.x);
            int mi = Math.Min(pos.x, curPos.x);
            int num = 0;
            for (int i = mi + 1; i < ma; i ++)
            {
                Vector2Int temp = new Vector2Int(i, curPos.y);
                if (slots[GetNum(temp)].camp != Camp.None)
                {
                    num ++;
                }
            }
            if (num == 0)
            {
                if (currentCamp == Camp.Red && slots[GetNum(pos)].camp != currentCamp)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Black;
                    return;
                }
                if (currentCamp == Camp.Black && slots[GetNum(pos)].camp != currentCamp)
                {
                    MoveTheChess(pos);
                    isSelectChess = false;
                    currentCamp = Camp.Red;
                    return;
                }
                return;
            }
            return;
        }
    }
    private void ElephantMove(Vector2Int pos) // 象移动
    {
        if (pos.x == curPos.x + 2 && pos.y == curPos.y + 2)
        {
            if (pos.x == curPos.x + 1 && pos.y == curPos.y + 1)
            {
                Debug.Log("堵象眼");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 2 && pos.y == curPos.y - 2)
        {
            if (pos.x == curPos.x - 1 && pos.y == curPos.y - 1)
            {
                Debug.Log("堵象眼");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 2 && pos.y == curPos.y + 2)
        {
            if (pos.x == curPos.x - 1 && pos.y == curPos.y + 1)
            {
                Debug.Log("堵象眼");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x + 2 && pos.y == curPos.y - 2)
        {
            if (pos.x == curPos.x + 1 && pos.y == curPos.y - 1)
            {
                Debug.Log("堵象眼");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
    }
    private void HorseMove(Vector2Int pos) // 马移动
    {
        Debug.Log(pos + " " + curPos);
        if (pos.x == curPos.x + 1 && pos.y == curPos.y + 2)
        {
            Vector2Int front = new Vector2Int(curPos.x, curPos.y + 1);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 1 && pos.y == curPos.y - 2)
        {
            Vector2Int front = new Vector2Int(curPos.x, curPos.y - 1);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 1 && pos.y == curPos.y + 2)
        {
            Vector2Int front = new Vector2Int(curPos.x, curPos.y + 1);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x + 1 && pos.y == curPos.y - 2)
        {
            Vector2Int front = new Vector2Int(curPos.x, curPos.y - 1);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }

        if (pos.x == curPos.x + 2 && pos.y == curPos.y + 1)
        {
            Vector2Int front = new Vector2Int(curPos.x + 1, curPos.y);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 2 && pos.y == curPos.y - 1)
        {
            Vector2Int front = new Vector2Int(curPos.x - 1, curPos.y);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x - 2 && pos.y == curPos.y + 1)
        {
            Vector2Int front = new Vector2Int(curPos.x - 1, curPos.y);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
        if (pos.x == curPos.x + 2 && pos.y == curPos.y - 1)
        {
            Vector2Int front = new Vector2Int(curPos.x + 1, curPos.y);
            Debug.Log(front);
            if (slots[GetNum(front)].camp != Camp.None)
            {
                Debug.Log("堵马脚");
                return;
            }
            MoveTheChess(pos);
            isSelectChess = false;
            if (currentCamp == Camp.Red) currentCamp = Camp.Black;
            else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
            return;
        }
    }
    private void BachelorMove(Vector2Int pos) // 士移动
    {
        if (currentCamp == Camp.Red)
        {
            if (pos.x < 3 || pos.x > 5)
            {
                Debug.Log("士只能在方格内走！");
                return;
            }
            if (pos.y <= 6)
            {
                Debug.Log("士只能在方格内走！");
                return;
            }

            if (pos.x == curPos.x + 1 && pos.y == curPos.y + 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x - 1 && pos.y == curPos.y - 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x - 1 && pos.y == curPos.y + 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x + 1 && pos.y == curPos.y - 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            return;
        }
        if (currentCamp == Camp.Black)
        {
            if (pos.x < 3 || pos.x > 5)
            {
                Debug.Log("士只能在方格内走！");
                return;
            }
            if (pos.y > 2)
            {
                Debug.Log("士只能在方格内走！");
                return;
            }
            if (pos.x == curPos.x + 1 && pos.y == curPos.y + 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x - 1 && pos.y == curPos.y - 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x - 1 && pos.y == curPos.y + 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            if (pos.x == curPos.x + 1 && pos.y == curPos.y - 1)
            {
                MoveTheChess(pos);
                if (currentCamp == Camp.Red) currentCamp = Camp.Black;
                else if (currentCamp == Camp.Black) currentCamp = Camp.Red;
                isSelectChess = false;
                return;
            }
            return;
        }
    }

    
}

Square

using UnityEngine;


public class Square : MonoBehaviour
{
    public Camp camp;
    public ChessType chessType;
    public GameObject Select;
    public GameObject icon;
    public Vector2Int index;
    
    public void SlotOnClicked()
    {
        EventHandler.CallSlotClicked(index);
    }
}


using System;
using UnityEngine;

public static class EventHandler
{
    public static event Action<Vector2Int> SlotClicked;
    public static void CallSlotClicked(Vector2Int pos)
    {
        SlotClicked?.Invoke(pos);
    }
}



public enum Camp
{
    None,
    Red,
    Black
}
public enum ChessType
{
    None,
    Check,
    Soldier,
    Satute,
    Elephant,
    Horse,
    Car,
    Bachelor
}

这个代码在我的仓库里开源有但是我图方便直接开源给你们， 我也水水博客这闲的无聊搞得，最近大项目创作瓶颈都不知道做啥了感觉做的不好玩，想重新搞但是做了这么久又不想弃坑，我技术还是不好得再加强！！！

简单的象棋开发
m0_64647636的博客
03-03 4218
我们需要准备的知识是c语言基础和easyx图形: easyx官网： https://easyx.cn/ 首先头文件少不了: #include<stdio.h>(c语言的头文件) #include<graphics.h>（easyx的） #include<mmsystem.h>（音乐播放的） #pragma comment(lib,"winmm.lib")（链接上音乐播放器的库） 然后老套路了: int main(int argc,cha..
unity开发的象棋游戏
12-31
unity写的象棋程序，全ugui并运用象棋ucci协议加载象棋引擎，用的是象棋旋风5层引擎，棋力非常强大。请用unity5.5以后版本打开。
Pathon开发象棋小游戏（绘制棋盘）
hwt1070359898的博客
08-20 5534
上一篇中，我们缕清了思路，知道了如何写，怎么做，从哪入手，这一篇，我们就正式开始敲代码了，编程使我快乐，对吧，emm~~~ 还记得这张图吧： 好了，向着目标，进发了。。。 程序中牵扯到的函数，头文件什么的，不懂的，怎么办？ 学习，千万别忘了’网络’这东西，‘度娘’，‘博客’，各种各样的学习工具，总有一款适合你，废话少说，Let's go！ import pygame import py...
Pathon开发象棋小游戏（判赢与按键）
hwt1070359898的博客
08-20 1718
上一篇呢，我们已经完成了吃子功能，添加了一些简易的规则，但这怎么够呢，要知道，一款好的游戏，严谨的规则是必不可少的，因此，在写判赢与按键之前呢，我们还要加一些附加的规则，比如：马鳖腿啊，相鳖腿啊，将士不能出田字格啊。。。还是一起来看代码吧~~~ import pygame import pygame.font import sys import traceback import copy fr...
象棋对弈程序的开发
05-02
这是一本由胡达先生所著的关于C语言和象棋对弈程序设计思路的好书【虽然没看，但貌似很强大的样子】，跟着书中的内容走，相信所有的内容都理解之后，您一定会成为编程达人。
Unity游戏源码unity中国象棋
最新发布
05-03
1. **项目结构**：Unity中国象棋项目的结构通常会包含以下几个部分： - **Assets文件夹**：存放所有的资源文件，包括模型、纹理、脚本、音频文件等。 - **Scenes文件夹**：存放游戏的不同场景，如主菜单、游戏界面...
Unity3D 2019.3开发的中国象棋的源代码.zip
04-28
本项目是基于Unity3D 2019.3版本开发的中国象棋游戏，旨在提供一个学习和交流的平台，帮助开发者深入理解2D游戏的实现过程，尤其是对于象棋类游戏的逻辑处理。 中国象棋作为中国传统棋类游戏，其规则复杂，策略性强...
中国象棋源码 unity亲测
09-21
Unity是一款强大的跨平台游戏开发引擎，被广泛应用于各种游戏类型的制作，从简单的2D小游戏到复杂的3D大作，它都能胜任。本资源“中国象棋源码 unity亲测”是基于Unity引擎开发的一款经典策略游戏——中国象棋的源...
unity全套中国象棋视频教程
01-09
《Unity中国象棋游戏开发全攻略》 Unity是一款强大的跨平台游戏引擎，广泛应用于游戏开发、虚拟现实（VR）、增强现实（AR）等领域。对于初学者来说，通过学习开发中国象棋游戏，可以深入理解Unity的基本操作、游戏...
Unity3D中国象棋游戏开发教程
结合给定的标题和描述信息，我们可以推断出该压缩文件可能包含与中国象棋相关的Unity3D游戏项目文件。这可能意味着压缩包内包含了用Unity3D开发的中国象棋游戏的源代码、资源文件、场景设置、脚本文件等。开发者可能...
Linux下Qt开发的中国象棋
10-12
开发环境：LinuxMint 17.1 开发工具：QtCreator 3.3.1 Qt版本：5.4.1 功能：实现了人机对战，网络对战，自己和自己下棋三种模式。主要功能包括重复局面检测，长将判负，悔棋，提示音播放，死棋检测，中文着法显示，步时限制，保存棋局到文件和从文件加载棋局。总共代码有5000行左右，历时200多个小时。
用Java开发的简单的象棋对战系统
12-21
基于Java的简易版的象棋对战系统，内有源码项目和开发报告
Java开发中国象棋源代码
03-18
Java开发中国象棋源代码
UnityChess:用Unity制作的3D国际象棋游戏
05-06
国际象棋 UnityChess是使用Unity / C＃构建的3D Chess游戏。 贡献 下载存储库的zip可能无法正常工作。 要正确克隆，并安装Git LFS。 有关更深入的说明/指南，请访问相关的。 请遵循github上的协作工作流程，详细描述。 该项目正在使用以下版本的Unity： 建议您使用来管理Unity版本，因为随着新版本的推出，该项目可能会升级。 安装 目前，还没有发布。 该项目仍处于开发的早期阶段。
Unity3D的国际象棋源码Chess Game.unitypackage
03-30
这是个国际象棋的unity插件，里面提供了算法的源码，可以根据自己需求进行修改。我用的是unity版本是2017.4.5。亲测可用
《中国象棋开发》QT
Python自学记录
03-13 701
QT使用 QApplication 抽象了QT的应用程序； QWidgt抽象窗口； exec()函数 进入消息循环，等待用户输入； QPainter绘图部分： void MyWidge::paintEvent(QPaintEvent *) { //绘制类，参数：绘制对象 //绘制打印机、绘制图画、拷屏 QPainter painter(this);//this代指这个...
如何使用Unity制作一个国际象棋
SC_Linno的博客
08-30 1445
如果有更新建议请私信@RWLinno项目地址：https://github.com/RWLinno/LinnoChess。
unity2018.4.3f1实现中国象棋游戏（一）
在Redhat7.2环境下用C语言写小游戏
12-12 1290
目录一、创建项目和导入资源二、工欲善其事，必先利其器象棋学习资料： 一、创建项目和导入资源 有了之前五子棋游戏的经验，在此不再细说了哈 二、工欲善其事，必先利其器 我们不管做策划还是做程序员，或者说做其他任何工作，我们在开始动手之前，我们应该先明白我们要做什么，做这个东西需要哪些技术和准备，应该如何去设计，做的过程中那个地方是难点，那个地方容易出bug，多想一下再动手。而不是一上手就去拼UI，都没搞明白怎么玩，技术拼蛮力无用的。 象棋学习资料： 中国象棋的基本规则： https://jingyan.
Unity中国象棋（一）——初始化棋子
LudoArtificis的成长之路
01-27 7515
新建一个plane，作为背景，新建一个StoneManager脚本，挂在plane上 初始化32个棋子，每个棋子自带6个属性值：ID，x轴的坐标位置，y轴的坐标位置，是否为红子，是否死亡，棋子的类型。通过结构体Stone实现； 由于每个棋子的位置、类型难以通过ID区分，并且棋子的数量较少，故直接用结构体StonePos将其一一赋值； 利用其ID（也可利用其是否为红子的属性）和其类型，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值