terminal-chess: comparison src/main.c

-:2834e444a956
+:bb967c8e51e9
 switch (eval_result) {
 case VALID_MOVE_SYNTAX:
 NetMove nmove = hton_move(move);
 net_send_data(opponent, NETCODE_MOVE, &nmove, NETMOVE_LEN);
 code = net_recieve_code(opponent);
-/* we could validate the move's check/checkmate flag with
-* the network response code, but we choose not to do it */
-gamestate->checkmate = code == NETCODE_CHECKMATE;
-gamestate->stalemate = code == NETCODE_STALEMATE;
 if (code == NETCODE_DECLINE_MOVE) {
 uint8_t reason;
 net_recieve_data(opponent, &reason, 1);
 eval_move_failed_msg(reason);
-} else if (code == NETCODE_ACCEPT
+} else if (code == NETCODE_ACCEPT) {
-|| code == NETCODE_CHECK
-|| code == NETCODE_CHECKMATE
-|| code == NETCODE_STALEMATE
-|| code == NETCODE_NOMATERIAL) {
 format_move(gamestate, &move);
 apply_move(gamestate, &move);
-if (is_game_running(gamestate)) {
+/* switch to waiting, even when the game ended.
-return 0;
+* we want to receive the "game end" code from the
-} else {
+* other party.
-return 1;
+*/
-}
+return 0;
 } else if (code == NETCODE_CONNLOST) {
 printw("Your opponent left the game.");
 return 1;
 } else {
 printw("Invalid network response.");
 } else {
 net_send_code(opponent, NETCODE_DECLINE);
 }
 }
 break;
+/* validate "the game has ended" claims */
 case NETCODE_THREEFOLD:
-/* validate the claim */
+case NETCODE_NOMATERIAL:
-if (check_threefold_repetition(gamestate)) {
+case NETCODE_STALEMATE:
+case NETCODE_CHECKMATE:
+if ((code == NETCODE_THREEFOLD && gamestate->threefold) ||
+(code == NETCODE_NOMATERIAL && gamestate->nomaterial) ||
+(code == NETCODE_STALEMATE && gamestate->stalemate) ||
+(code == NETCODE_CHECKMATE && gamestate->checkmate)) {
 /* auto-accept the claim */
-gamestate->threefold = true;
 net_send_code(opponent, NETCODE_ACCEPT);
 return 1;
 } else {
 /* silently decline, do not add message to UI */
 net_send_code(opponent, NETCODE_DECLINE);
 Move move = ntoh_move(nmove);
 code = validate_move(gamestate, &move);
 if (code == VALID_MOVE_SEMANTICS) {
 format_move(gamestate, &move);
 apply_move(gamestate, &move);
+net_send_code(opponent, NETCODE_ACCEPT);
+/* send a code for ending the game, if required */
+bool endgame = true;
 if (gamestate->checkmate) {
 net_send_code(opponent, NETCODE_CHECKMATE);
-return 1;
 } else if (gamestate->stalemate) {
 net_send_code(opponent, NETCODE_STALEMATE);
-return 1;
 } else if (gamestate->nomaterial) {
 net_send_code(opponent, NETCODE_NOMATERIAL);
-return 1;
+} else if (gamestate->threefold) {
-} else if (move.check) {
+/* Note: in our implementation it is an auto-draw claimed
-net_send_code(opponent, NETCODE_CHECK);
+* by the player confronted with the position. By standard
+* chess rules, also the player who creates the position may
+* claim the draw. But since we do it automatically, it
+* makes no practical difference.
+*/
+net_send_code(opponent, NETCODE_THREEFOLD);
 } else {
-net_send_code(opponent, NETCODE_ACCEPT);
+endgame = false;
 }
-/* check for threefold repetition */
+/* await a response to the "end game" code */
-/* Note: in our implementation it is an auto-draw claimed
+if (endgame) {
-* by the player confronted with the position. By standard
-* chess rules, also the player who creates the position may
-* claim the draw. But since we do it automatically, it makes
-* no practical difference.
-*/
-if (gamestate->threefold) {
-/* send this as a new package (basically as next move) */
-net_send_code(opponent, NETCODE_THREEFOLD);
-/* the protocol supports declining the claim  */
 uint8_t resp = net_recieve_code(opponent);
 if (resp == NETCODE_ACCEPT) {
 return 1;
 } else {
 /* does not happen in our implementation */
-// TODO: but what do we do if some other client declines? simply rage quit?
+// TODO: but what do we do if some other client declines?
-//       should we instead rework the protocol that it's not possible to decline?
+//       currently, we simply continue playing,
+//       but that does not make any sense
 return 0;
 }
-} else {
-return 0;
 }
+/* now it's our turn */
+return 0;
 } else {
 net_send_data(opponent, NETCODE_DECLINE_MOVE, &code, 1);
 }
 break;
 }

Mercurial > hg > terminal-chess / file comparison

comparison: src/main.c

src/main.c