git.pond.sub.org Git - empserver/blob - src/lib/common/game.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2008, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See files README, COPYING and CREDITS in the root of the source
  23  *  tree for related information and legal notices.  It is expected
  24  *  that future projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  game.c: Game file access
  29  *
  30  *  Known contributors to this file:
  31  *     Markus Armbruster, 2007
  32  */
  33
  34 /*
  35  * On Empire Time:
  36  *
  37  * An Empire turn is terminated by an update.  The Empire clock counts
  38  * turns and ETUs, i.e. it ticks etu_per_update times per turn.  When
  39  * updates move around in real time (schedule change, downtime, etc.),
  40  * the Empire clock automatically adapts the duration of an ETU
  41  * accordingly.
  42  */
  43
  44 #include <config.h>
  45
  46 #include <math.h>
  47 #include "file.h"
  48 #include "game.h"
  49 #include "optlist.h"
  50 #include "prototypes.h"
  51 #include "server.h"
  52
  53 /*
  54  * Disable updates
  55  */
  56 void
  57 game_ctrl_update(int enable)
  58 {
  59     struct gamestr *game = getgamep();
  60
  61     game->game_upd_disable = !enable;
  62     putgame();
  63 }
  64
  65 /*
  66  * Are updates disabled?
  67  */
  68 int
  69 updates_disabled(void)
  70 {
  71     return getgamep()->game_upd_disable;
  72 }
  73
  74 /*
  75  * Record an update in the game file, the current time is NOW.
  76  */
  77 void
  78 game_record_update(time_t now)
  79 {
  80     struct gamestr *game = getgamep();
  81
  82     game->game_turn++;
  83     game->game_tick = 0;
  84     game->game_rt = now;
  85     putgame();
  86 }
  87
  88 /*
  89  * Return current duration of an ETU in seconds.
  90  * Note: may return HUGE_VAL when the Empire clock is not ticking.
  91  */
  92 static double
  93 secs_per_etu(struct gamestr *game)
  94 {
  95     double secs;
  96
  97     if (!update_time[0])
  98         return HUGE_VAL;        /* no update scheduled */
  99
 100     secs = update_time[0] - game->game_rt;
 101     if (secs < 0)
 102         return HUGE_VAL;        /* update seems to be late */
 103     return secs / (etu_per_update - game->game_tick);
 104 }
 105
 106 /*
 107  * Update the Empire clock according to the current real time.
 108  * Return the game struct.
 109  */
 110 struct gamestr *
 111 game_tick_tick(void)
 112 {
 113     struct gamestr *game = getgamep();
 114     double dsecs, s_p_etu;
 115     int detu;
 116
 117     dsecs = time(NULL) - game->game_rt;
 118     if (CANT_HAPPEN(dsecs < 0))
 119         dsecs = 0;
 120     s_p_etu = secs_per_etu(game);
 121     detu = (int)(dsecs / s_p_etu);
 122     if (detu > 0) {
 123         if (CANT_HAPPEN(game->game_tick + detu > etu_per_update))
 124             detu = etu_per_update - game->game_tick;
 125         game->game_tick += detu;
 126         game->game_rt += detu * s_p_etu;
 127         putgame();
 128     }
 129
 130     return game;
 131 }
 132
 133 /*
 134  * Set ETU timestamp *TICK to the current ETU time.
 135  * Return by how many ETUs it was increased.
 136  */
 137 int
 138 game_tick_to_now(short *tick)
 139 {
 140     return game_step_a_tick(game_tick_tick(), tick);
 141 }
 142
 143 /*
 144  * Set ETU timestamp *TICK to the ETU time recorded in the game struct.
 145  * The Empire clock is not updated.
 146  * Return by how many ETUs it was increased.
 147  */
 148 int
 149 game_step_a_tick(struct gamestr *game, short *tick)
 150 {
 151     int etu;
 152
 153     etu = game->game_tick - *tick;
 154     if (CANT_HAPPEN(etu < 0))
 155         etu = 0;
 156     *tick = game->game_tick;
 157     return etu;
 158 }
 159
 160 /*
 161  * Reset ETU timestamp *TICK to zero.
 162  * Return how many ETUs it had left until etu_per_update.
 163  */
 164 int
 165 game_reset_tick(short *tick)
 166 {
 167     int etu;
 168
 169     etu = etu_per_update - *tick;
 170     if (CANT_HAPPEN(etu < 0))
 171         etu = 0;
 172     *tick = 0;
 173     return etu;
 174 }