git.pond.sub.org Git - empserver/blob - src/lib/update/mobility.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2009, 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  *  mobility.c: Add mobility to each of the items which accumulate mobility.
  29  *
  30  *  Known contributors to this file:
  31  *     Dave Pare, 1986
  32  *     Steve McClure, 1998-1999
  33  *     Markus Armbruster, 2004-2008
  34  */
  35
  36 #include <config.h>
  37
  38 #include "game.h"
  39 #include "land.h"
  40 #include "plane.h"
  41 #include "server.h"
  42 #include "ship.h"
  43 #include "update.h"
  44
  45 static int do_upd_checking;
  46
  47 static void do_mob_land(struct lndstr *, int);
  48 static void do_mob_plane(struct plnstr *, int);
  49 static void do_mob_sect(struct sctstr *sp, int etus);
  50 static void do_mob_ship(struct shpstr *, int);
  51
  52 void
  53 sct_do_upd_mob(struct sctstr *sp)
  54 {
  55     int etus;
  56
  57     if (do_upd_checking || update_running)
  58         return;
  59     if (sp->sct_own == 0)
  60         return;
  61     if (sp->sct_type == SCT_SANCT)
  62         return;
  63     etus = game_tick_to_now(&sp->sct_access);
  64     if (etus == 0)
  65         return;
  66
  67     do_upd_checking = 1;        /* avoid recursion */
  68     do_mob_sect(sp, etus);
  69     do_upd_checking = 0;
  70 }
  71
  72 void
  73 shp_do_upd_mob(struct shpstr *sp)
  74 {
  75     int etus;
  76
  77     if (do_upd_checking || update_running)
  78         return;
  79     if (sp->shp_own == 0)
  80         return;
  81     etus = game_tick_to_now(&sp->shp_access);
  82     if (etus == 0)
  83         return;
  84
  85     do_upd_checking = 1;        /* avoid recursion */
  86     do_mob_ship(sp, etus);
  87     do_upd_checking = 0;
  88 }
  89
  90 void
  91 lnd_do_upd_mob(struct lndstr *lp)
  92 {
  93     int etus;
  94
  95     if (do_upd_checking || update_running)
  96         return;
  97     if (lp->lnd_own == 0)
  98         return;
  99     etus = game_tick_to_now(&lp->lnd_access);
 100     if (etus == 0)
 101         return;
 102
 103     do_upd_checking = 1;        /* avoid recursion */
 104     do_mob_land(lp, etus);
 105     do_upd_checking = 0;
 106 }
 107
 108 void
 109 pln_do_upd_mob(struct plnstr *pp)
 110 {
 111     int etus;
 112
 113     if (do_upd_checking || update_running)
 114         return;
 115     if (pp->pln_own == 0)
 116         return;
 117     etus = game_tick_to_now(&pp->pln_access);
 118     if (etus == 0)
 119         return;
 120
 121     do_upd_checking = 1;        /* avoid recursion */
 122     do_mob_plane(pp, etus);
 123     do_upd_checking = 0;
 124 }
 125
 126 void
 127 mob_sect(void)
 128 {
 129     struct sctstr *sp;
 130     int n, etus;
 131     time_t now;
 132
 133     time(&now);
 134     for (n = 0; NULL != (sp = getsectid(n)); n++) {
 135         sp->sct_timestamp = now;
 136         if (opt_MOB_ACCESS)
 137             etus = game_reset_tick(&sp->sct_access);
 138         else
 139             etus = etu_per_update;
 140         do_mob_sect(sp, etus);
 141     }
 142 }
 143
 144 static void
 145 do_mob_sect(struct sctstr *sp, int etus)
 146 {
 147     int value;
 148
 149     if (CANT_HAPPEN(etus < 0))
 150         etus = 0;
 151
 152     if (sp->sct_own == 0)
 153         return;
 154     if (sp->sct_type == SCT_SANCT)
 155         return;
 156
 157     value = sp->sct_mobil + ((float)etus * sect_mob_scale);
 158     if (value > sect_mob_max)
 159         value = sect_mob_max;
 160     sp->sct_mobil = value;
 161 }
 162
 163 void
 164 mob_ship(void)
 165 {
 166     struct shpstr *sp;
 167     int n, etus;
 168     time_t now;
 169
 170     time(&now);
 171     for (n = 0; NULL != (sp = getshipp(n)); n++) {
 172         sp->shp_timestamp = now;
 173         if (opt_MOB_ACCESS)
 174             etus = game_reset_tick(&sp->shp_access);
 175         else
 176             etus = etu_per_update;
 177         do_mob_ship(sp, etus);
 178     }
 179 }
 180
 181 static void
 182 do_mob_ship(struct shpstr *sp, int etus)
 183 {
 184     int value;
 185
 186     if (CANT_HAPPEN(etus < 0))
 187         etus = 0;
 188
 189     if (sp->shp_own == 0)
 190         return;
 191
 192     value = sp->shp_mobil + (float)etus * ship_mob_scale;
 193     if (value > ship_mob_max)
 194         value = ship_mob_max;
 195     sp->shp_mobil = (signed char)value;
 196 }
 197
 198 void
 199 mob_land(void)
 200 {
 201     struct lndstr *lp;
 202     int n, etus;
 203     time_t now;
 204
 205     time(&now);
 206     for (n = 0; NULL != (lp = getlandp(n)); n++) {
 207         lp->lnd_timestamp = now;
 208         if (opt_MOB_ACCESS)
 209             etus = game_reset_tick(&lp->lnd_access);
 210         else
 211             etus = etu_per_update;
 212         do_mob_land(lp, etus);
 213     }
 214 }
 215
 216 static void
 217 do_mob_land(struct lndstr *lp, int etus)
 218 {
 219     int value;
 220
 221     if (CANT_HAPPEN(etus < 0))
 222         etus = 0;
 223
 224     if (lp->lnd_own == 0)
 225         return;
 226
 227     value = lp->lnd_mobil + ((float)etus * land_mob_scale);
 228     if (value > land_mob_max) {
 229         if (lp->lnd_harden < land_mob_max && !opt_MOB_ACCESS) {
 230             /*
 231              * Automatic fortification on excess mobility.
 232              * Disabled for MOB_ACCESS, because it leads to
 233              * excessively deep recursion and thus miserable
 234              * performance as the number of land units grows.
 235              *
 236              * Provide mobility to be used in lnd_fortify()
 237              * without overflowing lnd_mobil.
 238              */
 239             lp->lnd_mobil = land_mob_max;
 240             lnd_fortify(lp, value - land_mob_max);
 241         }
 242         value = land_mob_max;
 243     }
 244     lp->lnd_mobil = value;
 245 }
 246
 247 void
 248 mob_plane(void)
 249 {
 250     struct plnstr *pp;
 251     int n, etus;
 252     time_t now;
 253
 254     time(&now);
 255     for (n = 0; NULL != (pp = getplanep(n)); n++) {
 256         pp->pln_timestamp = now;
 257         if (opt_MOB_ACCESS)
 258             etus = game_reset_tick(&pp->pln_access);
 259         else
 260             etus = etu_per_update;
 261         do_mob_plane(pp, etus);
 262     }
 263 }
 264
 265 static void
 266 do_mob_plane(struct plnstr *pp, int etus)
 267 {
 268     int value;
 269
 270     if (CANT_HAPPEN(etus < 0))
 271         etus = 0;
 272
 273     if (pp->pln_own == 0)
 274         return;
 275
 276     value = pp->pln_mobil + ((float)etus * plane_mob_scale);
 277     if (value > plane_mob_max)
 278         value = plane_mob_max;
 279     pp->pln_mobil = value;
 280 }