/// <summary>
/// 判断指定方向以内,是否有子存在
/// </summary>
/// <param name="direct"></param>
/// <param name="type"></param>
/// <returns></returns>
public static Boolean CheckDirectOnChess(Point point, Direction direct, int count)
{
//缓存当前坐标的引用
ChessPoint tempPoint = Chess.Find(Chess.Find(point).DirectionPoint(direct));
int index = 0;
//寻找
while (index < count)
{
if (tempPoint == null)
{
return(false);
}
else if (tempPoint.Type != ChessType.NULL)
{
return(true);
}
tempPoint = Chess.Find(tempPoint.DirectionPoint(direct));
index++;
}
return(false);
}
public void Ctor_TakesValidParameters_ShouldSetNumberAndValue(char letter, int number)
{
var chessPoint = new ChessPoint(letter, number);
Assert.AreEqual(letter, chessPoint.Letter);
Assert.AreEqual(number, chessPoint.Number);
}
static Board()
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 9; j++)
{
Position[i, j] = new ChessPoint();
Position[i, j].Row = i;
Position[i, j].Col = j;
Position[i, j].IsEmpty = true;
Position[i, j].Name = "";
Position[i, j].Index = -1;
Position[i, j].Side = -1;
Position[i, j].ValidMove = new PictureBox();
Position[i, j].ValidMove.Image = Resources.ValidMove;
Position[i, j].ValidMove.Width = 20;
Position[i, j].ValidMove.Height = 20;
Position[i, j].ValidMove.BackColor = Color.Transparent;
Position[i, j].ValidMove.Top = i*48 + 47;
Position[i, j].ValidMove.Left = j*48 + 23;
Position[i, j].ValidMove.Cursor = Cursors.Hand;
Position[i, j].ValidMove.Visible = false;
}
}
}
/// <summary>
/// 对比赛进行初始化
/// </summary>
private void initChess()
{
this.tableLayoutPanel7.Controls.Clear();
//初始化棋盘
for (int rowIndex = 0; rowIndex < Chess.GlobleChess.GetLength(0); rowIndex++)
{
for (int columnIndex = 0; columnIndex < Chess.GlobleChess.GetLength(1); columnIndex++)
{
Chess.GlobleChess[rowIndex, columnIndex] = ChessPoint.CreateChessPoint(new Point(columnIndex, rowIndex), ChessType.NULL);
this.tableLayoutPanel7.Controls.Add(Chess.GlobleChess[rowIndex, columnIndex], columnIndex + 1, rowIndex + 1);
}
}
//初始化历史记录
Conf.globleRoute = new List <HistoryRecord>();
//初始化历史记录列表
this.routeListBox.Items.Clear();
//初始化先行方
Conf.CurrentTurn = ChessType.BLACK;
//初始化缓存棋步
Conf.LastPoint = null;
//打开组件
this.AbleAllCompents(true);
}
public void GetHashCode_TwoNonEqualsInstances_ReturnsFalse(char letter1, int number1, char letter2, int number2)
{
var chessPoint1 = new ChessPoint(letter1, number1);
var chessPoint2 = new ChessPoint(letter2, number2);
Assert.False(chessPoint1.GetHashCode() == chessPoint2.GetHashCode());
}
public void Equals_TakesNonEqualInstance_ReturnsFalse(char letter1, int number1, char letter2, int number2)
{
var chessPoint1 = new ChessPoint(letter1, number1);
var chessPoint2 = new ChessPoint(letter2, number2);
Assert.False(chessPoint1.Equals(chessPoint2));
}
async void _board_ChessMoved(ChessPoint newPoint, ChessPoint oldPoint, ChessmanBase newChessman, ChessmanBase oldChessman)
{
if (newChessman.IsRed == IsRedSelected)
{
//发送落子坐标
var result = await Const.Connection.InvokeAsync <string>("Action", oldPoint, newPoint, _receiver);
if (result != "SUCCESS")
{
MessageBox.Show(result, "ERROR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
if (oldChessman != null && oldChessman is King)
{
IsBlueReady = false;
IsRedReady = false;
await Const.Connection.InvokeAsync("GameOver");
if (oldChessman.IsRed == IsRedSelected)
{
MessageBox.Show("你输了", "Info", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
MessageBox.Show("你赢了", "Info", MessageBoxButton.OK, MessageBoxImage.Information);
}
Messenger.Default.Send(true, "Close");
}
}
public void OverloadedNotEqualsOperator_TakesNulls_ReturnsFalse()
{
ChessPoint chessPoint1 = null;
ChessPoint chessPoint2 = null;
Assert.False(chessPoint1 == chessPoint2);
}
private void NotifyAboutCheckMate(Player initiator, Player opponent, ChessPoint from, ChessPoint to)
{
var field = _virtualField.CloneMatrix();
_turnColor = _turnColor.Invert();
var winner = initiator.PlayerColor;
var winnerGameInfo = new WcfGameInfo(
initiator.PlayerColor,
opponent.PlayerName,
field.ToJaggedArray(),
_turnColor,
winner);
var loserGameInfo = new WcfGameInfo(
initiator.PlayerColor,
opponent.PlayerName,
field.ToJaggedArray(),
_turnColor,
winner);
initiator.Callback.GameHasEnded(winnerGameInfo, from.FromBusiness(), to.FromBusiness());
opponent.Callback.GameHasEnded(loserGameInfo, from.FromBusiness(), to.FromBusiness());
GameEnded?.Invoke(this, EventArgs.Empty);
}
public void OverloadedEqualsOperator_TakesEqualInstances_ReturnsTrue(char letter1, int number1, char letter2,
int number2)
{
var chessPoint1 = new ChessPoint(letter1, number1);
var chessPoint2 = new ChessPoint(letter2, number2);
Assert.True(chessPoint1 == chessPoint2);
}
/// <summary>
/// 是否是后2排
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static bool IsAfterCamp(ChessPoint point)
{
if (point.y < 2 || point.y > 9)
{
return(true);
}
return(false);
}
public static bool IsRailWay(ChessPoint pointS, ChessPoint pointT)
{
if (InRailArea(pointS) && InRailArea(pointT))
{
return(true);
}
return(false);
}
private void ShowChessMoveTo(ChessPoint point1, ChessPoint point2)
{
//显示轨迹
FieldRoadStation station = App.Package.ChessGame.GetFieldRoadStationByPoint(point1);
UIWChessItem uiItem = station.gameObject.GetComponent <UIWChessItem>();
uiItem.SetArrow(point2);
}
/// <summary>
/// 是否是第一排
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static bool IsFirstRow(ChessPoint point)
{
if (point.y == 5 || point.y == 6)
{
return(true);
}
return(false);
}
public ChessPoint[] ChessDataPathToPoints(ChessDataPath path)
{
ChessPoint[] re = new ChessPoint[path.ChessPoints.Count];
for (int i = 0; i < path.ChessPoints.Count; i++)
{
re[i] = new ChessPoint(path.ChessPoints[i].X, path.ChessPoints[i].Y);
}
return(re);
}
public void SetNumber_TakesValidNumber_ShouldSetNumber(int number)
{
var chessPoint = new ChessPoint('a', 3)
{
Number = number
};
Assert.AreEqual(number, chessPoint.Number);
}
public void SetLetter_TakesValidLetter_ShouldSetLetter(char letter)
{
var chessPoint = new ChessPoint('c', 1)
{
Letter = letter
};
Assert.AreEqual(letter, chessPoint.Letter);
}
public ChessPoint[] ToChessPoints()
{
ChessPoint[] points = new ChessPoint[pathStations.Count];
for (int i = 0; i < points.Length; i++)
{
points[i] = App.Package.ChessGame.GetFieldRoadStationById(pathStations[i]).point;
}
return(points);
}
public ChessHeroData GetChessHeroDataByPoint(ChessPoint point)
{
foreach (var item in m_ChessData)
{
if (item.Value.point.Equals(point))
{
return(item.Value);
}
}
return(null);
}
private void ClearSelection()
{
foreach (var selectedCell in _selectedCells)
{
selectedCell.MouseDown -= OnSelectedCellMouseDown;
CanvasRef.Children.Remove(selectedCell);
}
_selectedCells.Clear();
_selectedCell = DefaultCell;
}
/// <summary>
/// 是否是大本营
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static bool IsStronghold(ChessPoint point)
{
if (point.x == 1 || point.x == 3)
{
if (point.y == 0 || point.y == 11)
{
return(true);
}
}
return(false);
}
private bool IsClickable(ChessPoint point)
{
if (!FieldFrame.PlayerColor.HasValue)
{
return(true);
}
var clickedPointPlayerColor = FieldFrame[point].GetPlayerColor();
var selectedPoints = _selectedCells.Select(cell => (ChessPoint)cell.Tag);
return((clickedPointPlayerColor == TurnColor || selectedPoints.Contains(point)) &&
TurnColor == FieldFrame.PlayerColor.Value);
}
private void ChessMoveTo(ChessHeroData hero, ChessPoint point)
{
if (point.y / 6 > 0)
{
hero.gameObject.transform.parent = m_EnemyFied.transform;
}
else
{
hero.gameObject.transform.parent = m_MyselfFied.transform;
}
hero.point = point.Clone();
hero.gameObject.transform.localScale = Vector3.one;
hero.gameObject.transform.localPosition = GetChessLocalPosition(hero.point);
}
/// <summary>
/// Get vector path points.
/// </summary>
/// <param name="vector">Vector value.</param>
/// <returns>Points on the path.</returns>
protected IEnumerable <ChessPoint> GetVectorPathPoints(ChessVector vector)
{
var currentPos = Position;
bool opponent = false;
while (CanMove(currentPos = ChessPoint.Add(currentPos, vector)) && !opponent)
{
yield return(currentPos);
var targetPlace = Field[currentPos.X, currentPos.Y];
var targetSideName = targetPlace.GetPlayerColor();
opponent = targetSideName.HasValue && SideName != targetSideName && !IsIgnoreEnemyKing(targetPlace);
}
}
public HistoryStep BuildHistoryStep(int counter, ChessHeroData source, ChessPoint targetPoint, ChessDataPath path, int result)
{
ChessData s = new ChessData();
s.ChessRemoteId = source.remoteId;
s.Belong = source.belong;
s.ChessType = source.realChessType;
s.Point = source.point.ParseToRpc();
ChessData t = new ChessData();
t.Point = targetPoint.ParseToRpc();
return(BuildHistoryStep(counter, s, t, path, result));
}
/// <summary>
/// Constructor for <see cref="FieldInfoArgs"/>.
/// </summary>
public FieldInfoArgs(
ChessPiece[][] virtualField,
PlayerColor turnColor,
ChessPoint fromPoint,
ChessPoint toPoint,
PlayerColor playerColor,
PlayerColor?checkedPlayer)
{
VirtualField = virtualField;
TurnColor = turnColor;
FromPoint = fromPoint;
ToPoint = toPoint;
PlayerColor = playerColor;
CheckedPlayer = checkedPlayer;
}
private void SetSelection(ChessPoint selectedCell, IEnumerable <ChessPoint> movableCells)
{
var markedCells = movableCells.Union(
new[]
{
selectedCell
});
foreach (var markedCell in markedCells)
{
var rectangle = DrawRectagle(markedCell.X, markedCell.Y, MovableCellsBrush, 0);
rectangle.MouseDown += OnSelectedCellMouseDown;
_selectedCells.Add(rectangle);
}
}
/// <inheritdoc/>
public void Move(string sessionId, ChessPoint from, ChessPoint to)
{
lock (_playingGamesSyncObj)
{
var game =
_playingGames.FirstOrDefault(
g => g.Player1.SessionId == sessionId || g.Player2.SessionId == sessionId);
if (game == null)
{
throw new SessionNotFoundedException();
}
game.Move(sessionId, from, to);
}
}
/// <inheritdoc/>
protected override IEnumerable <ChessPoint> GetAvailableMovements(bool onlySteps = false)
{
var movements = new[]
{
new ChessVector(-2, -1),
new ChessVector(-1, -2),
new ChessVector(1, -2),
new ChessVector(2, -1),
new ChessVector(2, 1),
new ChessVector(1, 2),
new ChessVector(-1, 2),
new ChessVector(-2, 1),
};
return(movements.Select(vector => ChessPoint.Add(Position, vector)).Where(CanMove));
}
/// <summary>
///
/// </summary>
/// <param name="chessData"></param>
/// <param name="forceTrans">是否强制坐标转换</param>
/// <returns></returns>
ChessHeroData ChessDataToChessHeroData(ChessData chessData, bool forceTrans = false)
{
ChessHeroData chess = new ChessHeroData();
chess.group = App.Package.ChessGame.GetGroup(chessData.Belong);
chess.heroTypeId = chessData.ChessType;
chess.realChessType = chess.heroTypeId;
chess.remoteId = chessData.ChessRemoteId;
chess.point = ChessPoint.ParseFromRpc(chessData.Point);
chess.belong = chessData.Belong;
if (chess.group != ChessHeroGroup.Myself || forceTrans)
{
chess.point.x = 4 - chess.point.x;
chess.point.y = 11 - chess.point.y;
}
return(chess);
}
/// <inheritdoc/>
public bool TryGetMaster(VirtualField field, ChessPoint point, out PieceMasterBase master)
{
master = null;
if (0 <= point.X && point.X < field.Width && 0 <= point.Y && point.Y < field.Height)
{
var targetPlace = field[point];
if (targetPlace == ChessPiece.Empty)
{
return(false);
}
master = (PieceMasterBase)Activator.CreateInstance(_objectsProvider[targetPlace], field, point, this);
return(true);
}
return(false);
}
