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         itype = I_SHELL;
 655         break;
 656     case 't':           /* transport */
 657         if (!(pcp->pl_flags & P_C) || !ip)
 658             break;
 659         itype = ip->i_uid;
 660         load *= 2;
 661         break;
 662     case 'm':           /* mine */
 663         if ((pcp->pl_flags & P_MINE) == 0)
 664             break;
 665         itype = I_SHELL;
 666         load *= 2;
 667         break;
 668     case 'd':           /* drop */
 669         if (!(pcp->pl_flags & P_C) || CANT_HAPPEN(!ip))
 670             break;
 671         itype = ip->i_uid;
 672         if (pcp->pl_flags & P_V)
 673             load *= 2;
 674         break;
 675     case 'a':           /* paradrop */
 676         if (!(pcp->pl_flags & P_P))
 677             break;
 678         itype = I_MILIT;
 679         if (pcp->pl_flags & P_V)
 680             load *= 2;
 681         break;
 682     case 'r':           /* reconnaissance */
 683     case 'e':           /* escort */
 684     case 'i':           /* missile interception */
 685         if (CANT_HAPPEN(!(pcp->pl_flags & P_M)
 686                         || !(pcp->pl_flags & (P_N | P_O))))
 687             break;
 688         if (load)
 689             itype = I_SHELL;
 690         break;
 691     default:
 692         CANT_REACH();
 693         load = 0;
 694     }
 695
 696     if (itype != I_NONE) {
 697         needed = load / ichr[itype].i_lbs;
 698         if (needed <= 0) {
 699             pr("%s can't contribute to mission\n", prplane(pp));
 700             return -1;
 701         }
 702         if (nuk_on_plane(pp) >= 0) {
 703             if (mission == 's' || mission == 't')
 704                 needed = 0;
 705             else {
 706                 pr("%s can't fly this mission"
 707                    " while it is carrying a nuclear weapon",
 708                    prplane(pp));
 709                 return -1;
 710             }
 711         }
 712         if (itype == I_CIVIL && pp->pln_own != own) {
 713             pr("You don't control those civilians!\n");
 714             return -1;
 715         }
 716 #if 0
 717         /* Supply is broken somewhere, so don't use it for now */
 718         if (itype == I_SHELL && item[itype] < needed)
 719             item[itype] += supply_commod(plp->plane.pln_own,
 720                                          plp->plane.pln_x,
 721                                          plp->plane.pln_y,
 722                                          I_SHELL, needed);
 723 #endif
 724         abandon_needed = !!would_abandon(&sect, itype, needed, NULL);
 725         if (item[itype] < needed + abandon_needed) {
 726             pr("Not enough %s for %s\n", ichr[itype].i_name, prplane(pp));
 727             return -1;
 728         }
 729         item[itype] -= needed;
 730         plp->load = needed;
 731     }
 732
 733     if (pp->pln_ship >= 0) {
 734         if (pp->pln_own != ship.shp_own) {
 735             wu(0, ship.shp_own,
 736                "%s %s prepares for takeoff from ship %s\n",
 737                cname(pp->pln_own), prplane(pp), prship(&ship));
 738         }
 739         putship(ship.shp_uid, &ship);
 740     } else if (pp->pln_land >= 0) {
 741         if (pp->pln_own != land.lnd_own) {
 742             wu(0, land.lnd_own,
 743                "%s %s prepares for takeoff from unit %s\n",
 744                cname(pp->pln_own), prplane(pp), prland(&land));
 745         }
 746         putland(land.lnd_uid, &land);
 747     } else {
 748         if (pp->pln_own != sect.sct_own) {
 749             wu(0, sect.sct_own, "%s %s prepares for takeoff from %s\n",
 750                cname(pp->pln_own), prplane(pp),
 751                xyas(sect.sct_x, sect.sct_y, sect.sct_own));
 752         }
 753         putsect(&sect);
 754     }
 755     return 0;
 756 }
 757
 758 void
 759 pln_put(struct emp_qelem *list)
 760 {
 761     struct emp_qelem *qp, *next;
 762
 763     for (qp = list->q_forw; qp != list; qp = next) {
 764         next = qp->q_forw;
 765         pln_put1((struct plist *)qp);
 766     }
 767 }
 768
 769 void
 770 pln_put1(struct plist *plp)
 771 {
 772     struct plnstr *pp;
 773     struct shpstr ship;
 774     struct sctstr sect;
 775
 776     pp = &plp->plane;
 777
 778     if (CANT_HAPPEN((pp->pln_flags & PLN_LAUNCHED)
 779                     && (plchr[pp->pln_type].pl_flags & P_M)
 780                     && pp->pln_effic >= PLANE_MINEFF))
 781         pp->pln_effic = 0;   /* bug: missile launched but not used up */
 782
 783     if (!(pp->pln_flags & PLN_LAUNCHED))
 784         ;                       /* never took off */
 785     else if (pp->pln_effic < PLANE_MINEFF) {
 786         ;                       /* destroyed */
 787     } else if (pp->pln_ship >= 0) {
 788         /* It is landing on a carrier */
 789         getship(pp->pln_ship, &ship);
 790         /* We should do more, like make sure it's really
 791            a carrier, etc. but for now just make sure it's
 792            not sunk. */
 793         if (ship.shp_effic < SHIP_MINEFF) {
 794             mpr(pp->pln_own,
 795                 "Ship #%d has been sunk, plane #%d has nowhere to land, and\n"
 796                 "splashes into the sea.\n",
 797                 pp->pln_ship, pp->pln_uid);
 798             pp->pln_effic = 0;
 799         }
 800     } else {
 801         /* Presume we are landing back in a sector. */
 802         getsect(pp->pln_x, pp->pln_y, &sect);
 803         if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_WASTE) {
 804             mpr(pp->pln_own,
 805                 "Nowhere to land at %s, plane #%d crashes and burns...\n",
 806                 xyas(pp->pln_x, pp->pln_y, pp->pln_own), pp->pln_uid);
 807             pp->pln_effic = 0;
 808         }
 809     }
 810     pp->pln_flags &= ~PLN_LAUNCHED;
 811     putplane(pp->pln_uid, pp);
 812     emp_remque(&plp->queue);
 813     free(plp);
 814 }
 815
 816 /*
 817  * Can PP be loaded on a ship of SP's type?
 818  * Assume that it already carries N planes, of which NCH are choppers,
 819  * NXL xlight, NMSL light missiles, and the rest are light fixed-wing
 820  * planes.
 821  */
 822 int
 823 could_be_on_ship(struct plnstr *pp, struct shpstr *sp,
 824                  int n, int nch, int nxl, int nmsl)
 825 {
 826     struct plchrstr *pcp = &plchr[pp->pln_type];
 827     struct mchrstr *mcp = &mchr[sp->shp_type];
 828
 829     if (pcp->pl_flags & P_K)
 830         nch++;
 831     else if (pcp->pl_flags & P_E)
 832         nxl++;
 833     else if (!(pcp->pl_flags & P_L))
 834         return 0;
 835     else if (pcp->pl_flags & P_M)
 836         nmsl++;
 837     n++;
 838
 839     n -= MIN(nch, mcp->m_nchoppers);
 840     n -= MIN(nxl, mcp->m_nxlight);
 841     if (nmsl && !(mcp->m_flags & (M_MSL | M_FLY)))
 842         return 0;               /* missile slots wanted */
 843     if (nmsl < n && !(mcp->m_flags & M_FLY))
 844         return 0;               /* fixed-wing slots wanted */
 845     return n <= mcp->m_nplanes;
 846 }
 847
 848 /*
 849  * Fit a plane of PP's type on ship SP.
 850  * Updating the plane accordingly is the caller's job.
 851  * Return whether it fits.
 852  */
 853 static int
 854 fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
 855 {
 856     int n, nch, nxl, nmsl;
 857
 858     n = shp_nplane(sp, &nch, &nxl, &nmsl);
 859     return could_be_on_ship(pp, sp, n, nch, nxl, nmsl);
 860 }
 861
 862 int
 863 put_plane_on_ship(struct plnstr *plane, struct shpstr *ship)
 864 {
 865     if (plane->pln_ship == ship->shp_uid)
 866         return 1;               /* Already on ship */
 867
 868     if (!fit_plane_on_ship(plane, ship))
 869         return 0;
 870
 871     plane->pln_x = ship->shp_x;
 872     plane->pln_y = ship->shp_y;
 873     plane->pln_ship = ship->shp_uid;
 874     putplane(plane->pln_uid, plane);
 875     return 1;
 876 }
 877
 878 /*
 879  * Fit a plane of PP's type on land unit LP.
 880  * Updating the plane accordingly is the caller's job.
 881  * Return whether it fits.
 882  */
 883 static int
 884 fit_plane_on_land(struct plnstr *pp, struct lndstr *lp)
 885 {
 886     struct plchrstr *pcp = plchr + pp->pln_type;
 887     struct lchrstr *lcp = lchr + lp->lnd_type;
 888
 889     return (pcp->pl_flags & P_E) && lnd_nxlight(lp) < lcp->l_nxlight;
 890 }
 891
 892 int
 893 put_plane_on_land(struct plnstr *plane, struct lndstr *land)
 894 {
 895     if (plane->pln_land == land->lnd_uid)
 896         return 1;               /* Already on unit */
 897
 898     if (!fit_plane_on_land(plane, land))
 899         return 0;
 900
 901     plane->pln_x = land->lnd_x;
 902     plane->pln_y = land->lnd_y;
 903     plane->pln_land = land->lnd_uid;
 904     putplane(plane->pln_uid, plane);
 905     return 1;
 906 }
 907
 908 void
 909 plane_sweep(struct emp_qelem *plane_list, coord x, coord y)
 910 {
 911     struct plnstr *pp;
 912     struct plchrstr *pcp;
 913     struct emp_qelem *qp;
 914     struct emp_qelem *next;
 915     struct plist *ip;
 916     struct sctstr sect;
 917     int mines_there;
 918     int found = 0;
 919
 920     getsect(x, y, &sect);
 921     mines_there = sect.sct_mines;
 922
 923     if (mines_there == 0)
 924         return;
 925
 926     if (sect.sct_type != SCT_WATER)
 927         return;
 928
 929     for (qp = plane_list->q_forw; ((qp != plane_list) && (mines_there));
 930          qp = next) {
 931         next = qp->q_forw;
 932         ip = (struct plist *)qp;
 933         pp = &ip->plane;
 934         pcp = ip->pcp;
 935         if (!(pcp->pl_flags & P_SWEEP)) /* if it isn't an sweep plane */
 936             continue;
 937
 938         if (chance((100.0 - pln_acc(pp)) / 100.0)) {
 939             pr("Sweep! in %s\n",
 940                xyas(sect.sct_x, sect.sct_y, pp->pln_own));
 941             mines_there--;
 942             found = 1;
 943         }
 944     }
 945
 946     if (found && map_set(player->cnum, sect.sct_x, sect.sct_y, 'X', 0))
 947         writemap(player->cnum);
 948     sect.sct_mines = mines_there;
 949     putsect(&sect);
 950 }
 951
 952 int
 953 pln_hitchance(struct plnstr *pp, int hardtarget, int type)
 954 {
 955     struct plchrstr *pcp = plchr + pp->pln_type;
 956     double tfact = (double)(pp->pln_tech - pcp->pl_tech) /
 957         (pp->pln_tech - pcp->pl_tech / 2);
 958     int acc = pln_acc(pp);
 959     int hitchance;
 960
 961     if (type == EF_SHIP) {
 962         if (pcp->pl_flags & P_A)
 963             acc -= 20;
 964         if (!(pcp->pl_flags & P_T))
 965             acc += 35;
 966     }
 967     hitchance = (int)(pp->pln_effic * (1.0 - 0.1 * tfact) *
 968                       (1.0 - acc / 100.0)) - hardtarget;
 969
 970     /* smooth out the bottom of the graph with asymtote at 5 -KHS */
 971     if (hitchance < 20)
 972         hitchance = 5 + ldround(300.0 / (40.0 - hitchance), 1);
 973     if (hitchance > 100)
 974         hitchance = 100;
 975     return hitchance;
 976 }
 977
 978 int
 979 pln_damage(struct plnstr *pp, char type, int noisy)
 980 {
 981     struct plchrstr *pcp = plchr + pp->pln_type;
 982     int load, i;
 983     int hitroll;
 984     int dam = 0;
 985     int aim;
 986     int effective = 1;
 987     int pinbomber = 0;
 988
 989     if (CANT_HAPPEN(nuk_on_plane(pp) >= 0)) /* FIXME check uses! */
 990         return 0;
 991
 992     load = pln_load(pp);
 993     if (!load)                 /* e.g. ab, blowing up on launch pad */
 994         return 0;
 995
 996     i = roll(load) + 1;
 997     if (i > load)
 998         i = load;
 999
1000     if (pcp->pl_flags & P_M) {
1001         if (pcp->pl_flags & P_MAR)
1002             pinbomber = 1;
1003     } else if (pcp->pl_flags & P_T)
1004         pinbomber = 1;
1005
1006     aim = pln_acc(pp);
1007     if (type == 's') {
1008         effective = !pinbomber;
1009         aim = 30 + (pinbomber ? aim : 100 - aim);
1010     } else {
1011         effective = pinbomber;
1012         aim = 100 - aim;
1013     }
1014
1015     while (i--) {
1016         dam += roll(6);
1017         hitroll = roll(100);
1018         if (hitroll >= 90) {
1019             dam += 8;
1020             if (noisy)
1021                 mpr(pp->pln_own, "BLAM");
1022         } else if (hitroll < aim) {
1023             dam += 5;
1024             if (noisy)
1025                 mpr(pp->pln_own, "Blam");
1026         } else {
1027             dam += 1;
1028             if (noisy)
1029                 mpr(pp->pln_own, "blam");
1030         }
1031         if (i && noisy)
1032             mpr(pp->pln_own, "-");
1033     }
1034     if (noisy)
1035         mpr(pp->pln_own, "\n");
1036     if (effective)
1037         dam *= 2;
1038     return dam;
1039 }
1040
1041 int
1042 pln_identchance(struct plnstr *pp, int hardtarget, int type)
1043 {
1044     double misschance =
1045         (100.0 - pln_hitchance(pp, hardtarget, type)) / 100.0;
1046     return (int)(100 - 100 * misschance * misschance);
1047 }
1048
1049 int
1050 pln_mobcost(int dist, struct plnstr *pp, char mission)
1051 {
1052     double cost;
1053
1054     cost = 20.0 / (pp->pln_effic / 100.0);
1055     if (mission == 'e' || mission == 0)
1056         cost /= 2;              /* escort or intercept */
1057
1058     return ldround(cost * dist / pln_range_max(pp) + 5, 1);
1059 }
1060
1061 int
1062 pln_is_in_orbit(struct plnstr *pp)
1063 {
1064     return (plchr[pp->pln_type].pl_flags & (P_M | P_O)) == P_O
1065         && (pp->pln_flags & PLN_LAUNCHED);
1066 }
1067
1068 /*
1069  * Set PP's tech to TLEV along with everything else that depends on it.
1070  */
1071 void
1072 pln_set_tech(struct plnstr *pp, int tlev)
1073 {
1074     struct plchrstr *pcp = plchr + pp->pln_type;
1075     int limited_range = pp->pln_range < pln_range_max(pp);
1076     int range_max;
1077
1078     if (CANT_HAPPEN(tlev < pcp->pl_tech))
1079         tlev = pcp->pl_tech;
1080     pp->pln_tech = tlev;
1081
1082     range_max = pln_range_max(pp);
1083     if (!limited_range || pp->pln_range > range_max)
1084         pp->pln_range = range_max;
1085 }