git.pond.sub.org Git - empserver/blob - src/lib/subs/supply.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  *  supply.c: Supply subroutines
  29  *
  30  *  Known contributors to this file:
  31  *     Markus Armbruster, 2009
  32  */
  33
  34 #include <config.h>
  35
  36 #include <math.h>
  37 #include "file.h"
  38 #include "land.h"
  39 #include "nat.h"
  40 #include "optlist.h"
  41 #include "player.h"
  42 #include "prototypes.h"
  43 #include "sect.h"
  44 #include "ship.h"
  45
  46 static int supply_commod(int, int, int, i_type, int);
  47 static int s_commod(int, int, int, i_type, int, int);
  48 static int get_minimum(struct lndstr *, i_type);
  49
  50 int
  51 sct_supply(struct sctstr *sp, i_type type, int wanted)
  52 {
  53     if (sp->sct_item[type] < wanted) {
  54         sp->sct_item[type] += supply_commod(sp->sct_own,
  55                                             sp->sct_x, sp->sct_y, type,
  56                                             wanted - sp->sct_item[type]);
  57         putsect(sp);
  58     }
  59     return sp->sct_item[type] >= wanted;
  60 }
  61
  62 int
  63 shp_supply(struct shpstr *sp, i_type type, int wanted)
  64 {
  65     if (sp->shp_item[type] < wanted) {
  66         sp->shp_item[type] += supply_commod(sp->shp_own,
  67                                             sp->shp_x, sp->shp_y, type,
  68                                             wanted - sp->shp_item[type]);
  69         putship(sp->shp_uid, sp);
  70     }
  71     return sp->shp_item[type] >= wanted;
  72 }
  73
  74 int
  75 lnd_supply(struct lndstr *lp, i_type type, int wanted)
  76 {
  77     if (lp->lnd_item[type] < wanted) {
  78         lp->lnd_item[type] += supply_commod(lp->lnd_own,
  79                                             lp->lnd_x, lp->lnd_y, type,
  80                                             wanted - lp->lnd_item[type]);
  81         putland(lp->lnd_uid, lp);
  82     }
  83     return lp->lnd_item[type] >= wanted;
  84 }
  85
  86 int
  87 lnd_in_supply(struct lndstr *lp)
  88 {
  89     if (!opt_NOFOOD) {
  90         if (lp->lnd_item[I_FOOD] < get_minimum(lp, I_FOOD))
  91             return 0;
  92     }
  93     return lp->lnd_item[I_SHELL] >= get_minimum(lp, I_SHELL);
  94 }
  95
  96 int
  97 lnd_supply_all(struct lndstr *lp)
  98 {
  99     int fail = 0;
 100
 101     if (!opt_NOFOOD)
 102         fail |= !lnd_supply(lp, I_FOOD, get_minimum(lp, I_FOOD));
 103     fail |= !lnd_supply(lp, I_SHELL, get_minimum(lp, I_SHELL));
 104     return !fail;
 105 }
 106
 107 /*
 108  * Actually get the commod
 109  */
 110 static int
 111 supply_commod(int own, int x, int y, i_type type, int total_wanted)
 112 {
 113     if (total_wanted <= 0)
 114         return 0;
 115     return s_commod(own, x, y, type, total_wanted, !player->simulation);
 116 }
 117
 118 /*
 119  * Just return the number you COULD get, without doing it
 120  */
 121 static int
 122 try_supply_commod(int own, int x, int y, i_type type, int total_wanted)
 123 {
 124     if (total_wanted <= 0)
 125         return 0;
 126
 127     return s_commod(own, x, y, type, total_wanted, 0);
 128 }
 129
 130 /*
 131  * Actually get the commod
 132  *
 133  * First, try to forage in the sector
 134  * Second look for a warehouse or headquarters to leech
 135  * Third, look for a ship we own in a harbor
 136  * Fourth, look for supplies in a supply unit we own
 137  *              (one good reason to do this last is that the supply
 138  *               unit will then call resupply, taking more time)
 139  *
 140  * May want to put code to resupply with SAMs here, later --ts
 141  */
 142 static int
 143 s_commod(int own, int x, int y, i_type type, int total_wanted,
 144          int actually_doit)
 145 {
 146     int wanted = total_wanted;
 147     int gotten = 0, lookrange;
 148     struct sctstr sect, dest;
 149     struct nstr_sect ns;
 150     struct nstr_item ni;
 151     struct lchrstr *lcp;
 152     struct shpstr ship;
 153     struct lndstr land;
 154     /* leave at least 1 military in sectors/ships */
 155     int minimum = 0;
 156     int can_move;
 157     double move_cost, weight, mobcost;
 158     int packing;
 159     struct dchrstr *dp;
 160     struct ichrstr *ip;
 161     char buf[1024];
 162
 163     /* try to get it from sector we're in */
 164     getsect(x, y, &dest);
 165     getsect(x, y, &sect);
 166     if (sect.sct_own == own) {
 167         if (!opt_NOFOOD && type == I_FOOD)
 168             minimum = 1 + (int)ceil(food_needed(sect.sct_item,
 169                                                 etu_per_update));
 170         if (sect.sct_item[type] - wanted >= minimum) {
 171             sect.sct_item[type] -= wanted;
 172             if (actually_doit)
 173                 putsect(&sect);
 174             return total_wanted;
 175         } else if (sect.sct_item[type] - minimum > 0) {
 176             gotten += sect.sct_item[type] - minimum;
 177             wanted -= sect.sct_item[type] - minimum;
 178             sect.sct_item[type] = minimum;
 179             if (actually_doit)
 180                 putsect(&sect);
 181         }
 182     }
 183     /* look for a headquarters or warehouse */
 184     lookrange = tfact(own, 10.0);
 185     snxtsct_dist(&ns, x, y, lookrange);
 186     while (nxtsct(&ns, &sect) && wanted) {
 187         if (sect.sct_own != own)
 188             continue;
 189         if ((sect.sct_type != SCT_WAREH) &&
 190             (sect.sct_type != SCT_HEADQ) && (sect.sct_type != SCT_HARBR))
 191             continue;
 192         if ((sect.sct_type == SCT_HEADQ) &&
 193             (sect.sct_dist_x == sect.sct_x) &&
 194             (sect.sct_dist_y == sect.sct_y))
 195             continue;
 196         if (sect.sct_effic < 60)
 197             continue;
 198         if (!BestLandPath(buf, &dest, &sect, &move_cost, MOB_MOVE))
 199             continue;
 200         if (!opt_NOFOOD && type == I_FOOD)
 201             minimum = 1 + (int)ceil(food_needed(sect.sct_item,
 202                                                 etu_per_update));
 203         if (sect.sct_item[type] <= minimum) {
 204             /* Don't bother... */
 205             continue;
 206         }
 207         ip = &ichr[type];
 208         dp = &dchr[sect.sct_type];
 209         packing = ip->i_pkg[dp->d_pkg];
 210         if (packing > 1 && sect.sct_effic < 60)
 211             packing = 1;
 212         weight = (double)ip->i_lbs / packing;
 213         mobcost = move_cost * weight;
 214         if (mobcost > 0)
 215             can_move = (double)sect.sct_mobil / mobcost;
 216         else
 217             can_move = sect.sct_item[type] - minimum;
 218         if (can_move > sect.sct_item[type] - minimum)
 219             can_move = sect.sct_item[type] - minimum;
 220
 221         if (can_move >= wanted) {
 222             int n;
 223
 224             sect.sct_item[type] -= wanted;
 225
 226             /* take off mobility for delivering sect */
 227             n = roundavg(wanted * weight * move_cost);
 228             if (n < 0)
 229                 n = 0;
 230             if (n > sect.sct_mobil)
 231                 n = sect.sct_mobil;
 232             sect.sct_mobil -= n;
 233
 234             if (actually_doit)
 235                 putsect(&sect);
 236
 237             return total_wanted;
 238         } else if (can_move > 0) {
 239             int n;
 240             gotten += can_move;
 241             wanted -= can_move;
 242             sect.sct_item[type] -= can_move;
 243
 244             /* take off mobility for delivering sect */
 245             n = roundavg(can_move * weight * move_cost);
 246             if (n < 0)
 247                 n = 0;
 248             if (n > sect.sct_mobil)
 249                 n = sect.sct_mobil;
 250             sect.sct_mobil -= n;
 251
 252             if (actually_doit)
 253                 putsect(&sect);
 254         }
 255     }
 256
 257     /* look for an owned ship in a harbor */
 258     snxtitem_dist(&ni, EF_SHIP, x, y, lookrange);
 259
 260     while (nxtitem(&ni, &ship) && wanted) {
 261         if (ship.shp_own != own)
 262             continue;
 263
 264         if (!(mchr[(int)ship.shp_type].m_flags & M_SUPPLY))
 265             continue;
 266         getsect(ship.shp_x, ship.shp_y, &sect);
 267         if (sect.sct_type != SCT_HARBR)
 268             continue;
 269         if (sect.sct_effic < 2)
 270             continue;
 271         if (!BestLandPath(buf, &dest, &sect, &move_cost, MOB_MOVE))
 272             continue;
 273         if (!opt_NOFOOD && type == I_FOOD)
 274             minimum = 1 + (int)ceil(food_needed(ship.shp_item,
 275                                                 etu_per_update));
 276         if (ship.shp_item[type] <= minimum) {
 277             /* Don't bother... */
 278             continue;
 279         }
 280         ip = &ichr[type];
 281         dp = &dchr[sect.sct_type];
 282         packing = ip->i_pkg[dp->d_pkg];
 283         if (packing > 1 && sect.sct_effic < 60)
 284             packing = 1;
 285         weight = (double)ip->i_lbs / packing;
 286         mobcost = move_cost * weight;
 287         if (mobcost > 0)
 288             can_move = (double)sect.sct_mobil / mobcost;
 289         else
 290             can_move = ship.shp_item[type] - minimum;
 291         if (can_move > ship.shp_item[type] - minimum)
 292             can_move = ship.shp_item[type] - minimum;
 293         if (can_move >= wanted) {
 294             int n;
 295             ship.shp_item[type] -= wanted;
 296
 297             n = roundavg(wanted * weight * move_cost);
 298             if (n < 0)
 299                 n = 0;
 300             if (n > sect.sct_mobil)
 301                 n = sect.sct_mobil;
 302             sect.sct_mobil -= n;
 303             if (actually_doit) {
 304                 putship(ship.shp_uid, &ship);
 305                 putsect(&sect);
 306             }
 307             return total_wanted;
 308         } else if (can_move > 0) {
 309             int n;
 310             gotten += can_move;
 311             wanted -= can_move;
 312             ship.shp_item[type] -= can_move;
 313
 314             n = roundavg(can_move * weight * move_cost);
 315             if (n < 0)
 316                 n = 0;
 317             if (n > sect.sct_mobil)
 318                 n = sect.sct_mobil;
 319             sect.sct_mobil -= n;
 320
 321             if (actually_doit) {
 322                 putship(ship.shp_uid, &ship);
 323                 putsect(&sect);
 324             }
 325         }
 326     }
 327
 328     /* look for an owned supply unit */
 329     snxtitem_dist(&ni, EF_LAND, x, y, lookrange);
 330
 331     while (nxtitem(&ni, &land) && wanted) {
 332         int min;
 333
 334         if (land.lnd_own != own)
 335             continue;
 336
 337         lcp = &lchr[(int)land.lnd_type];
 338         if (!(lcp->l_flags & L_SUPPLY))
 339             continue;
 340
 341         if (land.lnd_item[type] <= get_minimum(&land, type))
 342             continue;
 343
 344         getsect(land.lnd_x, land.lnd_y, &sect);
 345         if (!BestLandPath(buf, &dest, &sect, &move_cost, MOB_MOVE))
 346             continue;
 347
 348         if ((land.lnd_ship >= 0) && (sect.sct_type != SCT_HARBR))
 349             continue;
 350
 351         if ((land.lnd_ship >= 0) && (sect.sct_effic < 2))
 352             continue;
 353
 354 #if 0
 355         /*
 356          * Recursive supply is disabled for now.  It can introduce
 357          * cycles into the "resupplies from" relation.  The code below
 358          * attempts to break these cycles by temporarily zapping the
 359          * commodity being supplied.  That puts the land file in a
 360          * funny state temporarily, risking loss of supplies when
 361          * something goes wrong on the way.  Worse, it increases
 362          * lnd_seqno even when !actually_doit, which can lead to
 363          * spurious seqno mismatch oopses in users of
 364          * lnd_could_be_supplied().  I can't be bothered to clean up
 365          * this mess right now, because recursive resupply is too dumb
 366          * to be really useful anyway: each step uses the first source
 367          * it finds, without consideration of mobility cost.  If you
 368          * re-enable it, don't forget to uncomment its documentation
 369          * in supply.t as well.
 370          */
 371         if (land.lnd_item[type] - wanted < get_minimum(&land, type)) {
 372             struct lndstr save;
 373
 374             /*
 375              * Temporarily zap this unit's store, so the recursion
 376              * avoids it.
 377              */
 378             save = land;
 379             land.lnd_item[type] = 0;
 380             putland(land.lnd_uid, &land);
 381             save.lnd_seqno = land.lnd_seqno;
 382
 383             land.lnd_item[type] =
 384                 save.lnd_item[type] + s_commod(own, land.lnd_x, land.lnd_y,
 385                                                type, wanted, actually_doit);
 386             if (actually_doit)
 387                 putland(land.lnd_uid, &land);
 388             else
 389                 putland(save.lnd_uid, &save);
 390         }
 391 #endif
 392
 393         min = get_minimum(&land, type);
 394         ip = &ichr[type];
 395         weight = ip->i_lbs;
 396         mobcost = move_cost * weight;
 397         if (mobcost > 0)
 398             can_move = (double)land.lnd_mobil / mobcost;
 399         else
 400             can_move = land.lnd_item[type] - min;
 401         if (can_move > land.lnd_item[type] - min)
 402             can_move = land.lnd_item[type] - min;
 403
 404         if (can_move >= wanted) {
 405             land.lnd_item[type] -= wanted;
 406             land.lnd_mobil -= roundavg(wanted * weight * move_cost);
 407
 408             if (actually_doit)
 409                 putland(land.lnd_uid, &land);
 410             return total_wanted;
 411         } else if (can_move > 0) {
 412             gotten += can_move;
 413             wanted -= can_move;
 414             land.lnd_item[type] -= can_move;
 415
 416             land.lnd_mobil -= roundavg(can_move * weight * move_cost);
 417
 418             if (actually_doit)
 419                 putland(land.lnd_uid, &land);
 420         }
 421     }
 422
 423     /* We've done the best we could */
 424     /* return the number gotten */
 425     return gotten;
 426 }
 427
 428
 429 /*
 430  * We want to get enough shells to fire once,
 431  * one update's worth of food.
 432  */
 433
 434 static int
 435 get_minimum(struct lndstr *lp, i_type type)
 436 {
 437     struct lchrstr *lcp;
 438     int max, want = 0;
 439
 440     lcp = &lchr[(int)lp->lnd_type];
 441     max = lcp->l_item[type];
 442
 443     switch (type) {
 444     case I_FOOD:
 445         if (opt_NOFOOD)
 446             return 0;           /* no food reqd, get out */
 447         want = (int)ceil(food_needed(lp->lnd_item, etu_per_update));
 448         break;
 449     case I_SHELL:
 450         want = lcp->l_ammo;
 451         break;
 452     default:
 453         return 0;
 454     }
 455
 456     if (want > max)
 457         want = max;
 458
 459     return want;
 460 }
 461
 462 int
 463 lnd_could_be_supplied(struct lndstr *lp)
 464 {
 465     int shells_needed, shells, keepshells;
 466     int food, food_needed, keepfood;
 467
 468     if (!opt_NOFOOD) {
 469         food_needed = get_minimum(lp, I_FOOD);
 470         food = keepfood = lp->lnd_item[I_FOOD];
 471         if (food < food_needed) {
 472             lp->lnd_item[I_FOOD] = 0;
 473             putland(lp->lnd_uid, lp);
 474             food += try_supply_commod(lp->lnd_own, lp->lnd_x, lp->lnd_y,
 475                                       I_FOOD, (food_needed - food));
 476             lp->lnd_item[I_FOOD] = keepfood;
 477             putland(lp->lnd_uid, lp);
 478         }
 479         if (food < food_needed)
 480             return 0;
 481
 482     }
 483
 484     shells_needed = lchr[lp->lnd_type].l_ammo;
 485     shells = keepshells = lp->lnd_item[I_SHELL];
 486     if (shells < shells_needed) {
 487         lp->lnd_item[I_SHELL] = 0;
 488         putland(lp->lnd_uid, lp);
 489         shells += try_supply_commod(lp->lnd_own, lp->lnd_x, lp->lnd_y,
 490                                     I_SHELL, (shells_needed - shells));
 491         lp->lnd_item[I_SHELL] = keepshells;
 492         putland(lp->lnd_uid, lp);
 493     }
 494
 495     if (shells < shells_needed)
 496         return 0;
 497
 498     return 1;
 499 }