/// <summary>
/// Primera instancia
/// </summary>
/// <param name="Screen">Viewport o deimensiones de la pantalla</param>
public Enviroment(Viewport Screen)
{
this.Screen = Screen;
point = new Chess();
pointcollect = new Chess[3];
for (int i = 0; i < 3; i++)
pointcollect[i] = new Chess();
Token = Ask.White.King;
InitializeComponents();
}
// Defines am i a player one or player two
// pt:PlayerType -II-
public void AddToGame(Chess game, PlayerType pt)
{
iam = pt;
// Sets the chess object
chess = game;
// Sets a callback for every step happened
AbstractGame.StepHandler ost = new AbstractGame.StepHandler(OnStep);
chess.RegisterAsPlayer(ref ost, iam);
}
public static unsafe BoardStruct* ManagedBoardToNative(Chess.Base.Board board)
{
var b = Board.Create();
b->Castle = 0;
if (board.CastlingRights.Contains(Base.Castling.KingsideBlack))
b->Castle |= Board.CASTLE_BK;
if (board.CastlingRights.Contains(Base.Castling.QueensideBlack))
b->Castle |= Board.CASTLE_BQ;
if (board.CastlingRights.Contains(Base.Castling.KingsideWhite))
b->Castle |= Board.CASTLE_WK;
if (board.CastlingRights.Contains(Base.Castling.QueensideWhite))
b->Castle |= Board.CASTLE_WQ;
b->EnPassantTile = (byte)board.EnPassantTile;
b->FiftyMoveRulePlies = (byte)board.FiftyMoveRulePlies;
b->PlayerTurn = (byte)board.PlayerTurn;
b->CurrentMove = (board.MoveCount - 1) * 2;
if (b->PlayerTurn == Board.COLOR_BLACK)
b->CurrentMove++;
for(int i = 0; i < 64; i++)
{
Chess.Base.Color color = board.GetColor(i);
Chess.Base.Piece piece = board.GetPiece(i);
if(color == 0 || piece == 0)
continue;
Board.SetPiece(b, i, (int)piece, (int)color);
}
//b->AttacksBlack = Board.AttackMap(b, Board.COLOR_BLACK);
//b->AttacksWhite = Board.AttackMap(b, Board.COLOR_WHITE);
b->Hash = Zobrist.Calculate(b);
//b->MoveHistory // N/A
return b;
}
//dimensione della scacchiera
public List<int> CreateGraphFromChessAndStartDijkstra(Chess[] chessboard, Vector2 dimensions, string strstart, string strend)
{
int _count = 1;
_findMinDistance = false;
_isGraphConnected = true;
List<int> ret = new List<int>();
for (int x = 0; x < chessboard.Length; x++)
{
MinDistanceWpf.Classes.Node n = new MinDistanceWpf.Classes.Node(Convert.ToString(x));
_nodes.Add(n);
_count++;
}
int offset, riga, ind;
int[,] coords = new int[8, 2] { { -1, 1 }, { -1, 0 }, { -1, 1 }, { 0, -1 }, { 1, -1 }, { 1, 0 }, { 1, 1 }, { 0, 1 } };
for (int x = 0; x < chessboard.Length; x++)
{
riga = (int)Math.Floor(x / dimensions.X);
offset = (int)(x % dimensions.X);
//relazioni
for (int i = 0; i < 8; i++)
{
ind = (int)((riga + coords[i, 1]) * dimensions.X + offset + coords[i, 0]);
if (((int)Math.Floor(ind / dimensions.X) == (riga + coords[i, 1])) &&
((ind % dimensions.X) == (offset + coords[i, 0])))
{
if (Check_Index(ind, ref chessboard)) //qui controlla anche se deve essere preso in considerazione o meno
AddConnection(Convert.ToString(x), Convert.ToString(ind), chessboard[ind].value);
}
}
}
Node start = _nodes.Find(n => n.Label == strstart); //cerca il nodo avente label a
Node end = _nodes.Find(n => n.Label == strend); //cerca il nodo avente label a
FindMinDistancePath(start, end);
ret = PaintMinDistancePath(start, end);
return ret;
}
public MainWindow()
{
InitializeComponent();
Chess chess = new Chess(this);
}
/// <summary>
/// 检测当前棋子是否可以消除
/// </summary>
/// <param name="chessobj">指定的棋子</param>
/// <returns>
/// true: 棋子可以消除
/// false : 棋子不满足消除的条件
/// </returns>
internal bool CanBurstByChess(Chess chessObj)
{
bool canBurst = false; //默认不可以消除
//判断是否满足消除的条件
if (
(chessObj.gameObject.name == strChessLest1 && chessObj.gameObject.name == strChessLest2) ||
(chessObj.gameObject.name == strChessLest1 && chessObj.gameObject.name == strChessRight1) ||
(chessObj.gameObject.name == strChessRight1 && chessObj.gameObject.name == strChessRight2) ||
(chessObj.gameObject.name == strChessUp1 && chessObj.gameObject.name == strChessUp2) ||
(chessObj.gameObject.name == strChessUp1 && chessObj.gameObject.name == strChessDown1) ||
(chessObj.gameObject.name == strChessDown1 && chessObj.gameObject.name == strChessDown2)
)
{
canBurst = true;
}
return canBurst;
}
private int getEmpties(Chess[,] board)
{
int empties = 0;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (board[i, j] == Chess.AVAILABLE)
empties++;
return empties;
}
private static bool DrawCellsinDiagonal(Chess Token)
{
bool Pass = false;
//seeking diagonal top left
diago = Z = Token.X - 1; eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Z > -1 && Dot.Board[Z][a].ID == ""; a--)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Z][a].Color = Color.SpringGreen;
Z--; eat = a - 1; diago = Z;
}
//if it'll eat
if (diago > -1 && eat > -1 && Dot.Board[diago][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[diago][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking diagonal bottom left
diago = Z = Token.X - 1; eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Z > -1 && Dot.Board[Z][a].ID == ""; a++)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Z][a].Color = Color.SpringGreen;
Z--; eat = a + 1; diago = Z;
}
//if it'll eat
if (diago > -1 && eat < 8 && Dot.Board[diago][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[diago][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking diagonal top right
diago = Z = Token.X + 1; eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Z < 8 && Dot.Board[Z][a].ID == ""; a--)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Z][a].Color = Color.SpringGreen;
Z++; eat = a - 1; diago = Z;
}
//if it'll eat
if (diago < 8 && eat > -1 && Dot.Board[diago][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[diago][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking diagonal bottom right
diago = Z = Token.X + 1; eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Z < 8 && Dot.Board[Z][a].ID == ""; a++)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Z][a].Color = Color.SpringGreen;
Z++; eat = a + 1; diago = Z;
}
//if it'll eat
if (diago < 8 && eat < 8 && Dot.Board[diago][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[diago][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
return Pass;
}
private static void King(Chess Token, MouseState mouse)
{
//up
if (Token.Y - 1 > -1 && Dot.Board[Token.X][Token.Y - 1].ID == "" | Dot.Board[Token.X][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X, Token.Y - 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y - 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//down
if (Token.Y + 1 < 8 && Dot.Board[Token.X][Token.Y + 1].ID == "" | Dot.Board[Token.X][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X, Token.Y + 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y + 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//left
for (int i = Token.X - 1; i >= (Castling(Token.Y, 0) ? Token.X - 2 : Token.X - 1); i--)
if (i > -1 && Dot.Board[i][Token.Y].ID == "" | Dot.Board[i][Token.Y].ID.Contains(enemy) && checKing(i, Token.Y, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[i][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(i * Player.X + Player.W, Token.Y * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
if (i == Token.X - 2) Fitup(0, 3);
Token.X = i;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//right
for (int i = Token.X + 1; i <= (Castling(Token.Y, 1) ? Token.X + 2 : Token.X + 1); i++)
if (i < 8 && Dot.Board[i][Token.Y].ID == "" | Dot.Board[i][Token.Y].ID.Contains(enemy) && checKing(i, Token.Y, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[i][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(i * Player.X + Player.W, Token.Y * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
if (i == Token.X + 2) Fitup(1, 5);
Token.X = i;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//diagonal top left
if (Token.X - 1 > -1 && Token.Y - 1 > -1 && Dot.Board[Token.X - 1][Token.Y - 1].ID == "" | Dot.Board[Token.X - 1][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X - 1, Token.Y - 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y - 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X--; Token.Y--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//diagonal top right
if (Token.X + 1 < 8 && Token.Y - 1 > -1 && Dot.Board[Token.X + 1][Token.Y - 1].ID == "" | Dot.Board[Token.X + 1][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X + 1, Token.Y - 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y - 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X++; Token.Y--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//diagonal bottom left
if (Token.X - 1 > -1 && Token.Y + 1 < 8 && Dot.Board[Token.X - 1][Token.Y + 1].ID == "" | Dot.Board[Token.X - 1][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X - 1, Token.Y + 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y + 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X--; Token.Y++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//diagonal bottom right
if (Token.X + 1 < 8 && Token.Y + 1 < 8 && Dot.Board[Token.X + 1][Token.Y + 1].ID == "" | Dot.Board[Token.X + 1][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X + 1, Token.Y + 1, 7))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y + 1].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X++; Token.Y++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
}
private void pictureBox1_MouseUp(object sender, MouseEventArgs e) //下棋
{
if (choice != 1 && choice != 2) //沒選玩家或電腦
{
return;
}
if (choice == 1) //玩家對弈
{
if (player == Chess.Black) //黑棋
{
check = m.setBlack(e.X, e.Y); //設定黑子
}
else
{
check = m.setWhite(e.X, e.Y); //設定白子
}
pictureBox1.Invalidate(); //畫圖
if (check) //下棋成功
{
if (player == Chess.Black) //檢查輸贏
{
check = m.checkWinLose(1);
}
else
{
check = m.checkWinLose(2);
}
if (check) //有贏家
{
if (player == Chess.Black)
{
ProgressLB.Text = "黑棋勝！";
}
else
{
ProgressLB.Text = "白棋勝！";
}
choice = 0;
countdown1(2);
countdown2(2);
return;
}
if (player == Chess.Black) //換人
{
player = Chess.White;
ProgressLB.Text = "白棋回合";
countdown1(2);
countdown2(1);
}
else
{
player = Chess.Black;
ProgressLB.Text = "黑棋回合";
countdown2(2);
countdown1(1);
}
total++; //總棋子+1
if (total == 225) //棋盤已滿
{
ProgressLB.Text = "棋盘已满，本局平棋！";
choice = 0;
countdown1(2);
countdown2(2);
}
}
}
else if (choice == 2) //玩家與電腦對弈
{
if (player == Chess.Black) //玩家是黑棋
{
check = m.setBlack(e.X, e.Y);
computer = 0; //電腦設為白棋
}
else
{
check = m.setWhite(e.X, e.Y);
computer = 1;
}
pictureBox1.Invalidate(); //畫圖
if (check) //下棋成功
{
if (player == Chess.Black) //檢查輸贏
{
check = m.checkWinLose(1);
}
else
{
check = m.checkWinLose(2);
}
if (check) //有贏家
{
if (player == Chess.Black)
{
ProgressLB.Text = "黑棋勝！";
}
else
{
ProgressLB.Text = "白棋勝！";
}
choice = 0;
return;
}
total++;
if (total == 225) //棋盤已滿
{
ProgressLB.Text = "棋盘已满，本局平棋！";
choice = 0;
}
else
{
//電腦下棋
if (m.ComputerAIMove(computer)) //呼叫電腦下棋函式
{
pictureBox1.Invalidate(); //畫圖
if (computer == 1) //檢查輸贏
{
check = m.checkWinLose(1);
}
else
{
check = m.checkWinLose(2);
}
if (check) //有贏家
{
if (computer == 1)
{
ProgressLB.Text = "黑棋勝！";
}
else
{
ProgressLB.Text = "白棋勝！";
}
choice = 0;
return;
}
total++;
if (total == 225) //棋盤已滿
{
ProgressLB.Text = "棋盘已满，本局平棋！";
choice = 0;
}
}
else //電腦沒步走，玩家勝利
{
MessageBox.Show("恭喜你，你赢了！棋盘上所有点均为电脑的禁手点！", "本局结果", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (player == Chess.Black)
{
ProgressLB.Text = "黑棋勝！";
}
else
{
ProgressLB.Text = "白棋勝！";
}
choice = 0;
return;
}
}
}
}
}
public static void Player_Click(MouseState mouse, Player player, char Enemy, Color color)
{
Color = color; Player = player; enemy = Enemy;
if (!move)
{
Clear(Color);
#region King
if (Dot.point.Size.Intersects(player.King.Size) && player.King.Visible && !intersect)
{
intersect = true;
if (DrawKingCells(player.King) && mouse.LeftButton == ButtonState.Pressed)
{
Dot.Token = player.King;
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.King.X][player.King.Y].ID = "";
move = true; id = 5; Asist = player.King;
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
}
#endregion
if (checKing(player.King.X, player.King.Y, 7))
{
#region pawns
for (int i = 0; i < 8; i++)
{
if (Dot.point.Size.Intersects(player.Pawn[i].Size) && player.Pawn[i].Visible && !intersect)
{
intersect = true;
bool Pass = false;
if (player.Rol) Pass = DrawUpPawnCells(Player.Pawn[i]);
else Pass = DrawDownPawnCells(Player.Pawn[i]);
if (Pass && mouse.LeftButton == ButtonState.Pressed)
{
Dot.Token = player.Pawn[i];
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.Pawn[i].X][player.Pawn[i].Y].ID = "";
move = true;
id = 0; Asist = player.Pawn[i];
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
break;
}
}
#endregion
#region Rook
for (int i = 0; i < 2; i++)
{
if (Dot.point.Size.Intersects(player.Rook[i].Size) && player.Rook[i].Visible && !intersect)
{
intersect = true;
if (DrawCellsinCrux(player.Rook[i]) && mouse.LeftButton == ButtonState.Pressed)
{
if (mouse.LeftButton == ButtonState.Pressed)
{
Dot.Token = player.Rook[i];
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.Rook[i].X][player.Rook[i].Y].ID = "";
move = true; id = 2; Asist = player.Rook[i];
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
break;
}
}
}
#endregion
#region Knight
for (int i = 0; i < 2; i++)
{
if (Dot.point.Size.Intersects(player.Knight[i].Size) && player.Knight[i].Visible && !intersect)
{
intersect = true;
if (DrawKnightCells(player.Knight[i]) && mouse.LeftButton == ButtonState.Pressed)
{
Dot.Token = player.Knight[i];
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.Knight[i].X][player.Knight[i].Y].ID = "";
move = true; id = 4; Asist = player.Knight[i]; break;
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
break;
}
}
#endregion
#region Bishop
for (int i = 0; i < 2; i++)
{
if (Dot.point.Size.Intersects(player.Bishop[i].Size) && player.Bishop[i].Visible && !intersect)
{
intersect = true;
if (DrawCellsinDiagonal(player.Bishop[i]) && mouse.LeftButton == ButtonState.Pressed)
{
Dot.Token = player.Bishop[i];
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.Bishop[i].X][player.Bishop[i].Y].ID = "";
move = true; id = 3; Asist = player.Bishop[i]; break;
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
break;
}
}
#endregion
#region Queen
if (Dot.point.Size.Intersects(player.Queen.Size) && player.Queen.Visible && !intersect)
{
intersect = true;
bool Crux = DrawCellsinCrux(player.Queen);
bool Diagonal = DrawCellsinDiagonal(player.Queen);
bool Pass = Diagonal || Crux;
if (mouse.LeftButton == ButtonState.Pressed && Pass)
{
Dot.Token = player.Queen;
Dot.point.Texture = Dot.pointcollect[1].Texture;
Dot.Board[player.Queen.X][player.Queen.Y].ID = "";
move = true; id = 1; Asist = player.Queen;
}
else Dot.point.Texture = Dot.pointcollect[0].Texture;
}
#endregion
}
#region Check Mate
if (!checKing(player.King.X, player.King.Y, 7))
{
if (!Stage.check)
Stage.Begin("CHECK...".ToCharArray());
Stage.check = true;
}
#endregion /Animation/
intersect = false;
}
//If the player has any Token
else Move(Asist, mouse, id);
Dot.point.Size.X = mouse.X;
Dot.point.Size.Y = mouse.Y;
}
public DamageInfo setPartner(Chess _c)
{
source_partner = _c;
return(this);
}
public void CreateChess()
{
chess = new Chess();
}
public DamageInfo setActor(Chess _c)
{
source_actor = _c;
return(this);
}
/*
* public async Task TrackChallenge(ApplicationDbContext context, Game game)
* {
* if (_challengeTasks.ContainsKey(game.ChallengeId))
* return;
* }
*
* protected async Task<EventType> LichessMonitor (Game game)
* {
* LichessApiClient client = new LichessApiClient(game.HomePlayer.User.AccessToken);
*
* CancellationTokenSource cts = new CancellationTokenSource();
* _challengeTokens.Add(game.ChallengeId, cts);
*
* await foreach (EventStreamResponse evt in client.Challenges.StreamIncomingEvents(cts.Token))
* {
* if (evt.Type == EventType.ChallengeCanceled ||
* evt.Type == EventType.ChallengeDeclined)
* return evt.Type;
* }
*
* }
*/
protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
while (true)
{
using (IServiceScope scope = _provider.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
var config = scope.ServiceProvider.GetRequiredService <IConfiguration> ();
var hubContext = scope.ServiceProvider.GetRequiredService <IHubContext <GameHub> >();
var dataService = scope.ServiceProvider.GetRequiredService <DataService>();
try
{
// Get the API access token
var lichessAuthNSection = config.GetSection("Authentication:Lichess");
var appToken = lichessAuthNSection["AppToken"];
// Create a client that can use the token
var client = new LichessApiClient(appToken);
// Get games from the last week that have not been completed
var matches = await context.Match.Where(m => m.IsVirtual && m.MatchStarted && !m.Completed)
.Include(m => m.Games).ThenInclude(g => g.HomePlayer).ThenInclude(p => p.User)
.Include(m => m.Games).ThenInclude(g => g.AwayPlayer).ThenInclude(p => p.User)
.ToListAsync();
if (matches is not null)
{
foreach (var match in matches)
{
MatchUpdateViewModel vm = new MatchUpdateViewModel
{
MatchId = match.MatchId,
Games = new List <GameJson>()
};
List <string> gameIds = new List <string>();
foreach (var game in match.Games)
{
if (!game.Completed && !String.IsNullOrEmpty(game.ChallengeId))
{
gameIds.Add(game.ChallengeId);
}
else if (game.Completed)
{
vm.Games.Add(MapGameToJson(game));
}
}
if (gameIds.Count > 0)
{
CancellationTokenSource cts = new CancellationTokenSource();
ExportGamesByIdsRequest request = new ExportGamesByIdsRequest
{
PgnInJson = true,
Moves = true,
Clocks = true,
Evals = false,
Opening = true
};
try
{
await foreach (LichessApi.Web.Models.Game ligame in client.Games
.ExportGamesByIds(request, gameIds, cts.Token))
{
// Remove this from the list
gameIds.Remove(ligame.Id);
Chess chess = new Chess();
if (!String.IsNullOrEmpty(ligame.Moves))
{
try
{
chess.loadSAN(ligame.Moves);
}
catch (Exception e)
{
Log.Error(e, "Error loading SAN {0}", ligame.Moves);
}
}
var game = match.Games.FirstOrDefault(g => g.ChallengeId.Equals(ligame.Id));
if (game != null)
{
string fen = chess.Fen();
game.CurrentFen = fen;
game.LastMove = ligame.LastMoveAt;
game.ChallengeStatus = ligame.Status.ToEnumString();
game.ChallengeMoves = ligame.Moves ?? "";
if (ligame.Status == GameStatus.Timeout ||
ligame.Status == GameStatus.Aborted)
{
ResetGame(game);
}
else if (ligame.Status == GameStatus.Started)
{
game.IsStarted = true;
}
else if (ligame.Status == GameStatus.Draw ||
ligame.Status == GameStatus.Stalemate)
{
// Result: 0 = Draw, 1 = Home Win, 2 = Away Win, 3 = Reset
GameResult result = GameResult.Draw;
await dataService.UpdateAndLogRatingCalculations(game, result);
game.Completed = true;
game.CompletedDate = DateTime.Now;
}
else if (ligame.Status == GameStatus.OutOfTime ||
ligame.Status == GameStatus.Resign ||
ligame.Status == GameStatus.Mate)
{
GameResult result = GameResult.Draw;
if (game.BoardPosition % 2 == 1)
{
// black player is home, white player is away
result = ligame.Winner.Equals("black")
? GameResult.Player1Wins
: GameResult.Player2Wins;
}
else
{
// white player is home, black player is away
result = ligame.Winner.Equals("white")
? GameResult.Player1Wins
: GameResult.Player2Wins;
}
// Everything beyond board 7 has flipped colors
if (game.BoardPosition > 7)
{
if (result == GameResult.Player1Wins)
{
result = GameResult.Player2Wins;
}
else
{
result = GameResult.Player1Wins;
}
}
await dataService.UpdateAndLogRatingCalculations(game, result);
game.Completed = true;
game.CompletedDate = DateTime.Now;
}
else if (ligame.Status == GameStatus.Cheat)
{
game.CheatingDetected = true;
}
context.Game.Update(game);
await context.SaveChangesAsync();
// Add game to json output
vm.Games.Add(MapGameToJson(game));
}
}
}
catch (ApiInvalidRequestException e)
{
Log.Error(e, "GameMonitor : Invalid Api request");
}
catch (ApiUnauthorizedException e)
{
Log.Error(e, "GameMonitor : Unauthorized request");
}
catch (ApiRateLimitExceededException e)
{
Log.Error(e, "GameMonitor: All requests are rate limited using various strategies, to ensure the API remains responsive for everyone. Only make one request at a time. If you receive an HTTP response with a 429 status, please wait a full minute before resuming API usage.");
await Task.Delay(60 * 1000); // Wait 60 seconds due to rate limit exceeded
}
catch (Exception e)
{
Log.Error(e, "GameMonitor : Error occurred");
}
// Are there any games that we didn't get responses back for?
if (gameIds.Count > 0)
{
foreach (string gameId in gameIds)
{
var game = match.Games.FirstOrDefault(g => g.ChallengeId.Equals(gameId));
if (game != null)
{
// This is to check for challenge games that are created but we would normally have to monitor
// by streaming events for every user
// Game is created but we aren't getting status updates on it
var response = await client.Connector.SendRawRequest(new Uri(game.ChallengeUrl), HttpMethod.Get);
var body = response.Body.ToString();
if (body.Contains("Challenge canceled") ||
body.Contains("Challenge declined"))
{
ResetGame(game);
context.Game.Update(game);
await context.SaveChangesAsync();
// Add game to json output
vm.Games.Add(MapGameToJson(game));
}
}
}
}
await hubContext.Clients.Groups("match_" + match.MatchId).SendAsync("UpdateMatches", vm);
await Task.Delay(500);
}
}
}
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
// if the DB is not currently connected, wait 15 seconds and try again
await Task.Delay(TimeSpan.FromSeconds(15));
continue;
}
}
var task = Task.Delay(TimeSpan.FromSeconds(10), cancellationToken);
try
{
await task;
}
catch (TaskCanceledException)
{
return;
}
}
}
public int ExplorePos = -1; //切换模式时，SL探索模式的位置
/// <summary>
/// 触发起点的处理放在具体位置
/// </summary>
/// <returns>The IDs,which event condition ready.</returns>
/// <param name="trigger">Trigger.</param>
/// <param name="int_argu">骑士站立、贴近事件为格子ID. 点击事件为click_ID</param>
public int[] isNowEventConditionReady(eEventTrigger trigger, int int_argu, Chess chess_argu)
{
List <int> events_ok = new List <int> ();
// foreach (var _evt in event_list) {
for (int checking_event_number = 0; checking_event_number < map_data.list_event_data.Count; checking_event_number++)
{
var _evt = map_data.list_event_data [checking_event_number];
//判断触发时机是否符合
if (trigger != _evt.condition.trigger_evt)
{
continue;
}
//前置事件判断
if (_evt.condition.pre_event_id >= 0 && map_data.list_event_data[_evt.condition.pre_event_id].triggered_times < _evt.condition.pre_event_launchtimes)
{
continue;
}
//触发阶段判断
if (_evt.condition.launch_phase != ePhaseType.All && Main.Inst.now_turnphase != null && _evt.condition.launch_phase != Main.Inst.now_turnphase.myType)
{
continue;
}
//触发次数判断
if (!(_evt.condition.trig_chance == 0 || _evt.condition.trig_chance > _evt.triggered_times))
{
continue;
}
//全局开关1判断
if (_evt.condition.gs_1 > 0 && !global_switch [_evt.condition.gs_1])
{
continue;
}
//全局开关2判断
if (_evt.condition.gs_2 > 0 && !global_switch[_evt.condition.gs_2])
{
continue;
}
//触发参数对照
switch (_evt.condition.trigger_evt)
{
case eEventTrigger.Reach_turn:
if (_evt.condition.trig_argu != now_turn)
{
continue;
}
break;
case eEventTrigger.Click:
if (_evt.condition.trig_argu != int_argu)
{
continue;
}
break;
case eEventTrigger.Kights_Stand:
//棋子对应的玩家有没有资格触发
if (!_evt.condition.players_who_can[(int)chess_argu.belong])
{
continue;
}
//查看棋子站的格子是否属于某个区域
bool match = false;
foreach (var item in Main.Inst.lv_ctrl.map_data.list_area_grid[_evt.condition.trig_argu].list)
{
if (item == chess_argu.container.number)
{
match = true;
break;
}
}
if (!match)
{
continue;
}
break;
case eEventTrigger.Monter_Dead:
if (_evt.condition.trig_argu != int_argu)
{
continue;
}
break;
case eEventTrigger.Phase_Change:
//不需要额外判断
default:
break;
}
//全局变量判断
if (_evt.condition.glo_v > 0)
{
switch (_evt.condition.glo_v_op)
{
case eCompareOP.大于:
if (!(global_variable [_evt.condition.glo_v] > _evt.condition.glo_v_compare))
{
continue;
}
break;
case eCompareOP.大于等于:
if (!(global_variable [_evt.condition.glo_v] >= _evt.condition.glo_v_compare))
{
continue;
}
break;
case eCompareOP.小于:
if (!(global_variable [_evt.condition.glo_v] < _evt.condition.glo_v_compare))
{
continue;
}
break;
case eCompareOP.小于等于:
if (!(global_variable [_evt.condition.glo_v] <= _evt.condition.glo_v_compare))
{
continue;
}
break;
case eCompareOP.等于:
if (!(global_variable [_evt.condition.glo_v] == _evt.condition.glo_v_compare))
{
continue;
}
break;
case eCompareOP.等于:
if (!(global_variable [_evt.condition.glo_v] != _evt.condition.glo_v_compare))
{
continue;
}
break;
default:
Debug.Log("关卡事件触发条件，变量对比方式错误");
break;
}
}
//携带道具判断
if (!(_evt.condition.with_item > 0 && true))
{
Debug.Log("携带道具判断未完成");
}
//携带角色判断
if (!(_evt.condition.with_char > 0 && true))
{
Debug.Log("携带角色判断未完成");
}
//怪物死亡判断
//目标事件ID和自身ID相同时，表示所有怪物死光
//其他表示指定的
bool monster_dead = true;
if (_evt.condition.EventMonter_Dead >= 0)
{
//将召唤
foreach (var coming_event in events_ok)
{
foreach (var unit in map_data.list_unit_data)
{
//有召唤发生，且需要怪物全死
if (unit.m_launch_event_order == coming_event && _evt.condition.EventMonter_Dead == checking_event_number)
{
monster_dead = false;
break;
}
//有召唤发生，且怪物的召唤事件ID与需要死的怪物批次相同
else if (unit.m_launch_event_order == coming_event && coming_event == _evt.condition.EventMonter_Dead)
{
monster_dead = false;
break;
}
if (!monster_dead)
{
break;
}
}
if (!monster_dead)
{
break;
}
}
//已召唤
foreach (KeyValuePair <long, Chess> item in Main.Inst.dic_chess)
{
Chess ch = item.Value;
//-1是玩家召唤，但玩家打翻的还会算
// if (ch.shoukan_event > 0 && ch.shoukan_event <= now_event_order)
//怪物全死有效
if (_evt.condition.EventMonter_Dead == checking_event_number)
{
if (ch.belong < ePlayer.Player1 || ch.belong > ePlayer.Player4)
{
monster_dead = false;
break;
}
}
else
{
//指定批次怪物死亡有效
if ((ch.belong < ePlayer.Player1 || ch.belong > ePlayer.Player4) && ch.shoukan_event == _evt.condition.EventMonter_Dead)
{
monster_dead = false;
break;
}
}
}
}
if (!monster_dead)
{
continue;
}
events_ok.Add(checking_event_number);
//_evt.triggered_times++; //
}
return(events_ok.ToArray());
//胜利条件由事件决定
// if (event_list.Count == now_event_order) {
// Main.Instance.GameOver (ePlayer.Player2);
// return false;
// }
// EventInfo evt = event_list[now_event_order];
//
// if (!isFirstRun && Main.Instance.now_turnphase.myType != evt.launch_phase
// && evt.launch_phase != ePhaseType.All)
// return false;
// //当前0表示所有之前事件对应的怪物死亡
// if (evt.condition.trigger == eEventTrigger.Phase_Change && evt.condition.EventMonter_Dead == 0) {
// foreach(KeyValuePair<int,Chess> item in Main.Instance.dic_chess){
// Chess ch = item.Value;
// //-1是玩家召唤，但玩家打翻的还会算
//// if (ch.shoukan_event > 0 && ch.shoukan_event <= now_event_order)
// if ((ch.belong< ePlayer.Player1 || ch.belong> ePlayer.Player4) && ch.shoukan_event <= now_event_order)
// return false;
// }
// return true;
// }
// Debug.Log ("其他条件未完成");
// return false;
}
private void Start()
{
chess = FindObjectOfType <Chess>();
this.GetComponent <Renderer>().material.color = originalColor;
isMoving = false;
}
public void StartChessGame()
{
currentChess = new Chess(chesspieces, currentWorld.size, currentWorld);
}
private static void Move(Chess Token, MouseState mouse, int model)
{
Token.Size.X = mouse.X - Player.width / 2;
Token.Size.Y = mouse.Y - Player.height / 2;
switch (model)
{
case 0:
#region pawns move
if (Player.Rol)
{
for (int a = Token.Y - 1; a >= Token.Y - (Token.initial ? 2 : 1) && Dot.Board[Token.X][a].ID == ""; a--)
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
process(Token.X, Token.Y = a, Token);
Token.initial = false;
}
break;
}
}
//Chewing token X - 1, Y - 1
if (Token.X - 1 > -1 && Token.Y - 1 > -1 && Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y - 1].Size)
&& !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size) && Dot.Board[Token.X - 1][Token.Y - 1].ID.Contains(enemy))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y--; Token.X--;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
}
//Chewing token X + 1, Y - 1
if (Token.X + 1 < 8 && Token.Y - 1 > -1 && Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y - 1].Size)
&& !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size) && Dot.Board[Token.X + 1][Token.Y - 1].ID.Contains(enemy))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y--; Token.X++;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
}
}
else
{
//black pawns
for (int a = Token.Y + 1; a <= Token.Y + (Token.initial ? 2 : 1) && Dot.Board[Token.X][a].ID == ""; a++)
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
process(Token.X, Token.Y = a, Token);
Token.initial = false;
}
break;
}
}
//Chewing token X + 1, Y + 1
if (Token.X + 1 < 8 && Token.Y + 1 < 8 && Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y + 1].Size)
&& !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size) && Dot.Board[Token.X + 1][Token.Y + 1].ID.Contains(enemy))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y++; Token.X++;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
}
//Chewing token X - 1, Y + 1
if (Token.X - 1 > -1 && Token.Y + 1 < 8 && Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y + 1].Size)
&& !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size) && Dot.Board[Token.X - 1][Token.Y + 1].ID.Contains(enemy))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y++; Token.X--;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
}
}
break;
#endregion
case 1:
#region queen move
//seeking in Crux
Crux(Token, mouse);
//seeking in Diagonal
Diagonal(Token, mouse);
break;
#endregion
case 2:
#region Rook move
//seeking in Crux
Crux(Token, mouse);
break;
#endregion
case 3:
#region bishop move
//seeking in Diagonal
Diagonal(Token, mouse);
break;
#endregion
case 4:
#region Knight move
//seeking in Knight
Knight(Token, mouse);
break;
#endregion
case 5:
#region king move
//seeking in King
King(Token, mouse);
break;
#endregion
}
}
//----------------------------------------工具函数------------------------------------------------------------
// 建立链接
private void linkChessAndGrid(Chess chess, Grid grid)
{
chess._GridPos = grid.getPos();
grid._Chess = chess;
}
private static void Diagonal(Chess Token, MouseState mouse)
{
//seeking diagonal top right
diago = Z = Token.X + 1; eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Z < 8 && Dot.Board[Z][a].ID == ""; a--)
{
if (Dot.point.Size.Intersects(Dot.Board[Z][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Z * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = Z, Token.Y = a, Token);
return;
}
Z++; diago = Z; eat = a - 1;
}
//eating diagonal top right
if (diago < 8 && eat > -1 && Dot.Board[diago][eat].ID.Contains(enemy) &&
Dot.point.Size.Intersects(Dot.Board[diago][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(diago * Player.X + Player.W, eat * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y = eat; Token.X = diago;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
return;
}
//seeking diagonal bottom right
diago = Z = Token.X + 1; eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Z < 8 && Dot.Board[Z][a].ID == ""; a++)
{
if (Dot.point.Size.Intersects(Dot.Board[Z][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Z * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = Z, Token.Y = a, Token);
return;
}
Z++; diago = Z; eat = a + 1;
}
//eating diagonal bottom right
if (diago < 8 && eat < 8 && Dot.Board[diago][eat].ID.Contains(enemy) &&
Dot.point.Size.Intersects(Dot.Board[diago][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(diago * Player.X + Player.W, eat * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y = eat; Token.X = diago;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
return;
}
//seeking diagonal top left
diago = Z = Token.X - 1; eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Z > -1 && Dot.Board[Z][a].ID == ""; a--)
{
if (Dot.point.Size.Intersects(Dot.Board[Z][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Z * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = Z, Token.Y = a, Token);
return;
}
Z--; diago = Z; eat = a - 1;
}
//eating diagonal top left
if (diago > -1 && eat > -1 && Dot.Board[diago][eat].ID.Contains(enemy) &&
Dot.point.Size.Intersects(Dot.Board[diago][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(diago * Player.X + Player.W, eat * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y = eat; Token.X = diago;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
return;
}
//seeking diagonal bottom left
diago = Z = Token.X - 1; eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Z > -1 && Dot.Board[Z][a].ID == ""; a++)
{
if (Dot.point.Size.Intersects(Dot.Board[Z][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Z * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = Z, Token.Y = a, Token);
return;
}
Z--; diago = Z; eat = a + 1;
}
//eating diagonal bottom left
if (diago > -1 && eat < 8 && Dot.Board[diago][eat].ID.Contains(enemy) &&
Dot.point.Size.Intersects(Dot.Board[diago][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(diago * Player.X + Player.W, eat * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y = eat; Token.X = diago;
Dot.Board[Token.X][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
process(Token.X, Token.Y, Token);
}
return;
}
}
static void Main(string[] args)
{
var chess = new Chess();
chess.Run();
}
private static bool DrawKnightCells(Chess Token)
{
bool Pass = false;
//X top left
if (Token.X - 2 > -1 && Token.Y - 1 > -1 && Dot.Board[Token.X - 2][Token.Y - 1].ID == "" | Dot.Board[Token.X - 2][Token.Y - 1].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X - 2][Token.Y - 1].ID.Contains(enemy)) Dot.Board[Token.X - 2][Token.Y - 1].Color = Color.Red;
else Dot.Board[Token.X - 2][Token.Y - 1].Color = Color.SpringGreen;
}
//Y top left
if (Token.X - 1 > -1 && Token.Y - 2 > -1 && Dot.Board[Token.X - 1][Token.Y - 2].ID == "" | Dot.Board[Token.X - 1][Token.Y - 2].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X - 1][Token.Y - 2].ID.Contains(enemy)) Dot.Board[Token.X - 1][Token.Y - 2].Color = Color.Red;
else Dot.Board[Token.X - 1][Token.Y - 2].Color = Color.SpringGreen;
}
//X top right
if (Token.X + 2 < 8 && Token.Y - 1 > -1 && Dot.Board[Token.X + 2][Token.Y - 1].ID == "" | Dot.Board[Token.X + 2][Token.Y - 1].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X + 2][Token.Y - 1].ID.Contains(enemy)) Dot.Board[Token.X + 2][Token.Y - 1].Color = Color.Red;
else Dot.Board[Token.X + 2][Token.Y - 1].Color = Color.SpringGreen;
}
//Y top right
if (Token.X + 1 < 8 && Token.Y - 2 > -1 && Dot.Board[Token.X + 1][Token.Y - 2].ID == "" | Dot.Board[Token.X + 1][Token.Y - 2].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X + 1][Token.Y - 2].ID.Contains(enemy)) Dot.Board[Token.X + 1][Token.Y - 2].Color = Color.Red;
else Dot.Board[Token.X + 1][Token.Y - 2].Color = Color.SpringGreen;
}
//Y bottom left
if (Token.X - 1 > -1 && Token.Y + 2 < 8 && Dot.Board[Token.X - 1][Token.Y + 2].ID == "" | Dot.Board[Token.X - 1][Token.Y + 2].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X - 1][Token.Y + 2].ID.Contains(enemy)) Dot.Board[Token.X - 1][Token.Y + 2].Color = Color.Red;
else Dot.Board[Token.X - 1][Token.Y + 2].Color = Color.SpringGreen;
}
//X bottom left
if (Token.X - 2 > -1 && Token.Y + 1 < 8 && Dot.Board[Token.X - 2][Token.Y + 1].ID == "" | Dot.Board[Token.X - 2][Token.Y + 1].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X - 2][Token.Y + 1].ID.Contains(enemy)) Dot.Board[Token.X - 2][Token.Y + 1].Color = Color.Red;
else Dot.Board[Token.X - 2][Token.Y + 1].Color = Color.SpringGreen;
}
//Y bottom right
if (Token.X + 1 < 8 && Token.Y + 2 < 8 && Dot.Board[Token.X + 1][Token.Y + 2].ID == "" | Dot.Board[Token.X + 1][Token.Y + 2].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X + 1][Token.Y + 2].ID.Contains(enemy)) Dot.Board[Token.X + 1][Token.Y + 2].Color = Color.Red;
else Dot.Board[Token.X + 1][Token.Y + 2].Color = Color.SpringGreen;
}
//X bottom right
if (Token.X + 2 < 8 && Token.Y + 1 < 8 && Dot.Board[Token.X + 2][Token.Y + 1].ID == "" | Dot.Board[Token.X + 2][Token.Y + 1].ID.Contains(enemy))
{
Pass = true;
Token.Color = Color.Wheat;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
if (Dot.Board[Token.X + 2][Token.Y + 1].ID.Contains(enemy)) Dot.Board[Token.X + 2][Token.Y + 1].Color = Color.Red;
else Dot.Board[Token.X + 2][Token.Y + 1].Color = Color.SpringGreen;
}
return Pass;
}
// Metodo BuscarMovimientos
// Busca movimientos en bbdd dada
private bool BuscarMovimientos()
{
// Obtener elo minimo y maximo
int eloMin, eloMax;
eloMin = 0;
eloMax = 10000;
switch (NSCmbElo.SelectedIndex)
{
// 1000-1399: Principiante
case 1:
eloMin = 1000;
eloMax = 1399;
break;
// 1400-1599: Aficionado
case 2:
eloMin = 1400;
eloMax = 1599;
break;
// 1600-1799: Club Medio
case 3:
eloMin = 1600;
eloMax = 1799;
break;
// 1800-1999: Club Fuerte
case 4:
eloMin = 1800;
eloMax = 1999;
break;
// 2000-2199: Exp. Nacional
case 5:
eloMin = 2000;
eloMax = 2199;
break;
// 2200-2299: Ca. Maestro
case 6:
eloMin = 2200;
eloMax = 2299;
break;
// 2300-2399: Maestro Fide
case 7:
eloMin = 2300;
eloMax = 2399;
break;
// 2400-2499: Maestro Inter
case 8:
eloMin = 2400;
eloMax = 2499;
break;
// 2500-2599: Gran Maestro
case 9:
eloMin = 2500;
eloMax = 2599;
break;
// 2600-2699: Sup. Maestro
case 10:
eloMin = 2600;
eloMax = 2699;
break;
// 2700-2799: Ca. Campeón
case 11:
eloMin = 2700;
eloMax = 2799;
break;
// 2800+: Campeón Mundo
case 12:
eloMin = 2800;
eloMax = 10000;
break;
}
NSLvItems.RemoveItems(NSLvItems.Items);
// Mostrar movimientos
ArrayList movimientos = Program.bbdd.ConsultaObtenerMovimientos(NSCmbBBDD.Text, NSTxbFechaIni.Text.Replace('/', '-'),
NSTxbFechaFin.Text.Replace('/', '-'), NSCmbJugador.Text, eloMin + "", eloMax + "");
if (movimientos != null)
{
for (int i = 0; i < movimientos.Count; i += 8)
{
string[] movS = movimientos[i + 7].ToString().Split(',');
string mov = Chess.NotacionAlgebraicaL(Convert.ToInt32(movS[0]), Convert.ToInt32(movS[1]), Convert.ToInt32(movS[2]),
Convert.ToInt32(movS[3]), Convert.ToInt32(movS[4]), Convert.ToInt32(movS[5]),
Convert.ToInt32(movS[6]), Convert.ToInt32(movS[7]), 0, 0);
NSLvItems.AddItem(movimientos[i + 3].ToString().Split(' ')[0], movimientos[i + 4].ToString(), movimientos[i + 5].ToString(), mov, movimientos[i + 7].ToString(), movimientos[i].ToString(), movimientos[i + 1].ToString(), movimientos[i + 6].ToString());
}
return(true);
}
return(false);
}
private void read( )
{
//侦听本地的端口号
udpclient = new UdpClient(Convert.ToInt32(txt_localport.Text));
remote = null;
//设定编码类型
Encoding enc = Encoding.Unicode;
int x, y;
while (ReadFlag == true)
{
Byte[] data = udpclient.Receive(ref remote);
//得到对方发送来的信息
String strData = enc.GetString(data);
string[] a = new string[5];
a = strData.Split('|');
switch (a[0])
{
case "join":
//获取传送信息到本地端口号的远程计算机IP地址
string remoteIP = remote.Address.ToString();
//显示接收信息以及传送信息的计算机IP地址
SetStatus(remoteIP + "已经加入你是黑方请先走棋");
mplayer = Chess.Black;
can_go = true; //能走棋
btnStart.Enabled = false;
break;
case "move":
x = Convert.ToInt16(a[1]);
y = Convert.ToInt16(a[2]);
SetStatus("对方下棋子位置：" + x.ToString() + "," + y.ToString());
//画对方棋子
Graphics g = this.pictureBox1.CreateGraphics();
if (Box[x, y] != Chess.none)
return;
if (mplayer == Chess.Black)
{
Image im = Image.FromFile(@"..\..\Resources\White.gif");
g.DrawImage(im, x * rectPix , y * rectPix , rectPix, rectPix);
//imageList1.Draw(g, x * rectPix + rectPix / 2, y * rectPix + rectPix / 2, (int)Chess.White);
Box[x, y] = Chess.White;
}
else
{
Image im = Image.FromFile(@"..\..\Resources\Black.gif");
g.DrawImage(im, x * rectPix , y * rectPix , rectPix, rectPix);
//imageList1.Draw(g, x * rectPix + rectPix / 2, y * rectPix + rectPix / 2, (int)Chess.Black);
Box[x, y] = Chess.Black;
}
//Box[p.X,p.Y]=mplayer;
can_go = true;
break;
case "over":
SetStatus(a[1] + "赢了此局");
MessageBox.Show("你赢了此局","恭喜！");
if (a[1] == "Black")
winner = Chess.Black;
else
winner = Chess.White;
can_go = false;
button2.Enabled = true;
break;
case "reset":
Reset_flag = true;
if (button2.Enabled == false) { reset(); Reset_flag = false; }
break;
}
}
}
public override void Attack(Chess target)
{
base.Attack(target);
ReleaseSkill(target);
}
private static Chess[,] parseBoard(string board)
{
if (board.Length != Engine.MAXSTEP) {
return null;
}
Chess[,] result = new Chess[Global.Width, Global.Height];
for (int i = 0; i < Global.Height; i++) {
for (int j = 0; j < Global.Width; j++) {
result[j, i] = parseChess(board[i * Global.Width + j]);
}
}
return result;
}
public Rook(Chess chess, Team team) : base(chess, team)
{
}
public bool Check_Index(int ind, ref Chess[] chessboard)
{
bool t = (ind >= 0) && (ind < chessboard.Length);
if (t)
return chessboard[ind].value < threshold;
else
return t;
}
private bool CheckChessLine(Chess chess, Direction direction, List <Chess> temp_ChessGroup = null)
{
if (temp_ChessGroup == null)
{
temp_ChessGroup = new List <Chess>();
}
if (chess == null)
{
return(false);
}
temp_ChessGroup.Add(chess);
if (temp_ChessGroup.Count >= GameManager.Instance.GameWinChessNum)
{
return(true);
}
int[] pos = chess.Pos;
Chess nextChess = null;
switch (direction)
{
case Direction.Up:
if (pos[1] > 0)
{
nextChess = chessArr[pos[0], pos[1] - 1];
}
break;
case Direction.Down:
if (pos[1] < chessArr.GetLength(1) - 1)
{
nextChess = chessArr[pos[0], pos[1] + 1];
}
break;
case Direction.Left:
if (pos[0] > 0)
{
nextChess = chessArr[pos[0] - 1, pos[1]];
}
break;
case Direction.Right:
if (pos[0] < chessArr.GetLength(0) - 1)
{
nextChess = chessArr[pos[0] + 1, pos[1]];
}
break;
case Direction.LeftDown:
if (pos[0] > 0 && pos[1] < chessArr.GetLength(1) - 1)
{
nextChess = chessArr[pos[0] - 1, pos[1] + 1];
}
break;
case Direction.RightDown:
if (pos[0] < chessArr.GetLength(0) - 1 && pos[1] < chessArr.GetLength(1) - 1)
{
nextChess = chessArr[pos[0] + 1, pos[1] + 1];
}
break;
case Direction.LeftUp:
if (pos[0] > 0 && pos[1] > 0)
{
nextChess = chessArr[pos[0] - 1, pos[1] - 1];
}
break;
case Direction.RightUp:
if (pos[0] < chessArr.GetLength(0) - 1 && pos[1] > 0)
{
nextChess = chessArr[pos[0] + 1, pos[1] - 1];
}
break;
}
if (nextChess != null)
{
return(CheckChessLine(nextChess, direction, temp_ChessGroup));
}
return(false);
}
//开始走棋
virtual public void StartMoveChessPlayer(Chess c)
{
}
private void Start()
{
chessGame = GameManager.Instance.chessGame;
}
//Kallas på om en kung är utslagen
public void gameOver(string gamestatus)
{
MessageBox.Show(gamestatus);
Chess chess = new Chess(this);
updateTable();
}
// Use this for initialization
void Start()
{
instance = this;
ChessInit();
CameraPoint = GameObject.Find("CameraPoint");
}
private static void Knight(Chess Token, MouseState mouse)
{
//X buttom right
if (Token.X + 2 < 8 && Token.Y + 1 < 8 && Dot.Board[Token.X + 2][Token.Y + 1].ID == "" | Dot.Board[Token.X + 2][Token.Y + 1].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 2][Token.Y + 1].Size))
{
Token.Size = new Rectangle((Token.X + 2) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X += 2; Token.Y++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//Y bottom right
if (Token.X + 1 < 8 && Token.Y + 2 < 8 && Dot.Board[Token.X + 1][Token.Y + 2].ID == "" | Dot.Board[Token.X + 1][Token.Y + 2].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y + 2].Size))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y + 2) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y += 2; Token.X++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//X bottom left
if (Token.X - 2 > -1 && Token.Y + 1 < 8 && Dot.Board[Token.X - 2][Token.Y + 1].ID == "" | Dot.Board[Token.X - 2][Token.Y + 1].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 2][Token.Y + 1].Size))
{
Token.Size = new Rectangle((Token.X - 2) * Player.X + Player.W, (Token.Y + 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X -= 2; Token.Y++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//Y bottom left
if (Token.X - 1 > -1 && Token.Y + 2 < 8 && Dot.Board[Token.X - 1][Token.Y + 2].ID == "" | Dot.Board[Token.X - 1][Token.Y + 2].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y + 2].Size))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y + 2) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y += 2; Token.X--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//X top right
if (Token.X + 2 < 8 && Token.Y - 1 > -1 && Dot.Board[Token.X + 2][Token.Y - 1].ID == "" | Dot.Board[Token.X + 2][Token.Y - 1].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 2][Token.Y - 1].Size))
{
Token.Size = new Rectangle((Token.X + 2) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X += 2; Token.Y--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//Y top right
if (Token.X + 1 < 8 && Token.Y - 2 > -1 && Dot.Board[Token.X + 1][Token.Y - 2].ID == "" | Dot.Board[Token.X + 1][Token.Y - 2].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X + 1][Token.Y - 2].Size))
{
Token.Size = new Rectangle((Token.X + 1) * Player.X + Player.W, (Token.Y - 2) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y -= 2; Token.X++;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//Y top left
if (Token.X - 1 > -1 && Token.Y - 2 > -1 && Dot.Board[Token.X - 1][Token.Y - 2].ID == "" | Dot.Board[Token.X - 1][Token.Y - 2].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 1][Token.Y - 2].Size))
{
Token.Size = new Rectangle((Token.X - 1) * Player.X + Player.W, (Token.Y - 2) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.Y -= 2; Token.X--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
//X top left
if (Token.X - 2 > -1 && Token.Y - 1 > -1 && Dot.Board[Token.X - 2][Token.Y - 1].ID == "" | Dot.Board[Token.X - 2][Token.Y - 1].ID.Contains(enemy))
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X - 2][Token.Y - 1].Size))
{
Token.Size = new Rectangle((Token.X - 2) * Player.X + Player.W, (Token.Y - 1) * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Token.X -= 2; Token.Y--;
if (Dot.Board[Token.X][Token.Y].ID.Contains(enemy))
{
Dot.Board[Token.X][Token.Y].Token.Visible = false; Player.Earn += score(Dot.Board[Token.X][Token.Y].ID);
Stage.EarnedToken(Dot.Board[Token.X][Token.Y].Token.Texture, Dot.Board[Token.X][Token.Y].ID.Contains("2") ? 0 : 1);
}
process(Token.X, Token.Y, Token);
}
}
}
}
public bool IsOpposite(Chess c)
{
return((int)group * (int)c.group < 0);
}
private static void process(int x, int y, Chess Token)
{
if (Token.ID.Contains("Rook") || Token.ID.Contains("King")) Token.castle = false;
Dot.Board[x][y].ID = Token.ID;
Dot.Board[x][y].Token = Token;
Dot.point.Texture = Dot.pointcollect[0].Texture;
move = false; Turn = !Turn; pal = true;
Clear(Color);
}
//simply reset the rotation for the chess
public static void resetChess(Chess chess)
{
chess.onBoard = true;
chess.transform.eulerAngles = new Vector3(-270, 0, 180);
}
private static void Crux(Chess Token, MouseState mouse)
{
//seeking up
eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Dot.Board[Token.X][a].ID == ""; a--)
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X, Token.Y = a, Token);
return;
}
eat = a - 1;
}
// eating up
if (eat > -1 && Dot.Board[Token.X][eat].ID.Contains(enemy) && Dot.point.Size.Intersects(Dot.Board[Token.X][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, eat * Player.Y, Player.width, Player.height); ;
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
{
Dot.Board[Token.X][eat].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][eat].Token.Texture, Dot.Board[Token.X][eat].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][eat].ID);
process(Token.X, Token.Y = eat, Token);
}
return;
}
//seeking down
eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Dot.Board[Token.X][a].ID == ""; a++)
{
if (Dot.point.Size.Intersects(Dot.Board[Token.X][a].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, a * Player.Y, Player.width, Player.height);
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X, Token.Y = a, Token);
return;
}
eat = a + 1;
}
// eating down
if (eat < 8 && Dot.Board[Token.X][eat].ID.Contains(enemy) && Dot.point.Size.Intersects(Dot.Board[Token.X][eat].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(Token.X * Player.X + Player.W, eat * Player.Y, Player.width, Player.height); ;
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
{
Dot.Board[Token.X][eat].Token.Visible = false;
Stage.EarnedToken(Dot.Board[Token.X][eat].Token.Texture, Dot.Board[Token.X][eat].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[Token.X][eat].ID);
process(Token.X, Token.Y = eat, Token);
}
return;
}
//seeking right
eat = Token.X + 1;
for (int a = Token.X + 1; a < 8 && Dot.Board[a][Token.Y].ID == ""; a++)
{
if (Dot.point.Size.Intersects(Dot.Board[a][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(a * Player.X + Player.W, Player.Y * Token.Y, Player.width, Player.height);
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = a, Token.Y, Token);
return;
}
eat = a + 1;
}
// eating right
if (eat < 8 && Dot.Board[eat][Token.Y].ID.Contains(enemy) && Dot.point.Size.Intersects(Dot.Board[eat][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(eat * Player.X + Player.W, Token.Y * Player.Y, Player.width, Player.height);
if (mouse.LeftButton == ButtonState.Pressed)
{
Dot.Board[eat][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[eat][Token.Y].Token.Texture, Dot.Board[eat][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[eat][Token.Y].ID);
process(Token.X = eat, Token.Y, Token);
}
return;
}
//seeking left
eat = Token.X - 1;
for (int a = Token.X - 1; a > -1 && Dot.Board[a][Token.Y].ID == ""; a--)
{
if (Dot.point.Size.Intersects(Dot.Board[a][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(a * Player.X + Player.W, Player.Y * Token.Y, Player.width, Player.height);
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
process(Token.X = a, Token.Y, Token);
return;
}
eat = a - 1;
}
// eating left
if (eat > -1 && Dot.Board[eat][Token.Y].ID.Contains(enemy) && Dot.point.Size.Intersects(Dot.Board[eat][Token.Y].Size) && !Dot.point.Size.Intersects(Dot.Board[Token.X][Token.Y].Size))
{
Token.Size = new Rectangle(eat * Player.X + Player.W, Token.Y * Player.Y, Player.width, Player.height);
intersect = true;
if (mouse.LeftButton == ButtonState.Pressed)
{
Dot.Board[eat][Token.Y].Token.Visible = false;
Stage.EarnedToken(Dot.Board[eat][Token.Y].Token.Texture, Dot.Board[eat][Token.Y].ID.Contains("2") ? 0 : 1);
Player.Earn += score(Dot.Board[eat][Token.Y].ID);
process(Token.X = eat, Token.Y, Token);
}
return;
}
}
private void BeginGame()
{
chessInstance = Instantiate(chessPrefab) as Chess;
chessInstance.GenerateTiles();
chessInstance.GeneratePieces();
}
private static bool DrawCellsinCrux(Chess Token)
{
bool Pass = false;
//seeking up
eat = Token.Y - 1;
for (int a = Token.Y - 1; a > -1 && Dot.Board[Token.X][a].ID == ""; a--)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Token.X][a].Color = Color.SpringGreen;
eat = a - 1;
}
//if it'll eat
if (eat > -1 && Dot.Board[Token.X][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[Token.X][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking down
eat = Token.Y + 1;
for (int a = Token.Y + 1; a < 8 && Dot.Board[Token.X][a].ID == ""; a++)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Token.X][a].Color = Color.SpringGreen;
eat = a + 1;
}
//if it'll eat
if (eat < 8 && Dot.Board[Token.X][eat].ID.Contains(enemy)) { Pass = true; Dot.Board[Token.X][eat].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking left
eat = Token.X - 1;
for (int a = Token.X - 1; a > -1 && Dot.Board[a][Token.Y].ID == ""; a--)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[a][Token.Y].Color = Color.SpringGreen;
eat = a - 1;
}
//if it'll eat
if (eat > -1 && Dot.Board[eat][Token.Y].ID.Contains(enemy)) { Pass = true; Dot.Board[eat][Token.Y].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
//seeking right
eat = Token.X + 1;
for (int a = Token.X + 1; a < 8 && Dot.Board[a][Token.Y].ID == ""; a++)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[a][Token.Y].Color = Color.SpringGreen;
eat = a + 1;
}
//if it'll eat
if (eat < 8 && Dot.Board[eat][Token.Y].ID.Contains(enemy)) { Pass = true; Dot.Board[eat][Token.Y].Color = Color.Red; Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue; }
return Pass;
}
/// <summary>
/// 初始化所有委托
/// </summary>
public void InitHandle()
{
//如果两项委托为空
if (GeneticAlgorithm.fitnessCalculator == null || Genome.genomeCreater == null)
{
//适应度度量函数
GeneticAlgorithm.fitnessCalculator = delegate(Genome gene)
{
//打开人工智能探路标记
Conf.AIRouterState = true;
//当前串中最大的威力
double maxPower = double.MinValue;
//当前串中最小的威力
double minPower = double.MaxValue;
//当前串中最大的威力棋子的位置
int maxPowerIndex = 0;
//当前串中最小的威力棋子的位置
int minPowerIndex = 0;
//设定当前添加的棋子类型
ChessType currentType = AIType;
for (int i = 0; i < gene.Genes.Length; i++)
{
//模拟更新棋盘中的棋子类型
Chess.UpdateChessTypeForAI(gene.Genes[i], currentType);
//计算单子威力*位权
double tempPower = SinglePower(gene.Genes[i], currentType) * 1 * Math.Pow(0.96, i);
if (tempPower > maxPower)
{
maxPowerIndex = i;
maxPower = tempPower;
}
if (tempPower < minPower)
{
minPowerIndex = i;
minPower = tempPower;
}
//当前的最大威力值>权值*100 退出循环
if (maxPower > (100 * Math.Pow(0.96, i)))
{
break;
}
//转换下棋方,currentTpye变换
if (currentType == ChessType.BLACK)
{
currentType = ChessType.WHITE;
}
else
{
currentType = ChessType.BLACK;
}
}
//赋值适应度
if (Math.Abs(minPower) > Math.Abs(maxPower))
{
gene.BestGenIndex = minPowerIndex;
gene.Fitness = minPower;
}
else
{
gene.Fitness = maxPower;
gene.BestGenIndex = maxPowerIndex;
}
//恢复对棋盘的改变
for (int i = 0; i < gene.Genes.Length; i++)
{
Chess.UpdateChessTypeForAI(gene.Genes[i], ChessType.NULL);
}
//关闭人工智能探路标记
Conf.AIRouterState = false;
};
//创建随机基因组的函数
Genome.genomeCreater = createGensHandle;
}
}
private static bool DrawKingCells(Chess Token)
{
bool Pass = false;
//right
for (int i = Token.X + 1; i <= (Castling(Token.Y, 1) ? Token.X + 2 : Token.X + 1); i++)
if (i < 8 && Dot.Board[i][Token.Y].ID == "" | Dot.Board[i][Token.Y].ID.Contains(enemy) && checKing(i, Token.Y, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[i][Token.Y].ID.Contains(enemy)) Dot.Board[i][Token.Y].Color = Color.Red;
else Dot.Board[i][Token.Y].Color = Color.SpringGreen;
}
//left
for (int i = Token.X - 1; i >= (Castling(Token.Y, 0) ? Token.X - 2 : Token.X - 1); i--)
if (i > -1 && Dot.Board[i][Token.Y].ID == "" | Dot.Board[i][Token.Y].ID.Contains(enemy) && checKing(i, Token.Y, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[i][Token.Y].ID.Contains(enemy)) Dot.Board[i][Token.Y].Color = Color.Red;
else Dot.Board[i][Token.Y].Color = Color.SpringGreen;
}
//down
if (Token.Y + 1 < 8 && Dot.Board[Token.X][Token.Y + 1].ID == "" | Dot.Board[Token.X][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X, Token.Y + 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X][Token.Y + 1].ID.Contains(enemy)) Dot.Board[Token.X][Token.Y + 1].Color = Color.Red;
else Dot.Board[Token.X][Token.Y + 1].Color = Color.SpringGreen;
}
//up
if (Token.Y - 1 > -1 && Dot.Board[Token.X][Token.Y - 1].ID == "" | Dot.Board[Token.X][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X, Token.Y - 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X][Token.Y - 1].ID.Contains(enemy)) Dot.Board[Token.X][Token.Y - 1].Color = Color.Red;
else Dot.Board[Token.X][Token.Y - 1].Color = Color.SpringGreen;
}
//diagonal bottom left
if (Token.X - 1 > -1 && Token.Y + 1 < 8 && Dot.Board[Token.X - 1][Token.Y + 1].ID == "" | Dot.Board[Token.X - 1][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X - 1, Token.Y + 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X - 1][Token.Y + 1].ID.Contains(enemy)) Dot.Board[Token.X - 1][Token.Y + 1].Color = Color.Red;
else Dot.Board[Token.X - 1][Token.Y + 1].Color = Color.SpringGreen;
}
//diagonal top right
if (Token.X + 1 < 8 && Token.Y - 1 > -1 && Dot.Board[Token.X + 1][Token.Y - 1].ID == "" | Dot.Board[Token.X + 1][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X + 1, Token.Y - 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X + 1][Token.Y - 1].ID.Contains(enemy)) Dot.Board[Token.X + 1][Token.Y - 1].Color = Color.Red;
else Dot.Board[Token.X + 1][Token.Y - 1].Color = Color.SpringGreen;
}
//diagonal bottom right
if (Token.X + 1 < 8 && Token.Y + 1 < 8 && Dot.Board[Token.X + 1][Token.Y + 1].ID == "" | Dot.Board[Token.X + 1][Token.Y + 1].ID.Contains(enemy) && checKing(Token.X + 1, Token.Y + 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X + 1][Token.Y + 1].ID.Contains(enemy)) Dot.Board[Token.X + 1][Token.Y + 1].Color = Color.Red;
else Dot.Board[Token.X + 1][Token.Y + 1].Color = Color.SpringGreen;
}
//diagonal top left
if (Token.X - 1 > -1 && Token.Y - 1 > -1 && Dot.Board[Token.X - 1][Token.Y - 1].ID == "" | Dot.Board[Token.X - 1][Token.Y - 1].ID.Contains(enemy) && checKing(Token.X - 1, Token.Y - 1, 7))
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
if (Dot.Board[Token.X - 1][Token.Y - 1].ID.Contains(enemy)) Dot.Board[Token.X - 1][Token.Y - 1].Color = Color.Red;
else Dot.Board[Token.X - 1][Token.Y - 1].Color = Color.SpringGreen;
}
return Pass;
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
if (hit.transform.tag == "ChessPiece")
{
if (currentSelection)
{
lastSel = currentSelection;
}
currentSelection = hit.transform.gameObject.GetComponent <Chess>();
if (!lastSel)
{
lastSel = currentSelection;
}
if (currentSelection != lastSel)
{
foreach (GameObject obj in GameObject.FindGameObjectsWithTag("floor"))
{
if (obj.GetComponent <Renderer>().material != obj.GetComponent <highlightMaterial>().m_default)
{
obj.GetComponent <Renderer>().material = obj.GetComponent <highlightMaterial>().m_default;
}
}
}
hit.transform.gameObject.GetComponent <Chess>().showMove();
Debug.Log(string.Format("current: {0} / last: {1}", currentSelection.GetType(), lastSel.GetType()));
}
if (hit.transform.tag == "floor")
{
if (currentSelection)
{
if (hit.transform.gameObject.GetComponent <Renderer>().material != hit.transform.gameObject.GetComponent <highlightMaterial>().m_default)
{
currentSelection.pos = hit.transform.position;
currentSelection.pos.y = currentSelection.transform.position.y;
currentSelection.moving = true;
if (lastMove)
{
lastMove = currentMove;
}
currentMove = currentSelection;
if (!lastMove)
{
lastMove = currentMove;
}
foreach (GameObject obj in GameObject.FindGameObjectsWithTag("floor"))
{
if (obj.GetComponent <Renderer>().material != obj.GetComponent <highlightMaterial>().m_default)
{
obj.GetComponent <Renderer>().material = obj.GetComponent <highlightMaterial>().m_default;
}
}
}
}
}
}
}
}
private static bool DrawUpPawnCells(Chess Token)
{
bool Pass = false;
if (Token.X - 1 > -1 && Token.Y - 1 > -1 && Dot.Board[Token.X - 1][Token.Y - 1].ID.Contains(enemy))
{
Pass = true; Dot.Board[Token.X - 1][Token.Y - 1].Color = Color.Red;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
}
if (Token.X + 1 < 8 && Token.Y - 1 > -1 && Dot.Board[Token.X + 1][Token.Y - 1].ID.Contains(enemy))
{
Pass = true; Dot.Board[Token.X + 1][Token.Y - 1].Color = Color.Red;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
}
for (int a = Token.Y - 1; a > -1 && a >= Token.Y - (Token.initial ? 2 : 1) && Dot.Board[Token.X][a].ID == ""; a--)
{
Pass = true;
Dot.Board[Token.X][Token.Y].Color = Color.SkyBlue;
Token.Color = Color.Wheat;
Dot.Board[Token.X][a].Color = Color.SpringGreen;
}
return Pass;
}
private static void processBoard(string[] boardParts, TextWriter output, NodeCounter counter)
{
// check params first
if (boardParts.Length < 2)
{
output.Write("Error: not enough arguments supplied.\t");
return;
}
Chess[,] board = parseBoard(boardParts[0]);
if (board == null)
{
output.Write("Error: board not recognized.\t");
return;
}
Chess mover = parseMover(boardParts[1]);
if (mover == Chess.AVAILABLE)
{
output.Write("Error: mover not recognized.\t");
return;
}
bool wld = false, warmup = false;
int mid = 0;
for (int i = 2; i < boardParts.Length; i++)
{
string option = boardParts[i].ToUpper();
if (option == "WLD")
{
wld = true;
}
else if (option == "WARMUP")
{
warmup = true;
}
else if (option.StartsWith("MID"))
{
Int32.TryParse(option.Substring(3), out mid);
if (mid < 0)
{
mid = 0;
}
}
}
Engine.clearCache();
Engine engine = new Engine();
engine.setBoard(board);
DateTime timeStart = DateTime.Now;
SearchResult res = (mid == 0) ? engine.solveExact(mover, wld) : engine.solve(mover, mid, false);
TimeSpan timeSpan = DateTime.Now - timeStart;
SearchStats stats = engine.getSearchStats();
engine.Dispose();
output.Write(resultString(res, wld, mid));
output.Write("\t");
output.Write(moveString(res));
output.Write("\t");
output.Write(nodesString(stats.EvaluationCount));
output.Write("\t");
output.Write(npsString(timeSpan, stats.EvaluationCount));
output.Write("\t");
output.Write(timeSpan.TotalSeconds.ToString("0.0") + " s");
output.Write("\t");
if (!warmup)
{
counter.totalNodes += stats.EvaluationCount;
counter.totalTime += timeSpan;
}
}
private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
{
if (can_go != true)
{
MessageBox.Show("不能走棋，请等对方");
return;
}
//e.X为pictureBox1内的
Graphics g = this.pictureBox1.CreateGraphics();
int x = e.X / rectPix;
int y = e.Y / rectPix;
if (x < 0 || y < 0 || x >= 16 || y >= 16)
{
MessageBox.Show("超边界了");
return;
}
Point p = new Point(x * rectPix + rectPix / 2, y * rectPix + rectPix / 2);
//label1.Text = p.X.ToString() + "|" + p.Y.ToString() + "|" + e.X.ToString() + " " + e.Y.ToString();
string s1 = p.X.ToString() + "|" + p.Y.ToString();
if (Box[x, y] != Chess.none)
return;
//label2.Text = p2.X.ToString() + "|" + p2.Y.ToString();
Image im = Image.FromFile(@"..\..\Resources\" + mplayer.ToString() + ".gif");
g.DrawImage(im, x * rectPix , y * rectPix , rectPix, rectPix);
//imageList1.Draw(g, x * rectPix + rectPix / 2,y * rectPix + rectPix / 2, (int)mplayer);
Box[x, y] = mplayer;
//label2.Text = Box[x, y].ToString();
string str_send = "move|" + x + "|" + y;
can_go = false;
send(str_send);
if (win_lose() == true)//判断输赢否
{
str_send = "over|" + mplayer.ToString();
winner = mplayer;
SetStatus(mplayer.ToString() + "赢了此局！");
button2.Enabled = true;
send(str_send);
}
}
void Start()
{
chess = GameObject.FindObjectOfType <Chess> ();
insideMenu = false;
insideButton = false;
}
private void reset()
{
if (mplayer == Chess.Black)
{
if (Reset_flag == true)// 对方已经重新开始
{
SetStatus("你是白方,处于重新开始状态！");
mplayer = Chess.White;
can_go = false;
}
else
SetStatus("你是白方,处于等待对方重新开始状态！");
}
else
{
if (Reset_flag == true)//对方已经重新开始
{
SetStatus("你是黑方，请先走棋");
mplayer = Chess.Black;
can_go = true;
}
else
SetStatus("你是黑方,处于等待对方重新开始状态！");
}
}
public Rules()
{
dad = new DragandDrop();
chess = new Chess();
}
void Awake()
{
Instance = this;
}
public static void Run()
{
var chess = new Chess();
chess.Run();
}
private Chess[,] getBoard(ulong black, ulong white)
{
Chess[,] board = new Chess[8, 8];
ulong mask = 1;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
board[i, j] = ((black & mask) != 0 ? Chess.BLACK :
((white & mask) != 0 ? Chess.WHITE : Chess.AVAILABLE));
mask <<= 1;
}
}
return board;
}
public void BeginBoard()
{
Chess.BOARD = Chess.BoardLoad(Chess.BeginPosition);
Chess.Board();
}
static void Main()
{
Chess game = new Chess();
game.Start();
}
void IPointInterface.setChess(Chess chess)
{
this.currentChess = chess;
setSprite(ChessSpriteFactory.getInstance().getChessSprite(chess));
}
public Chess[] ChessBoard(Vector3[] vertices, OpenTK.Vector4 dimensions)
{
int Chess_per_line = (int)((dimensions.Z / dimensions.X));
int Chess_total = (int)(Chess_per_line * (dimensions.W / dimensions.Y));
Chess[] Return = new Chess[Chess_total];
float lwidth = 0, rwidth = dimensions.X, dheight = 0, uheight = dimensions.Y;
double tot = 0, media = 0, quadmedia = 0, minus = variance_max;
for (int x = 0; x < Chess_total; x++)
{
tot = 0; media = 0; quadmedia = 0;
Return[x].value = 0;
Return[x].index = x;
Return[x].Position.X = lwidth;
Return[x].Position.Y = rwidth;
Return[x].Position.Z = dheight;
Return[x].Position.W = uheight;
for (int j = 0; j < vertices.Length; j++)
{
if ((vertices[j].X >= lwidth) &&
(vertices[j].X <= rwidth) &&
(vertices[j].Z >= dheight) &&
(vertices[j].Z <= uheight))
{
media += vertices[j].Y;
quadmedia += Math.Pow(vertices[j].Y, 2);
tot++;
}
}
if (tot != 0)
{
media /= tot; quadmedia /= tot;
Return[x].media = media;
//Console.WriteLine("m: " + media + "q: " + quadmedia + "tot " + tot);
#warning arrotondamento per evitare oscillazioni
Return[x].value = Math.Round( Math.Sqrt((quadmedia - Math.Pow(media, 2))) );
///ulteriore condizione per evitare oscillazioni
///
if (Return[x].value < 10)
Return[x].value = 1;
System.Diagnostics.Debug.WriteLine(Return[x].value);
if (Return[x].value > founded_var_max)
founded_var_max = Return[x].value;
}
else
{
Return[x].media = 10000;
Return[x].value = (float)variance_max;
}
if (Return[x].value < minus)
minus = Return[x].value;
// aggiorno la posizione
lwidth += dimensions.X;
rwidth += dimensions.X;
if (((x + 1) % Chess_per_line) == 0 && (x != 0))
{
uheight += dimensions.Y;
dheight += dimensions.Y;
lwidth = 0;
rwidth = dimensions.X;
}
}
Console.WriteLine("Minus: " + minus);
Console.WriteLine("Max: " + founded_var_max);
return Return;
}
public override System.Threading.Tasks.Task<System.Web.Mvc.ActionResult> ManageLogins(Chess.Web.Controllers.ManageController.ManageMessageId? message)
{
var callInfo = new T4MVC_System_Web_Mvc_ActionResult(Area, Name, ActionNames.ManageLogins);
ModelUnbinderHelpers.AddRouteValues(callInfo.RouteValueDictionary, "message", message);
ManageLoginsOverride(callInfo, message);
return System.Threading.Tasks.Task.FromResult(callInfo as ActionResult);
}
public void Revers()
{
Chess.REVERS = !Chess.REVERS;
Chess.Board();
}
//下棋
virtual public Chess setChess(int card_id, ePlayer card_belong, ChessContainer t_grid, BKKZ.POW01.AI.eAI_Type ai_type, bool trigger_shokan_skill, int shoukan_event, int event_sequence)
{
//TODO 后期加入召唤参数，如果是强制召唤才能把当前格子上的骑士顶开
if (t_grid.my_chess != null)
{
t_grid.my_chess.KickAway();
}
//分支 pve玩家召唤时有可能是第二次召唤
bool need_new = true;
long chessid = 0;
if (Main.Inst.lv_ctrl.map_data.my_type == eMapType.PvE_Mult || Main.Inst.lv_ctrl.map_data.my_type == eMapType.PvE_Solo)
{
chessid = Chess.genarateChessID(card_id, (int)card_belong, shoukan_event, event_sequence);
need_new = !Main.Inst.dic_chess.ContainsKey(chessid);
}
Chess the_chess = null;
if (need_new)
{
//创建棋子
the_chess = Instantiate(BKTools.LoadAsset <GameObject>(eResBundle.Prefabs, PrefabPath.Chess)).GetComponent <Chess>();
the_chess.attribute.card_id = card_id;
the_chess.belong = card_belong;
the_chess.owner = card_belong;
the_chess.MouseDown = Main.Inst.MouseDownOnChess;
the_chess.MouseUp = Main.Inst.MouseUpOnChess;
//召唤信息——对应事件——玩家为-1
the_chess.shoukan_event = shoukan_event;
//事件ID确认后可以获得事件序号
the_chess.shoukan_event_sequence = event_sequence;
//初始化数据
the_chess.initData();
//初始化图片
the_chess.initImage();
Main.Inst.dic_chess.Add(the_chess.ChessID, the_chess);
//创建AI
if (card_belong < ePlayer.Player1 || card_belong > ePlayer.Player4)
{
BKKZ.POW01.AI.MonsterAI.createMonsterAI(the_chess.ChessID, ai_type);
}
}
else
{
the_chess = Main.Inst.dic_chess[chessid];
the_chess.gameObject.SetActive(true);
}
t_grid.appendChess(the_chess);
//召唤技能
if (trigger_shokan_skill)
{
the_chess.ShouKanSkillAndPincer();
}
//驱散迷雾
//BKTools.FogLift(newchess.container.number, newchess.attribute.spd + GameRule.Default_PvE_Fog_Lift_Range, GameRule.Default_PvE_Fog_Lift_Range, new int[] { (int)newchess.belong });
// Main.Instance.b_setchess = true;
// Main.Instance.now_phase = ePhase.Battle;
// Main.Instance.b_phase_trigger = true;//从战斗阶段往主要阶段2
// 只有主流会耗卡
if (Main.Inst.now_turnphase.myType == ePhaseType.Main1)
{
UseHandCard();
}
if (Main.Inst.now_turnphase.myType != ePhaseType.Drama)
{
CheckMoveEvent(the_chess, nextPhaseDefault);
}
return(the_chess);
}
