Unity复刻骑砍中的帝国象棋（一）
起因和简介
这两天从一款游戏中发现了这么个棋类小游戏，觉得挺有意思，没错，就是下面这个：
作为程序员的我，一下就想到复刻它一下。这个棋类小游戏，我并不知道它确切的名字，好像叫帝国象棋？？好吧，这个不重要，重要的是我要实现它，顺便说一下，这个应该不会侵权吧，我可是真的只是为了学习，毕竟就算100%实现了，也不是以赚钱为目的的。先来说说它的规则吧，其实这个游戏我并没有玩，规则是我从其他人的攻略文章里搜来的：
- 双方分为攻击方和防守方，中间摆成十字的棋子，是防守方，四周的4组品字形棋子为攻击方。防守方中有一个棋子是王，就是正中间那个头上有皇冠图标的那个棋子。
- 所有的棋子，全部走直线，类似中国象棋里的“车”的走法。但是棋盘正中间的那个位置，任何棋子都不可以进入，也不可以越过，即便是“王”，离开之后就不能再回到中间去。
- 两个己方棋子，如果能“夹住”一个敌方棋子，那么就可以把它吃掉。水平或者垂直方向均可。棋盘中间的位置可以视作任何一方的己方棋子。一方棋子如果主动走到两边具有敌对棋子的位置，并不会“自杀”，对方如果想要杀死该棋子，只能从另一个方向夹击，或原夹击形式的棋子离开后重新回到原位置，重新形成夹击才能杀死该棋子。
- 防守方的“王”，如果能行走到任意方向上的棋盘的边缘，则防守方胜利。攻击方如果能杀死“王”，则攻击方胜利。
规则描述虽然文字挺多，但是实际上很简单。
开发计划和实现
目前写这篇文章之时，已经实现了走棋规则的判断、胜负的判断，就是说可以实现人和人的对战了。下一步，如果有时间的话，将会再完善一下这个小工程，主要是：①完善UI，实现开始、退出的对话框，以及胜利、失败的提示等。②如果还有时间，打算再实现一个AI功能，思路跟我之前写过的一片棋类游戏AI相差不多。有兴趣的可以一观：四字连珠。
目前的演示视频如下：
Unity复刻骑砍游戏中的帝国象棋（一）
具体实现
数据描述
首先是棋盘的数据描述，这是整个游戏最重要的数据结构，这个游戏的棋盘是个9*9的方格，很显然，最适合的就是用数组描述，比较直观的就是2维数组，但是二维数组在访问频率较高的场合，会稍稍影响性能，如果你用的Rider，它会给你提示：
上图的意思是，使用多维数组效率很低，建议使用一维数组代替。
基于Rider给予的忠告，这里我使用的是一维数组。但是为了方便，还是以2维的形式去访问，然后写一个2维转1维的索引转换函数：
private static int CoordToIndex(int x, int y)
{
return Mathf.Clamp(x * 9 + y, 0, 80);
}
也许这样的转换在实质上跟使用2维数组是性能等价的，但Rider不提示性能问题了，作为有点强迫症的可以心安理得，当然，如果你用的是VS，那就无所谓了，就算2维数组性能不如一维，这种性能的差异也可以忽略不计。
那么问题来了，数组里面放什么呢？如果想搞的稍微复杂一些，可以专门写一个棋子类，然后用数组作为容器，去盛放这些棋子。但是我并没有这么做，主要是感觉没大有必要，于是我用了2个数组，来描述这个棋盘。
private enum ChessType
{
None, // 表示该位置没有棋子
Offensive, // 表示该位置是攻击方的棋子
Defense, // 表示该位置是防守方的棋子
King // 表示该位置是防守方的王
}
private readonly ChessType[] boardMap = new ChessType [81];
private readonly GameObject[] chesses = new GameObject[81];
上面代码，定义了一个ChessType，其实就是这个棋盘上每个方格的状态。然后用一个9*9=81长度的数组来表示整个棋盘，还有一个一样的数组，用来盛放棋子的GameObject，方便进行位置调整和被杀后的剔除。
然后就是棋盘的初始化：
private void PutChess(int x, int y, ChessType ct)
{
GameObject obj;
switch (ct)
{
case ChessType.Defense:
obj = Instantiate(defenseChessPrefab, transform);
break;
case ChessType.King:
obj = Instantiate(kingChessPrefab, transform);
break;
case ChessType.Offensive:
obj = Instantiate(offensiveChessPrefab, transform);
break;
default:
return;
}
obj.transform.localPosition = CoordToLocal(x, y);
int index = CoordToIndex(x, y);
boardMap[index] = ct;
chesses[index] = obj;
}
private void ResetChessBoard()
{
for (int i = 0; i < 81; ++i)
{
boardMap[i] = ChessType.None;
if (chesses[i] != null)
{
Destroy(chesses[i]);
chesses[i] = null;
}
}
PutChess(3, 0, ChessType.Offensive);
PutChess(4, 0, ChessType.Offensive);
PutChess(5, 0, ChessType.Offensive);
PutChess(4, 1, ChessType.Offensive);
PutChess(0, 3, ChessType.Offensive);
PutChess(0, 4, ChessType.Offensive);
PutChess(0, 5, ChessType.Offensive);
PutChess(1, 4, ChessType.Offensive);
PutChess(8, 3, ChessType.Offensive);
PutChess(8, 4, ChessType.Offensive);
PutChess(8, 5, ChessType.Offensive);
PutChess(7, 4, ChessType.Offensive);
PutChess(3, 8, ChessType.Offensive);
PutChess(4, 8, ChessType.Offensive);
PutChess(5, 8, ChessType.Offensive);
PutChess(4, 7, ChessType.Offensive);
PutChess(2, 4, ChessType.Defense);
PutChess(3, 4, ChessType.Defense);
PutChess(4, 2, ChessType.Defense);
PutChess(4, 3, ChessType.Defense);
PutChess(4, 5, ChessType.Defense);
PutChess(4, 6, ChessType.Defense);
PutChess(5, 4, ChessType.Defense);
PutChess(6, 4, ChessType.Defense);
PutChess(4, 4, ChessType.King);
}
棋盘坐标转换
只要在游戏开始的时候，调用ResetChessBoard方法，就可以重新摆一盘棋了。这里面有个函数CoordToLocal,用于根据棋盘坐标来计算棋子的局部坐标：
private static Vector3 CoordToLocal(int x, int y)
{
return new Vector3(x * deltaCellSize - 0.47f + 0.0522222f, (8 - y) * deltaCellSize - 0.47f + 0.0522222f, 0.05f);
}
实际上，这个函数写的并不太优雅，原因是它跟模型的尺寸和棋盘的纹理位置是相关的，这就意味着如果你更换一个棋盘模型，这个函数就得重写。当然，能够通用的方法也有很多，为了简单，同时也为了性能，这里就这么写死了。
同时，对应的，也要有鼠标棋盘后，把点击位置转换为棋盘坐标的方法：
if (Physics.Raycast(mainCamera.ScreenPointToRay(Input.mousePosition), out RaycastHit hit, 500f))
{
int x = Mathf.FloorToInt((hit.point.x + 0.47f) / deltaCellSize);
int y = Mathf.FloorToInt((hit.point.z + 0.47f) / deltaCellSize);
// x, y就是棋盘坐标
}
游戏逻辑
整个游戏过程，可以用状态机来描述不同的状态，代码和意义如下：
private enum PlayState
{
GameOver, // 游戏结束状态，或者游戏尚未开始状态
ComputerThink, // 计算机正在思考
PlayerThink, // 玩家正在思考
PlayerTakeChess, // 玩家举起了一枚棋子（选定某棋子，但尚未决定如何行走）
PlayerPutChess // 玩家将举起的棋子放到了指定位置（决定了如何行走）
}
针对不同的状态，就可以写不同的逻辑，然后在各个状态中进行切换：
思考状态 PlayerThink
case PlayState.PlayerThink:
if (Input.GetMouseButtonDown(0))
{
if (Physics.Raycast(mainCamera.ScreenPointToRay(Input.mousePosition), out RaycastHit hit, 500f))
{
int x = Mathf.FloorToInt((hit.point.x + 0.47f) / deltaCellSize);
int y = Mathf.FloorToInt((hit.point.z + 0.47f) / deltaCellSize);
if (TryGetChessByCoord(x, y, out GameObject chess) && TakeupChess(x, y))
{
chess.transform.localPosition += takeChessOffset;
currentTakedChess = chess;
takedChessCoord.x = x;
takedChessCoord.y = y;
state = PlayState.PlayerTakeChess;
}
}
}
break;
如上，在玩家思索状态下，如果检测到了鼠标左键被按下，那么就发射一条射线，判断是否点击了棋盘上的己方棋子，如果是己方棋子，则继续判断这个棋子是不是可以被拿起：如果棋子四周有其他棋子，也就是说这枚棋子实际上不能进行移动，那么这枚棋子就不能被拿起，比如说这一枚：
只有点击的是能够被拿起的棋子，那么就拿起这枚棋子，并且将状态切换到PlayState.PlayerTakeChess。
另外，举起棋子要做的事情是：枚举这枚棋子所有可能的走位，然后在所有的走位上打上标记，就是生成一个小圆点，表示可以走到的位置。这里用到了一个简单的对象池，而且只要想一下就不难发现，因为棋盘大小是9*9，所以，所有可能的走位不可能超过9+9-1=17个，因此这个对象池可以实现实例化17个这样的标记预制体，然后根据实际需要来摆放。
举起棋子的状态 PlayerTakeChess
- ① 如果玩家点了鼠标右键，那么表示玩家改变了主意，表示要放弃刚刚选择的棋子，要重新选择棋子，这时候要把已经举起的棋子放下，状态重新切换为思考状态。
- ② 如果玩家点了鼠标左键，首先判断所点的位置是不是原棋子的位置，如果是，那就同①，表示要放弃该棋子；如果所点的是另一个棋子，并且这枚棋子可以被举起，那么同样表示玩家改变了主意，此时需要放下原来举起的棋子，然后举起新选择的棋子，状态不改变；如果玩家点击的是所举起的棋子可以到达的空位，那么就标记该位置为目标位置，并将状态切换为“放置棋子”。
case PlayState.PlayerTakeChess:
if (Input.GetMouseButtonDown(1))
{
ClearChessPoints();
state = PlayState.PlayerThink;
currentTakedChess.transform.localPosition -= takeChessOffset;
currentTakedChess = null;
break;
}
if (Input.GetMouseButtonDown(0))
{
if (Physics.Raycast(mainCamera.ScreenPointToRay(Input.mousePosition), out RaycastHit hit, 500f))
{
int x = Mathf.FloorToInt((hit.point.x + 0.47f) / deltaCellSize);
int y = Mathf.FloorToInt((hit.point.z + 0.47f) / deltaCellSize);
if (takedChessCoord.x == x && takedChessCoord.y == y)
{
ClearChessPoints();
currentTakedChess.transform.localPosition -= takeChessOffset;
currentTakedChess = null;
state = PlayState.PlayerThink;
break;
}
if (IsPutable(x, y))
{
ClearChessPoints();
tickLerp = 0;
originChessPosition = currentTakedChess.transform.localPosition;
targetChessPosition = CoordToLocal(x, y);
int index = CoordToIndex(takedChessCoord.x, takedChessCoord.y);
takedChessType = boardMap[index];
boardMap[index] = ChessType.None;
chesses[index] = null;
takedChessCoord.x = x;
takedChessCoord.y = y;
state = PlayState.PlayerPutChess;
break;
}
if (TryGetChessByCoord(x, y, out GameObject chess))
{
int curindex = CoordToIndex(x, y);
if (IsFriend(curindex, boardMap[CoordToIndex(takedChessCoord.x, takedChessCoord.y)]))
{
ClearChessPoints();
currentTakedChess.transform.localPosition -= takeChessOffset;
}
if (TakeupChess(x, y))
{
chess.transform.localPosition += takeChessOffset;
currentTakedChess = chess;
takedChessCoord.x = x;
takedChessCoord.y = y;
state = PlayState.PlayerTakeChess;
}
else
state = PlayState.PlayerThink;
}
}
}
break;
放置棋子状态 PlayerPutChess
case PlayState.PlayerPutChess:
if (tickLerp < 0.99f)
{
tickLerp += 2.5f * Time.deltaTime;
currentTakedChess.transform.localPosition =
Vector3.Lerp(originChessPosition, targetChessPosition, tickLerp);
}
else
{
currentTakedChess.transform.localPosition = targetChessPosition;
int index = CoordToIndex(takedChessCoord.x, takedChessCoord.y);
boardMap[index] = takedChessType;
chesses[index] = currentTakedChess;
currentTakedChess = null;
if (IsWin() || KillChess() || NoEnemyChessCanMove())
{
GameOver();
break;
}
isPlayerOffensive = !isPlayerOffensive;
if (isPlayWithPlayer)
{
state = PlayState.PlayerThink;
}
else
{
state = PlayState.ComputerThink;
}
}
break;
这个状态的逻辑就比较简单些，主要是完成棋子移动的动画，并且，移动完成后，进行是否赢了的判断、是否杀死了对方的棋子，如果是杀死的是防御方的王，也要判定赢了；还有，如果敌人虽然仍有棋子，但全部无法移动，比如被堵到角落，也需要判定胜利。如果判断一方胜利，那么就结束游戏。然后将状态切换到GameOver，否则的话，就视情况将状态切换到玩家思考或者电脑思考状态，取决于游戏模式是人机对战还是跟人人对战。
这里重要的方法有两个，判断输赢和判断吃子的方法，请参考代码注释：
// 如果王已经逃走，判定防御方胜利
private bool IsWin()
{
// 如果操作的棋子是王，那么判断是否移动到了棋盘的任意方向的边界
if (takedChessType == ChessType.King)
{
if (takedChessCoord.x is 0 or 8 || takedChessCoord.y is 0 or 8)
return true;
}
return false;
}
// 判断杀死棋子，如果杀死的是王，那么返回true，表示攻击方胜利
private bool KillChess()
{
bool result = false;
if (takedChessCoord.x >= 2)
{
if (IsFriend(CoordToIndex(takedChessCoord.x - 2, takedChessCoord.y)))
{
int index = CoordToIndex(takedChessCoord.x - 1, takedChessCoord.y);
if (IsEnemy(index))
{
result |= RemoveChess(index);
}
}
}
if (takedChessCoord.y >= 2)
{
if (IsFriend(CoordToIndex(takedChessCoord.x, takedChessCoord.y - 2)))
{
int index = CoordToIndex(takedChessCoord.x, takedChessCoord.y - 1);
if (IsEnemy(index))
{
result |= RemoveChess(index);
}
}
}
if (takedChessCoord.x <= 6)
{
if (IsFriend(CoordToIndex(takedChessCoord.x + 2, takedChessCoord.y)))
{
int index = CoordToIndex(takedChessCoord.x + 1, takedChessCoord.y);
if (IsEnemy(index))
{
result |= RemoveChess(index);
}
}
}
if (takedChessCoord.y <= 6)
{
if (IsFriend(CoordToIndex(takedChessCoord.x, takedChessCoord.y + 2)))
{
int index = CoordToIndex(takedChessCoord.x, takedChessCoord.y + 1);
if (IsEnemy(index))
{
result |= RemoveChess(index);
}
}
}
return result;
}
// 移除被吃掉的棋子，如果是王，返回true
private bool RemoveChess(int index)
{
Destroy(chesses[index]);
chesses[index] = null;
bool result = boardMap[index] == ChessType.King;
boardMap[index] = ChessType.None;
return result;
}
// 判断指定位置的棋子是否为tp类型棋子的友方，如果tp未指定，判断依据为当前所举棋子
private bool IsFriend(int index, ChessType tp = ChessType.None)
{
// 棋盘正中的位置，可以视作任何方的乙方单位
if (index == 4 * 9 + 4)
return true;
if (tp == ChessType.None)
tp = takedChessType;
return tp switch
{
ChessType.Offensive => boardMap[index] == ChessType.Offensive,
ChessType.King or ChessType.Defense => boardMap[index] == ChessType.King ||
boardMap[index] == ChessType.Defense,
_ => false
};
}
// 判断指定位置是否为当前方的敌对棋子
private bool IsEnemy(int index)
{
return takedChessType switch
{
ChessType.Offensive => boardMap[index] == ChessType.King || boardMap[index] == ChessType.Defense,
ChessType.King or ChessType.Defense => boardMap[index] == ChessType.Offensive,
_ => false
};
}
// 敌人是否没有任何棋子可以移动
private bool NoEnemyChessCanMove()
{
if (isPlayerOffensive)
return !boardMap.Where((t, i) => t is ChessType.King or ChessType.Defense && IsChessMoveable(i)).Any();
return !boardMap.Where((t, i) => t == ChessType.Offensive && IsChessMoveable(i)).Any();
}
// 判定一个棋子是否可以移动
private bool IsChessMoveable(int index)
{
int x = index / 9;
int y = index % 9;
int t = x - 1;
if (t >= 0 && (y != 4 || t != 4) && boardMap[CoordToIndex(t, y)] == ChessType.None)
return true;
t = x + 1;
if (t <= 8 && (y != 4 || t != 4) && boardMap[CoordToIndex(t, y)] == ChessType.None)
return true;
t = y - 1;
if (t >= 0 && (x != 4 || t != 4) && boardMap[CoordToIndex(x, t)] == ChessType.None)
return true;
t = y + 1;
return t <= 8 && (x != 4 || t != 4) && boardMap[CoordToIndex(x, t)] == ChessType.None;
}
尚未开发的功能
- UI
- AI
源码下载
https://download.csdn.net/download/sdhexu/87222722
![[附源码]计算机毕业设计springboot拉勾教育课程管理系统](https://img-blog.csdnimg.cn/2979b3c094b9420db4d9f939efb3aa0d.png)
![[附源码]Python计算机毕业设计Django的文成考研培训管理系统](https://img-blog.csdnimg.cn/a91adbc05a72486d9d2abf220033f58c.png)
![[附源码]Python计算机毕业设计Django的玉石交易系统](https://img-blog.csdnimg.cn/2c117505bb3c439f8a6ecdfd6234c089.png)
![[附源码]计算机毕业设计SpringBoot计算机相关专业考研资料管理系统](https://img-blog.csdnimg.cn/ece30d73d864465ca71f7618c4542c2c.png)
