/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2008, 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
* ---
*
* plnsub.c: Plane subroutine stuff
- *
+ *
* Known contributors to this file:
* Dave Pare, 1986
* Ken Stevens, 1995
* Steve McClure, 1998-2000
- * Markus Armbruster, 2004-2008
+ * Markus Armbruster, 2004-2009
*/
#include <config.h>
if (cno < 0 || !getship(cno, &ship))
return 0;
- count_planes(&ship);
-
/* for both lists */
for (list = bomb_list;
list;
for (qp = list->q_forw; qp != list; qp = qp->q_forw) {
plp = (struct plist *)qp;
if (cno >= 0) {
- count_planes(&ship);
- if (!could_be_on_ship(&plp->plane, &ship))
+ 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))
plp->plane.pln_ship = cno;
}
}
- if (cno >= 0)
- putship(ship.shp_uid, &ship);
}
void
}
}
-int
+void
pln_arm(struct emp_qelem *list, int dist, char mission, struct ichrstr *ip,
- int flags, int mission_flags)
+ int flags)
{
struct emp_qelem *qp;
struct emp_qelem *next;
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 (!(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;
- /* FIXME escorts turn ASW patrol into ordinary recon */
- }
- if (!(plp->pcp->pl_flags & P_MINE)) {
- /* no asw on this mission */
- mission_flags &= ~P_MINE;
- /* FIXME no effect */
- }
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
switch (mission) {
case 's': /* strategic bomb */
case 'p': /* pinpoint bomb */
- if (pp->pln_nuketype == -1) {
+ if (nuk_on_plane(pp) < 0) {
itype = I_SHELL;
needed = load;
}
{
struct plnstr *pp;
struct shpstr ship;
- struct lndstr land;
struct sctstr sect;
pp = &plp->plane;
if (!(pp->pln_flags & PLN_LAUNCHED))
; /* never took off */
else if (pp->pln_effic < PLANE_MINEFF) {
- /* destroyed */
- if (pp->pln_ship >= 0) {
- getship(pp->pln_ship, &ship);
- take_plane_off_ship(pp, &ship);
- }
- if (pp->pln_land >= 0) {
- getland(pp->pln_land, &land);
- take_plane_off_land(pp, &land);
- }
+ ; /* destroyed */
} else if (pp->pln_ship >= 0) {
/* It is landing on a carrier */
getship(pp->pln_ship, &ship);
}
/*
- * Fit a plane of PP's type on ship SP.
- * Adjust SP's plane counters.
- * Updating the plane accordingly is the caller's job.
- * Return whether it fits.
+ * 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.
*/
-static int
-fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
+int
+could_be_on_ship(struct plnstr *pp, struct shpstr *sp,
+ int n, int nch, int nxl, int nmsl)
{
- struct plchrstr *pcp = plchr + pp->pln_type;
- struct mchrstr *mcp = mchr + sp->shp_type;
- int wanted;
-
- if (pcp->pl_flags & P_K) {
- /* chopper, try chopper slot first */
- if (sp->shp_nchoppers < mcp->m_nchoppers)
- return ++sp->shp_nchoppers;
- /* else try plane slot */
- wanted = M_FLY;
- } else if (pcp->pl_flags & P_E) {
- /* x-light, try x-light slot first */
- if (sp->shp_nxlight < mcp->m_nxlight)
- return ++sp->shp_nxlight;
- /* else try plane slot */
- wanted = M_MSL | M_FLY;
- } else if (!(pcp->pl_flags & P_L)) {
- /* not light, no go */
- wanted = 0;
- } else if (pcp->pl_flags & P_M) {
- /* missile, use plane slot */
- wanted = M_MSL | M_FLY;
- } else {
- /* fixed-wing plane, use plane slot */
- wanted = M_FLY;
- }
-
- if ((mcp->m_flags & wanted) == 0)
- return 0; /* ship not capable */
-
- if (sp->shp_nplane < mcp->m_nplanes)
- return ++sp->shp_nplane;
-
- return 0;
+ struct plchrstr *pcp = &plchr[pp->pln_type];
+ struct mchrstr *mcp = &mchr[sp->shp_type];
+
+ 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;
}
/*
- * Fit a plane of PP's type off ship SP.
- * Adjust SP's plane counters, badly. You need to run count_planes()
- * before the next fit_plane_on_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 void
-fit_plane_off_ship(struct plnstr *pp, struct shpstr *sp)
+static int
+fit_plane_on_ship(struct plnstr *pp, struct shpstr *sp)
{
- /*
- * Frees chopper and nxlight slots first, which is why we need to
- * run count_planes() before fit_plane_on_ship().
- */
- struct plchrstr *pcp = plchr + pp->pln_type;
-
- if (pcp->pl_flags & P_K) {
- if (sp->shp_nchoppers) {
- sp->shp_nchoppers--;
- return;
- }
- } else if (pcp->pl_flags & P_E) {
- if (sp->shp_nxlight) {
- sp->shp_nxlight--;
- return;
- }
- }
+ int n, nch, nxl, nmsl;
- if (CANT_HAPPEN(sp->shp_nplane == 0))
- sp->shp_nplane = 1;
- sp->shp_nplane--;
+ n = shp_nplane(sp, &nch, &nxl, &nmsl);
+ return could_be_on_ship(pp, sp, n, nch, nxl, nmsl);
}
int
plane->pln_y = ship->shp_y;
plane->pln_ship = ship->shp_uid;
putplane(plane->pln_uid, plane);
- putship(ship->shp_uid, ship);
return 1;
}
-void
-take_plane_off_ship(struct plnstr *plane, struct shpstr *ship)
-{
- if (CANT_HAPPEN(plane->pln_ship != ship->shp_uid))
- return;
-
- fit_plane_off_ship(plane, ship);
- plane->pln_ship = -1;
- putship(ship->shp_uid, ship);
- putplane(plane->pln_uid, plane);
-}
-
/*
* Fit a plane of PP's type on land unit LP.
- * Adjust LP's plane counters.
* Updating the plane accordingly is the caller's job.
* Return whether it fits.
*/
struct plchrstr *pcp = plchr + pp->pln_type;
struct lchrstr *lcp = lchr + lp->lnd_type;
- if ((pcp->pl_flags & P_E) && lp->lnd_nxlight < lcp->l_nxlight)
- return ++lp->lnd_nxlight;
-
- return 0;
-}
-
-/*
- * Fit a plane of PP's type off land unit LP.
- * Adjust LP's plane counters.
- * Updating the plane accordingly is the caller's job.
- */
-static void
-fit_plane_off_land(struct plnstr *pp, struct lndstr *lp)
-{
- if (CANT_HAPPEN(lp->lnd_nxlight == 0))
- lp->lnd_nxlight = 1;
- lp->lnd_nxlight--;
+ return (pcp->pl_flags & P_E) && lnd_nxlight(lp) < lcp->l_nxlight;
}
int
plane->pln_y = land->lnd_y;
plane->pln_land = land->lnd_uid;
putplane(plane->pln_uid, plane);
- putland(land->lnd_uid, land);
return 1;
}
-void
-take_plane_off_land(struct plnstr *plane, struct lndstr *land)
-{
- if (CANT_HAPPEN(plane->pln_land != land->lnd_uid))
- return;
-
- fit_plane_off_land(plane, land);
- plane->pln_land = -1;
- putland(land->lnd_uid, land);
- putplane(plane->pln_uid, plane);
-}
-
-/*
- * Could a plane of PP's type be on on ship SP?
- */
-int
-could_be_on_ship(struct plnstr *pp, struct shpstr *sp)
-{
- struct shpstr ship;
-
- ship = *sp;
- ship.shp_nplane = ship.shp_nchoppers = ship.shp_nxlight = 0;
- return fit_plane_on_ship(pp, &ship);
-}
-
void
plane_sweep(struct emp_qelem *plane_list, coord x, coord y)
{
putsect(§);
}
-void
-count_planes(struct shpstr *sp)
-{
- struct nstr_item ni;
- struct plnstr plane;
- int nplane, nchoppers, nxlight;
-
- if (sp->shp_effic < SHIP_MINEFF)
- return;
-
- nplane = sp->shp_nplane;
- sp->shp_nplane = 0;
- nchoppers = sp->shp_nchoppers;
- sp->shp_nchoppers = 0;
- nxlight = sp->shp_nxlight;
- sp->shp_nxlight = 0;
-
- snxtitem_xy(&ni, EF_PLANE, sp->shp_x, sp->shp_y);
- while (nxtitem(&ni, &plane)) {
- if (plane.pln_own == 0)
- continue;
- if (plane.pln_ship == sp->shp_uid) {
- if (!fit_plane_on_ship(&plane, sp))
- CANT_REACH();
- }
- }
-
- if (nplane != sp->shp_nplane ||
- nxlight != sp->shp_nxlight || nchoppers != sp->shp_nchoppers) {
- putship(sp->shp_uid, sp);
- }
-}
-
-void
-count_land_planes(struct lndstr *lp)
-{
- struct nstr_item ni;
- struct plnstr plane;
- int nplane;
-
- if (lp->lnd_effic < LAND_MINEFF)
- return;
-
- nplane = lp->lnd_nxlight;
- lp->lnd_nxlight = 0;
-
- snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, &plane)) {
- if (plane.pln_own == 0)
- continue;
- if (plane.pln_land == lp->lnd_uid)
- if (!fit_plane_on_land(&plane, lp))
- CANT_REACH();
- }
-
- if (lp->lnd_nxlight != nplane)
- putland(lp->lnd_uid, lp);
-}
-
int
pln_hitchance(struct plnstr *pp, int hardtarget, int type)
{
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");
- pp->pln_nuketype = -1;
*nukedamp = detonate(&nuke, x, y,
pp->pln_flags & PLN_AIRBURST);
return 0;