int
torp(void)
{
natid vshipown;
int range;
int dam;
int subno;
int victno;
int erange;
double hitchance;
struct shpstr vship;
struct shpstr sub;
struct mchrstr *sub_mcp;
char *ptr;
struct nstr_item nbst;
char buf[1024];
int ntorping = 0;
char prompt[128];
if (!snxtitem(&nbst, EF_SHIP, player->argp[1], "From ship(s)? "))
return RET_SYN;
while (nxtitem(&nbst, &sub)) {
if (sub.shp_own != player->cnum)
continue;
if ((mchr[(int)sub.shp_type].m_flags & M_TORP) == 0)
continue;
if (sub.shp_item[I_GUN] == 0
|| sub.shp_item[I_SHELL] < SHP_TORP_SHELLS)
continue;
if (sub.shp_item[I_MILIT] < 1)
continue;
if (sub.shp_effic < 60)
continue;
if (sub.shp_mobil <= 0)
continue;
ntorping++;
}
pr("%d ships are eligible to torpedo\n", ntorping);
snxtitem_rewind(&nbst);
while (nxtitem(&nbst, &sub)) {
if (!sub.shp_own)
continue;
if (sub.shp_own != player->cnum) {
continue;
}
sub_mcp = &mchr[sub.shp_type];
if (!(sub_mcp->m_flags & M_TORP)) {
pr("Ship # %d: A %s can't fire torpedoes!\n",
sub.shp_uid, sub_mcp->m_name);
continue;
}
if (sub.shp_item[I_GUN] == 0
|| sub.shp_item[I_SHELL] < SHP_TORP_SHELLS) {
pr("Ship #%d has insufficient armament\n", sub.shp_uid);
continue;
}
if (sub.shp_item[I_MILIT] < 1) {
pr("Ship #%d has insufficient crew\n", sub.shp_uid);
continue;
}
if (sub.shp_effic < 60) {
pr("Ship #%d torpedo tubes inoperative.\n", sub.shp_uid);
continue;
}
if (sub.shp_mobil <= 0) {
pr("Ship #%d has insufficient mobility\n", sub.shp_uid);
continue;
}
subno = sub.shp_uid;
sprintf(prompt, "Ship %d, target? ", sub.shp_uid);
if (!(ptr = getstarg(player->argp[2], prompt, buf)))
return RET_SYN;
if (!check_ship_ok(&sub))
return RET_FAIL;
if ((victno = atoi(ptr)) < 0)
return RET_SYN;
if (!getship(victno, &vship))
return RET_FAIL;
if (!vship.shp_own)
return RET_FAIL;
vshipown = vship.shp_own;
if (victno == subno) {
pr("Shooting yourself, eh? How strange...\n");
continue;
}
if (mchr[(int)vship.shp_type].m_flags & M_SUB) {
if (!(sub_mcp->m_flags & M_SUBT)) {
pr("You can't torpedo a submarine!\n");
continue;
}
}
dam = shp_torp(&sub, 1);
sub.shp_mission = 0;
putship(sub.shp_uid, &sub);
if (CANT_HAPPEN(dam < 0)) {
pr("Ship #%d has insufficient armament\n", sub.shp_uid);
continue;
}
if (!(sub_mcp->m_flags & M_SUB)) {
pr("Starting our attack run...\n");
anti_torp(sub.shp_uid, ntorping, vshipown);
}
getship(sub.shp_uid, &sub);
if (sub.shp_own == 0)
continue;
erange = roundrange(torprange(&sub));
pr("Effective torpedo range is %d.0\n", erange);
pr("Whooosh... ");
getship(victno, &vship);
vshipown = vship.shp_own;
range = mapdist(sub.shp_x, sub.shp_y, vship.shp_x, vship.shp_y);
hitchance = shp_torp_hitchance(&sub, range);
if (range <= erange) {
pr("Hitchance = %.0f%%\n", hitchance * 100);
}
if (range > erange)
pr("Out of range\n");
else if (!line_of_sight(NULL, sub.shp_x, sub.shp_y,
vship.shp_x, vship.shp_y)) {
pr("BOOM!... Torpedo slams into land before reaching target.\n");
/* We only tell the victim if we were within range. */
if (vshipown != 0 && vshipown != player->cnum)
wu(0, vshipown, "Torpedo sighted @ %s by %s\n",
xyas(sub.shp_x, sub.shp_y, vshipown),
prship(&vship));
} else if (chance(hitchance)) {
pr("BOOM!...\n");
if (vshipown != 0 && vshipown != player->cnum)
wu(0, vshipown, "%s in %s torpedoed %s for %d damage.\n",
sub_mcp->m_flags & M_SUB ? "sub" : prship(&sub),
xyas(sub.shp_x, sub.shp_y, vshipown),
prship(&vship), dam);
pr("Torpedo hit %s for %d damage.\n", prsub(&vship), dam);
if (!(mchr[vship.shp_type].m_flags & M_SUB)) {
if (mchr[sub.shp_type].m_flags & M_SUB)
nreport(vshipown, N_TORP_SHIP, 0, 1);
else
nreport(vshipown, N_SHIP_TORP, player->cnum, 1);
}
shipdamage(&vship, dam);
if (vship.shp_effic < SHIP_MINEFF)
pr("%s sunk!\n", prsub(&vship));
if (vship.shp_rflags & RET_TORPED)
retreat_ship(&vship, vshipown, 't');
putship(vship.shp_uid, &vship);
} else {
pr("Missed\n");
if (vshipown != 0 && vshipown != player->cnum)
wu(0, vshipown, "Torpedo sighted @ %s by %s\n",
xyas(sub.shp_x, sub.shp_y, vshipown), prship(&vship));
}
if (sub_mcp->m_flags & M_SUB)
anti_torp(sub.shp_uid, ntorping, vshipown);
}
return RET_OK;
}
int
sona(void)
{
struct nstr_item ni, nit;
struct sctstr sect;
struct shpstr ship;
struct shpstr targ;
struct natstr *natp;
struct mchrstr *mcp;
struct mchrstr *tmcp;
struct nstr_sect ns;
int range;
int visib, pingrange;
int srange;
int vrange;
int dist;
int x, y;
int cx, cy;
int changed = 0;
int row;
/* Where these are used are non-re-entrant, so we keep 'em around */
static char **rad = NULL;
static char *radbuf = NULL;
static signed char **vis = NULL;
static signed char *visbuf = NULL;
if (!snxtitem(&ni, EF_SHIP, player->argp[1], NULL))
return RET_SYN;
if (!radbuf)
radbuf = malloc(WORLD_Y * MAPWIDTH(1));
if (!visbuf)
visbuf = malloc(WORLD_Y * MAPWIDTH(1));
if (!rad && radbuf) {
rad = malloc(WORLD_Y * sizeof(char *));
if (rad) {
for (x = 0; x < WORLD_Y; x++) {
rad[x] = &radbuf[(WORLD_X + 1) * x];
}
}
}
if (!vis && visbuf) {
vis = malloc(WORLD_Y * sizeof(signed char *));
if (vis) {
for (x = 0; x < WORLD_Y; x++) {
vis[x] = &visbuf[(WORLD_X + 1) * x];
}
}
}
if (!radbuf || !visbuf || !rad || !vis) {
pr("Memory error, tell the deity.\n");
logerror("malloc failed in sona\n");
return RET_FAIL;
}
while (nxtitem(&ni, &ship)) {
if (!player->owner)
continue;
mcp = &mchr[(int)ship.shp_type];
if (!(mcp->m_flags & M_SONAR))
continue;
getsect(ship.shp_x, ship.shp_y, §);
if (sect.sct_type != SCT_WATER)
continue;
range = (int)techfact(ship.shp_tech, mcp->m_vrnge);
srange = MIN(7, 7 * range * ship.shp_effic / 200);
pr("%s at %s efficiency %d%%, max range %d\n",
prship(&ship),
xyas(ship.shp_x, ship.shp_y, player->cnum),
ship.shp_effic, srange);
snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
blankfill(radbuf, &ns.range, 1);
while (nxtsct(&ns, §)) {
if (player->owner || sect.sct_type == SCT_WATER)
rad[ns.dy][ns.dx] = dchr[sect.sct_type].d_mnem;
else {
rad[ns.dy][ns.dx] = '?';
}
}
snxtsct_dist(&ns, ship.shp_x, ship.shp_y, srange);
cx = deltx(&ns.range, ship.shp_x);
cy = delty(&ns.range, ship.shp_y);
while (nxtsct(&ns, §)) {
if (!line_of_sight(rad, cx, cy, ns.dx, ns.dy)) {
rad[ns.dy][ns.dx] = ' ';
continue;
}
if (ship.shp_tech >= 310 && sect.sct_type == SCT_WATER) {
if (sect.sct_mines) {
pr("Sonar detects %d mines in %s!\n",
sect.sct_mines,
xyas(sect.sct_x, sect.sct_y, player->cnum));
rad[ns.dy][ns.dx] = 'X';
}
}
changed |= map_set(player->cnum, sect.sct_x, sect.sct_y,
rad[ns.dy][ns.dx], 0);
}
memset(visbuf, 0, (WORLD_Y * (WORLD_X + 1)));
snxtitem_dist(&nit, EF_SHIP, ship.shp_x, ship.shp_y, range);
while (nxtitem(&nit, &targ)) {
if (targ.shp_own == player->cnum || targ.shp_own == 0)
continue;
tmcp = &mchr[(int)targ.shp_type];
visib = shp_visib(&targ);
pingrange = MIN(7, MAX(visib, 10) * range / 10);
vrange = pingrange * ship.shp_effic / 200;
dist = mapdist(targ.shp_x, targ.shp_y, ship.shp_x, ship.shp_y);
pingrange = (MAX(pingrange, 2) * targ.shp_effic) / 100;
if (dist > pingrange)
continue;
if (tmcp->m_flags & M_SONAR && targ.shp_own) {
natp = getnatp(targ.shp_own);
if (natp->nat_flags & NF_SONAR)
wu(0, targ.shp_own,
"Sonar ping from %s detected by %s!\n",
xyas(ship.shp_x, ship.shp_y,
targ.shp_own), prship(&targ));
if (targ.shp_rflags & RET_SONARED)
retreat_ship(&targ, targ.shp_own, 's');
}
if (dist > vrange)
continue;
x = deltx(&ns.range, (int)targ.shp_x);
y = delty(&ns.range, (int)targ.shp_y);
if (rad[y][x] != dchr[SCT_WATER].d_mnem && rad[y][x] != 'X')
continue;
if (tmcp->m_flags & M_SUB &&
relations_with(targ.shp_own, player->cnum) < FRIENDLY) {
if (mcp->m_vrnge + visib < 8)
pr("Sonar detects sub #%d @ %s\n",
targ.shp_uid,
xyas(targ.shp_x, targ.shp_y, player->cnum));
else if (mcp->m_vrnge + visib < 10)
pr("Sonar detects %s @ %s\n",
prship(&targ),
xyas(targ.shp_x, targ.shp_y, player->cnum));
else
pr("Sonar detects %s %s @ %s\n",
cname(targ.shp_own), prship(&targ),
xyas(targ.shp_x, targ.shp_y, player->cnum));
} else
pr("Sonar detects %s %s @ %s\n",
cname(targ.shp_own), prship(&targ),
xyas(targ.shp_x, targ.shp_y, player->cnum));
if (visib > vis[y][x]) {
vis[y][x] = visib;
/* &~0x20 makes it a cap letter */
rad[y][x] = (*mchr[(int)targ.shp_type].m_name) & ~0x20;
}
}
if (!player->argp[2]) {
rad[cy][cx] = '0';
for (row = 0; row < ns.range.height; row++)
if (!blankrow(rad[row]))
pr("%s\n", rad[row]);
}
pr("\n");
}
if (changed)
writemap(player->cnum);
return RET_OK;
}
int
boar(void)
{
struct combat off[1]; /* boarding ship or sector */
struct combat def[1]; /* defending ship */
struct emp_qelem olist; /* boarding units */
struct emp_qelem dlist; /* defending units */
int ototal; /* total boarding strength */
int a_engineer = 0; /* boarder engineers are present */
int a_spy = 0; /* the best boarder scout */
struct shpstr ship; /* for retreating */
struct sctstr sect;
struct lndstr land;
struct nstr_item ni;
int foundland, def_uid;
natid def_own;
char *p;
char buf[1024];
att_combat_init(def, EF_SHIP);
/*
* Collect input from the boarder
*/
/* What are we boarding? */
p = getstarg(player->argp[1], "Victim ship #? ", buf);
if (!p || (def->shp_uid = atoi(p)) < 0)
return RET_SYN;
/*
* Ask the boarder what he wants to board with
*/
if (!(p = getstarg(player->argp[2], "Boarding party from? ", buf)))
return RET_SYN;
if (issector(p)) {
att_combat_init(off, EF_SECTOR);
if (!sarg_xy(p, &off->x, &off->y))
return RET_SYN;
getsect(off->x, off->y, §);
if (sect.sct_own != player->cnum) {
pr("You don't own %s!\n", xyas(off->x, off->y, player->cnum));
return RET_SYN;
}
if (sect.sct_mobil <= 0) {
/* Look for land units with mobility */
snxtitem_xy(&ni, EF_LAND, off->x, off->y);
foundland = 0;
while (nxtitem(&ni, &land)) {
if (land.lnd_own != player->cnum)
continue;
if (land.lnd_ship >= 0 || land.lnd_land >= 0)
continue;
if (land.lnd_mobil <= 0)
continue;
/* Only land units with assault can board */
if (!(lchr[(int)land.lnd_type].l_flags & L_ASSAULT))
continue;
foundland = 1;
}
if (!foundland) {
pr("You don't have any mobility (sector or land units) in %s!\n",
xyas(off->x, off->y, player->cnum));
return RET_SYN;
}
}
} else {
att_combat_init(off, EF_SHIP);
if ((off->shp_uid = atoi(p)) < 0)
return RET_SYN;
}
if (att_abort(A_BOARD, off, def)) {
pr("Board aborted\n");
return RET_OK;
}
/* Fire at the attacking ship */
att_approach(off, def);
if (att_abort(A_BOARD, off, def)) {
pr("Board aborted\n");
att_empty_attack(A_BOARD, 0, def);
return RET_OK;
}
/* Show what we're boarding */
att_show(def);
/* Ask the player what he wants to board with */
att_ask_offense(A_BOARD, off, def, &olist, &a_spy, &a_engineer);
if (att_abort(A_BOARD, off, def)) {
pr("Board aborted\n");
att_empty_attack(A_BOARD, 0, def);
return att_free_lists(&olist, NULL);
}
ototal = att_get_offense(A_BOARD, off, &olist, def);
if (att_abort(A_BOARD, off, def)) {
pr("Board aborted\n");
att_empty_attack(A_BOARD, 0, def);
return att_free_lists(&olist, NULL);
}
/*
* We have now got all the answers from the boarder. From this point
* forward, we can assume that this battle is the _only_ thing
* happening in the game.
*/
/* Get the real defense */
att_get_defense(&olist, def, &dlist, a_spy, ototal);
/*
* Death, carnage, and destruction.
*/
/*
* Careful: when the fight sinks the ship, put_combat() clobbers
* *def (see FIXME there).
*/
def_uid = def->shp_uid;
def_own = def->own;
if (!(att_fight(A_BOARD, off, &olist, 1.0, def, &dlist, 1.0))) {
getship(def_uid, &ship);
if (ship.shp_rflags & RET_BOARDED) {
retreat_ship(&ship, def_own, 'u');
putship(def_uid, &ship);
}
}
return RET_OK;
}