terminal-chess: comparison src/chess/rules.c

-:189c7c77aaab
+:3fc6b1d6cbe9
 static void calc_movetime(GameState *gamestate, Move *move) {
 struct timeval curtimestamp;
 gettimeofday(&curtimestamp, NULL);
 move->timestamp.tv_sec = curtimestamp.tv_sec;
 move->timestamp.tv_usec = (int32_t) curtimestamp.tv_usec;
+move->movetime.tv_usec = 0;
+move->movetime.tv_sec = 0;
 if (gamestate->movecount > 1) {
 struct movetimeval lasttstamp = last_move(gamestate).timestamp;
 uint64_t sec = curtimestamp.tv_sec - lasttstamp.tv_sec;
 suseconds_t micros;
 if (curtimestamp.tv_usec < lasttstamp.tv_usec) {
 micros = 1000000-(lasttstamp.tv_usec - curtimestamp.tv_usec);
 sec--;
 } else {
 micros = curtimestamp.tv_usec - lasttstamp.tv_usec;
 }
-move->movetime.tv_sec = sec;
+while (micros >= 1000000) {
-move->movetime.tv_usec = (int32_t) micros;
+micros -= 1000000;
-} else {
+sec++;
-/* no move time for the first move of both white and black */
+}
-move->movetime.tv_usec = 0;
-move->movetime.tv_sec = 0;
+if (sec >= gamestate->info.delay) {
+move->movetime.tv_sec = sec;
+move->movetime.tv_usec = (int32_t) micros;
+}
 }
 }
 static void addmove(GameState* gamestate, Move *data) {
 if (gamestate->movecount == gamestate->movecapacity) {
 }
 void gamestate_at_move(GameState *gamestate,
 unsigned move_number, GameState *replay) {
 gamestate_init(replay);
+memcpy(&replay->info, &gamestate->info, sizeof(GameInfo));
 replay->review = true;
 if (move_number > gamestate->movecount) {
 move_number = gamestate->movecount;
 }
 for (unsigned i = 0 ; i < move_number ; i++) {
 } else {
 return false;
 }
 }
-uint16_t remaining_movetime(GameInfo *gameinfo, GameState *gamestate,
+uint16_t remaining_movetime(GameState *gamestate, uint8_t color) {
-uint8_t color) {
 unsigned move_number = gamestate->movecount;
 if (color == BLACK) {
 move_number |= 1;
 } else {
 move_number = (move_number + 1) & ~1;
 }
-return remaining_movetime2(gameinfo, gamestate, move_number);
+return remaining_movetime2(gamestate, move_number);
 }
-uint16_t remaining_movetime2(GameInfo *gameinfo, GameState *gamestate,
+uint16_t remaining_movetime2(GameState *gamestate, unsigned move_number) {
-unsigned move_number) {
+if (!gamestate->info.timecontrol) {
-if (!gameinfo->timecontrol) {
 return 0;
 }
-unsigned total_time = gameinfo->time;
+unsigned total_time = gamestate->info.time;
 unsigned used_time = 0;
 suseconds_t micros = 0;
 /* when this is a 0+X game, the clock starts with the increment */
-if (gameinfo->time == 0) {
+if (gamestate->info.time == 0) {
-total_time += gameinfo->addtime;
+total_time += gamestate->info.addtime;
 }
 /* go through all already played moves */
 unsigned first_move = move_number % 2;
 unsigned next_move = move_number;
 if (next_move > gamestate->movecount) next_move = gamestate->movecount;
 for (unsigned i = first_move ; i < next_move ; i += 2) {
 used_time += gamestate->moves[i].movetime.tv_sec;
 micros += gamestate->moves[i].movetime.tv_usec;
 /* add increments starting with move 2 */
-if (i > 1) total_time += gameinfo->addtime;
+if (i > 1) total_time += gamestate->info.addtime;
+}
+/* apply microseconds */
+while (micros >= 1000000) {
+micros -= 1000000;
+used_time++;
 }
 /* when the player is currently playing, count down the clock */
 if (is_game_running(gamestate) && move_number > 1 &&
 move_number == gamestate->movecount) {
 struct movetimeval lastmovetstamp =
 gamestate->moves[move_number - 1].timestamp;
 struct timeval currenttstamp;
 gettimeofday(&currenttstamp, NULL);
-used_time += currenttstamp.tv_sec - lastmovetstamp.tv_sec;
-micros += currenttstamp.tv_usec - lastmovetstamp.tv_usec;
+/* calculate current move time */
-}
+unsigned cmsec = currenttstamp.tv_sec - lastmovetstamp.tv_sec;
+suseconds_t cmusec = currenttstamp.tv_usec - lastmovetstamp.tv_usec;
-/* apply the microseconds */
-used_time += micros / 1000000;
+/* add microseconds carried over from last move and apply both */
+cmusec += micros;
+cmsec += cmusec / 1000000;
+/* add the time and respect a possible dealy */
+if (cmsec >= gamestate->info.delay) {
+used_time += cmsec - gamestate->info.delay;
+}
+}
 return used_time >= total_time ? 0 : total_time - used_time;
 }
 int print_clk(uint16_t time, char *str, bool always_hours) {

Mercurial > hg > terminal-chess / file comparison

comparison: src/chess/rules.c

src/chess/rules.c