git.pond.sub.org Git - empserver/blob - src/lib/subs/plnsub.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  *  plnsub.c: Plane subroutine stuff
  29  *
  30  *  Known contributors to this file:
  31  *     Dave Pare, 1986
  32  *     Ken Stevens, 1995
  33  *     Steve McClure, 1998-2000
  34  *     Markus Armbruster, 2004-2009
  35  */
  36
  37 #include <config.h>
  38
  39 #include "file.h"
  40 #include "item.h"
  41 #include "land.h"
  42 #include "lost.h"
  43 #include "map.h"
  44 #include "misc.h"
  45 #include "nat.h"
  46 #include "nsc.h"
  47 #include "nuke.h"
  48 #include "optlist.h"
  49 #include "path.h"
  50 #include "plane.h"
  51 #include "player.h"
  52 #include "prototypes.h"
  53 #include "sect.h"
  54 #include "ship.h"
  55 #include "xy.h"
  56
  57 static int fit_plane_on_ship(struct plnstr *, struct shpstr *);
  58
  59 /*
  60  * Get planes and escorts argument.
  61  * Read planes into *NI_BOMB, and (optional) escorts into *NI_ESC.
  62  * If INPUT_BOMB is not empty, use it, else prompt for more input.
  63  * Same for INPUT_ESC.
  64  * If we got a plane argument, initialize *NI_BOMB and *NI_ESC, and
  65  * return 0.
  66  * Else return -1 (*NI_BOMB and *NI_ESC may be modified).
  67  */
  68 int
  69 get_planes(struct nstr_item *ni_bomb, struct nstr_item *ni_esc,
  70            char *input_bomb, char *input_esc)
  71 {
  72     if (!snxtitem(ni_bomb, EF_PLANE, input_bomb, NULL))
  73         return -1;
  74     if (!snxtitem(ni_esc, EF_PLANE, input_esc, "escort(s)? ")) {
  75         if (player->aborted)
  76             return -1;
  77         pr("No escorts...\n");
  78     }
  79     return 0;
  80 }
  81
  82 /*
  83  * Get assembly point argument.
  84  * If INPUT is not empty, use it, else prompt for more input using PROMPT.
  85  * If this yields a valid assembly point, read it into *AP_SECT and
  86  * return AP_SECT.
  87  * Else complain and return NULL.
  88  * *AP_SECT and BUF[1024] may be modified in either case.
  89  */
  90 struct sctstr *
  91 get_assembly_point(char *input, struct sctstr *ap_sect, char *buf)
  92 {
  93     char *p;
  94     coord x, y;
  95     struct nstr_item ni;
  96     struct shpstr ship;
  97
  98     p = getstarg(input, "assembly point? ", buf);
  99     if (!p || *p == 0)
 100         return NULL;
 101     if (!sarg_xy(p, &x, &y) || !getsect(x, y, ap_sect))
 102         return NULL;
 103
 104     /* over own or allied sector is fine */
 105     if (ap_sect->sct_own == player->cnum
 106         || getrel(getnatp(ap_sect->sct_own), player->cnum) == ALLIED)
 107         return ap_sect;
 108
 109     /* over own or allied ship is fine */
 110     snxtitem_xy(&ni, EF_SHIP, x, y);
 111     while (nxtitem(&ni, &ship)) {
 112         if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
 113             continue;
 114         if (ship.shp_own == player->cnum
 115             || getrel(getnatp(ship.shp_own), player->cnum) == ALLIED)
 116             return ap_sect;
 117     }
 118
 119     pr("Assembly point not owned by you or an ally!\n");
 120     return NULL;
 121 }
 122
 123 int
 124 pln_onewaymission(struct sctstr *target, int *shipno, int *flagp)
 125 {
 126     int nships;
 127     int cno;
 128     int flags, fl;
 129     struct shpstr ship;
 130     char buf[1024];
 131     char *p;
 132
 133     flags = *flagp;
 134
 135     /* offer carriers */
 136     nships = carriersatxy(target->sct_x, target->sct_y, player->cnum);
 137     if (nships) {
 138         for (;;) {
 139             p = getstring("Carrier #? ", buf);
 140             if (!p)
 141                 return -1;
 142             if (!*p)
 143                 break;
 144             cno = atoi(p);
 145             if (cno < 0
 146                 || !getship(cno, &ship)
 147                 || (!player->owner
 148                     && (getrel(getnatp(ship.shp_own), player->cnum)
 149                         != ALLIED))) {
 150                 pr("Not yours\n");
 151                 continue;
 152             }
 153             if (ship.shp_x != target->sct_x || ship.shp_y != target->sct_y) {
 154                 pr("Ship #%d not in %s\n", cno,
 155                    xyas(target->sct_x, target->sct_y, player->cnum));
 156                 continue;
 157             }
 158             fl = carrier_planes(&ship, 0);
 159             if (fl == 0) {
 160                 pr("Can't land on %s.\n", prship(&ship));
 161                 continue;
 162             }
 163             /* clear to land on ship#CNO */
 164             pr("landing on carrier %d\n", cno);
 165             flags |= fl;
 166             *shipno = cno;
 167             *flagp = flags;
 168             return 0;
 169         }
 170     }
 171
 172     /* try to land at sector */
 173     if (target->sct_own != player->cnum
 174         && getrel(getnatp(target->sct_own), player->cnum) != ALLIED) {
 175         pr("Nowhere to land at sector %s!\n",
 176            xyas(target->sct_x, target->sct_y, player->cnum));
 177         return -1;
 178     }
 179     if (target->sct_type == SCT_MOUNT) {
 180         pr("Nowhere to land at sector %s!\n",
 181            xyas(target->sct_x, target->sct_y, player->cnum));
 182         return -1;
 183     }
 184     if (target->sct_type != SCT_AIRPT || target->sct_effic < 60)
 185         flags |= P_V;
 186
 187     /* clear to land at sector */
 188     *shipno = -1;
 189     *flagp = flags;
 190     return 0;
 191 }
 192
 193 int
 194 pln_oneway_to_carrier_ok(struct emp_qelem *bomb_list,
 195                          struct emp_qelem *esc_list, int cno)
 196 {
 197     struct emp_qelem *list, *qp;
 198     struct plist *plp;
 199     struct shpstr ship;
 200
 201     if (cno < 0 || !getship(cno, &ship))
 202         return 0;
 203
 204     /* for both lists */
 205     for (list = bomb_list;
 206          list;
 207          list = list == bomb_list ? esc_list : NULL) {
 208         for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
 209             plp = (struct plist *)qp;
 210             if (plp->plane.pln_ship == ship.shp_uid)
 211                 continue;
 212             if (!fit_plane_on_ship(&plp->plane, &ship))
 213                 return 0;
 214         }
 215     }
 216     return 1;
 217 }
 218
 219 void
 220 pln_newlanding(struct emp_qelem *list, coord tx, coord ty, int cno)
 221 {
 222     struct emp_qelem *qp;
 223     struct plist *plp;
 224     struct shpstr ship;
 225     struct sctstr sect;
 226
 227     if (cno >= 0)
 228         getship(cno, &ship);
 229     for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
 230         plp = (struct plist *)qp;
 231         if (cno >= 0) {
 232             if (!could_be_on_ship(&plp->plane, &ship, 0, 0, 0, 0))
 233                 pr("\t%s cannot land on ship #%d! %s aborts!\n",
 234                    prplane(&plp->plane), cno, prplane(&plp->plane));
 235             else if (!put_plane_on_ship(&plp->plane, &ship))
 236                 pr("\tNo room on ship #%d! %s aborts!\n",
 237                    cno, prplane(&plp->plane));
 238             else {
 239                 if (plp->plane.pln_own != ship.shp_own) {
 240                     wu(0, ship.shp_own, "%s %s lands on your %s\n",
 241                        cname(player->cnum), prplane(&plp->plane),
 242                        prship(&ship));
 243                 }
 244             }
 245         } else {
 246             plp->plane.pln_x = tx;
 247             plp->plane.pln_y = ty;
 248             getsect(tx, ty, &sect);
 249             if (plp->plane.pln_own != sect.sct_own) {
 250                 wu(0, sect.sct_own,
 251                    "%s %s lands at your sector %s\n",
 252                    cname(player->cnum),
 253                    prplane(&plp->plane), xyas(tx, ty, sect.sct_own));
 254             }
 255             plp->plane.pln_ship = cno;
 256         }
 257     }
 258 }
 259
 260 void
 261 pln_dropoff(struct emp_qelem *list, struct ichrstr *ip, coord tx, coord ty,
 262             int cno)
 263 {
 264     struct emp_qelem *qp;
 265     struct plist *plp;
 266     int amt;
 267     struct sctstr sect;
 268     struct shpstr ship;
 269     int there;
 270     int max;
 271
 272     if (!ip)
 273         return;
 274     amt = 0;
 275     for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
 276         plp = (struct plist *)qp;
 277         amt += plp->load;
 278     }
 279     if (cno < 0) {
 280         getsect(tx, ty, &sect);
 281         if (!sect.sct_own) {
 282             if (sect.sct_type == SCT_WATER)
 283                 pr("Your %s sink like a rock!\n", ip->i_name);
 284             else
 285                 pr("Your %s vanish without a trace.\n", ip->i_name);
 286             return;
 287         }
 288         if (sect.sct_own != player->cnum
 289             && getrel(getnatp(sect.sct_own), player->cnum) != ALLIED) {
 290             pr("You don't own %s!  Cargo jettisoned...\n",
 291                xyas(tx, ty, player->cnum));
 292             return;
 293         }
 294         if (ip->i_uid == I_CIVIL && sect.sct_own != sect.sct_oldown) {
 295             pr("%s is occupied.  Your civilians suffer from identity crisis and die.\n",
 296                xyas(tx, ty, player->cnum));
 297             return;
 298         }
 299         there = sect.sct_item[ip->i_uid];
 300         max = ITEM_MAX;
 301     } else {
 302         getship(cno, &ship);
 303         there = ship.shp_item[ip->i_uid];
 304         max = mchr[ship.shp_type].m_item[ip->i_uid];
 305     }
 306     there += amt;
 307     if (there > max) {
 308         pr("%d excess %s discarded\n", max - there, ip->i_name);
 309         amt = max - there;
 310         there = max;
 311     }
 312     pr("%d %s landed safely", amt, ip->i_name);
 313     if (cno < 0) {
 314         sect.sct_item[ip->i_uid] = there;
 315         if (sect.sct_own != player->cnum)
 316             wu(0, sect.sct_own, "%s planes drop %d %s in %s\n",
 317                cname(player->cnum), amt, ip->i_name,
 318                xyas(tx, ty, sect.sct_own));
 319         pr(" at %s\n", xyas(tx, ty, player->cnum));
 320         putsect(&sect);
 321     } else {
 322         ship.shp_item[ip->i_uid] = there;
 323         if (ship.shp_own != player->cnum)
 324             wu(0, ship.shp_own, "%s planes land %d %s on carrier %d\n",
 325                cname(player->cnum), amt, ip->i_name, ship.shp_uid);
 326         pr(" on carrier #%d\n", ship.shp_uid);
 327         putship(ship.shp_uid, &ship);
 328     }
 329 }
 330
 331 void
 332 pln_mine(struct emp_qelem *list, coord tx, coord ty)
 333 {
 334     struct emp_qelem *qp;
 335     struct plist *plp;
 336     int amt;
 337     struct sctstr sect;
 338
 339     amt = 0;
 340     for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
 341         plp = (struct plist *)qp;
 342         amt += plp->load;
 343
 344     }
 345     if (amt > 0) {
 346         getsect(tx, ty, &sect);
 347         if (sect.sct_type != SCT_WATER) {
 348             pr("Your seamines have no effect here.\n");
 349             return;
 350         }
 351         sect.sct_mines = MIN(sect.sct_mines + amt, MINES_MAX);
 352         pr("%d mines laid in %s.\n", amt, xyas(tx, ty, player->cnum));
 353         if (map_set(player->cnum, tx, ty, 'X', 0))
 354             writemap(player->cnum);
 355         putsect(&sect);
 356     }
 357 }
 358
 359 /*
 360  * Has PP's type capabilities satisfying WANTFLAGS and NOWANTFLAGS?
 361  * A plane type is capable unless
 362  * - it lacks all of the P_B, P_T in WANTFLAGS, or
 363  * - it lacks all of the P_F, P_ESC in WANTFLAGS, or
 364  * - it lacks all of the P_E, P_L, P_K in WANTFLAGS, or
 365  * - it lacks any of the other capabilities in WANTFLAGS, or
 366  * - it has any of the capabilities in NOWANTFLAGS.
 367  */
 368 int
 369 pln_capable(struct plnstr *pp, int wantflags, int nowantflags)
 370 {
 371     int flags = plchr[(int)pp->pln_type].pl_flags;
 372
 373     if (wantflags & (P_B | P_T)) {
 374         if ((flags & wantflags & (P_B | P_T)) == 0)
 375             return 0;
 376         wantflags &= ~(P_B | P_T);
 377     }
 378
 379     if (wantflags & (P_F | P_ESC)) {
 380         if ((flags & wantflags & (P_F | P_ESC)) == 0)
 381             return 0;
 382         wantflags &= ~(P_F | P_ESC);
 383     }
 384
 385     if (wantflags & (P_E | P_L | P_K)) {
 386         if ((flags & wantflags & (P_E | P_L | P_K)) == 0)
 387             return 0;
 388         wantflags &= ~(P_E | P_L | P_K);
 389     }
 390
 391     if ((flags & wantflags) != wantflags)
 392         return 0;
 393
 394     if (flags & nowantflags)
 395         return 0;
 396
 397     return 1;
 398 }
 399
 400 /*
 401  * Return union of capabilities of planes in LIST.
 402  */
 403 int
 404 pln_caps(struct emp_qelem *list)
 405 {
 406     struct emp_qelem *qp;
 407     struct plist *plp;
 408     int fl;
 409
 410     fl = 0;
 411     for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
 412         plp = (struct plist *)qp;
 413         fl |= plp->pcp->pl_flags;
 414     }
 415
 416     return fl;
 417 }
 418
 419 /*
 420  * Find plane types that can operate from carrier SP.
 421  * If MSL find missile types, else non-missile types.
 422  * Return a combination of P_L, P_K, P_E.
 423  * It's zero if SP can't support air operations due to its type or
 424  * state (low efficiency).
 425  */
 426 int
 427 carrier_planes(struct shpstr *sp, int msl)
 428 {
 429     struct mchrstr *mcp = mchr + sp->shp_type;
 430     int res;
 431
 432     if (sp->shp_effic < SHP_AIROPS_EFF)
 433         return 0;
 434
 435     res = 0;
 436     if (mcp->m_flags & M_FLY)
 437         res |= P_L;
 438     if ((mcp->m_flags & M_MSL) && msl)
 439         res |= P_L;
 440     if (mcp->m_nchoppers && !msl)
 441         res |= P_K;
 442     if (mcp->m_nxlight)
 443         res |= P_E;
 444     return res;
 445 }
 446
 447 int
 448 pln_airbase_ok(struct plnstr *pp, int oneway, int noisy)
 449 {
 450     struct shpstr ship;
 451     struct lndstr land;
 452     struct sctstr sect;
 453     struct plchrstr *pcp = plchr + pp->pln_type;
 454
 455     if (CANT_HAPPEN(noisy && pp->pln_own != player->cnum))
 456         noisy = 0;
 457
 458     if (pp->pln_ship >= 0) {
 459         /* ship: needs to be own or allied, efficient */
 460         if (!getship(pp->pln_ship, &ship)) {
 461             CANT_REACH();
 462             return 0;
 463         }
 464         if (ship.shp_own != pp->pln_own
 465             && getrel(getnatp(ship.shp_own), pp->pln_own) != ALLIED) {
 466             if (noisy)
 467                 pr("(note) An ally does not own the ship %s is on\n",
 468                    prplane(pp));
 469             return 0;
 470         }
 471         if (!(carrier_planes(&ship, pcp->pl_flags & P_M) & pcp->pl_flags))
 472             return 0;
 473
 474     } else if (pp->pln_land >= 0) {
 475         /* land: needs to be own or allied, efficient, not embarked */
 476         if (!getland(pp->pln_land, &land)) {
 477             CANT_REACH();
 478             return 0;
 479         }
 480         if (land.lnd_own != pp->pln_own
 481             && getrel(getnatp(land.lnd_own), pp->pln_own) != ALLIED) {
 482             if (noisy)
 483                 pr("(note) An ally does not own the unit %s is on\n",
 484                    prplane(pp));
 485             return 0;
 486         }
 487         if (land.lnd_effic < LND_AIROPS_EFF || !(pcp->pl_flags & P_E))
 488             return 0;
 489         if (land.lnd_ship >= 0 || land.lnd_land >= 0)
 490             return 0;
 491
 492     } else {
 493         /* sector: needs to be own or allied, efficient airfield */
 494         if (!getsect(pp->pln_x, pp->pln_y, &sect)) {
 495             CANT_REACH();
 496             return 0;
 497         }
 498
 499         if (sect.sct_own != pp->pln_own
 500             && getrel(getnatp(sect.sct_own), pp->pln_own) != ALLIED) {
 501             if (noisy)
 502                 pr("(note) An ally does not own the sector %s is in\n",
 503                    prplane(pp));
 504             return 0;
 505         }
 506         /* need airfield unless VTOL */
 507         if ((pcp->pl_flags & P_V) == 0) {
 508             if (sect.sct_type != SCT_AIRPT) {
 509                 if (noisy)
 510                     pr("%s not at airport\n", prplane(pp));
 511                 return 0;
 512             }
 513             if (sect.sct_effic < 40) {
 514                 if (noisy)
 515                     pr("%s is not 40%% efficient, %s can't take off from there.\n",
 516                        xyas(sect.sct_x, sect.sct_y, pp->pln_own),
 517                        prplane(pp));
 518                 return 0;
 519             }
 520             if (!oneway && sect.sct_effic < 60) {
 521                 if (noisy)
 522                     pr("%s is not 60%% efficient, %s can't land there.\n",
 523                        xyas(sect.sct_x, sect.sct_y, pp->pln_own),
 524                        prplane(pp));
 525                 return 0;
 526             }
 527         }
 528     }
 529
 530     return 1;
 531 }
 532
 533 void
 534 pln_sel(struct nstr_item *ni, struct emp_qelem *list, struct sctstr *ap,
 535         int ap_to_target, int rangemult, int wantflags, int nowantflags)
 536 {
 537     struct plnstr plane;
 538     int range;
 539     struct plchrstr *pcp;
 540     struct plist *plp;
 541
 542     emp_initque(list);
 543     while (nxtitem(ni, &plane)) {
 544         if (!player->owner)
 545             continue;
 546         if (plane.pln_mobil <= 0)
 547             continue;
 548         if (plane.pln_effic < 40) {
 549             pr("%s not efficient enough (must be 40%%)\n",
 550                prplane(&plane));
 551             continue;
 552         }
 553         if (!pln_capable(&plane, wantflags, nowantflags))
 554             continue;
 555         if (opt_MARKET) {
 556             if (ontradingblock(EF_PLANE, &plane)) {
 557                 pr("plane #%d inelligible - it's for sale.\n",
 558                    plane.pln_uid);
 559                 continue;
 560             }
 561         }
 562
 563         range = mapdist(plane.pln_x, plane.pln_y, ap->sct_x, ap->sct_y);
 564         if (range > 4) {
 565             pr("%s too far from assembly point\n", prplane(&plane));
 566             continue;
 567         }
 568         range += ap_to_target;
 569         range *= rangemult;
 570         pcp = &plchr[(int)plane.pln_type];
 571         if (plane.pln_range < range) {
 572             pr("%s out of range (%d:%d)\n",
 573                prplane(&plane), plane.pln_range, range);
 574             continue;
 575         }
 576         if (!pln_airbase_ok(&plane, rangemult != 2, 1))
 577             continue;
 578         pr("%s standing by\n", prplane(&plane));
 579         plane.pln_mission = 0;
 580         putplane(plane.pln_uid, &plane);
 581         plp = malloc(sizeof(struct plist));
 582         plp->load = 0;
 583         plp->pcp = pcp;
 584         plp->plane = plane;
 585         emp_insque(&plp->queue, list);
 586     }
 587 }
 588
 589 void
 590 pln_arm(struct emp_qelem *list, int dist, char mission, struct ichrstr *ip)
 591 {
 592     struct emp_qelem *qp;
 593     struct emp_qelem *next;
 594     struct plist *plp;
 595     struct plnstr *pp;
 596
 597     for (qp = list->q_forw; qp != list; qp = next) {
 598         next = qp->q_forw;
 599         plp = (struct plist *)qp;
 600         pp = &plp->plane;
 601         getplane(pp->pln_uid, pp);
 602         if ((pp->pln_flags & PLN_LAUNCHED)
 603             || pln_equip(plp, ip, mission) < 0) {
 604             emp_remque(qp);
 605             free(qp);
 606             continue;
 607         }
 608         pp->pln_flags |= PLN_LAUNCHED;
 609         pp->pln_mobil -= pln_mobcost(dist, pp, mission);
 610         putplane(pp->pln_uid, pp);
 611         pr("%s equipped\n", prplane(pp));
 612     }
 613 }
 614
 615 int
 616 pln_equip(struct plist *plp, struct ichrstr *ip, char mission)
 617 {
 618     struct plchrstr *pcp;
 619     struct plnstr *pp;
 620     int load, needed;
 621     struct lndstr land;
 622     struct shpstr ship;
 623     struct sctstr sect;
 624     i_type itype;
 625     short *item;
 626     int own;
 627     int abandon_needed;
 628
 629     pp = &plp->plane;
 630     pcp = plp->pcp;
 631     if (pp->pln_ship >= 0) {
 632         getship(pp->pln_ship, &ship);
 633         item = ship.shp_item;
 634         own = ship.shp_own;
 635     } else if (pp->pln_land >= 0) {
 636         getland(pp->pln_land, &land);
 637         item = land.lnd_item;
 638         own = land.lnd_own;
 639     } else {
 640         getsect(pp->pln_x, pp->pln_y, &sect);
 641         item = sect.sct_item;
 642         own = sect.sct_oldown;
 643     }
 644     if (pcp->pl_fuel > item[I_PETROL]) {
 645         pr("%s not enough petrol there!\n", prplane(pp));
 646         return -1;
 647     }
 648     item[I_PETROL] -= pcp->pl_fuel;
 649     load = pln_load(pp);
 650     itype = I_NONE;
 651     switch (mission) {
 652     case 's':           /* strategic bomb */
 653     case 'p':           /* pinpoint bomb */
 654         if (nuk_on_plane(pp) >= 0)
 655             break;
 656         itype = I_SHELL;
 657         break;
 658     case 't':           /* transport */
 659         if (!(pcp->pl_flags & P_C) || !ip)
 660             break;
 661         itype = ip->i_uid;
 662         load *= 2;
 663         break;
 664     case 'm':           /* mine */
 665         if ((pcp->pl_flags & P_MINE) == 0)
 666             break;
 667         itype = I_SHELL;
 668         load *= 2;
 669         break;
 670     case 'd':           /* drop */
 671         if (!(pcp->pl_flags & P_C) || CANT_HAPPEN(!ip))
 672             break;
 673         itype = ip->i_uid;
 674         if (pcp->pl_flags & P_V)
 675             load *= 2;
 676         break;
 677     case 'a':           /* paradrop */
 678         if (!(pcp->pl_flags & P_P))
 679             break;
 680         itype = I_MILIT;
 681         if (pcp->pl_flags & P_V)
 682             load *= 2;
 683         break;
 684     case 'r':           /* reconnaissance */
 685     case 'e':           /* escort */
 686     case 'i':           /* missile interception */
 687         if (CANT_HAPPEN(!(pcp->pl_flags & P_M)
 688                         || !(pcp->pl_flags & (P_N | P_O))))
 689             break;
 690         if (load)
 691             itype = I_SHELL;
 692         break;
 693     default:
 694         CANT_REACH();
 695         load = 0;
 696     }
 697
 698     if (itype != I_NONE) {
 699         needed = load / ichr[itype].i_lbs;
 700         if (needed <= 0) {
 701             pr("%s can't contribute to mission\n", prplane(pp));
 702             return -1;
 703         }
 704         if (itype == I_CIVIL && pp->pln_own != own) {
 705             pr("You don't control those civilians!\n");
 706             return -1;
 707         }
 708 #if 0
 709         /* Supply is broken somewhere, so don't use it for now */
 710         if (itype == I_SHELL && item[itype] < needed)
 711             item[itype] += supply_commod(plp->plane.pln_own,
 712                                          plp->plane.pln_x,
 713                                          plp->plane.pln_y,
 714                                          I_SHELL, needed);
 715 #endif
 716         abandon_needed = !!would_abandon(&sect, itype, needed, NULL);
 717         if (item[itype] < needed + abandon_needed) {
 718             pr("Not enough %s for %s\n", ichr[itype].i_name, prplane(pp));
 719             return -1;
 720         }
 721         item[itype] -= needed;
 722         plp->load = needed;
 723     }
 724
 725     if (pp->pln_ship >= 0) {
 726         if (pp->pln_own != ship.shp_own) {
 727             wu(0, ship.shp_own,
 728                "%s %s prepares for takeoff from ship %s\n",
 729                cname(pp->pln_own), prplane(pp), prship(&ship));
 730         }
 731         putship(ship.shp_uid, &ship);
 732     } else if (pp->pln_land >= 0) {
 733         if (pp->pln_own != land.lnd_own) {
 734             wu(0, land.lnd_own,
 735                "%s %s prepares for takeoff from unit %s\n",
 736                cname(pp->pln_own), prplane(pp), prland(&land));
 737         }
 738         putland(land.lnd_uid, &land);
 739     } else {
 740         if (pp->pln_own != sect.sct_own) {
 741             wu(0, sect.sct_own, "%s %s prepares for takeoff from %s\n",
 742                cname(pp->pln_own), prplane(pp),
 743                xyas(sect.sct_x, sect.sct_y, sect.sct_own));
 744         }
 745         putsect(&sect);
 746     }
 747     return 0;
 748 }
 749
 750 void
 751 pln_put(struct emp_qelem *list)
 752 {
 753     struct emp_qelem *qp, *next;
 754
 755     for (qp = list->q_forw; qp != list; qp = next) {
 756         next = qp->q_forw;
 757         pln_put1((struct plist *)qp);
 758     }
 759 }
 760
 761 void
 762 pln_put1(struct plist *plp)
 763 {
 764     struct plnstr *pp;
 765     struct shpstr ship;
 766     struct sctstr sect;
 767
 768     pp = &plp->plane;
 769
 770     if (CANT_HAPPEN((pp->pln_flags & PLN_LAUNCHED)
 771                     && (plchr[pp->pln_type].pl_flags & P_M)
 772                     && pp->pln_effic >= PLANE_MINEFF))
 773         pp->pln_effic = 0;   /* bug: missile launched but not used up */
 774
 775     if (!(pp->pln_flags & PLN_LAUNCHED))
 776         ;                       /* never took off */
 777     else if (pp->pln_effic < PLANE_MINEFF) {
 778         ;                       /* destroyed */
 779     } else if (pp->pln_ship >= 0) {
 780         /* It is landing on a carrier */
 781         getship(pp->pln_ship, &ship);
 782         /* We should do more, like make sure it's really
 783            a carrier, etc. but for now just make sure it's
 784            not sunk. */
 785         if (ship.shp_effic < SHIP_MINEFF) {
 786             mpr(pp->pln_own,
 787                 "Ship #%d has been sunk, plane #%d has nowhere to land, and\n"
 788                 "splashes into the sea.\n",
 789                 pp->pln_ship, pp->pln_uid);
 790             pp->pln_effic = 0;
 791         }
 792     } else {
 793         /* Presume we are landing back in a sector. */
 794         getsect(pp->pln_x, pp->pln_y, &sect);
 795         if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_WASTE) {
 796             mpr(pp->pln_own,
 797                 "Nowhere to land at %s, plane #%d crashes and burns...\n",
 798                 xyas(pp->pln_x, pp->pln_y, pp->pln_own), pp->pln_uid);
 799             pp->pln_effic = 0;
 800         }
 801     }
 802     pp->pln_flags &= ~PLN_LAUNCHED;
 803     putplane(pp->pln_uid, pp);
 804     emp_remque(&plp->queue);
 805     free(plp);
 806 }
 807
 808 /*
 809  * Can PP be loaded on a ship of SP's type?
 810  * Assume that it already carries N planes, of which NCH are choppers,
 811  * NXL xlight, NMSL light missiles, and the rest are light fixed-wing
 812  * planes.
 813  */
 814 int
 815 could_be_on_ship(struct plnstr *pp, struct shpstr *sp,
 816                  int n, int nch, int nxl, int nmsl)
 817 {
 818     struct plchrstr *pcp = &plchr[pp->pln_type];
 819     struct mchrstr *mcp = &mchr[sp->shp_type];
 820
 821     if (pcp->pl_flags & P_K)
 822         nch++;
 823     else if (pcp->pl_flags & P_E)
 824         nxl++;
 825     else if (!(pcp->pl_flags & P_L))
 826         return 0;
 827     else if (pcp->pl_flags & P_M)
 828         nmsl++;
 829     n++;
 830
 831     n -= MIN(nch, mcp->m_nchoppers);
 832     n -= MIN(nxl, mcp->m_nxlight);
 833     if (nmsl && !(mcp->m_flags & (M_MSL | M_FLY)))
 834         return 0;               /* missile slots wanted */
 835     if (nmsl < n && !(mcp->m_flags & M_FLY))
 836         return 0;               /* fixed-wing slots wanted */
 837     return n <= mcp->m_nplanes;
 838 }
 839
 840 /*
 841  * Fit a plane of PP's type on ship SP.
 842  * Updating the plane accordingly is the caller's job.
 843  * Return whether it fits.
 844  */
 845 static int
 846 fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
 847 {
 848     int n, nch, nxl, nmsl;
 849
 850     n = shp_nplane(sp, &nch, &nxl, &nmsl);
 851     return could_be_on_ship(pp, sp, n, nch, nxl, nmsl);
 852 }
 853
 854 int
 855 put_plane_on_ship(struct plnstr *plane, struct shpstr *ship)
 856 {
 857     if (plane->pln_ship == ship->shp_uid)
 858         return 1;               /* Already on ship */
 859
 860     if (!fit_plane_on_ship(plane, ship))
 861         return 0;
 862
 863     plane->pln_x = ship->shp_x;
 864     plane->pln_y = ship->shp_y;
 865     plane->pln_ship = ship->shp_uid;
 866     putplane(plane->pln_uid, plane);
 867     return 1;
 868 }
 869
 870 /*
 871  * Fit a plane of PP's type on land unit LP.
 872  * Updating the plane accordingly is the caller's job.
 873  * Return whether it fits.
 874  */
 875 static int
 876 fit_plane_on_land(struct plnstr *pp, struct lndstr *lp)
 877 {
 878     struct plchrstr *pcp = plchr + pp->pln_type;
 879     struct lchrstr *lcp = lchr + lp->lnd_type;
 880
 881     return (pcp->pl_flags & P_E) && lnd_nxlight(lp) < lcp->l_nxlight;
 882 }
 883
 884 int
 885 put_plane_on_land(struct plnstr *plane, struct lndstr *land)
 886 {
 887     if (plane->pln_land == land->lnd_uid)
 888         return 1;               /* Already on unit */
 889
 890     if (!fit_plane_on_land(plane, land))
 891         return 0;
 892
 893     plane->pln_x = land->lnd_x;
 894     plane->pln_y = land->lnd_y;
 895     plane->pln_land = land->lnd_uid;
 896     putplane(plane->pln_uid, plane);
 897     return 1;
 898 }
 899
 900 void
 901 plane_sweep(struct emp_qelem *plane_list, coord x, coord y)
 902 {
 903     struct plnstr *pp;
 904     struct plchrstr *pcp;
 905     struct emp_qelem *qp;
 906     struct emp_qelem *next;
 907     struct plist *ip;
 908     struct sctstr sect;
 909     int mines_there;
 910     int found = 0;
 911
 912     getsect(x, y, &sect);
 913     mines_there = sect.sct_mines;
 914
 915     if (mines_there == 0)
 916         return;
 917
 918     if (sect.sct_type != SCT_WATER)
 919         return;
 920
 921     for (qp = plane_list->q_forw; ((qp != plane_list) && (mines_there));
 922          qp = next) {
 923         next = qp->q_forw;
 924         ip = (struct plist *)qp;
 925         pp = &ip->plane;
 926         pcp = ip->pcp;
 927         if (!(pcp->pl_flags & P_SWEEP)) /* if it isn't an sweep plane */
 928             continue;
 929
 930         if (chance((100.0 - pln_acc(pp)) / 100.0)) {
 931             pr("Sweep! in %s\n",
 932                xyas(sect.sct_x, sect.sct_y, pp->pln_own));
 933             mines_there--;
 934             found = 1;
 935         }
 936     }
 937
 938     if (found && map_set(player->cnum, sect.sct_x, sect.sct_y, 'X', 0))
 939         writemap(player->cnum);
 940     sect.sct_mines = mines_there;
 941     putsect(&sect);
 942 }
 943
 944 int
 945 pln_hitchance(struct plnstr *pp, int hardtarget, int type)
 946 {
 947     struct plchrstr *pcp = plchr + pp->pln_type;
 948     double tfact = (double)(pp->pln_tech - pcp->pl_tech) /
 949         (pp->pln_tech - pcp->pl_tech / 2);
 950     int acc = pln_acc(pp);
 951     int hitchance;
 952
 953     if (type == EF_SHIP) {
 954         if (pcp->pl_flags & P_A)
 955             acc -= 20;
 956         if (!(pcp->pl_flags & P_T))
 957             acc += 35;
 958     }
 959     hitchance = (int)(pp->pln_effic * (1.0 - 0.1 * tfact) *
 960                       (1.0 - acc / 100.0)) - hardtarget;
 961
 962     /* smooth out the bottom of the graph with asymtote at 5 -KHS */
 963     if (hitchance < 20)
 964         hitchance = 5 + ldround(300.0 / (40.0 - hitchance), 1);
 965     if (hitchance > 100)
 966         hitchance = 100;
 967     return hitchance;
 968 }
 969
 970 /* return 0 if there was a nuclear detonation */
 971
 972 int
 973 pln_damage(struct plnstr *pp, coord x, coord y, char type, int *nukedamp,
 974            int noisy)
 975 {
 976     struct nukstr nuke;
 977     struct plchrstr *pcp = plchr + pp->pln_type;
 978     int load, i;
 979     int hitroll;
 980     int dam = 0;
 981     int aim;
 982     int effective = 1;
 983     int pinbomber = 0;
 984
 985     if (getnuke(nuk_on_plane(pp), &nuke)) {
 986         mpr(pp->pln_own, "Releasing RV's for %s detonation...\n",
 987             pp->pln_flags & PLN_AIRBURST ? "airburst" : "groundburst");
 988         *nukedamp = detonate(&nuke, x, y,
 989                              pp->pln_flags & PLN_AIRBURST);
 990         return 0;
 991     }
 992     *nukedamp = 0;
 993
 994     load = pln_load(pp);
 995     if (!load)                 /* e.g. ab, blowing up on launch pad */
 996         return 0;
 997
 998     i = roll(load) + 1;
 999     if (i > load)
1000         i = load;
1001
1002     if (pcp->pl_flags & P_M) {
1003         if (pcp->pl_flags & P_MAR)
1004             pinbomber = 1;
1005     } else if (pcp->pl_flags & P_T)
1006         pinbomber = 1;
1007
1008     aim = pln_acc(pp);
1009     if (type == 's') {
1010         effective = !pinbomber;
1011         aim = 30 + (pinbomber ? aim : 100 - aim);
1012     } else {
1013         effective = pinbomber;
1014         aim = 100 - aim;
1015     }
1016
1017     while (i--) {
1018         dam += roll(6);
1019         hitroll = roll(100);
1020         if (hitroll >= 90) {
1021             dam += 8;
1022             if (noisy)
1023                 mpr(pp->pln_own, "BLAM");
1024         } else if (hitroll < aim) {
1025             dam += 5;
1026             if (noisy)
1027                 mpr(pp->pln_own, "Blam");
1028         } else {
1029             dam += 1;
1030             if (noisy)
1031                 mpr(pp->pln_own, "blam");
1032         }
1033         if (i && noisy)
1034             mpr(pp->pln_own, "-");
1035     }
1036     if (noisy)
1037         mpr(pp->pln_own, "\n");
1038     if (effective)
1039         dam *= 2;
1040     return dam;
1041 }
1042
1043 int
1044 pln_identchance(struct plnstr *pp, int hardtarget, int type)
1045 {
1046     double misschance =
1047         (100.0 - pln_hitchance(pp, hardtarget, type)) / 100.0;
1048     return (int)(100 - 100 * misschance * misschance);
1049 }
1050
1051 int
1052 pln_mobcost(int dist, struct plnstr *pp, char mission)
1053 {
1054     double cost;
1055
1056     cost = 20.0 / (pp->pln_effic / 100.0);
1057     if (mission == 'e' || mission == 0)
1058         cost /= 2;              /* escort or intercept */
1059
1060     return ldround(cost * dist / pln_range_max(pp) + 5, 1);
1061 }
1062
1063 int
1064 pln_is_in_orbit(struct plnstr *pp)
1065 {
1066     return (plchr[pp->pln_type].pl_flags & (P_M | P_O)) == P_O
1067         && (pp->pln_flags & PLN_LAUNCHED);
1068 }
1069
1070 /*
1071  * Set PP's tech to TLEV along with everything else that depends on it.
1072  */
1073 void
1074 pln_set_tech(struct plnstr *pp, int tlev)
1075 {
1076     struct plchrstr *pcp = plchr + pp->pln_type;
1077     int limited_range = pp->pln_range < pln_range_max(pp);
1078     int range_max;
1079
1080     if (CANT_HAPPEN(tlev < pcp->pl_tech))
1081         tlev = pcp->pl_tech;
1082     pp->pln_tech = tlev;
1083
1084     range_max = pln_range_max(pp);
1085     if (!limited_range || pp->pln_range > range_max)
1086         pp->pln_range = range_max;
1087 }