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-2010, 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         load = 0;
 685         break;
 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 (nuk_on_plane(pp) >= 0) {
 705             if (mission == 's' || mission == 't')
 706                 needed = 0;
 707             else {
 708                 pr("%s can't fly this mission"
 709                    " while it is carrying a nuclear weapon",
 710                    prplane(pp));
 711                 return -1;
 712             }
 713         }
 714         if (itype == I_CIVIL && pp->pln_own != own) {
 715             pr("You don't control those civilians!\n");
 716             return -1;
 717         }
 718 #if 0
 719         /* Supply is broken somewhere, so don't use it for now */
 720         if (itype == I_SHELL && item[itype] < needed)
 721             item[itype] += supply_commod(plp->plane.pln_own,
 722                                          plp->plane.pln_x,
 723                                          plp->plane.pln_y,
 724                                          I_SHELL, needed);
 725 #endif
 726         abandon_needed = !!would_abandon(&sect, itype, needed, NULL);
 727         if (item[itype] < needed + abandon_needed) {
 728             pr("Not enough %s for %s\n", ichr[itype].i_name, prplane(pp));
 729             return -1;
 730         }
 731         item[itype] -= needed;
 732         plp->load = needed;
 733     }
 734
 735     if (pp->pln_ship >= 0) {
 736         if (pp->pln_own != ship.shp_own) {
 737             wu(0, ship.shp_own,
 738                "%s %s prepares for takeoff from ship %s\n",
 739                cname(pp->pln_own), prplane(pp), prship(&ship));
 740         }
 741         putship(ship.shp_uid, &ship);
 742     } else if (pp->pln_land >= 0) {
 743         if (pp->pln_own != land.lnd_own) {
 744             wu(0, land.lnd_own,
 745                "%s %s prepares for takeoff from unit %s\n",
 746                cname(pp->pln_own), prplane(pp), prland(&land));
 747         }
 748         putland(land.lnd_uid, &land);
 749     } else {
 750         if (pp->pln_own != sect.sct_own) {
 751             wu(0, sect.sct_own, "%s %s prepares for takeoff from %s\n",
 752                cname(pp->pln_own), prplane(pp),
 753                xyas(sect.sct_x, sect.sct_y, sect.sct_own));
 754         }
 755         putsect(&sect);
 756     }
 757     return 0;
 758 }
 759
 760 void
 761 pln_put(struct emp_qelem *list)
 762 {
 763     struct emp_qelem *qp, *next;
 764
 765     for (qp = list->q_forw; qp != list; qp = next) {
 766         next = qp->q_forw;
 767         pln_put1((struct plist *)qp);
 768     }
 769 }
 770
 771 void
 772 pln_put1(struct plist *plp)
 773 {
 774     struct plnstr *pp;
 775     struct shpstr ship;
 776     struct sctstr sect;
 777
 778     pp = &plp->plane;
 779
 780     if (CANT_HAPPEN((pp->pln_flags & PLN_LAUNCHED)
 781                     && (plchr[pp->pln_type].pl_flags & P_M)
 782                     && pp->pln_effic >= PLANE_MINEFF))
 783         pp->pln_effic = 0;   /* bug: missile launched but not used up */
 784
 785     if (!(pp->pln_flags & PLN_LAUNCHED))
 786         ;                       /* never took off */
 787     else if (pp->pln_effic < PLANE_MINEFF) {
 788         ;                       /* destroyed */
 789     } else if (pp->pln_ship >= 0) {
 790         /* It is landing on a carrier */
 791         getship(pp->pln_ship, &ship);
 792         /* We should do more, like make sure it's really
 793            a carrier, etc. but for now just make sure it's
 794            not sunk. */
 795         if (ship.shp_effic < SHIP_MINEFF) {
 796             mpr(pp->pln_own,
 797                 "Ship #%d has been sunk, plane #%d has nowhere to land, and\n"
 798                 "splashes into the sea.\n",
 799                 pp->pln_ship, pp->pln_uid);
 800             pp->pln_effic = 0;
 801         }
 802     } else {
 803         /* Presume we are landing back in a sector. */
 804         getsect(pp->pln_x, pp->pln_y, &sect);
 805         if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_WASTE) {
 806             mpr(pp->pln_own,
 807                 "Nowhere to land at %s, plane #%d crashes and burns...\n",
 808                 xyas(pp->pln_x, pp->pln_y, pp->pln_own), pp->pln_uid);
 809             pp->pln_effic = 0;
 810         }
 811     }
 812     pp->pln_flags &= ~PLN_LAUNCHED;
 813     putplane(pp->pln_uid, pp);
 814     emp_remque(&plp->queue);
 815     free(plp);
 816 }
 817
 818 /*
 819  * Can PP be loaded on a ship of SP's type?
 820  * Assume that it already carries N planes, of which NCH are choppers,
 821  * NXL xlight, NMSL light missiles, and the rest are light fixed-wing
 822  * planes.
 823  */
 824 int
 825 could_be_on_ship(struct plnstr *pp, struct shpstr *sp,
 826                  int n, int nch, int nxl, int nmsl)
 827 {
 828     struct plchrstr *pcp = &plchr[pp->pln_type];
 829     struct mchrstr *mcp = &mchr[sp->shp_type];
 830
 831     if (pcp->pl_flags & P_K)
 832         nch++;
 833     else if (pcp->pl_flags & P_E)
 834         nxl++;
 835     else if (!(pcp->pl_flags & P_L))
 836         return 0;
 837     else if (pcp->pl_flags & P_M)
 838         nmsl++;
 839     n++;
 840
 841     n -= MIN(nch, mcp->m_nchoppers);
 842     n -= MIN(nxl, mcp->m_nxlight);
 843     if (nmsl && !(mcp->m_flags & (M_MSL | M_FLY)))
 844         return 0;               /* missile slots wanted */
 845     if (nmsl < n && !(mcp->m_flags & M_FLY))
 846         return 0;               /* fixed-wing slots wanted */
 847     return n <= mcp->m_nplanes;
 848 }
 849
 850 /*
 851  * Fit a plane of PP's type on ship SP.
 852  * Updating the plane accordingly is the caller's job.
 853  * Return whether it fits.
 854  */
 855 static int
 856 fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
 857 {
 858     int n, nch, nxl, nmsl;
 859
 860     n = shp_nplane(sp, &nch, &nxl, &nmsl);
 861     return could_be_on_ship(pp, sp, n, nch, nxl, nmsl);
 862 }
 863
 864 int
 865 put_plane_on_ship(struct plnstr *plane, struct shpstr *ship)
 866 {
 867     if (plane->pln_ship == ship->shp_uid)
 868         return 1;               /* Already on ship */
 869
 870     if (!fit_plane_on_ship(plane, ship))
 871         return 0;
 872
 873     plane->pln_x = ship->shp_x;
 874     plane->pln_y = ship->shp_y;
 875     plane->pln_ship = ship->shp_uid;
 876     putplane(plane->pln_uid, plane);
 877     return 1;
 878 }
 879
 880 /*
 881  * Fit a plane of PP's type on land unit LP.
 882  * Updating the plane accordingly is the caller's job.
 883  * Return whether it fits.
 884  */
 885 static int
 886 fit_plane_on_land(struct plnstr *pp, struct lndstr *lp)
 887 {
 888     struct plchrstr *pcp = plchr + pp->pln_type;
 889     struct lchrstr *lcp = lchr + lp->lnd_type;
 890
 891     return (pcp->pl_flags & P_E) && lnd_nxlight(lp) < lcp->l_nxlight;
 892 }
 893
 894 int
 895 put_plane_on_land(struct plnstr *plane, struct lndstr *land)
 896 {
 897     if (plane->pln_land == land->lnd_uid)
 898         return 1;               /* Already on unit */
 899
 900     if (!fit_plane_on_land(plane, land))
 901         return 0;
 902
 903     plane->pln_x = land->lnd_x;
 904     plane->pln_y = land->lnd_y;
 905     plane->pln_land = land->lnd_uid;
 906     putplane(plane->pln_uid, plane);
 907     return 1;
 908 }
 909
 910 void
 911 plane_sweep(struct emp_qelem *plane_list, coord x, coord y)
 912 {
 913     struct plnstr *pp;
 914     struct plchrstr *pcp;
 915     struct emp_qelem *qp;
 916     struct emp_qelem *next;
 917     struct plist *ip;
 918     struct sctstr sect;
 919     int mines_there;
 920     int found = 0;
 921
 922     getsect(x, y, &sect);
 923     mines_there = sect.sct_mines;
 924
 925     if (mines_there == 0)
 926         return;
 927
 928     if (sect.sct_type != SCT_WATER)
 929         return;
 930
 931     for (qp = plane_list->q_forw; ((qp != plane_list) && (mines_there));
 932          qp = next) {
 933         next = qp->q_forw;
 934         ip = (struct plist *)qp;
 935         pp = &ip->plane;
 936         pcp = ip->pcp;
 937         if (!(pcp->pl_flags & P_SWEEP)) /* if it isn't an sweep plane */
 938             continue;
 939
 940         if (chance((100.0 - pln_acc(pp)) / 100.0)) {
 941             pr("Sweep! in %s\n",
 942                xyas(sect.sct_x, sect.sct_y, pp->pln_own));
 943             mines_there--;
 944             found = 1;
 945         }
 946     }
 947
 948     if (found && map_set(player->cnum, sect.sct_x, sect.sct_y, 'X', 0))
 949         writemap(player->cnum);
 950     sect.sct_mines = mines_there;
 951     putsect(&sect);
 952 }
 953
 954 int
 955 pln_hitchance(struct plnstr *pp, int hardtarget, int type)
 956 {
 957     struct plchrstr *pcp = plchr + pp->pln_type;
 958     double tfact = (double)(pp->pln_tech - pcp->pl_tech) /
 959         (pp->pln_tech - pcp->pl_tech / 2);
 960     int acc = pln_acc(pp);
 961     int hitchance;
 962
 963     if (type == EF_SHIP) {
 964         if (pcp->pl_flags & P_A)
 965             acc -= 20;
 966         if (!(pcp->pl_flags & P_T))
 967             acc += 35;
 968     }
 969     hitchance = (int)(pp->pln_effic * (1.0 - 0.1 * tfact) *
 970                       (1.0 - acc / 100.0)) - hardtarget;
 971
 972     /* smooth out the bottom of the graph with asymtote at 5 -KHS */
 973     if (hitchance < 20)
 974         hitchance = 5 + ldround(300.0 / (40.0 - hitchance), 1);
 975     if (hitchance > 100)
 976         hitchance = 100;
 977     return hitchance;
 978 }
 979
 980 int
 981 pln_damage(struct plnstr *pp, char type, int noisy)
 982 {
 983     struct plchrstr *pcp = plchr + pp->pln_type;
 984     int load, i;
 985     int hitroll;
 986     int dam = 0;
 987     int aim;
 988     int effective = 1;
 989     int pinbomber = 0;
 990
 991     if (CANT_HAPPEN(nuk_on_plane(pp) >= 0)) /* FIXME check uses! */
 992         return 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 }