+/****************************************************************************
+ CHESS Game
+
+ Copyright (c) 2001 Jerome Jacovella-St-Louis
+ All Rights Reserved.
+
+ chess.ec - Chess Main Window
+****************************************************************************/
+#ifdef ECERE_STATIC
+import static "ecere"
+#else
+import "ecere"
+#endif
+import "chess2D.ec"
+import "chess3D.ec"
+import "promotion.ec"
+import "connect.ec"
+import "about.ec"
+import "ai.ec"
+import "chessutils.ec"
+
+// --- Definitions ---
+define APPNAME = "ECERE Chess v0.4";
+define CHESS_PORT = 7778;
+define SERVER_COLOR = Black;
+define CLIENT_COLOR = White;
+
+// Network Messages
+enum ChessMessage : byte { NewGame = 1, Position = 2 };
+
+struct ChessPacket
+{
+ ChessMessage type;
+ Player player;
+ byte x1,y1,x2,y2;
+ PieceType promotion;
+};
+
+ChessApp app;
+
+class ChessApp : GuiApplication
+{
+ appName = APPNAME;
+#if defined(__WIN32__)
+ driver = "Direct3D";
+#else
+ driver = "OpenGL";
+#endif
+ Chess{};
+
+ void Main()
+ {
+ app = this;
+ GuiApplication::Main();
+ }
+}
+
+class Chess : Window
+{
+ background = gray, hasMenuBar = true, hasStatusBar = true,
+ text = APPNAME, hasClose = true, hasMaximize = true, hasMinimize = true,
+ borderStyle = sizable, hasClose = true,
+ anchor = Anchor { left = 0, top = 0, right = 0, bottom = 0 };
+
+ bool hosting, local, ai;
+ Socket sockets[Player];
+
+ ChessService service { port = CHESS_PORT, chess = this };
+
+ MenuItem * driverItems;
+
+ ChessState chessState;
+
+ StatusField stateField { statusBar, width = 200 };
+ StatusField turnField { statusBar, width = 100 };
+
+ property ChessState * chessState { get { return &chessState; } }
+
+ // AI Player Threading
+ AIThread aiThread { chess = this };
+
+ // Windows
+
+ ListBox moveList
+ {
+ parent = this,
+ isActiveClient = true,
+ text = "MoveList",
+ autoScroll = true,
+ hasMinimize = true,
+ borderStyle = sizable,
+ hasVertScroll = true,
+ hasHorzScroll = true,
+ position = Point { x = 445 },
+ size = Size { 200, 450 }
+ };
+
+ Chess2D chess2D
+ {
+ parent = this,
+ text = "2D Chess Board",
+ chessState = &chessState
+ };
+
+ Chess3D chess3D
+ {
+ parent = this,
+ text = "3D Chess Board",
+ anchor = Anchor { left = 0.5, top = 0.5, right = 0, bottom = 0 },
+ chessState = &chessState,
+ state = maximized
+ };
+
+ // Main Menu
+ menu = Menu {};
+
+ Menu gameMenu { menu, "Game", g };
+ Menu networkMenu { menu, "Network", n };
+ Menu viewMenu { menu, "View", v };
+ Menu windowMenu { menu, "Window", w };
+ MenuDivider { menu };
+ Menu helpMenu { menu, "Help", h };
+
+ // Game Menu
+ MenuItem aiItem
+ {
+ gameMenu, "New AI Game\tCtrl+N", n, ctrlN;
+
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ if(EndGame())
+ {
+ ai = true;
+ chessState.gameRunning = true;
+
+ chessState.isLocalPlayer[White] = true;
+ chessState.isLocalPlayer[Black] = false;
+
+ EnableMenus();
+
+ RandomSeed((int)(GetTime() * 10000));
+
+ NewGame();
+ }
+ return true;
+ }
+ };
+
+ MenuItem localItem
+ {
+ gameMenu, "New Local Game\tCtrl+L", l, ctrlL;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ if(EndGame())
+ {
+ local = true;
+ chessState.gameRunning = true;
+ chessState.isLocalPlayer[White] = true;
+ chessState.isLocalPlayer[Black] = true;
+ EnableMenus();
+ NewGame();
+ }
+ return true;
+ }
+ };
+
+ MenuItem endGameItem
+ {
+ gameMenu, "End Game", e;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ EndGame();
+ return true;
+ }
+ };
+
+ MenuItem { gameMenu, "Exit\tAlt+F4", x, NotifySelect = MenuFileExit };
+
+ // Network Menu
+ MenuItem connectItem
+ {
+ networkMenu, "Connect...", c;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ if(EndGame())
+ {
+ hosting = false;
+ service.Stop();
+ ConnectDialog { master = this }.Modal();
+ }
+ return true;
+ }
+ };
+
+ MenuItem disconnectItem
+ {
+ networkMenu, "Disconnect", d, NotifySelect = endGameItem.NotifySelect
+ };
+
+ MenuItem hostItem
+ {
+ networkMenu, "Host", h;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ if(EndGame())
+ {
+ if(service.Start())
+ {
+ hosting = true;
+ EnableMenus();
+ }
+ }
+ return true;
+ }
+ };
+
+ MenuItem stopItem
+ {
+ networkMenu, "Stop Hosting", s;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ if(EndGame())
+ {
+ hosting = false;
+ service.Stop();
+ EnableMenus();
+ }
+ return true;
+ }
+ };
+
+ // View Menu
+ MenuItem fullScreenItem
+ {
+ //viewMenu, "Full Screen", f, checkable = true;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ app.fullScreen ^= true;
+ SetDriver();
+ anchor = Anchor { left = 0, top = 0, right = 0, bottom = 0 };
+ return true;
+ }
+ };
+
+ bool SetDisplayDriver(MenuItem selection, Modifiers mods)
+ {
+ //app.driver = app.drivers[selection.id];
+ SetDriver();
+ return true;
+ }
+
+ // Window Menu
+ MenuItem { windowMenu, "Next\tF6", n, NotifySelect = MenuWindowNext };
+ MenuItem { windowMenu, "Previous\tShift-F6", p, NotifySelect = MenuWindowPrevious };
+ MenuDivider { windowMenu };
+ MenuItem { windowMenu, "Windows...", w, NotifySelect = MenuWindowWindows };
+
+ // Help Menu
+ MenuItem aboutItem
+ {
+ helpMenu, "About...\tF1", a, f1;
+ bool NotifySelect(MenuItem selection, Modifiers mods)
+ {
+ AboutChess { master = this }.Modal();
+ return true;
+ }
+ };
+
+ // --- Chess Utilities ---
+ bool MakeMove(int x1, int y1, int x2, int y2, PieceType promotion)
+ {
+ bool valid = false;
+
+ PieceType type = chessState.board[y1][x1].type;
+ Player player = chessState.board[y1][x1].player;
+
+ // Pawn Promotion
+ if(type == Pawn && y2 == ((player == White) ? 7 : 0))
+ {
+ if(chessState.isLocalPlayer[chessState.turn] &&
+ IsMoveValid(x1,y1,x2,y2, chessState, null, true))
+ {
+ chess2D.Update(null);
+ chess3D.Update(null);
+ promotion = (PieceType)Promotion { master = this }.Modal();
+ }
+ }
+
+ if(StateMakeMove(chessState, x1,y1,x2,y2, promotion, true, null))
+ {
+ valid = true;
+
+ if(chessState.isLocalPlayer[player] && !local && !ai)
+ {
+ ChessPacket packet
+ {
+ type = Position,
+ player = player,
+ x1 = (byte)x1,
+ y1 = (byte)y1,
+ x2 = (byte)x2,
+ y2 = (byte)y2,
+ promotion = promotion
+ };
+ sockets[player^(Player)1].Send((byte *)&packet, sizeof(ChessPacket));
+ }
+
+ if(player == Black)
+ {
+ moveList.AddStringf(" %c%c-%c%c",
+ x1+'a',y1+'1', x2+'a',y2+'1');
+ }
+ else
+ {
+ moveList.AddStringf("%3d. %c%c-%c%c",
+ chessState.numMoves/2+1, x1+'a',y1+'1', x2+'a',y2+'1');
+ }
+
+
+ // Update Status Bar
+ {
+ MoveStack stack { };
+ GenerateMoveList(chessState, stack);
+
+ delete stack.moves;
+
+ if(Check(chessState, chessState.turn, -1, -1))
+ {
+ if(stack.count)
+ {
+ chessState.state = Check; // TODO: Fix this
+ stateField.text = "Check!";
+ }
+ else
+ {
+ chessState.state = CheckMate;
+ if(chessState.turn == White)
+ stateField.text = "White are Checkmate.";
+ else
+ stateField.text = "Black are Checkmate.";
+ }
+ }
+ else if(!stack.count)
+ {
+ chessState.state = StaleMate;
+ stateField.text = "Stalemate.";
+ }
+ else
+ stateField.text = "";
+
+ // TOFIX: Gets confused with function!
+ if((chessState.state == Check || chessState.state == Normal) &&
+ chessState.isLocalPlayer[chessState.turn] && !local)
+ turnField.text = "Your turn";
+ else
+ turnField.text = "";
+ }
+ }
+
+ chess2D.Update(null);
+ chess3D.Update(null);
+ return valid;
+ }
+
+ void ProcessUserMove(int x1, int y1, int x2, int y2)
+ {
+ if(MakeMove(x1, y1, x2, y2, 0))
+ {
+ if(ai)
+ aiThread.Play();
+ }
+
+ chess2D.Update(null);
+
+ chess3D.Update(null);
+ }
+
+ // #define QUEENMATE
+
+ void NewGame()
+ {
+ int x,y;
+
+ moveList.Clear();
+
+ chessState.state = Normal;
+ chessState.numMoves = 0;
+
+ for(y = 0; y <8; y++)
+ for(x = 0; x<8; x++)
+ chessState.board[y][x] = Piece {};
+
+ // WHITE PIECES
+
+ #ifndef QUEENMATE
+ for(x = 0; x<8; x++)
+ chessState.board[1][x] = Piece { White, Pawn };
+ chessState.board[0][0] = chessState.board[0][7] = Piece { White, Rook };
+ chessState.board[0][1] = chessState.board[0][6] = Piece { White, Knight };
+ chessState.board[0][2] = chessState.board[0][5] = Piece { White, Bishop };
+ chessState.board[0][3] = Piece { White, Queen };
+ #endif
+ chessState.board[0][4] = Piece { White, King };
+
+ // BLACK PIECES
+ #ifndef QUEENMATE
+ for(x = 0; x<8; x++)
+ chessState.board[6][x] = Piece { Black, Pawn };
+ chessState.board[7][0] = chessState.board[7][7] = Piece { Black, Rook };
+ chessState.board[7][1] = chessState.board[7][6] = Piece { Black, Knight };
+ chessState.board[7][2] = chessState.board[7][5] = Piece { Black, Bishop };
+ #endif
+ chessState.board[7][3] = Piece { Black, Queen };
+ chessState.board[7][4] = Piece { Black, King };
+
+ // CASTLE STATUS
+ #ifndef QUEENMATE
+ chessState.kingMoved[Black] = chessState.kingMoved[White] = false;
+ chessState.kRookMoved[Black] = chessState.kRookMoved[White] = false;
+ chessState.qRookMoved[Black] = chessState.qRookMoved[White] = false;
+ #else
+ chessState.kRookMoved[Black] = chessState.kRookMoved[White] = true;
+ chessState.qRookMoved[Black] = chessState.qRookMoved[White] = true;
+ #endif
+
+ // KING POSITION
+ chessState.kings[Black].x = chessState.kings[White].x = 4;
+ chessState.kings[Black].y = 7;
+ chessState.kings[White].y = 0;
+
+ #if 0
+ chessState.kings[Black].x = 4;
+ chessState.kings[Black].y = 6;
+ chessState.kings[White].x = 4;
+ chessState.kings[White].y = 0;
+
+ chessState.kingMoved[0] = false;
+ chessState.kingMoved[1] = true;
+ chessState.kRookMoved[0] = false;
+ chessState.qRookMoved[0] = false;
+ chessState.kRookMoved[1] = true;
+ chessState.qRookMoved[1] = true;
+
+ chessState.board[0][0] = Piece { White, Rook };
+ chessState.board[0][4] = Piece { White, King };
+ chessState.board[0][7] = Piece { White, Rook };
+ chessState.board[1][0] = Piece { White, Pawn };
+ chessState.board[1][2] = Piece { White, Pawn };
+ chessState.board[1][5] = Piece { White, Pawn };
+ chessState.board[1][6] = Piece { White, Pawn };
+ chessState.board[1][7] = Piece { White, Pawn };
+ chessState.board[2][1] = Piece { White, Pawn };
+ chessState.board[2][2] = Piece { White, Knight };
+ chessState.board[4][3] = Piece { White, Pawn };
+ chessState.board[5][6] = Piece { White, Bishop };
+
+ chessState.board[5][0] = Piece { Black, Pawn };
+ chessState.board[5][1] = Piece { Black, Pawn };
+ chessState.board[5][3] = Piece { Black, Knight };
+ chessState.board[5][5] = Piece { Black, Pawn };
+ chessState.board[5][7] = Piece { Black, Bishop };
+ chessState.board[6][0] = Piece { White, Rook };
+ chessState.board[6][2] = Piece { Black, Pawn };
+ chessState.board[6][3] = Piece { Black, Pawn };
+ chessState.board[6][4] = Piece { Black, King };
+ chessState.board[7][1] = Piece { Black, Knight };
+ chessState.board[7][2] = Piece { Black, Bishop };
+ #endif
+ chessState.turn = White;
+
+ chessState.castled[White] =
+ chessState.castled[Black] = false;
+
+ // EN PASSANT STATUS
+ chessState.enPassant.x = -1;
+ chessState.enPassant.y = -1;
+
+ chessState.pieceCount[White][Pawn] = chessState.pieceCount[Black][Pawn] = 8;
+ chessState.pieceCount[White][Knight] = chessState.pieceCount[Black][Knight] = 2;
+ chessState.pieceCount[White][Bishop] = chessState.pieceCount[Black][Bishop] = 2;
+ chessState.pieceCount[White][Rook] = chessState.pieceCount[Black][Rook] = 2;
+ chessState.pieceCount[White][Queen] = chessState.pieceCount[Black][Queen] = 1;
+ chessState.pieceCount[White][King] = chessState.pieceCount[Black][King] = 1;
+
+ chessState.materialValue[White] =
+ chessState.pieceCount[White][Pawn] * materialValues[Pawn] +
+ chessState.pieceCount[White][Knight] * materialValues[Knight] +
+ chessState.pieceCount[White][Bishop] * materialValues[Bishop] +
+ chessState.pieceCount[White][Rook] * materialValues[Rook] +
+ chessState.pieceCount[White][Queen] * materialValues[Queen];
+ chessState.materialValue[Black] =
+ chessState.pieceCount[Black][Pawn] * materialValues[Pawn] +
+ chessState.pieceCount[Black][Knight] * materialValues[Knight] +
+ chessState.pieceCount[Black][Bishop] * materialValues[Bishop] +
+ chessState.pieceCount[Black][Rook] * materialValues[Rook] +
+ chessState.pieceCount[Black][Queen] * materialValues[Queen];
+
+ chess2D.Update(null);
+ chess3D.Update(null);
+
+ if(chessState.isLocalPlayer[chessState.turn] && !local)
+ turnField.text = "Your turn";
+ stateField.text = "";
+
+ /*
+ // 1
+ MakeMoveChar('e',2, 'e',4);
+ MakeMoveChar('a',7, 'a',6);
+ // 2
+ MakeMoveChar('d',2, 'd',4);
+ MakeMoveChar('f',7, 'f',5);
+ // 3
+ MakeMoveChar('e',4, 'f',5);
+ MakeMoveChar('b',8, 'c',6);
+ // 4
+ MakeMoveChar('d',4, 'd',5);
+ MakeMoveChar('c',6, 'e',5);
+ // 5
+ MakeMoveChar('f',2, 'f',4);
+ MakeMoveChar('e',5, 'f',7);
+ // 6
+ MakeMoveChar('g',1, 'f',3);
+ MakeMoveChar('c',7, 'c',5);
+ // 7
+ MakeMoveChar('c',2, 'c',4);
+ MakeMoveChar('g',7, 'g',6);
+ // 8
+ MakeMoveChar('f',5, 'g',6);
+ MakeMoveChar('f',7, 'd',6);
+ // 9
+ MakeMoveChar('g',6, 'h',7);
+ MakeMoveChar('g',8, 'h',6);
+ // 10
+ MakeMoveChar('f',1, 'd',3);
+ MakeMoveChar('d',6, 'f',7);
+ // 11
+ MakeMoveChar('c',1, 'd',2);
+ MakeMoveChar('d',8, 'b',6);
+ // 12
+ MakeMoveChar('d',2, 'c',3);
+ MakeMoveChar('b',6, 'd',6);
+ // 13
+ MakeMoveChar('c',3, 'h',8);
+ MakeMoveChar('f',7, 'h',8);
+ // 14
+ MakeMoveChar('d',1, 'd',2);
+ MakeMoveChar('e',7, 'e',6);
+ */
+ }
+
+ void MakeMoveChar(char x1, int y1, char x2, int y2)
+ {
+ MakeMove(x1 - 'a', y1 - 1, x2 - 'a', y2 - 1, Queen);
+ }
+
+ void EnableMenus()
+ {
+ stopItem.disabled = !hosting;
+ disconnectItem.disabled = !sockets[SERVER_COLOR] && !sockets[CLIENT_COLOR];
+ endGameItem.disabled = !chessState.gameRunning;
+ hostItem.disabled = hosting;
+ }
+
+ void SetDriver()
+ {
+ int c;
+ for(c = 0; c<app.numDrivers; c++)
+ if(!strcmp(app.drivers[c], app.driver))
+ {
+ driverItems[c].checked = true;
+ break;
+ }
+ }
+
+ // --- Chess Window Class ---
+ bool OnCreate()
+ {
+ int c;
+
+ driverItems = new MenuItem[app.numDrivers];
+ for(c = 0; c<app.numDrivers; c++)
+ {
+ driverItems[c] = MenuItem { viewMenu, app.drivers[c], NotifySelect = SetDisplayDriver };
+ driverItems[c].id = c;
+ driverItems[c].isRadio = true;
+ }
+ // this.SetPalette(palette, true);
+
+ SetDriver();
+ NewGame();
+ EnableMenus();
+
+ return true;
+ }
+
+ bool EndGame()
+ {
+ if(chessState.gameRunning &&
+ (chessState.state == Normal || chessState.state == Check))
+ {
+ if(MessageBox { type = okCancel, contents = "Quit current game?",
+ master = this, text = "ECERE Chess" }.Modal() == cancel)
+ return false;
+ }
+ if(sockets[SERVER_COLOR])
+ sockets[SERVER_COLOR].Disconnect(0);
+ else if(sockets[CLIENT_COLOR])
+ sockets[CLIENT_COLOR].Disconnect(0);
+ else if(local || ai)
+ {
+ if(ai) aiThread.Abort();
+ local = ai = false;
+ chessState.gameRunning = false;
+ }
+ EnableMenus();
+
+ turnField.text = "";
+ stateField.text = "";
+
+ return true;
+ }
+
+ bool OnClose(bool parentClosing)
+ {
+ return EndGame();
+ }
+
+ void OnDestroy()
+ {
+ delete sockets[Black];
+ delete sockets[White];
+ delete driverItems;
+ }
+
+ void Connect(char * address)
+ {
+ ChessSocket socket { chess = this };
+ if(socket.Connect(address, CHESS_PORT))
+ {
+ sockets[SERVER_COLOR] = socket;
+ EnableMenus();
+
+ chessState.isLocalPlayer[CLIENT_COLOR] = true;
+ chessState.isLocalPlayer[SERVER_COLOR] = false;
+ }
+ }
+}
+
+// --- Chess Communications ---
+class ChessSocket : Socket
+{
+ Chess chess;
+ property Chess chess { set { chess = value; } }
+
+ void OnDisconnect(int code)
+ {
+ if(this == chess.sockets[CLIENT_COLOR])
+ {
+ chess.sockets[CLIENT_COLOR] = null;
+ chess.chessState->gameRunning = false;
+ chess.turnField.text = "";
+ chess.stateField.text = "";
+ }
+ else if(this == chess.sockets[SERVER_COLOR])
+ {
+ chess.sockets[SERVER_COLOR] = null;
+ chess.chessState->gameRunning = false;
+ chess.turnField.text = "";
+ chess.stateField.text = "";
+ }
+
+ chess.EnableMenus();
+ chess.chess2D.Update(null);
+ chess.chess3D.Update(null);
+ }
+
+ uint OnReceive(const byte * buffer, uint count)
+ {
+ if(count >= sizeof(ChessPacket))
+ {
+ ChessPacket packet = *(ChessPacket *)buffer;
+ switch(packet.type)
+ {
+ case Position:
+ chess.MakeMove(packet.x1, packet.y1, packet.x2, packet.y2, packet.promotion);
+ chess.Activate();
+ break;
+ case NewGame:
+ chess.chessState->gameRunning = true;
+ chess.NewGame();
+ break;
+ }
+ return sizeof(ChessPacket);
+ }
+ return 0;
+ }
+
+ void OnConnect()
+ {
+ chess.sockets[SERVER_COLOR] = this;
+ chess.chessState->gameRunning = true;
+ chess.EnableMenus();
+ chess.NewGame();
+ }
+}
+
+class ChessService : Service
+{
+ Chess chess;
+ property Chess chess { set { chess = value; } }
+
+ void OnAccept()
+ {
+ if(!chess.chessState->gameRunning)
+ {
+ ChessPacket packet { type = NewGame };
+
+ chess.sockets[CLIENT_COLOR] = ChessSocket { this, chess = chess };
+ chess.sockets[CLIENT_COLOR].Send((byte *)&packet, sizeof(ChessPacket));
+
+ chess.chessState->isLocalPlayer[SERVER_COLOR] = true;
+ chess.chessState->isLocalPlayer[CLIENT_COLOR] = false;
+
+ chess.NewGame();
+ chess.chessState->gameRunning = true;
+ chess.EnableMenus();
+ chess.chess2D.Update(null);
+ chess.chess3D.Update(null);
+ }
+ }
+}
Ecere Software / chess / commitdiff
