/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Copyright (C) 1986-2009, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
*
* ---
*
- * See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
- * related information and legal notices. It is expected that any future
- * projects/authors will amend these files as needed.
+ * See files README, COPYING and CREDITS in the root of the source
+ * tree for related information and legal notices. It is expected
+ * that future projects/authors will amend these files as needed.
*
* ---
*
* plnsub.c: Plane subroutine stuff
- *
+ *
* Known contributors to this file:
* Dave Pare, 1986
* Ken Stevens, 1995
* Steve McClure, 1998-2000
+ * Markus Armbruster, 2004-2009
*/
-#include <math.h>
+#include <config.h>
+
+#include "file.h"
+#include "item.h"
+#include "land.h"
+#include "lost.h"
+#include "map.h"
#include "misc.h"
+#include "nat.h"
+#include "nsc.h"
+#include "nuke.h"
+#include "optlist.h"
+#include "path.h"
+#include "plane.h"
#include "player.h"
-#include "var.h"
+#include "prototypes.h"
#include "sect.h"
#include "ship.h"
-#include "land.h"
-#include "item.h"
-#include "plane.h"
-#include "nuke.h"
#include "xy.h"
-#include "nsc.h"
-#include "news.h"
-#include "file.h"
-#include "nat.h"
-#include "path.h"
-#include "prototypes.h"
-#include "optlist.h"
-static int pln_equip(struct plist *, struct ichrstr *, int, s_char);
+static int pln_equip(struct plist *, struct ichrstr *, int, char);
+static int fit_plane_on_ship(struct plnstr *, struct shpstr *);
+
+/*
+ * Get planes and escorts argument.
+ * Read planes into *NI_BOMB, and (optional) escorts into *NI_ESC.
+ * If INPUT_BOMB is not empty, use it, else prompt for more input.
+ * Same for INPUT_ESC.
+ * If we got a plane argument, initialize *NI_BOMB and *NI_ESC, and
+ * return 0.
+ * Else return -1 (*NI_BOMB and *NI_ESC may be modified).
+ */
+int
+get_planes(struct nstr_item *ni_bomb, struct nstr_item *ni_esc,
+ char *input_bomb, char *input_esc)
+{
+ if (!snxtitem(ni_bomb, EF_PLANE, input_bomb, NULL))
+ return -1;
+ if (!snxtitem(ni_esc, EF_PLANE, input_esc, "escort(s)? ")) {
+ if (player->aborted)
+ return -1;
+ pr("No escorts...\n");
+ }
+ return 0;
+}
+
+/*
+ * Get assembly point argument.
+ * If INPUT is not empty, use it, else prompt for more input using PROMPT.
+ * If this yields a valid assembly point, read it into *AP_SECT and
+ * return AP_SECT.
+ * Else complain and return NULL.
+ * *AP_SECT and BUF[1024] may be modified in either case.
+ */
+struct sctstr *
+get_assembly_point(char *input, struct sctstr *ap_sect, char *buf)
+{
+ char *p;
+ coord x, y;
+ struct nstr_item ni;
+ struct shpstr ship;
+
+ p = getstarg(input, "assembly point? ", buf);
+ if (!p || *p == 0)
+ return NULL;
+ if (!sarg_xy(p, &x, &y) || !getsect(x, y, ap_sect))
+ return NULL;
+
+ /* over own or allied sector is fine */
+ if (ap_sect->sct_own == player->cnum
+ || getrel(getnatp(ap_sect->sct_own), player->cnum) == ALLIED)
+ return ap_sect;
+
+ /* over own or allied ship is fine */
+ snxtitem_xy(&ni, EF_SHIP, x, y);
+ while (nxtitem(&ni, &ship)) {
+ if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
+ continue;
+ if (ship.shp_own == player->cnum
+ || getrel(getnatp(ship.shp_own), player->cnum) == ALLIED)
+ return ap_sect;
+ }
+
+ pr("Assembly point not owned by you or an ally!\n");
+ return NULL;
+}
int
pln_onewaymission(struct sctstr *target, int *shipno, int *flagp)
{
int nships;
int cno;
- int flags;
- int n;
+ int flags, fl;
struct shpstr ship;
- s_char buf[1024];
- s_char *p;
+ char buf[1024];
+ char *p;
flags = *flagp;
- if ((target->sct_own && target->sct_own != player->cnum &&
- (getrel(getnatp(target->sct_own), player->cnum) != ALLIED)) &&
- (target->sct_type != SCT_HARBR) &&
- (target->sct_type != SCT_BSPAN)) {
- pr("Nowhere to land at sector %s!\n",
- xyas(target->sct_x, target->sct_y, player->cnum));
- return -1;
- }
- if (target->sct_type == SCT_MOUNT) {
- pr("Nowhere to land at sector %s!\n",
- xyas(target->sct_x, target->sct_y, player->cnum));
- return -1;
- }
- cno = -1;
- if (target->sct_type != SCT_AIRPT || target->sct_effic < 60)
- flags |= P_V;
- if (target->sct_type == SCT_WATER || target->sct_type == SCT_HARBR
- || target->sct_type == SCT_BSPAN) {
- nships = carriersatxy(target->sct_x, target->sct_y,
- M_FLY | M_CHOPPER, 0, player->cnum);
- if (nships <= 0) {
- if (target->sct_type == SCT_WATER) {
- pr("Nowhere to land at sector %s!\n",
- xyas(target->sct_x, target->sct_y, player->cnum));
+
+ /* offer carriers */
+ nships = carriersatxy(target->sct_x, target->sct_y, player->cnum);
+ if (nships) {
+ for (;;) {
+ p = getstring("Carrier #? ", buf);
+ if (!p)
return -1;
- } else {
- if ((target->sct_own && target->sct_own != player->cnum)
- && (getrel(getnatp(target->sct_own), player->cnum) !=
- ALLIED)) {
- pr("Nowhere to land at sector %s!\n",
- xyas(target->sct_x, target->sct_y, player->cnum));
- return -1;
- }
- *shipno = cno;
- *flagp = flags;
- return 0;
- }
- }
- cno = (-1);
- n = (-1);
- while (cno < 0) {
- if (!(p = getstarg(0, "Carrier #? ", buf)) || !*p)
+ if (!*p)
break;
- n = atoi(p);
- if (n < 0 || !getship(n, &ship)
+ cno = atoi(p);
+ if (cno < 0
+ || !getship(cno, &ship)
|| (!player->owner
&& (getrel(getnatp(ship.shp_own), player->cnum)
!= ALLIED))) {
continue;
}
if (ship.shp_x != target->sct_x || ship.shp_y != target->sct_y) {
- pr("Ship #%d not in %s\n", n,
+ pr("Ship #%d not in %s\n", cno,
xyas(target->sct_x, target->sct_y, player->cnum));
continue;
}
- if (!(mchr[(int)ship.shp_type].m_flags & M_FLY)
- && !(mchr[(int)ship.shp_type].m_flags & M_XLIGHT)
- && !(mchr[(int)ship.shp_type].m_flags & M_CHOPPER)
- ) {
+ fl = carrier_planes(&ship, 0);
+ if (fl == 0) {
pr("Can't land on %s.\n", prship(&ship));
continue;
}
- pr("landing on carrier %d\n", n);
- cno = n;
- flags &= ~P_V;
- if (mchr[(int)ship.shp_type].m_flags & M_FLY)
- flags |= P_L;
- if (mchr[(int)ship.shp_type].m_flags & M_CHOPPER)
- flags |= P_K;
- if (mchr[(int)ship.shp_type].m_flags & M_XLIGHT)
- flags |= P_E;
- }
- if ((target->sct_own && target->sct_own != player->cnum) &&
- (getrel(getnatp(target->sct_own), player->cnum) != ALLIED) &&
- (cno == -1)) {
- pr("Nowhere to land at sector %s!\n",
- xyas(target->sct_x, target->sct_y, player->cnum));
- return -1;
+ /* clear to land on ship#CNO */
+ pr("landing on carrier %d\n", cno);
+ flags |= fl;
+ *shipno = cno;
+ *flagp = flags;
+ return 0;
}
}
- if ((target->sct_own == 0) && (cno < 0)) {
+ /* try to land at sector */
+ if (target->sct_own != player->cnum
+ && getrel(getnatp(target->sct_own), player->cnum) != ALLIED) {
+ pr("Nowhere to land at sector %s!\n",
+ xyas(target->sct_x, target->sct_y, player->cnum));
+ return -1;
+ }
+ if (target->sct_type == SCT_MOUNT) {
pr("Nowhere to land at sector %s!\n",
xyas(target->sct_x, target->sct_y, player->cnum));
return -1;
}
+ if (target->sct_type != SCT_AIRPT || target->sct_effic < 60)
+ flags |= P_V;
- *shipno = cno;
+ /* clear to land at sector */
+ *shipno = -1;
*flagp = flags;
return 0;
}
{
struct emp_qelem *list, *qp;
struct plist *plp;
- struct plchrstr *pcp;
struct shpstr ship;
- struct mchrstr *mcp;
- int nchoppers, nxlight, nplane;
if (cno < 0 || !getship(cno, &ship))
return 0;
- count_planes(&ship);
- nchoppers = ship.shp_nchoppers;
- nxlight = ship.shp_nxlight;
- nplane = ship.shp_nplane;
- mcp = &mchr[(int)ship.shp_type];
-
/* for both lists */
for (list = bomb_list;
list;
list = list == bomb_list ? esc_list : NULL) {
for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
- /* FIXME duplicates put_plane_on_ship() logic; refactor */
plp = (struct plist *)qp;
- pcp = &plchr[(int)plp->plane.pln_type];
if (plp->plane.pln_ship == ship.shp_uid)
continue;
- /* try chopper space */
- if ((pcp->pl_flags & P_K) && (mcp->m_flags & M_CHOPPER)
- && nchoppers < mcp->m_nchoppers)
- ++nchoppers;
- /* try xlight space */
- else if ((pcp->pl_flags & P_E) && (mcp->m_flags & M_XLIGHT)
- && nxlight < mcp->m_nxlight)
- ++nxlight;
- /* try plane space */
- else if ((((pcp->pl_flags & P_L) && (mcp->m_flags & M_FLY))
- || ((pcp->pl_flags & P_M) && (pcp->pl_flags & P_L)
- && (mcp->m_flags & M_MSL)))
- && nplane < mcp->m_nplanes)
- ++nplane;
- else
- return 0; /* won't be able to land */
+ if (!fit_plane_on_ship(&plp->plane, &ship))
+ return 0;
}
}
return 1;
for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
plp = (struct plist *)qp;
if (cno >= 0) {
- count_planes(&ship);
- if (!can_be_on_ship(plp->plane.pln_uid, ship.shp_uid))
+ if (!could_be_on_ship(&plp->plane, &ship, 0, 0, 0, 0))
pr("\t%s cannot land on ship #%d! %s aborts!\n",
prplane(&plp->plane), cno, prplane(&plp->plane));
else if (!put_plane_on_ship(&plp->plane, &ship))
- pr("\tNo room on ship #%d! %s aborts!\n", cno,
- prplane(&plp->plane));
+ pr("\tNo room on ship #%d! %s aborts!\n",
+ cno, prplane(&plp->plane));
else {
if (plp->plane.pln_own != ship.shp_own) {
-/* plp->plane.pln_own = ship.shp_own;*/
- wu(0, ship.shp_own,
- "%s %s lands on your %s\n",
- cname(player->cnum),
- prplane(&plp->plane), prship(&ship));
+ wu(0, ship.shp_own, "%s %s lands on your %s\n",
+ cname(player->cnum), prplane(&plp->plane),
+ prship(&ship));
}
}
} else {
plp->plane.pln_y = ty;
getsect(tx, ty, §);
if (plp->plane.pln_own != sect.sct_own) {
-/* plp->plane.pln_own = sect.sct_own;*/
wu(0, sect.sct_own,
"%s %s lands at your sector %s\n",
cname(player->cnum),
plp->plane.pln_ship = cno;
}
}
- if (cno >= 0)
- putship(ship.shp_uid, &ship);
}
void
pln_dropoff(struct emp_qelem *list, struct ichrstr *ip, coord tx, coord ty,
- void *ptr, int type)
+ int cno)
{
struct emp_qelem *qp;
struct plist *plp;
int amt;
- struct sctstr *sectp;
- struct shpstr *sp;
+ struct sctstr sect;
+ struct shpstr ship;
int there;
int max;
- struct mchrstr *mp;
if (ip == 0)
return;
plp = (struct plist *)qp;
amt += plp->misc;
}
- if (type == EF_SECTOR) {
- sectp = ptr;
- if (sectp->sct_type == SCT_WATER && ip->i_vtype == V_SHELL) {
- /* aerial mining */
- sectp->sct_mines = min(sectp->sct_mines + amt, MINES_MAX);
- pr("%d mines laid in %s.\n", amt,
- xyas(sectp->sct_x, sectp->sct_y, player->cnum));
- if (amt > 0
- && map_set(player->cnum, sectp->sct_x, sectp->sct_y, 'X', 0))
- writemap(player->cnum);
- putsect(sectp);
+ if (cno < 0) {
+ getsect(tx, ty, §);
+ if (!sect.sct_own) {
+ if (sect.sct_type == SCT_WATER)
+ pr("Your %s sink like a rock!\n", ip->i_name);
+ else
+ pr("Your %s vanish without a trace.\n", ip->i_name);
return;
}
- there = sectp->sct_item[ip->i_vtype];
+ if (sect.sct_own != player->cnum
+ && getrel(getnatp(sect.sct_own), player->cnum) != ALLIED) {
+ pr("You don't own %s! Cargo jettisoned...\n",
+ xyas(tx, ty, player->cnum));
+ return;
+ }
+ if (ip->i_uid == I_CIVIL && sect.sct_own != sect.sct_oldown) {
+ pr("%s is occupied. Your civilians suffer from identity crisis and die.\n",
+ xyas(tx, ty, player->cnum));
+ return;
+ }
+ there = sect.sct_item[ip->i_uid];
max = ITEM_MAX;
} else {
- sp = ptr;
- there = sp->shp_item[ip->i_vtype];
- mp = &mchr[(int)sp->shp_type];
- max = vl_find(ip->i_vtype, mp->m_vtype,
- mp->m_vamt, (int)mp->m_nv);
+ getship(cno, &ship);
+ there = ship.shp_item[ip->i_uid];
+ max = mchr[ship.shp_type].m_item[ip->i_uid];
}
there += amt;
if (there > max) {
there = max;
}
pr("%d %s landed safely", amt, ip->i_name);
- if (type == EF_SECTOR) {
- sectp = ptr;
- sectp->sct_item[ip->i_vtype] = there;
- if (sectp->sct_own != player->cnum)
- wu(0, sectp->sct_own, "%s planes drop %d %s in %s\n",
+ if (cno < 0) {
+ sect.sct_item[ip->i_uid] = there;
+ if (sect.sct_own != player->cnum)
+ wu(0, sect.sct_own, "%s planes drop %d %s in %s\n",
cname(player->cnum), amt, ip->i_name,
- xyas(sectp->sct_x, sectp->sct_y, sectp->sct_own));
+ xyas(tx, ty, sect.sct_own));
pr(" at %s\n", xyas(tx, ty, player->cnum));
- putsect((struct sctstr *)ptr);
+ putsect(§);
} else {
- struct shpstr *sp = (struct shpstr *)ptr;
- sp->shp_item[ip->i_vtype] = there;
- if (sp->shp_own != player->cnum)
- wu(0, sp->shp_own, "%s planes land %d %s on carrier %d\n",
- cname(player->cnum), amt, ip->i_name, sp->shp_uid);
- pr(" on carrier #%d\n", sp->shp_uid);
- putship(sp->shp_uid, sp);
+ ship.shp_item[ip->i_uid] = there;
+ if (ship.shp_own != player->cnum)
+ wu(0, ship.shp_own, "%s planes land %d %s on carrier %d\n",
+ cname(player->cnum), amt, ip->i_name, ship.shp_uid);
+ pr(" on carrier #%d\n", ship.shp_uid);
+ putship(ship.shp_uid, &ship);
}
}
void
-pln_sel(struct nstr_item *ni, struct emp_qelem *list, struct sctstr *ap,
- int ap_to_target, int rangemult, int wantflags, int nowantflags)
+pln_mine(struct emp_qelem *list, coord tx, coord ty)
+{
+ struct emp_qelem *qp;
+ struct plist *plp;
+ int amt;
+ struct sctstr sect;
+
+ amt = 0;
+ for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
+ plp = (struct plist *)qp;
+ amt += plp->misc;
+
+ }
+ if (amt > 0) {
+ getsect(tx, ty, §);
+ if (sect.sct_type != SCT_WATER) {
+ pr("Your seamines have no effect here.\n");
+ return;
+ }
+ sect.sct_mines = MIN(sect.sct_mines + amt, MINES_MAX);
+ pr("%d mines laid in %s.\n", amt, xyas(tx, ty, player->cnum));
+ if (map_set(player->cnum, tx, ty, 'X', 0))
+ writemap(player->cnum);
+ putsect(§);
+ }
+}
+
+/*
+ * Has PP's type capabilities satisfying WANTFLAGS and NOWANTFLAGS?
+ * A plane type is capable unless
+ * - it lacks all of the P_F, P_ESC in WANTFLAGS, or
+ * - it lacks all of the P_E, P_L, P_K in WANTFLAGS, or
+ * - it lacks any of the other capabilities in WANTFLAGS, or
+ * - it has any of the capabilities in NOWANTFLAGS.
+ */
+int
+pln_capable(struct plnstr *pp, int wantflags, int nowantflags)
+{
+ int flags = plchr[(int)pp->pln_type].pl_flags;
+
+ if (wantflags & (P_F | P_ESC)) {
+ if ((flags & wantflags & (P_F | P_ESC)) == 0)
+ return 0;
+ wantflags &= ~(P_F | P_ESC);
+ }
+
+ if (wantflags & (P_E | P_L | P_K)) {
+ if ((flags & wantflags & (P_E | P_L | P_K)) == 0)
+ return 0;
+ wantflags &= ~(P_E | P_L | P_K);
+ }
+
+ if ((flags & wantflags) != wantflags)
+ return 0;
+
+ if (flags & nowantflags)
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Find plane types that can operate from carrier SP.
+ * If MSL find missile types, else non-missile types.
+ * Return a combination of P_L, P_K, P_E.
+ * It's zero if SP can't support air operations due to its type or
+ * state (low efficiency).
+ */
+int
+carrier_planes(struct shpstr *sp, int msl)
+{
+ struct mchrstr *mcp = mchr + sp->shp_type;
+ int res;
+
+ if (sp->shp_effic < SHP_AIROPS_EFF)
+ return 0;
+
+ res = 0;
+ if (mcp->m_flags & M_FLY)
+ res |= P_L;
+ if ((mcp->m_flags & M_MSL) && msl)
+ res |= P_L;
+ if (mcp->m_nchoppers && !msl)
+ res |= P_K;
+ if (mcp->m_nxlight)
+ res |= P_E;
+ return res;
+}
+
+int
+pln_airbase_ok(struct plnstr *pp, int oneway, int noisy)
{
- struct plnstr plane;
struct shpstr ship;
struct lndstr land;
struct sctstr sect;
+ struct plchrstr *pcp = plchr + pp->pln_type;
+
+ if (CANT_HAPPEN(noisy && pp->pln_own != player->cnum))
+ noisy = 0;
+
+ if (pp->pln_ship >= 0) {
+ /* ship: needs to be own or allied, efficient */
+ if (!getship(pp->pln_ship, &ship)) {
+ CANT_REACH();
+ return 0;
+ }
+ if (ship.shp_own != pp->pln_own
+ && getrel(getnatp(ship.shp_own), pp->pln_own) != ALLIED) {
+ if (noisy)
+ pr("(note) An ally does not own the ship %s is on\n",
+ prplane(pp));
+ return 0;
+ }
+ if (!(carrier_planes(&ship, pcp->pl_flags & P_M) & pcp->pl_flags))
+ return 0;
+
+ } else if (pp->pln_land >= 0) {
+ /* land: needs to be own or allied, efficient, not embarked */
+ if (!getland(pp->pln_land, &land)) {
+ CANT_REACH();
+ return 0;
+ }
+ if (land.lnd_own != pp->pln_own
+ && getrel(getnatp(land.lnd_own), pp->pln_own) != ALLIED) {
+ if (noisy)
+ pr("(note) An ally does not own the unit %s is on\n",
+ prplane(pp));
+ return 0;
+ }
+ if (land.lnd_effic < LND_AIROPS_EFF || !(pcp->pl_flags & P_E))
+ return 0;
+ if (land.lnd_ship >= 0 || land.lnd_land >= 0)
+ return 0;
+
+ } else {
+ /* sector: needs to be own or allied, efficient airfield */
+ if (!getsect(pp->pln_x, pp->pln_y, §)) {
+ CANT_REACH();
+ return 0;
+ }
+
+ if (sect.sct_own != pp->pln_own
+ && getrel(getnatp(sect.sct_own), pp->pln_own) != ALLIED) {
+ if (noisy)
+ pr("(note) An ally does not own the sector %s is in\n",
+ prplane(pp));
+ return 0;
+ }
+ /* need airfield unless VTOL */
+ if ((pcp->pl_flags & P_V) == 0) {
+ if (sect.sct_type != SCT_AIRPT) {
+ if (noisy)
+ pr("%s not at airport\n", prplane(pp));
+ return 0;
+ }
+ if (sect.sct_effic < 40) {
+ if (noisy)
+ pr("%s is not 40%% efficient, %s can't take off from there.\n",
+ xyas(sect.sct_x, sect.sct_y, pp->pln_own),
+ prplane(pp));
+ return 0;
+ }
+ if (!oneway && sect.sct_effic < 60) {
+ if (noisy)
+ pr("%s is not 60%% efficient, %s can't land there.\n",
+ xyas(sect.sct_x, sect.sct_y, pp->pln_own),
+ prplane(pp));
+ return 0;
+ }
+ }
+ }
+
+ return 1;
+}
+
+void
+pln_sel(struct nstr_item *ni, struct emp_qelem *list, struct sctstr *ap,
+ int ap_to_target, int rangemult, int wantflags, int nowantflags)
+{
+ struct plnstr plane;
int range;
struct plchrstr *pcp;
struct plist *plp;
- register int y;
- register int bad, bad1;
- unsigned int x;
emp_initque(list);
- while (nxtitem(ni, (s_char *)&plane)) {
+ while (nxtitem(ni, &plane)) {
if (!player->owner)
continue;
- if (plane.pln_mobil <= (s_char)0)
+ if (plane.pln_mobil <= 0)
+ continue;
+ if (plane.pln_effic < 40) {
+ pr("%s not efficient enough (must be 40%%)\n",
+ prplane(&plane));
+ continue;
+ }
+ if (!pln_capable(&plane, wantflags, nowantflags))
continue;
if (opt_MARKET) {
- if (ontradingblock(EF_PLANE, (int *)&plane)) {
+ if (ontradingblock(EF_PLANE, &plane)) {
pr("plane #%d inelligible - it's for sale.\n",
plane.pln_uid);
continue;
pr("%s too far from assembly point\n", prplane(&plane));
continue;
}
- if (plane.pln_effic < 40) {
- pr("%s not efficient enough (must be 40%%)\n",
- prplane(&plane));
- continue;
- }
range += ap_to_target;
- pcp = &plchr[(int)plane.pln_type];
- bad = 0;
- bad1 = 0;
- if (wantflags) {
- for (x = 0; x < sizeof(wantflags) * 8; x++) {
- y = (1 << x);
- if ((wantflags & y) == y)
- if ((pcp->pl_flags & y) != y) {
- switch (y) {
- case P_F:
- case P_ESC:
- bad1 = 2;
- break;
- case P_E:
- case P_L:
- case P_K:
- bad1 = 1;
- break;
- default:
- bad = 1;
- }
- }
- }
- if (bad)
- continue;
- if (bad1 == 2) {
- if ((pcp->pl_flags & P_ESC) || (pcp->pl_flags & P_F))
- bad1 = 0;
- }
- if (bad1 == 1) {
- if ((wantflags & P_L) && (pcp->pl_flags & P_L))
- bad1 = 0;
- if ((wantflags & P_K) && (pcp->pl_flags & P_K))
- bad1 = 0;
- if ((wantflags & P_E) && (pcp->pl_flags & P_E))
- bad1 = 0;
- }
- if (bad1)
- continue;
- }
- bad = 0;
- bad1 = 0;
- if (nowantflags) {
- for (x = 0; x < sizeof(nowantflags) * 8; x++) {
- y = (1 << x);
- if ((nowantflags & y) == y)
- if ((pcp->pl_flags & y) == y)
- bad = 1;
- }
- if (bad)
- continue;
- }
range *= rangemult;
+ pcp = &plchr[(int)plane.pln_type];
if (plane.pln_range < range) {
- pr("%s out of range (%d:%d)\n", prplane(&plane),
- plane.pln_range, range);
+ pr("%s out of range (%d:%d)\n",
+ prplane(&plane), plane.pln_range, range);
continue;
}
- if (plane.pln_ship >= 0) {
- if (!getship(plane.pln_ship, &ship) ||
- plane.pln_own != player->cnum) {
- shipsunk:
- plane.pln_effic = 0;
- pr("(note) ship not valid for %s\n", prplane(&plane));
- putplane(plane.pln_uid, &plane);
- continue;
- }
- if (!can_be_on_ship(plane.pln_uid, ship.shp_uid))
- goto shipsunk;
- if (ship.shp_effic < SHIP_MINEFF)
- goto shipsunk;
- if (ship.shp_effic < 50)
- continue;
- /* Can't fly off non-owned ships or non-allied ship */
- if ((ship.shp_own != player->cnum) &&
- (getrel(getnatp(ship.shp_own), player->cnum) != ALLIED)) {
- pr("(note) An ally does not own the ship %s is on\n",
- prplane(&plane));
- continue;
- }
- }
- if (plane.pln_land >= 0) {
- if (!getland(plane.pln_land, &land) ||
- (plane.pln_own != player->cnum)) {
- landdead:
- plane.pln_effic = 0;
- pr("(note) land unit not valid for %s\n", prplane(&plane));
- putplane(plane.pln_uid, &plane);
- continue;
- }
- if (!(plchr[(int)plane.pln_type].pl_flags & P_E))
- goto landdead;
- if (land.lnd_effic < LAND_MINEFF)
- goto landdead;
- if (land.lnd_effic < 50)
- continue;
- /* Can't fly off units in ships or other units */
- if ((land.lnd_ship >= 0) || (land.lnd_land >= 0))
- continue;
- /* Can't fly off non-owned units or non-allied unit */
- if ((land.lnd_own != player->cnum) &&
- (getrel(getnatp(land.lnd_own), player->cnum) != ALLIED)) {
- pr("(note) An ally does not own the unit %s is on\n",
- prplane(&plane));
- continue;
- }
- }
- /* Now, check the sector status if not on a plane or unit */
- if ((plane.pln_ship < 0) && (plane.pln_land < 0)) {
- if (!getsect(plane.pln_x, plane.pln_y, §))
- continue;
- /* First, check allied status */
- /* Can't fly from non-owned sectors or non-allied sectors */
- if ((sect.sct_own != player->cnum) &&
- (getrel(getnatp(sect.sct_own), player->cnum) != ALLIED)) {
- pr("(note) An ally does not own the sector %s is in\n",
- prplane(&plane));
- continue;
- }
- /* non-vtol plane */
- if ((pcp->pl_flags & P_V) == 0) {
- if (sect.sct_type != SCT_AIRPT) {
- pr("%s not at airport\n", prplane(&plane));
- continue;
- }
- if (sect.sct_effic < 40) {
- pr("%s is not 40%% efficient, %s can't take off from there.\n", xyas(sect.sct_x, sect.sct_y, plane.pln_own), prplane(&plane));
- continue;
- }
- if (rangemult == 2 && sect.sct_effic < 60) {
- pr("%s is not 60%% efficient, %s can't land there.\n",
- xyas(sect.sct_x, sect.sct_y, plane.pln_own),
- prplane(&plane));
- continue;
- }
- }
- }
+ if (!pln_airbase_ok(&plane, rangemult != 2, 1))
+ continue;
pr("%s standing by\n", prplane(&plane));
plane.pln_mission = 0;
putplane(plane.pln_uid, &plane);
- plp = (struct plist *)malloc(sizeof(struct plist));
- plp->state = P_OK;
+ plp = malloc(sizeof(struct plist));
plp->misc = 0;
plp->bombs = 0;
plp->pcp = pcp;
}
}
-int
-pln_arm(struct emp_qelem *list, int dist, int mission, struct ichrstr *ip,
- int flags, int mission_flags, int *tech)
+void
+pln_arm(struct emp_qelem *list, int dist, char mission, struct ichrstr *ip,
+ int flags)
{
struct emp_qelem *qp;
struct emp_qelem *next;
struct plist *plp;
+ struct plnstr *pp;
- if (*tech == 0)
- *tech = 9999;
for (qp = list->q_forw; qp != list; qp = next) {
next = qp->q_forw;
plp = (struct plist *)qp;
- if (pln_equip(plp, ip, flags, mission) < 0) {
+ pp = &plp->plane;
+ getplane(pp->pln_uid, pp);
+ if ((pp->pln_flags & PLN_LAUNCHED)
+ || pln_equip(plp, ip, flags, mission) < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
- if (flags & (P_S | P_I)) {
- if (plp->pcp->pl_flags & P_S)
- mission_flags |= P_S;
- if (plp->pcp->pl_flags & P_I)
- mission_flags |= P_I;
- }
- if (*tech > plp->plane.pln_tech)
- *tech = plp->plane.pln_tech;
- if (!(plp->pcp->pl_flags & P_H))
- /* no stealth on this mission */
- mission_flags &= ~P_H;
- if (!(plp->pcp->pl_flags & P_X))
- /* no stealth on this mission */
- mission_flags &= ~P_X;
- if (!(plp->pcp->pl_flags & P_A)) {
- /* no asw on this mission */
- mission_flags &= ~P_A;
- }
- if (!(plp->pcp->pl_flags & P_MINE)) {
- /* no asw on this mission */
- mission_flags &= ~P_MINE;
- }
- plp->plane.pln_mobil -= pln_mobcost(dist, &plp->plane, flags);
- pr("%s equipped\n", prplane(&plp->plane));
+ pp->pln_flags |= PLN_LAUNCHED;
+ pp->pln_mobil -= pln_mobcost(dist, pp, flags);
+ putplane(pp->pln_uid, pp);
+ pr("%s equipped\n", prplane(pp));
}
- return mission_flags;
}
static int
-pln_equip(struct plist *plp, struct ichrstr *ip, int flags, s_char mission)
+pln_equip(struct plist *plp, struct ichrstr *ip, int flags, char mission)
{
- register struct plchrstr *pcp;
+ struct plchrstr *pcp;
struct plnstr *pp;
- int needed;
+ int load, needed;
struct lndstr land;
struct shpstr ship;
struct sctstr sect;
- int itype;
- int rval;
+ i_type itype;
short *item;
int own;
+ int abandon_needed;
pp = &plp->plane;
pcp = plp->pcp;
own = sect.sct_oldown;
}
if (ip) {
- if (ip->i_vtype == V_CIVIL) {
+ if (ip->i_uid == I_CIVIL) {
if (pp->pln_own != own) {
pr("You don't control those civilians!\n");
return -1;
return -1;
}
item[I_PETROL] -= pcp->pl_fuel;
- rval = 0;
if ((flags & P_F) == 0) {
- itype = 0;
+ load = pln_load(pp);
+ itype = I_NONE;
needed = 0;
switch (mission) {
- case 's':
- case 'p':
- if (pp->pln_nuketype == -1) {
+ case 's': /* strategic bomb */
+ case 'p': /* pinpoint bomb */
+ if (nuk_on_plane(pp) < 0) {
itype = I_SHELL;
- needed = pp->pln_load;
+ needed = load;
}
break;
- case 't':
+ case 't': /* transport */
+ case 'd': /* drop */
if ((pcp->pl_flags & P_C) == 0 || ip == 0)
break;
- itype = ip->i_vtype;
- needed = (pp->pln_load * 2) / ip->i_lbs;
+ itype = ip->i_uid;
+ needed = (load * 2) / ip->i_lbs;
break;
- case 'd':
- itype = ip->i_vtype;
- needed = (pp->pln_load * 2) / ip->i_lbs;
- /* Is this mine dropping excursion? */
- if (itype == I_SHELL && (pcp->pl_flags & P_MINE))
- break;
- /* Is this a cargo drop? */
- if ((pcp->pl_flags & P_C) == 0 || ip == 0) {
- itype = 0;
- needed = 0;
+ case 'm': /* mine */
+ if ((pcp->pl_flags & P_MINE) == 0)
break;
- }
+ itype = I_SHELL;
+ needed = (load * 2) / ip->i_lbs;
break;
- case 'a':
+ case 'a': /* paradrop */
if ((pcp->pl_flags & (P_V | P_C)) == 0)
break;
itype = I_MILIT;
- needed = pp->pln_load / ip->i_lbs;
+ needed = load / ip->i_lbs;
break;
- case 'n':
- if (pp->pln_nuketype == (s_char)-1)
- rval = -1;
+ case 'r': /* reconnaissance */
break;
default:
- break;
+ CANT_REACH();
}
- if (rval < 0 || (itype && needed <= 0)) {
+ if (itype != I_NONE && needed <= 0) {
pr("%s can't contribute to mission\n", prplane(pp));
return -1;
}
+ if (itype != I_NONE) {
#if 0
- /* Supply is broken somewhere, so don't use it for now */
- if (item[itype] < needed && itype == I_SHELL)
- item[itype] += supply_commod(plp->plane.pln_own,
- plp->plane.pln_x, plp->plane.pln_y,
- I_SHELL, needed);
+ /* Supply is broken somewhere, so don't use it for now */
+ if (itype == I_SHELL && item[itype] < needed)
+ item[itype] += supply_commod(plp->plane.pln_own,
+ plp->plane.pln_x,
+ plp->plane.pln_y,
+ I_SHELL, needed);
#endif
- if (item[itype] < needed) {
- pr("Not enough %s for %s\n", ichr[itype].i_name, prplane(pp));
- return -1;
- } else {
+ abandon_needed = !!would_abandon(§, itype, needed, NULL);
+ if (item[itype] < needed + abandon_needed) {
+ pr("Not enough %s for %s\n", ichr[itype].i_name, prplane(pp));
+ return -1;
+ }
item[itype] -= needed;
}
if (itype == I_SHELL && (mission == 's' || mission == 'p'))
} else {
if (pp->pln_own != sect.sct_own) {
wu(0, sect.sct_own, "%s %s prepares for takeoff from %s\n",
- cname(pp->pln_own), prplane(pp), xyas(sect.sct_x,
- sect.sct_y,
- sect.sct_own));
+ cname(pp->pln_own), prplane(pp),
+ xyas(sect.sct_x, sect.sct_y, sect.sct_own));
}
putsect(§);
}
- return rval;
+ return 0;
}
void
pln_put(struct emp_qelem *list)
{
- register struct emp_qelem *qp;
- register struct emp_qelem *newqp;
- struct plist *plp;
- struct plnstr *pp;
- struct shpstr ship;
- struct sctstr sect;
+ struct emp_qelem *qp, *next;
- /* Here is where planes return home from bombing runs.
- We need to make sure they still have somewhere to return
- home to! */
- qp = list->q_forw;
- while (qp != list) {
- plp = (struct plist *)qp;
- pp = &plp->plane;
- /* Ok, check out where it wants to land */
- if (pp->pln_ship >= 0) {
- /* It is landing on a carrier */
- getship(pp->pln_ship, &ship);
- /* We should do more, like make sure it's really
- a carrier, etc. but for now just make sure it's
- not sunk. */
- if (ship.shp_effic < SHIP_MINEFF) {
- mpr(pp->pln_own,
- "Ship #%d has been sunk, plane #%d has nowhere to land, and\nsplashes into the sea.\n",
- pp->pln_ship, pp->pln_uid);
- pp->pln_effic = 0;
- }
- } else {
- /* Presume we are landing back in a sector. */
- getsect(pp->pln_x, pp->pln_y, §);
- if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_WASTE) {
- mpr(pp->pln_own,
- "Nowhere to land at %s, plane #%d crashes and burns...\n",
- xyas(pp->pln_x, pp->pln_y, pp->pln_own), pp->pln_uid);
- pp->pln_effic = 0;
- }
- }
- putplane(pp->pln_uid, pp);
- newqp = qp->q_forw;
- emp_remque(qp);
- free((s_char *)qp);
- qp = newqp;
+ for (qp = list->q_forw; qp != list; qp = next) {
+ next = qp->q_forw;
+ pln_put1((struct plist *)qp);
}
}
void
-pln_removedupes(struct emp_qelem *bomb_list, struct emp_qelem *esc_list)
+pln_put1(struct plist *plp)
{
- struct emp_qelem *bomb;
- struct emp_qelem *esc;
- struct plist *bombp;
- struct plist *escp;
+ struct plnstr *pp;
+ struct shpstr ship;
+ struct sctstr sect;
- if (QEMPTY(bomb_list) || QEMPTY(esc_list))
- return;
- bomb = bomb_list->q_forw;
- while (bomb != bomb_list) {
- if (QEMPTY(esc_list)) {
- bomb = bomb_list;
- continue;
+ pp = &plp->plane;
+
+ if (CANT_HAPPEN((pp->pln_flags & PLN_LAUNCHED)
+ && (plchr[pp->pln_type].pl_flags & P_M)
+ && pp->pln_effic >= PLANE_MINEFF))
+ pp->pln_effic = 0; /* bug: missile launched but not used up */
+
+ if (!(pp->pln_flags & PLN_LAUNCHED))
+ ; /* never took off */
+ else if (pp->pln_effic < PLANE_MINEFF) {
+ ; /* destroyed */
+ } else if (pp->pln_ship >= 0) {
+ /* It is landing on a carrier */
+ getship(pp->pln_ship, &ship);
+ /* We should do more, like make sure it's really
+ a carrier, etc. but for now just make sure it's
+ not sunk. */
+ if (ship.shp_effic < SHIP_MINEFF) {
+ mpr(pp->pln_own,
+ "Ship #%d has been sunk, plane #%d has nowhere to land, and\n"
+ "splashes into the sea.\n",
+ pp->pln_ship, pp->pln_uid);
+ pp->pln_effic = 0;
}
- esc = esc_list->q_forw;
- bombp = (struct plist *)bomb;
- while (esc != esc_list) {
- escp = (struct plist *)esc;
- if (escp->plane.pln_uid == bombp->plane.pln_uid) {
- emp_remque(esc);
- free((s_char *)esc);
- esc = esc_list;
- } else
- esc = esc->q_forw;
+ } else {
+ /* Presume we are landing back in a sector. */
+ getsect(pp->pln_x, pp->pln_y, §);
+ if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_WASTE) {
+ mpr(pp->pln_own,
+ "Nowhere to land at %s, plane #%d crashes and burns...\n",
+ xyas(pp->pln_x, pp->pln_y, pp->pln_own), pp->pln_uid);
+ pp->pln_effic = 0;
}
- bomb = bomb->q_forw;
}
+ pp->pln_flags &= ~PLN_LAUNCHED;
+ putplane(pp->pln_uid, pp);
+ emp_remque(&plp->queue);
+ free(plp);
}
+/*
+ * Can PP be loaded on a ship of SP's type?
+ * Assume that it already carries N planes, of which NCH are choppers,
+ * NXL xlight, NMSL light missiles, and the rest are light fixed-wing
+ * planes.
+ */
int
-put_plane_on_ship(struct plnstr *plane, struct shpstr *ship)
+could_be_on_ship(struct plnstr *pp, struct shpstr *sp,
+ int n, int nch, int nxl, int nmsl)
{
- struct plchrstr *pcp;
- struct mchrstr *mcp;
-
- pcp = &plchr[(int)plane->pln_type];
- mcp = &mchr[(int)ship->shp_type];
-
- if (((int)plane->pln_ship) == ((int)ship->shp_uid))
- return 1; /* Already on ship */
-
- /* Try to put on ship as a chopper plane */
- if ((pcp->pl_flags & P_K) &&
- (mcp->m_flags & M_CHOPPER) &&
- (ship->shp_nchoppers < mcp->m_nchoppers)) {
-
- ship->shp_nchoppers++;
- plane->pln_x = ship->shp_x;
- plane->pln_y = ship->shp_y;
- plane->pln_ship = ship->shp_uid;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
+ struct plchrstr *pcp = &plchr[pp->pln_type];
+ struct mchrstr *mcp = &mchr[sp->shp_type];
- /* Try to put on ship as an xlight plane */
- if ((pcp->pl_flags & P_E) &&
- (mcp->m_flags & M_XLIGHT) &&
- (ship->shp_nxlight < mcp->m_nxlight)) {
-
- ship->shp_nxlight++;
- plane->pln_x = ship->shp_x;
- plane->pln_y = ship->shp_y;
- plane->pln_ship = ship->shp_uid;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* Try to put on ship as a normal plane */
- if ((((pcp->pl_flags & P_L) && (mcp->m_flags & M_FLY)) ||
- ((pcp->pl_flags & P_M) && (pcp->pl_flags & P_L) &&
- (mcp->m_flags & M_MSL))) &&
- (ship->shp_nplane < mcp->m_nplanes)) {
-
- ship->shp_nplane++;
- plane->pln_x = ship->shp_x;
- plane->pln_y = ship->shp_y;
- plane->pln_ship = ship->shp_uid;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* We have failed */
- return 0;
+ if (pcp->pl_flags & P_K)
+ nch++;
+ else if (pcp->pl_flags & P_E)
+ nxl++;
+ else if (!(pcp->pl_flags & P_L))
+ return 0;
+ else if (pcp->pl_flags & P_M)
+ nmsl++;
+ n++;
+
+ n -= MIN(nch, mcp->m_nchoppers);
+ n -= MIN(nxl, mcp->m_nxlight);
+ if (nmsl && !(mcp->m_flags & (M_MSL | M_FLY)))
+ return 0; /* missile slots wanted */
+ if (nmsl < n && !(mcp->m_flags & M_FLY))
+ return 0; /* fixed-wing slots wanted */
+ return n <= mcp->m_nplanes;
}
-int
-take_plane_off_ship(struct plnstr *plane, struct shpstr *ship)
+/*
+ * Fit a plane of PP's type on ship SP.
+ * Updating the plane accordingly is the caller's job.
+ * Return whether it fits.
+ */
+static int
+fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
{
- struct plchrstr *pcp;
- struct mchrstr *mcp;
-
- pcp = &plchr[(int)plane->pln_type];
- mcp = &mchr[(int)ship->shp_type];
-
- /* Try to take off ship as a chopper plane */
- if ((pcp->pl_flags & P_K) &&
- (mcp->m_flags & M_CHOPPER) && (ship->shp_nchoppers)) {
-
- ship->shp_nchoppers--;
- plane->pln_ship = -1;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* Try to take off ship as an xlight plane */
- if ((pcp->pl_flags & P_E) &&
- (mcp->m_flags & M_XLIGHT) && (ship->shp_nxlight)) {
+ int n, nch, nxl, nmsl;
- ship->shp_nxlight--;
- plane->pln_ship = -1;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* Try to take off ship as a normal plane */
- if ((((pcp->pl_flags & P_L) && (mcp->m_flags & M_FLY)) ||
- ((pcp->pl_flags & P_M) && (pcp->pl_flags & P_L) &&
- (mcp->m_flags & M_MSL))) && (ship->shp_nplane)) {
-
- ship->shp_nplane--;
- plane->pln_ship = -1;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* We have failed */
- return 0;
+ n = shp_nplane(sp, &nch, &nxl, &nmsl);
+ return could_be_on_ship(pp, sp, n, nch, nxl, nmsl);
}
int
-take_plane_off_land(struct plnstr *plane, struct lndstr *land)
+put_plane_on_ship(struct plnstr *plane, struct shpstr *ship)
{
- struct plchrstr *pcp;
- struct lchrstr *lcp;
+ if (plane->pln_ship == ship->shp_uid)
+ return 1; /* Already on ship */
- pcp = &plchr[(int)plane->pln_type];
- lcp = &lchr[(int)land->lnd_type];
+ if (!fit_plane_on_ship(plane, ship))
+ return 0;
- /* Try to take off ship as an xlight plane */
- if ((pcp->pl_flags & P_E) &&
- (lcp->l_flags & L_XLIGHT) && (land->lnd_nxlight)) {
+ plane->pln_x = ship->shp_x;
+ plane->pln_y = ship->shp_y;
+ plane->pln_ship = ship->shp_uid;
+ putplane(plane->pln_uid, plane);
+ return 1;
+}
- land->lnd_nxlight--;
- plane->pln_land = -1;
- putland(land->lnd_uid, land);
- putplane(plane->pln_uid, plane);
- return 1;
- }
+/*
+ * Fit a plane of PP's type on land unit LP.
+ * Updating the plane accordingly is the caller's job.
+ * Return whether it fits.
+ */
+static int
+fit_plane_on_land(struct plnstr *pp, struct lndstr *lp)
+{
+ struct plchrstr *pcp = plchr + pp->pln_type;
+ struct lchrstr *lcp = lchr + lp->lnd_type;
- /* We have failed */
- return 0;
+ return (pcp->pl_flags & P_E) && lnd_nxlight(lp) < lcp->l_nxlight;
}
int
-can_be_on_ship(int p, int s)
+put_plane_on_land(struct plnstr *plane, struct lndstr *land)
{
- struct plnstr plane;
- struct shpstr ship;
- struct plchrstr *pcp;
- struct mchrstr *mcp;
-
- getplane(p, &plane);
- getship(s, &ship);
-
- pcp = &plchr[(int)plane.pln_type];
- mcp = &mchr[(int)ship.shp_type];
-
- if (pcp->pl_flags & P_L)
- if (mcp->m_flags & M_FLY)
- return 1;
-
- if (pcp->pl_flags & P_K)
- if (mcp->m_flags & M_CHOPPER)
- return 1;
-
- if (pcp->pl_flags & P_M)
- if (mcp->m_flags & M_MSL)
- return 1;
+ if (plane->pln_land == land->lnd_uid)
+ return 1; /* Already on unit */
- if (pcp->pl_flags & P_E)
- if (mcp->m_flags & M_XLIGHT)
- return 1;
+ if (!fit_plane_on_land(plane, land))
+ return 0;
- return 0;
+ plane->pln_x = land->lnd_x;
+ plane->pln_y = land->lnd_y;
+ plane->pln_land = land->lnd_uid;
+ putplane(plane->pln_uid, plane);
+ return 1;
}
void
if (!(pcp->pl_flags & P_SWEEP)) /* if it isn't an sweep plane */
continue;
- if (chance(((double)(100 - pp->pln_acc)) / 100.0)) {
+ if (chance((100.0 - pln_acc(pp)) / 100.0)) {
pr("Sweep! in %s\n",
xyas(sect.sct_x, sect.sct_y, pp->pln_own));
mines_there--;
putsect(§);
}
-void
-count_planes(struct shpstr *sp)
-{
- struct nstr_item ni;
- struct plnstr plane;
- struct plchrstr *pcp;
- struct mchrstr *mcp;
- int nplane = 0;
- int nchoppers = 0;
- int nxlight = 0;
-
- if (sp->shp_effic < SHIP_MINEFF)
- return;
-
- mcp = &mchr[(int)sp->shp_type];
- snxtitem_xy(&ni, EF_PLANE, sp->shp_x, sp->shp_y);
- while (nxtitem(&ni, (s_char *)&plane)) {
- if (plane.pln_own == 0)
- continue;
- if (plane.pln_ship == sp->shp_uid) {
- pcp = &plchr[(int)plane.pln_type];
- if ((pcp->pl_flags & P_K) && (nchoppers < mcp->m_nchoppers))
- nchoppers++;
- else if ((pcp->pl_flags & P_E) && (nxlight < mcp->m_nxlight))
- nxlight++;
- else if ((pcp->pl_flags & P_L) || (pcp->pl_flags & P_M))
- nplane++;
- }
- }
-
- if (nplane != sp->shp_nplane ||
- nxlight != sp->shp_nxlight || nchoppers != sp->shp_nchoppers) {
- sp->shp_nplane = nplane;
- sp->shp_nxlight = nxlight;
- sp->shp_nchoppers = nchoppers;
- putship(sp->shp_uid, sp);
- }
-}
-
-void
-count_land_planes(struct lndstr *lp)
-{
- struct nstr_item ni;
- struct plnstr plane;
- int nplane = 0;
-
- if (lp->lnd_effic < LAND_MINEFF)
- return;
-
- snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
- if (plane.pln_own == 0)
- continue;
- if (plane.pln_land == lp->lnd_uid)
- nplane++;
- }
-
- if (lp->lnd_nxlight != nplane) {
- lp->lnd_nxlight = nplane;
- putland(lp->lnd_uid, lp);
- }
-}
-
-int
-count_sect_planes(struct sctstr *sp)
-{
- int count = 0;
- struct nstr_item ni;
- struct plnstr plane;
-
- snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
- if (!plane.pln_own)
- continue;
- if (plane.pln_flags & PLN_LAUNCHED)
- continue;
- if (plane.pln_x == sp->sct_x && plane.pln_y == sp->sct_y)
- ++count;
- }
-
- return count;
-}
-
-int
-put_plane_on_land(struct plnstr *plane, struct lndstr *land)
-{
- struct plchrstr *pcp;
- struct lchrstr *lcp;
-
- pcp = &plchr[(int)plane->pln_type];
- lcp = &lchr[(int)land->lnd_type];
-
- if (((int)plane->pln_land) == ((int)land->lnd_uid))
- return 1; /* Already on unit */
-
- /* Try to put on unit as an xlight plane */
- if ((pcp->pl_flags & P_E) &&
- (lcp->l_flags & L_XLIGHT) &&
- (land->lnd_nxlight < lcp->l_nxlight)) {
-
- land->lnd_nxlight++;
- plane->pln_x = land->lnd_x;
- plane->pln_y = land->lnd_y;
- plane->pln_land = land->lnd_uid;
- putland(land->lnd_uid, land);
- putplane(plane->pln_uid, plane);
- return 1;
- }
-
- /* We have failed */
- return 0;
-}
-
int
pln_hitchance(struct plnstr *pp, int hardtarget, int type)
{
struct plchrstr *pcp = plchr + pp->pln_type;
- float tfact = (float)(pp->pln_tech - pcp->pl_tech) /
+ double tfact = (double)(pp->pln_tech - pcp->pl_tech) /
(pp->pln_tech - pcp->pl_tech / 2);
- int acc = pp->pln_acc;
+ int acc = pln_acc(pp);
int hitchance;
if (type == EF_SHIP) {
acc += 35;
}
hitchance = (int)(pp->pln_effic * (1.0 - 0.1 * tfact) *
- (1.0 - (float)acc / 100.0)) - hardtarget;
+ (1.0 - acc / 100.0)) - hardtarget;
/* smooth out the bottom of the graph with asymtote at 5 -KHS */
if (hitchance < 20)
/* return 0 if there was a nuclear detonation */
int
-pln_damage(struct plnstr *pp, coord x, coord y, s_char type, int *nukedamp,
+pln_damage(struct plnstr *pp, coord x, coord y, char type, int *nukedamp,
int noisy)
{
+ struct nukstr nuke;
struct plchrstr *pcp = plchr + pp->pln_type;
- int i;
+ int load, i;
int hitroll;
int dam = 0;
int aim;
int effective = 1;
int pinbomber = 0;
- if (pp->pln_nuketype != (s_char)-1) {
+ if (getnuke(nuk_on_plane(pp), &nuke)) {
mpr(pp->pln_own, "Releasing RV's for %s detonation...\n",
pp->pln_flags & PLN_AIRBURST ? "airburst" : "groundburst");
- *nukedamp = detonate(pp, x, y);
+ *nukedamp = detonate(&nuke, x, y,
+ pp->pln_flags & PLN_AIRBURST);
return 0;
- } else
- *nukedamp = 0;
+ }
+ *nukedamp = 0;
- if (!pp->pln_load) /* e.g. ab, blowing up on launch pad */
+ load = pln_load(pp);
+ if (!load) /* e.g. ab, blowing up on launch pad */
return 0;
- i = roll(pp->pln_load) + 1;
- if (i > pp->pln_load)
- i = pp->pln_load;
+ i = roll(load) + 1;
+ if (i > load)
+ i = load;
if (pcp->pl_flags & P_M) {
if (pcp->pl_flags & P_MAR)
} else if (pcp->pl_flags & P_T)
pinbomber = 1;
- aim = 100 - pp->pln_acc;
+ aim = pln_acc(pp);
if (type == 's') {
- if (pinbomber) {
- aim = pp->pln_acc;
- effective = 0;
- }
- aim += 30;
+ effective = !pinbomber;
+ aim = 30 + (pinbomber ? aim : 100 - aim);
} else {
- if (!pinbomber) {
- effective = 0;
- }
+ effective = pinbomber;
+ aim = 100 - aim;
}
+
while (i--) {
dam += roll(6);
hitroll = roll(100);
int
pln_mobcost(int dist, struct plnstr *pp, int flags)
{
- int cost;
+ double cost;
+ cost = 20.0 / (pp->pln_effic / 100.0);
if ((flags & P_F) || (flags & P_ESC))
- cost = 10 * 100 / pp->pln_effic;
- else
- cost = 20 * 100 / pp->pln_effic;
+ cost /= 2;
- cost = ldround((double)cost * dist / pp->pln_range_max, 1);
+ return ldround(cost * dist / pln_range_max(pp) + 5, 1);
+}
- return min(32 + pp->pln_mobil, cost + 5);
+int
+pln_is_in_orbit(struct plnstr *pp)
+{
+ return (plchr[pp->pln_type].pl_flags & (P_M | P_O)) == P_O
+ && (pp->pln_flags & PLN_LAUNCHED);
}
/*
pln_set_tech(struct plnstr *pp, int tlev)
{
struct plchrstr *pcp = plchr + pp->pln_type;
- int tech_diff = tlev - pcp->pl_tech;
- int limited_range = pp->pln_range < pp->pln_range_max;
-
- if (CANT_HAPPEN(tech_diff < 0)) {
- tlev -= tech_diff;
- tech_diff = 0;
- }
+ int limited_range = pp->pln_range < pln_range_max(pp);
+ int range_max;
+ if (CANT_HAPPEN(tlev < pcp->pl_tech))
+ tlev = pcp->pl_tech;
pp->pln_tech = tlev;
- pp->pln_att = PLN_ATTDEF(pcp->pl_att, tech_diff);
- pp->pln_def = PLN_ATTDEF(pcp->pl_def, tech_diff);
- pp->pln_acc = PLN_ACC(pcp->pl_acc, tech_diff);
- pp->pln_range_max = PLN_RAN(pcp->pl_range, tech_diff);
- pp->pln_load = PLN_LOAD(pcp->pl_load, tech_diff);
-
- if (!limited_range || pp->pln_range > pp->pln_range_max)
- pp->pln_range = pp->pln_range_max;
+
+ range_max = pln_range_max(pp);
+ if (!limited_range || pp->pln_range > range_max)
+ pp->pln_range = range_max;
}
projects / empserver / blobdiff