2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2018, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure, Markus Armbruster
6 * Empire 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 3 of the License, or
9 * (at your option) any later version.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 * See files README, COPYING and CREDITS in the root of the source
22 * tree for related information and legal notices. It is expected
23 * that future projects/authors will amend these files as needed.
27 * game.c: Game file access
29 * Known contributors to this file:
30 * Markus Armbruster, 2007-2009
36 * An Empire turn is terminated by an update. The Empire clock counts
37 * turns and ETUs, i.e. it ticks etu_per_update times per turn. When
38 * updates move around in real time (schedule change, downtime, etc.),
39 * the Empire clock automatically adapts the duration of an ETU
51 * Enable / disable updates
54 game_ctrl_update(int enable)
56 struct gamestr *game = getgamep();
58 game->game_upd_disable = !enable;
63 * Are updates disabled?
66 updates_disabled(void)
68 return getgamep()->game_upd_disable;
72 * Enable / disable play
75 game_ctrl_play(int enable)
77 struct gamestr *game = getgamep();
79 game->game_down = !enable;
87 game_play_disabled(void)
89 return getgamep()->game_down;
93 * Notice that a player broke sanctuary.
94 * This starts the Empire clock if it hasn't been started yet.
97 game_note_bsanct(void)
99 struct gamestr *game = getgamep();
101 if (game->game_rt == 0) {
102 game->game_rt = time(NULL);
108 * Record an update in the game file, the current time is @now.
109 * This starts the Empire clock if it hasn't been started yet.
112 game_record_update(time_t now)
114 struct gamestr *game = getgamep();
123 * Return current duration of an ETU in seconds.
124 * Note: may return HUGE_VAL when the Empire clock is not ticking.
127 secs_per_etu(struct gamestr *game)
131 if (!game->game_rt || !update_time[0])
132 return HUGE_VAL; /* not started or no update scheduled */
134 secs = update_time[0] - game->game_rt;
136 return HUGE_VAL; /* update seems to be late */
137 return secs / (etu_per_update - game->game_tick);
141 * Update the Empire clock according to the current real time.
142 * Return the game struct.
147 struct gamestr *game = getgamep();
148 double dsecs, s_p_etu;
151 dsecs = time(NULL) - game->game_rt;
152 if (CANT_HAPPEN(dsecs < 0))
154 s_p_etu = secs_per_etu(game);
155 detu = (int)(dsecs / s_p_etu);
157 if (CANT_HAPPEN(game->game_tick + detu > etu_per_update))
158 detu = etu_per_update - game->game_tick;
159 game->game_tick += detu;
160 game->game_rt += detu * s_p_etu;
168 * Set ETU timestamp *@tick to the current ETU time.
169 * Return by how many ETUs it was increased.
172 game_tick_to_now(short *tick)
174 return game_step_a_tick(game_tick_tick(), tick);
178 * Set ETU timestamp *@tick to the ETU time recorded in the game struct.
179 * The Empire clock is not updated.
180 * Return by how many ETUs it was increased.
183 game_step_a_tick(struct gamestr *game, short *tick)
187 etu = game->game_tick - *tick;
188 if (CANT_HAPPEN(etu < 0))
190 *tick = game->game_tick;
195 * Reset ETU timestamp *@tick to zero.
196 * Return how many ETUs it had left until etu_per_update.
199 game_reset_tick(short *tick)
203 etu = etu_per_update - *tick;
204 if (CANT_HAPPEN(etu < 0))