2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2004, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure
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.
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, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
23 * related information and legal notices. It is expected that any future
24 * projects/authors will amend these files as needed.
28 * mobility.c: Add mobility to each of the items which accumulate mobility.
30 * Known contributors to this file:
32 * Steve McClure, 1998-1999
52 static int timestamp_fixing;
53 static int do_upd_checking = 0;
55 static void do_mob_land(struct lndstr *, int);
56 static void do_mob_plane(struct plnstr *, int);
57 static void do_mob_sect(struct sctstr *sp, int etus);
58 static void do_mob_ship(struct shpstr *, int);
61 increase_mob(time_t *counter, float mult)
72 secs = now - *counter;
73 if (secs < 1 || secs < s_p_etu)
75 newetus = (int)(secs / s_p_etu);
78 left = (secs % s_p_etu);
80 newmob = (float)(newetus * mult);
81 inewmob = (int)(newetus * mult);
82 if (newmob == inewmob || newetus > 7)
86 } while (newetus > 0);
91 *counter = *counter - left;
99 update_timestamps(time_t lastsavedtime)
101 struct shpstr *shipp;
102 struct sctstr *sectp;
103 struct lndstr *landp;
104 struct plnstr *planep;
109 timestamp_fixing = 1;
111 delta = now - lastsavedtime;
112 for (n = 0; (shipp = getshipp(n)); n++)
113 shipp->shp_access += delta;
114 for (n = 0; (sectp = getsectid(n)); n++)
115 sectp->sct_access += delta;
116 for (n = 0; (landp = getlandp(n)); n++)
117 landp->lnd_access += delta;
118 for (n = 0; (planep = getplanep(n)); n++)
119 planep->pln_access += delta;
120 timestamp_fixing = 0;
126 struct shpstr *shipp;
127 struct sctstr *sectp;
128 struct lndstr *landp;
129 struct plnstr *planep;
136 sectp = getsectid(n);
138 planep = getplanep(n);
141 shp_do_upd_mob(shipp);
143 sct_do_upd_mob(sectp);
145 lnd_do_upd_mob(landp);
147 pln_do_upd_mob(planep);
148 if (!shipp && !sectp && !landp && !planep)
156 sct_do_upd_mob(struct sctstr *sp)
160 if (do_upd_checking || timestamp_fixing || update_pending)
162 if (sp->sct_own == 0)
164 if (sp->sct_type == SCT_SANCT)
166 if ((etus = increase_mob(&sp->sct_access, sect_mob_scale)) == 0)
169 do_mob_sect(sp, etus);
175 shp_do_upd_mob(struct shpstr *sp)
179 if (do_upd_checking || timestamp_fixing || update_pending)
181 if (sp->shp_own == 0)
183 if ((etus = increase_mob(&sp->shp_access, ship_mob_scale)) == 0)
186 do_mob_ship(sp, etus);
191 lnd_do_upd_mob(struct lndstr *lp)
195 if (do_upd_checking || timestamp_fixing || update_pending)
197 if (lp->lnd_own == 0)
199 if ((etus = increase_mob(&lp->lnd_access, land_mob_scale)) == 0)
203 do_mob_land(lp, etus);
208 pln_do_upd_mob(struct plnstr *pp)
212 if (do_upd_checking || timestamp_fixing || update_pending)
214 if (pp->pln_own == 0)
216 if ((etus = increase_mob(&pp->pln_access, plane_mob_scale)) == 0)
220 do_mob_plane(pp, etus);
232 for (n = 0; NULL != (sp = getsectid(n)); n++) {
233 sp->sct_timestamp = now;
237 do_mob_sect(sp, etus);
242 do_mob_sect(struct sctstr *sp, int etus)
246 if (sp->sct_own == 0)
248 if (sp->sct_type == SCT_SANCT)
250 /* Do we have to even bother? */
251 if (sp->sct_mobil >= sect_mob_max) {
252 /* No, so set just in case and then return */
253 sp->sct_mobil = sect_mob_max;
256 value = sp->sct_mobil + ((float)etus * sect_mob_scale);
257 if (value > sect_mob_max)
258 value = sect_mob_max;
259 sp->sct_mobil = value;
270 for (n = 0; NULL != (sp = getshipp(n)); n++) {
271 sp->shp_timestamp = now;
275 do_mob_ship(sp, etus);
280 do_mob_ship(struct shpstr *sp, int etus)
284 int can_add, have_fuel_for, total_add;
287 if (sp->shp_own == 0)
290 /* Do we even have to bother updating this mobility? */
291 if (sp->shp_mobil >= ship_mob_max) {
292 /* No, so don't. Just set it to max (just in case) and
294 sp->shp_mobil = ship_mob_max;
298 if (opt_FUEL == 0) { /* only a bit to do ... */
299 value = sp->shp_mobil + ((float)etus * ship_mob_scale);
300 if (value > ship_mob_max)
301 value = ship_mob_max;
302 sp->shp_mobil = value;
303 return; /* so we ship the FUEL stuff */
306 /* opt_FUEL in force */
307 if (mchr[(int)sp->shp_type].m_fuelu == 0) {
308 value = sp->shp_mobil + ((float)etus * ship_mob_scale);
309 if (value > ship_mob_max)
310 value = ship_mob_max;
311 sp->shp_mobil = (s_char)value;
313 can_add = ship_mob_max - sp->shp_mobil;
314 if (can_add > ((float)etus * ship_mob_scale))
315 can_add = ((float)etus * ship_mob_scale);
316 have_fuel_for = ldround((((double)sp->shp_fuel /
317 (double)mchr[(int)sp->shp_type].
318 m_fuelu) * (double)fuel_mult), 1);
320 if (can_add > have_fuel_for) {
322 need = can_add - have_fuel_for;
324 d *= (double)mchr[(int)sp->shp_type].m_fuelu;
325 d /= (double)fuel_mult;
327 if ((d - (int)d) > 0.0)
330 newfuel = supply_commod(sp->shp_own, sp->shp_x,
331 sp->shp_y, I_PETROL, need);
332 sp->shp_fuel += (u_char)(newfuel * 5);
335 have_fuel_for = ldround((((double)sp->shp_fuel /
336 (double)mchr[(int)sp->shp_type].
337 m_fuelu) * (double)fuel_mult), 1);
339 if (can_add > have_fuel_for) {
341 need = can_add - have_fuel_for;
343 d *= (double)mchr[(int)sp->shp_type].m_fuelu;
344 d /= (double)fuel_mult;
346 if ((d - (int)d) > 0.0)
349 newfuel = supply_commod(sp->shp_own, sp->shp_x,
350 sp->shp_y, I_OIL, need);
351 sp->shp_fuel += (u_char)(newfuel * 50);
354 have_fuel_for = ldround((((double)sp->shp_fuel /
355 (double)mchr[(int)sp->shp_type].
356 m_fuelu) * (double)fuel_mult), 1);
358 if (can_add > have_fuel_for)
359 total_add = have_fuel_for;
362 d = (double)total_add;
363 d *= (double)mchr[(int)sp->shp_type].m_fuelu;
364 d /= (double)fuel_mult;
365 sp->shp_fuel -= (u_char)ldround(d, 1);
366 sp->shp_fuel = (u_char)min(sp->shp_fuel,
367 mchr[(int)sp->shp_type].m_fuelc);
368 sp->shp_mobil += (s_char)total_add;
380 for (n = 0; NULL != (lp = getlandp(n)); n++) {
381 lp->lnd_timestamp = now;
385 do_mob_land(lp, etus);
390 do_mob_land(struct lndstr *lp, int etus)
394 int can_add, have_fuel_for, total_add;
397 if (lp->lnd_own == 0)
400 if (lp->lnd_mobil >= land_mob_max) {
401 lp->lnd_mobil = land_mob_max;
402 if (lp->lnd_harden >= land_mob_max) {
403 lp->lnd_harden = land_mob_max;
408 if (opt_FUEL == 0) { /* just some bits and pieces */
409 value = lp->lnd_mobil + ((float)etus * land_mob_scale);
410 if (value > land_mob_max) {
411 lnd_fortify(lp, value - land_mob_max);
412 value = land_mob_max;
414 lp->lnd_mobil = value;
419 /* opt_FUEL in force ... */
420 if (lp->lnd_fuelu == 0) {
421 value = lp->lnd_mobil + ((float)etus * land_mob_scale);
422 if (value > land_mob_max) {
423 lnd_fortify(lp, value - land_mob_max);
424 value = land_mob_max;
426 lp->lnd_mobil = value;
430 can_add = land_mob_max - lp->lnd_mobil;
432 if (can_add > ((float)etus * land_mob_scale))
433 can_add = ((float)etus * land_mob_scale);
435 have_fuel_for = (lp->lnd_fuel / lp->lnd_fuelu) * fuel_mult;
437 if (can_add > have_fuel_for) {
439 need = can_add - have_fuel_for;
441 d *= (double)lp->lnd_fuelu;
442 d /= (double)fuel_mult;
444 if ((d - (int)d) > 0.0)
447 newfuel = supply_commod(lp->lnd_own, lp->lnd_x,
448 lp->lnd_y, I_PETROL, need);
449 lp->lnd_fuel += (u_char)(newfuel * 5);
452 have_fuel_for = (lp->lnd_fuel / lp->lnd_fuelu) * fuel_mult;
454 if (can_add > have_fuel_for) {
456 need = can_add - have_fuel_for;
458 d *= (double)lp->lnd_fuelu;
459 d /= (double)fuel_mult;
461 if ((d - (int)d) > 0.0)
464 newfuel = supply_commod(lp->lnd_own, lp->lnd_x,
465 lp->lnd_y, I_OIL, need);
466 lp->lnd_fuel += (u_char)(newfuel * 50);
469 have_fuel_for = (lp->lnd_fuel / lp->lnd_fuelu) * fuel_mult;
471 if (can_add > have_fuel_for) {
472 total_add = have_fuel_for;
475 d = (double)total_add;
476 d *= (double)lp->lnd_fuelu;
477 d /= (double)fuel_mult;
478 lp->lnd_fuel -= (u_char)ldround(d, 1);
479 lp->lnd_fuel = (u_char)min(lp->lnd_fuel, lp->lnd_fuelc);
480 if (total_add + lp->lnd_mobil > land_mob_max) {
481 total_add = land_mob_max - lp->lnd_mobil;
483 /* no automatic fortification here, as it would cost fuel */
485 lp->lnd_mobil += (s_char)total_add;
497 for (n = 0; NULL != (pp = getplanep(n)); n++) {
498 pp->pln_timestamp = now;
502 do_mob_plane(pp, etus);
507 do_mob_plane(struct plnstr *pp, int etus)
511 if (pp->pln_own == 0)
513 if (pp->pln_mobil >= plane_mob_max) {
514 pp->pln_mobil = plane_mob_max;
518 value = pp->pln_mobil + ((float)etus * plane_mob_scale);
519 if (value > plane_mob_max)
520 value = plane_mob_max;
521 pp->pln_mobil = value;