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-2008
  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  * Notice that a player broke sanctuary.
  76  * This starts the Empire clock if it hasn't been started yet.
  77  */
  78 void
  79 game_note_bsanct(void)
  80 {
  81     struct gamestr *game = getgamep();
  82
  83     if (game->game_rt == 0) {
  84         game->game_rt = time(NULL);
  85         putgame();
  86     }
  87 }
  88
  89 /*
  90  * Record an update in the game file, the current time is NOW.
  91  * This starts the Empire clock if it hasn't been started yet.
  92  */
  93 void
  94 game_record_update(time_t now)
  95 {
  96     struct gamestr *game = getgamep();
  97
  98     game->game_turn++;
  99     game->game_tick = 0;
 100     game->game_rt = now;
 101     putgame();
 102 }
 103
 104 /*
 105  * Return current duration of an ETU in seconds.
 106  * Note: may return HUGE_VAL when the Empire clock is not ticking.
 107  */
 108 static double
 109 secs_per_etu(struct gamestr *game)
 110 {
 111     double secs;
 112
 113     if (!game->game_rt || !update_time[0])
 114         return HUGE_VAL;        /* not started or no update scheduled */
 115
 116     secs = update_time[0] - game->game_rt;
 117     if (secs < 0)
 118         return HUGE_VAL;        /* update seems to be late */
 119     return secs / (etu_per_update - game->game_tick);
 120 }
 121
 122 /*
 123  * Update the Empire clock according to the current real time.
 124  * Return the game struct.
 125  */
 126 struct gamestr *
 127 game_tick_tick(void)
 128 {
 129     struct gamestr *game = getgamep();
 130     double dsecs, s_p_etu;
 131     int detu;
 132
 133     dsecs = time(NULL) - game->game_rt;
 134     if (CANT_HAPPEN(dsecs < 0))
 135         dsecs = 0;
 136     s_p_etu = secs_per_etu(game);
 137     detu = (int)(dsecs / s_p_etu);
 138     if (detu > 0) {
 139         if (CANT_HAPPEN(game->game_tick + detu > etu_per_update))
 140             detu = etu_per_update - game->game_tick;
 141         game->game_tick += detu;
 142         game->game_rt += detu * s_p_etu;
 143         putgame();
 144     }
 145
 146     return game;
 147 }
 148
 149 /*
 150  * Set ETU timestamp *TICK to the current ETU time.
 151  * Return by how many ETUs it was increased.
 152  */
 153 int
 154 game_tick_to_now(short *tick)
 155 {
 156     return game_step_a_tick(game_tick_tick(), tick);
 157 }
 158
 159 /*
 160  * Set ETU timestamp *TICK to the ETU time recorded in the game struct.
 161  * The Empire clock is not updated.
 162  * Return by how many ETUs it was increased.
 163  */
 164 int
 165 game_step_a_tick(struct gamestr *game, short *tick)
 166 {
 167     int etu;
 168
 169     etu = game->game_tick - *tick;
 170     if (CANT_HAPPEN(etu < 0))
 171         etu = 0;
 172     *tick = game->game_tick;
 173     return etu;
 174 }
 175
 176 /*
 177  * Reset ETU timestamp *TICK to zero.
 178  * Return how many ETUs it had left until etu_per_update.
 179  */
 180 int
 181 game_reset_tick(short *tick)
 182 {
 183     int etu;
 184
 185     etu = etu_per_update - *tick;
 186     if (CANT_HAPPEN(etu < 0))
 187         etu = 0;
 188     *tick = 0;
 189     return etu;
 190 }