public int CalculateScore(ChessBoardSnapshot boardSnapshot, ChessPlayerType playerType)
{
int ret = 0;
ChessPieceType[] board = boardSnapshot.board;
for (int i = 0; i < board.Length; i++)
{
if (!board[i].IsValid())
{
continue;
}
if (board[i].IsEmpty())
{
continue;
}
if (board[i].IsSameTeamAs(playerType))
{
ret += profilesDict[board[i]].score + 1;
}
else if (board[i].IsDifferentTeamAs(playerType))
{
ret -= profilesDict[board[i]].score + 1;
}
}
return(ret);
}
/// <summary>
/// 当进入一个房间（通过创建或加入）时被调用。在所有客户端（包括主客户端）上被调用.
/// </summary>
/// <remarks>这种方法通常用于实例化玩家角色。
/// 如果一场比赛必须“积极地”被开始，你也可以调用一个由用户的按键或定时器触发的PunRPC 。
///
/// 当这个被调用时，你通常可以通过PhotonNetwork.playerList访问在房间里现有的玩家。
/// 同时，所有自定义属性Room.customProperties应该已经可用。检查Room.playerCount就知道房间里是否有足够的玩家来开始游戏.</remarks>
public override void OnJoinedRoom()
{
local = PhotonNetwork.player;
remote = PhotonNetwork.player.GetNext();
if (PhotonNetwork.isMasterClient && local != null)
{
localPlayerType = ChessPlayerType.Red;
LocalGameStatusText.text = "您是红方棋手……";
this.LocalPlayerNameText.text = local.NickName + ":红方";
ExitGames.Client.Photon.Hashtable playerType = new ExitGames.Client.Photon.Hashtable();
playerType.Add("playerType", "红方选手");
local.SetCustomProperties(playerType, null, false);
}
else
{
this.LocalPlayerNameText.text = local.NickName + ":黑方";
ExitGames.Client.Photon.Hashtable playerType = new ExitGames.Client.Photon.Hashtable();
playerType.Add("playerType", "黑方选手");
local.SetCustomProperties(playerType, null, false);
localPlayerType = ChessPlayerType.Black;
LocalGameStatusText.text = "您是黑方棋手……";
}
if (PhotonNetwork.room.PlayerCount == 2 && this.turnManager.Turn == 0)
{
// 当房间内有两个玩家,则开始首回合
Play();
}
if (PhotonNetwork.room.PlayerCount > 2)
{
localPlayerType = ChessPlayerType.Guest;
LocalGameStatusText.text = "棋局已开始，正在进入观棋模式……";
}
if (remote != null)
{
RemoteGameStatusText.text = "已匹配！";
// 应该是这种格式: "name 00"
if (PhotonNetwork.isMasterClient)
{
this.RemotePlayerNameText.text = remote.NickName + "—黑方";
}
else
{
this.RemotePlayerNameText.text = remote.NickName + "—红方";
}
}
else
{
this.RemotePlayerNameText.text = "匹配...";
LocalGameStatusText.text = "等待其他玩家...";
RemoteGameStatusText.text = "正在匹配...";
}
RefreshUIViews();
}
public static ChessPlayerType ToOpposite(this ChessPlayerType playerType)
{
if (playerType == ChessPlayerType.White)
{
return(ChessPlayerType.Black);
}
if (playerType == ChessPlayerType.Black)
{
return(ChessPlayerType.White);
}
return(playerType);
}
/// <summary>
/// 更新玩家文本信息
/// </summary>
private void UpdatePlayerTexts()
{
PhotonPlayer remote = PhotonNetwork.player.GetNext();
PhotonPlayer local = PhotonNetwork.player;
if (remote != null)
{
// 应该是这种格式: "name 00"
if (PhotonNetwork.isMasterClient)
{
this.RemotePlayerText.text = remote.NickName + "—黑方 | Black " + remote.GetScore().ToString("D2");
}
else
{
this.RemotePlayerText.text = remote.NickName + "—红方 | Red " + remote.GetScore().ToString("D2");
}
}
else
{
TimerFillImage.anchorMax = new Vector2(0f, 1f);
this.TimeText.text = "";
this.RemotePlayerText.text = "等待其他玩家 00";
}
if (local != null)
{
// 应该是这种样式: "YOU 00"
if (PhotonNetwork.isMasterClient)
{
localPlayerType = ChessPlayerType.Red;
this.LocalPlayerText.text = local.NickName + ":红方 | Red " + local.GetScore().ToString("D2");
//Debug.Log ("MasterClient");
}
else
{
localPlayerType = ChessPlayerType.Black;
this.LocalPlayerText.text = local.NickName + ":黑方 | Black " + local.GetScore().ToString("D2");
}
if (localPlayerType == ChessPlayerType.Guest)
{
this.LocalPlayerText.text = PhotonNetwork.player.Get(2).NickName + ":黑方 | Black " + PhotonNetwork.player.Get(1).GetScore().ToString("D2");
//Debug.Log ("ChessPlayerType.Guest");
}
}
}
public static bool IsDifferentTeamAs(this ChessPieceType pieceType, ChessPlayerType playerType)
{
if (!pieceType.IsValid())
{
return(false);
}
if (pieceType.IsEmpty())
{
return(false);
}
if (pieceType.IsWhite() && playerType == ChessPlayerType.Black)
{
return(true);
}
if (pieceType.IsBlack() && playerType == ChessPlayerType.White)
{
return(true);
}
return(false);
}
/// <summary>
/// 当进入一个房间（通过创建或加入）时被调用。在所有客户端（包括主客户端）上被调用.
/// </summary>
/// <remarks>这种方法通常用于实例化玩家角色。
/// 如果一场比赛必须“积极地”被开始，你也可以调用一个由用户的按键或定时器触发的PunRPC 。
///
/// 当这个被调用时，你通常可以通过PhotonNetwork.playerList访问在房间里现有的玩家。
/// 同时，所有自定义属性Room.customProperties应该已经可用。检查Room.playerCount就知道房间里是否有足够的玩家来开始游戏.</remarks>
public override void OnJoinedRoom()
{
PhotonPlayer local = PhotonNetwork.player;
if (PhotonNetwork.isMasterClient)
{
localPlayerType = ChessPlayerType.Red;
GameStatusText.text = "您是红方棋手……";
Debug.Log("OnJoinedRoom+您是红方棋手");
ExitGames.Client.Photon.Hashtable playerType = new ExitGames.Client.Photon.Hashtable();
playerType.Add("playerType", "红方选手");
local.SetCustomProperties(playerType, null, false);
}
if (PhotonNetwork.room.PlayerCount == 2)
{
if (!PhotonNetwork.isMasterClient)
{
ExitGames.Client.Photon.Hashtable playerType = new ExitGames.Client.Photon.Hashtable();
playerType.Add("playerType", "黑方选手");
local.SetCustomProperties(playerType, null, false);
localPlayerType = ChessPlayerType.Black;
GameStatusText.text = "您是黑方棋手……";
}
if (this.turnManager.Turn == 0)
{
// 当房间内有两个玩家,则开始首回合
this.StartTurn();
}
}
if (PhotonNetwork.room.PlayerCount > 2)
{
if (localPlayerType == ChessPlayerType.Guest)
{
GameStatusText.text = "棋局已开始，正在进入观棋模式……";
}
}
RefreshUIViews();
}
/// <summary>
/// 离线模式
/// </summary>
public void OfflineModeAct(int nPly)
{
HidePath();
chessManManager.hidePointer();
_isRedTurn = true;
PhotonNetwork.offlineMode = true;
nFlag = 0;
PlayMusic(welcomMusic);
AI.OnNewGame(1, nPly);
chessManManager.ChessmanInit();
LocalGameStatusText.text = "开局！";
RemoteGameStatusText.text = "开局！";
localPlayerType = ChessPlayerType.Red;
LocalGameStatusText.text = "您是红方棋手……";
if (PlayerPrefs.HasKey("PlayerName"))
{
this.LocalPlayerNameText.text = PlayerPrefs.GetString("PlayerName") + ":红方";
}
RemotePlayerNameText.text = "AI:黑方";
UpdatePlayerScoreTexts();
this.StartTurn();
}
/// <summary>
/// 当进入一个房间（通过创建或加入）时被调用。在所有客户端（包括主客户端）上被调用.
/// </summary>
/// <remarks>这种方法通常用于实例化玩家角色。
/// 如果一场比赛必须“积极地”被开始，你也可以调用一个由用户的按键或定时器触发的PunRPC 。
///
/// 当这个被调用时，你通常可以通过PhotonNetwork.playerList访问在房间里现有的玩家。
/// 同时，所有自定义属性Room.customProperties应该已经可用。检查Room.playerCount就知道房间里是否有足够的玩家来开始游戏.</remarks>
public override void OnJoinedRoom()
{
if (PhotonNetwork.isMasterClient)
{
localPlayerType = ChessPlayerType.Red;
GameStatusText.text = "您是红方棋手……";
Debug.Log("OnJoinedRoom+您是红方棋手");
}
if (PhotonNetwork.room.PlayerCount == 2)
{
if (!PhotonNetwork.isMasterClient)
{
localPlayerType = ChessPlayerType.Black;
GameStatusText.text = "您是黑方棋手……";
}
if (this.turnManager.Turn == 0)
{
// 当房间内有两个玩家,则开始首回合
this.StartTurn();
}
}
else
{
Debug.Log("Waiting for another player");
GameStatusText.text = "等待玩家加入……";
}
if (PhotonNetwork.room.PlayerCount > 2)
{
if (localPlayerType == ChessPlayerType.Guest)
{
GameStatusText.text = "棋局已开始，正在进入观棋模式……";
}
}
RefreshUIViews();
}
public static bool IsDifferentTeamAs(this ChessPlayerType playerType, ChessPieceType pieceType)
{
return(pieceType.IsDifferentTeamAs(playerType));
}
public ChessBoardSnapshot[] FindPossibleMoves(ChessBoardSnapshot boardSnapshot, ChessPlayerType playerType)
{
List <ChessBoardSnapshot> ret = new List <ChessBoardSnapshot>();
Dictionary <int, ChessPosition> boardDict = boardSnapshot.ToDictionary();
foreach (KeyValuePair <int, ChessPosition> kvp in boardDict)
{
ChessPosition position = kvp.Value;
if (position.type.IsDifferentTeamAs(playerType))
{
continue;
}
ChessCoordinate from = position.coord;
ChessPieceMove[] possibleMoves = GameManager.Instance.profilesDict[position.type].possibleMoves;
for (int j = 0; j < possibleMoves.Length; j++)
{
ChessCoordinate to = from + possibleMoves[j].move;
int k = 1;
while
(
to.IsWithinRange() &&
(possibleMoves[j].repeatTimes < 0 || k <= possibleMoves[j].repeatTimes)
)
{
if (GameManager.Instance.IsValidSpecialRule(possibleMoves[j].specialRule, position, from, to))
{
// When there are only finite amount of moves, set only when reached destination
if (possibleMoves[j].repeatTimes < 0 || k == possibleMoves[j].repeatTimes)
{
bool isLastMove = false;
if (possibleMoves[j].pattern == ChessPieceMovePattern.Normal)
{
if (boardDict.ContainsKey(to.ToArrayCoord()))
{
if (boardDict[to.ToArrayCoord()].type.IsSameTeamAs(position.type))
{
break;
}
isLastMove = true;
}
}
else if (possibleMoves[j].pattern == ChessPieceMovePattern.MoveOnly)
{
if (boardDict.ContainsKey(to.ToArrayCoord()))
{
break;
}
}
else if (possibleMoves[j].pattern == ChessPieceMovePattern.CaptureOnly)
{
if (!boardDict.ContainsKey(to.ToArrayCoord()))
{
break;
}
if (boardDict[to.ToArrayCoord()].type.IsSameTeamAs(position.type))
{
break;
}
}
// Pawn Promotion
if (position.type.IsPawn())
{
if
(
position.type == ChessPieceType.WhitePawn &&
position.coord.y == 0
)
{
position.type = ChessPieceType.WhiteQueen;
}
else if
(
position.type == ChessPieceType.BlackPawn &&
position.coord.y == 7
)
{
position.type = ChessPieceType.BlackQueen;
}
}
ret.Add(GameManager.Instance.AdjustBoard
(
boardSnapshot,
position.type.ToIcon() + " " + from.x + "," + from.y + "-->" + to.x + "," + to.y,
new ChessPosition(ChessPieceType.None, from, true),
new ChessPosition(position.type, to, true)
));
if (isLastMove)
{
break;
}
}
else
{
if (boardDict.ContainsKey(to.ToArrayCoord()))
{
break;
}
}
}
to += possibleMoves[j].move;
k++;
}
}
}
return(ret.ToArray());
}
