git.pond.sub.org Git - empserver/blob - src/lib/subs/unitsub.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2013, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                Ken Stevens, Steve McClure, Markus Armbruster
   5  *
   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.
  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, see <http://www.gnu.org/licenses/>.
  18  *
  19  *  ---
  20  *
  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.
  24  *
  25  *  ---
  26  *
  27  *  unitsub.c: Common subroutines for multiple type of units
  28  *
  29  *  Known contributors to this file:
  30  *     Ron Koenderink, 2007
  31  *     Markus Armbruster, 2009-2011
  32  */
  33
  34 #include <config.h>
  35
  36 #include "file.h"
  37 #include "path.h"
  38 #include "player.h"
  39 #include "optlist.h"
  40 #include "prototypes.h"
  41 #include "unit.h"
  42
  43 char *
  44 unit_nameof(struct empobj *gp)
  45 {
  46     switch (gp->ef_type) {
  47     case EF_SHIP:
  48         return prship((struct shpstr *)gp);
  49     case EF_PLANE:
  50         return prplane((struct plnstr *)gp);
  51     case EF_LAND:
  52         return prland((struct lndstr *)gp);
  53     case EF_NUKE:
  54         return prnuke((struct nukstr *)gp);
  55     }
  56     CANT_REACH();
  57     return "The Beast #666";
  58 }
  59
  60 void
  61 unit_list(struct emp_qelem *unit_list)
  62 {
  63     struct emp_qelem *qp;
  64     struct emp_qelem *next;
  65     struct ulist *ulp;
  66     int type, npln, nch, nxl;
  67     struct empobj *unit;
  68     struct lndstr *lnd;
  69     struct shpstr *shp;
  70
  71     if (CANT_HAPPEN(QEMPTY(unit_list)))
  72         return;
  73     qp = unit_list->q_back;
  74     ulp = (struct ulist *)qp;
  75     type = ulp->unit.gen.ef_type;
  76     if (CANT_HAPPEN(type != EF_LAND && type != EF_SHIP))
  77         return;
  78
  79     if (type == EF_LAND)
  80         pr("lnd#     land type       x,y    a  eff mil  sh gun xl ln  mu tech retr\n");
  81     else
  82         pr("shp#     ship type       x,y   fl  eff mil  sh gun pn he xl ln mob tech\n");
  83
  84     for (; qp != unit_list; qp = next) {
  85         next = qp->q_back;
  86         ulp = (struct ulist *)qp;
  87         lnd = &ulp->unit.land;
  88         shp = &ulp->unit.ship;
  89         unit = &ulp->unit.gen;
  90         if (CANT_HAPPEN(type != unit->ef_type))
  91             continue;
  92         pr("%4d ", unit->uid);
  93         pr("%-16.16s ", empobj_chr_name(unit));
  94         prxy("%4d,%-4d ", unit->x, unit->y);
  95         pr("%1.1s", &unit->group);
  96         pr("%4d%%", unit->effic);
  97         if (type == EF_LAND) {
  98             pr("%4d", lnd->lnd_item[I_MILIT]);
  99             pr("%4d", lnd->lnd_item[I_SHELL]);
 100             pr("%4d", lnd->lnd_item[I_GUN]);
 101             pr("%3d%3d", lnd_nxlight(lnd), lnd_nland(lnd));
 102         } else {
 103             pr("%4d", shp->shp_item[I_MILIT]);
 104             pr("%4d", shp->shp_item[I_SHELL]);
 105             pr("%4d", shp->shp_item[I_GUN]);
 106             npln = shp_nplane(shp, &nch, &nxl, NULL);
 107             pr("%3d%3d%3d", npln - nch - nxl, nch, nxl);
 108             pr("%3d", shp_nland(shp));
 109         }
 110         pr("%4d", unit->mobil);
 111         pr("%4d", unit->tech);
 112         if (type == EF_LAND) {
 113             pr("%4d%%", lnd->lnd_retreat);
 114         }
 115         pr("\n");
 116     }
 117 }
 118
 119 void
 120 unit_put(struct emp_qelem *list, natid actor)
 121 {
 122     struct emp_qelem *qp;
 123     struct emp_qelem *newqp;
 124     struct ulist *ulp;
 125     struct empobj *unit;
 126
 127     qp = list->q_back;
 128     while (qp != list) {
 129         ulp = (struct ulist *)qp;
 130         unit = &ulp->unit.gen;
 131         if (CANT_HAPPEN(unit->ef_type != EF_LAND
 132                         && unit->ef_type != EF_SHIP))
 133             continue;
 134         if (actor) {
 135             mpr(actor, "%s stopped at %s\n", unit_nameof(unit),
 136                 xyas(unit->x, unit->y, actor));
 137             if (unit->ef_type == EF_LAND) {
 138                 if (ulp->mobil < -127)
 139                     ulp->mobil = -127;
 140                 unit->mobil = ulp->mobil;
 141             }
 142         }
 143         if (unit->ef_type == EF_SHIP)
 144             unit->mobil = (int)ulp->mobil;
 145         put_empobj(unit->ef_type, unit->uid, unit);
 146         newqp = qp->q_back;
 147         emp_remque(qp);
 148         free(qp);
 149         qp = newqp;
 150     }
 151 }
 152
 153 char *
 154 unit_path(int together, struct empobj *unit, char *buf, size_t bufsz)
 155 {
 156     coord destx;
 157     coord desty;
 158     struct sctstr sect;
 159     size_t len;
 160     double c;
 161     int mtype;
 162
 163     if (CANT_HAPPEN(unit->ef_type != EF_LAND && unit->ef_type != EF_SHIP))
 164         return NULL;
 165
 166     if (!sarg_xy(buf, &destx, &desty))
 167         return buf;
 168     if (!together) {
 169         pr("Cannot go to a destination sector if not all starting in the same sector\n");
 170         return NULL;
 171     }
 172     if (unit->ef_type == EF_SHIP) {
 173         c = path_find(unit->x, unit->y, destx, desty,
 174                       player->cnum, MOB_SAIL);
 175         if (c < 0 || unit->mobil <= 0) {
 176             pr("Can't get to '%s' right now.\n",
 177                xyas(destx, desty, player->cnum));
 178             return NULL;
 179         }
 180     } else {
 181         getsect(unit->x, unit->y, &sect);
 182         mtype = lnd_mobtype((struct lndstr *)unit);
 183         /*
 184          * Note: passing sect.sct_own for actor is funny, but works:
 185          * its only effect is to confine the search to that nation's
 186          * land.  It doesn't affect mobility costs.  The real actor is
 187          * different for marching in allied land, and passing it would
 188          * break path finding there.
 189          */
 190         c = path_find(unit->x, unit->y, destx, desty, sect.sct_own, mtype);
 191         if (c < 0) {
 192             pr("No owned %s from %s to %s!\n",
 193                mtype == MOB_RAIL ? "railway" : "path",
 194                xyas(unit->x, unit->y, player->cnum),
 195                xyas(destx, desty, player->cnum));
 196             return NULL;
 197         }
 198     }
 199     len = path_find_route(buf, bufsz, unit->x, unit->y, destx, desty);
 200     if (len == 0 || unit->ef_type == EF_LAND) {
 201         if (len + 1 < bufsz)
 202             strcpy(buf + len, "h");
 203         len++;
 204     }
 205     if (len >= bufsz) {
 206         pr("Can't handle path to %s, it's too long, sorry\n",
 207            xyas(destx, desty, player->cnum));
 208         return NULL;
 209     }
 210     if (unit->ef_type == EF_LAND)
 211         pr("Using path '%s'\n", buf);
 212     return buf;
 213 }
 214
 215 void
 216 unit_view(struct emp_qelem *list)
 217 {
 218     struct sctstr sect;
 219     struct emp_qelem *qp;
 220     struct emp_qelem *next;
 221     struct ulist *ulp;
 222
 223     for (qp = list->q_back; qp != list; qp = next) {
 224         next = qp->q_back;
 225         ulp = (struct ulist *)qp;
 226         if (CANT_HAPPEN(!(ef_flags(ulp->unit.gen.ef_type) & EFF_XY)))
 227             continue;
 228         getsect(ulp->unit.gen.x, ulp->unit.gen.y, &sect);
 229         if (ulp->unit.gen.ef_type == EF_SHIP) {
 230             if (((struct mchrstr *)ulp->chrp)->m_flags & M_FOOD)
 231                 pr("[fert:%d] ", sect.sct_fertil);
 232             if (((struct mchrstr *)ulp->chrp)->m_flags & M_OIL)
 233                 pr("[oil:%d] ", sect.sct_oil);
 234         }
 235         pr("%s @ %s %d%% %s\n", unit_nameof(&ulp->unit.gen),
 236            xyas(ulp->unit.gen.x, ulp->unit.gen.y, player->cnum),
 237            sect.sct_effic, dchr[sect.sct_type].d_name);
 238     }
 239 }
 240
 241 /*
 242  * Update cargo of CARRIER for movement or destruction.
 243  * If the carrier is destroyed, destroy its cargo (planes, land units,
 244  * nukes).
 245  * Else update their location to the carrier's.  Any op sectors equal
 246  * to location get updated, too.
 247  * Return number of units updated.
 248  */
 249 int
 250 unit_update_cargo(struct empobj *carrier)
 251 {
 252     int cargo_type;
 253     struct nstr_item ni;
 254     union empobj_storage obj;
 255     int n = 0;
 256
 257     for (cargo_type = EF_PLANE; cargo_type <= EF_NUKE; cargo_type++) {
 258         snxtitem_cargo(&ni, cargo_type, carrier->ef_type, carrier->uid);
 259         while (nxtitem(&ni, &obj)) {
 260             if (!carrier->own) {
 261                 mpr(obj.gen.own, "%s lost!\n", unit_nameof(&obj.gen));
 262                 obj.gen.effic = 0;
 263             } else {
 264                 /* mission op-area centered on the obj travels with it */
 265                 if (obj.gen.opx == obj.gen.x && obj.gen.opy == obj.gen.y) {
 266                     obj.gen.opx = carrier->x;
 267                     obj.gen.opy = carrier->y;
 268                 }
 269                 obj.gen.x = carrier->x;
 270                 obj.gen.y = carrier->y;
 271             }
 272             put_empobj(cargo_type, obj.gen.uid, &obj);
 273             n++;
 274         }
 275     }
 276     return n;
 277 }
 278
 279 /*
 280  * Drop cargo of UNIT.
 281  * Give it to NEWOWN, unless it's zero.
 282  */
 283 void
 284 unit_drop_cargo(struct empobj *unit, natid newown)
 285 {
 286     int type;
 287     struct nstr_item ni;
 288     union empobj_storage cargo;
 289
 290     for (type = EF_PLANE; type <= EF_NUKE; type++) {
 291         snxtitem_cargo(&ni, type, unit->ef_type, unit->uid);
 292         while (nxtitem(&ni, &cargo)) {
 293             switch (type) {
 294             case EF_PLANE:
 295                 cargo.plane.pln_ship = cargo.plane.pln_land = -1;
 296                 break;
 297             case EF_LAND:
 298                 cargo.land.lnd_ship = cargo.land.lnd_land = -1;
 299                 break;
 300             case EF_NUKE:
 301                 cargo.nuke.nuk_plane = -1;
 302                 break;
 303             }
 304             mpr(cargo.gen.own, "%s transferred off %s %d to %s\n",
 305                 unit_nameof(&cargo.gen),
 306                 ef_nameof(unit->ef_type), unit->uid,
 307                 xyas(cargo.gen.x, cargo.gen.y, cargo.gen.own));
 308             if (newown)
 309                 unit_give_away(&cargo.gen, newown, cargo.gen.own);
 310             put_empobj(type, cargo.gen.uid, &cargo.gen);
 311         }
 312     }
 313 }
 314
 315 /*
 316  * Give UNIT and its cargo to RECIPIENT.
 317  * No action if RECIPIENT already owns UNIT.
 318  * If GIVER is non-zero, inform RECIPIENT and GIVER of the transaction.
 319  * Clears mission and group on the units given away.
 320  */
 321 void
 322 unit_give_away(struct empobj *unit, natid recipient, natid giver)
 323 {
 324     int type;
 325     struct nstr_item ni;
 326     union empobj_storage cargo;
 327
 328     if (unit->own == recipient)
 329         return;
 330
 331     if (giver) {
 332         mpr(unit->own, "%s given to %s\n",
 333             unit_nameof(unit), cname(recipient));
 334         mpr(recipient, "%s given to you by %s\n",
 335             unit_nameof(unit), cname(giver));
 336     }
 337
 338     unit->own = recipient;
 339     unit_wipe_orders(unit);
 340     put_empobj(unit->ef_type, unit->uid, unit);
 341
 342     for (type = EF_PLANE; type <= EF_NUKE; type++) {
 343         snxtitem_cargo(&ni, type, unit->ef_type, unit->uid);
 344         while (nxtitem(&ni, &cargo))
 345             unit_give_away(&cargo.gen, recipient, giver);
 346     }
 347 }
 348
 349 /*
 350  * Wipe orders and such from UNIT.
 351  */
 352 void
 353 unit_wipe_orders(struct empobj *unit)
 354 {
 355     struct shpstr *sp;
 356     struct plnstr *pp;
 357     struct lndstr *lp;
 358     int i;
 359
 360     unit->group = 0;
 361     unit->opx = unit->opy = 0;
 362     unit->mission = 0;
 363     unit->radius = 0;
 364
 365     switch (unit->ef_type) {
 366     case EF_SHIP:
 367         sp = (struct shpstr *)unit;
 368         sp->shp_destx[0] = sp->shp_desty[0] = 0;
 369         sp->shp_destx[1] = sp->shp_desty[1] = 0;
 370         for (i = 0; i < TMAX; ++i) {
 371             sp->shp_tstart[i] = I_NONE;
 372             sp->shp_tend[i] = I_NONE;
 373             sp->shp_lstart[i] = 0;
 374             sp->shp_lend[i] = 0;
 375         }
 376         sp->shp_autonav = 0;
 377         sp->shp_mobquota = 0;
 378         sp->shp_path[0] = 0;
 379         sp->shp_follow = sp->shp_uid;
 380         sp->shp_rflags = 0;
 381         sp->shp_rpath[0] = 0;
 382         break;
 383     case EF_PLANE:
 384         pp = (struct plnstr *)unit;
 385         pp->pln_range = pln_range_max(pp);
 386         break;
 387     case EF_LAND:
 388         lp = (struct lndstr *)unit;
 389         lp->lnd_retreat = morale_base;
 390         lp->lnd_rflags = 0;
 391         lp->lnd_rpath[0] = 0;
 392         break;
 393     case EF_NUKE:
 394         break;
 395     default:
 396         CANT_REACH();
 397     }
 398 }