int
sate(void)
{
static int sct_shp_or_lnd[] = { EF_SECTOR, EF_SHIP, EF_LAND, EF_BAD };
double tech;
int pln_uid;
struct plnstr plane;
int type = EF_BAD;
if (!player->argp[1] ||
!*player->argp[1] ||
!isdigit(*player->argp[1]) ||
(pln_uid = atoi(player->argp[1])) < 0)
return RET_SYN;
if (!getplane(pln_uid, &plane)) {
pr("No such plane\n");
return RET_FAIL;
}
if (plane.pln_own != player->cnum && !player->god) {
pr("You don't own plane #%d\n", pln_uid);
return RET_FAIL;
}
if (!pln_is_in_orbit(&plane)) {
pr("%s isn't in orbit\n", prplane(&plane));
return RET_FAIL;
}
if (plane.pln_mobil < plane_mob_max) {
pr("%s doesn't have enough mobility (needs %d)\n",
prplane(&plane), plane_mob_max);
return RET_FAIL;
}
if (player->argp[2]) {
type = ef_byname_from(player->argp[2], sct_shp_or_lnd);
if (type < 0) {
return RET_SYN;
}
}
if (plchr[(int)plane.pln_type].pl_flags & P_S)
pr("Satellite Spy Report:\n");
else
pr("Satellite Map Report:\n");
pr("%s at ", prplane(&plane));
tech = techfact(plane.pln_tech, 20.0);
return satmap(plane.pln_x, plane.pln_y, plane.pln_effic,
(int)tech, plchr[(int)plane.pln_type].pl_flags, type);
}
int
prod_plane(int etus, int natnum, struct bp *bp, int buildem)
/* Build = 1, maintain =0 */
{
struct plnstr *pp;
struct natstr *np;
int n, k = 0;
int start_money;
for (n = 0; NULL != (pp = getplanep(n)); n++) {
if (pp->pln_own == 0)
continue;
if (pp->pln_own != natnum)
continue;
if (pp->pln_effic < PLANE_MINEFF) {
makelost(EF_PLANE, pp->pln_own, pp->pln_uid,
pp->pln_x, pp->pln_y);
pp->pln_own = 0;
continue;
}
if (pln_is_in_orbit(pp)) {
if (!player->simulation && buildem == 0
&& !(pp->pln_flags & PLN_SYNCHRONOUS))
move_sat(pp);
continue;
}
np = getnatp(pp->pln_own);
start_money = np->nat_money;
upd_plane(pp, etus, np, bp, buildem);
air_money[pp->pln_own] += np->nat_money - start_money;
if (buildem == 0 || np->nat_money != start_money)
k++;
if (player->simulation)
np->nat_money = start_money;
}
return k;
}
int
pdump(void)
{
int nplanes;
struct nstr_item np;
struct plnstr plane;
struct nukstr nuke;
int field[128];
struct natstr *natp;
int n, i;
time_t now;
if (!snxtitem(&np, EF_PLANE, player->argp[1], NULL))
return RET_SYN;
prdate();
if (!player->argp[2]) {
for (n = 1; n <= 32; n++)
field[n - 1] = n;
field[n - 1] = 0;
} else {
n = 2;
i = 0;
while (player->argp[n]) {
if (!strcmp("type", player->argp[n])) {
field[i++] = 1;
} else if (!strcmp("x", player->argp[n])) {
field[i++] = 2;
} else if (!strcmp("y", player->argp[n])) {
field[i++] = 3;
} else if (!strcmp("wing", player->argp[n])) {
field[i++] = 4;
} else if (!strcmp("eff", player->argp[n])) {
field[i++] = 5;
} else if (!strcmp("mob", player->argp[n])) {
field[i++] = 6;
} else if (!strcmp("tech", player->argp[n])) {
field[i++] = 7;
} else if (!strcmp("att", player->argp[n])) {
field[i++] = 8;
} else if (!strcmp("def", player->argp[n])) {
field[i++] = 9;
} else if (!strcmp("acc", player->argp[n])) {
field[i++] = 10;
} else if (!strcmp("react", player->argp[n])) {
field[i++] = 11;
} else if (!strcmp("range", player->argp[n])) {
field[i++] = 12;
} else if (!strcmp("load", player->argp[n])) {
field[i++] = 13;
} else if (!strcmp("fuel", player->argp[n])) {
field[i++] = 14;
} else if (!strcmp("hard", player->argp[n])) {
field[i++] = 15;
} else if (!strcmp("ship", player->argp[n])) {
field[i++] = 16;
} else if (!strcmp("land", player->argp[n])) {
field[i++] = 17;
} else if (!strcmp("laun", player->argp[n])) {
field[i++] = 18;
} else if (!strcmp("orb", player->argp[n])) {
field[i++] = 19;
} else if (!strcmp("nuke", player->argp[n])) {
field[i++] = 20;
} else if (!strcmp("grd", player->argp[n])) {
field[i++] = 21;
} else {
pr("Unrecognized field %s\n", player->argp[n]);
}
if (n++ > 100) {
pr("Too many fields\n");
return RET_FAIL;
}
}
field[i] = 0;
}
if (player->god)
pr(" ");
time(&now);
pr("DUMP PLANES %ld\n", (long)now);
if (player->god)
pr("own ");
pr("id");
n = 0;
while (field[n]) {
switch (field[n]) {
case 1:
pr(" type");
break;
case 2:
pr(" x");
break;
case 3:
pr(" y");
break;
case 4:
pr(" wing");
break;
case 5:
pr(" eff");
break;
case 6:
pr(" mob");
break;
case 7:
pr(" tech");
break;
case 8:
pr(" att");
break;
case 9:
pr(" def");
break;
case 10:
pr(" acc");
break;
case 11:
pr(" react");
break;
case 12:
pr(" range");
break;
case 13:
pr(" load");
break;
case 14:
pr(" fuel");
break;
case 15:
pr(" hard");
break;
case 16:
pr(" ship");
break;
case 17:
pr(" land");
break;
case 18:
pr(" laun");
break;
case 19:
pr(" orb");
break;
case 20:
pr(" nuke");
break;
case 21:
pr(" grd");
break;
}
n++;
}
pr("\n");
nplanes = 0;
natp = getnatp(player->cnum);
while (nxtitem(&np, &plane)) {
if (!player->owner || plane.pln_own == 0)
continue;
nplanes++;
if (player->god)
pr("%d ", plane.pln_own);
pr("%d", np.cur);
n = 0;
while (field[n]) {
switch (field[n++]) {
case 1:
pr(" %.4s", plchr[(int)plane.pln_type].pl_name);
break;
case 2:
pr(" %d", xrel(natp, plane.pln_x));
break;
case 3:
pr(" %d", yrel(natp, plane.pln_y));
break;
case 4:
pr(" %c", plane.pln_wing ? plane.pln_wing : '~');
break;
case 5:
pr(" %d", plane.pln_effic);
break;
case 6:
pr(" %d", plane.pln_mobil);
break;
case 7:
pr(" %d", plane.pln_tech);
break;
case 8:
pr(" %d", pln_att(&plane));
break;
case 9:
pr(" %d", pln_def(&plane));
break;
case 10:
pr(" %d", pln_acc(&plane));
break;
case 11:
pr(" %d", plane.pln_range);
break;
case 12:
pr(" %d", pln_range_max(&plane));
break;
case 13:
pr(" %d", pln_load(&plane));
break;
case 14:
pr(" %d", plchr[(int)plane.pln_type].pl_fuel);
break;
case 15:
pr(" %d", plane.pln_harden);
break;
case 16:
pr(" %d", plane.pln_ship);
break;
case 17:
pr(" %d", plane.pln_land);
break;
case 18:
pr(pln_is_in_orbit(&plane) ? " Y" : " N");
break;
case 19:
pr(pln_is_in_orbit(&plane)
&& (plane.pln_flags & PLN_SYNCHRONOUS)
? " Y" : " N");
break;
case 20:
if (getnuke(nuk_on_plane(&plane), &nuke)) {
pr(" %.5s", nchr[nuke.nuk_type].n_name);
break;
} else
pr(" N/A");
break;
case 21:
pr(" %c", plane.pln_flags & PLN_AIRBURST ? 'A' : 'G');
break;
}
}
pr("\n");
}
if (nplanes == 0) {
if (player->argp[1])
pr("%s: No plane(s)\n", player->argp[1]);
else
pr("%s: No plane(s)\n", "");
return RET_FAIL;
} else
pr("%d plane%s\n", nplanes, splur(nplanes));
return RET_OK;
}
/*
* format: trade
*/
int
trad(void)
{
struct sctstr sect;
struct natstr *natp;
struct comstr comt;
int lotno;
float price;
coord sx, sy;
int n;
char *p;
struct nstr_item ni;
struct trdstr trade;
struct trdstr tmpt;
union empobj_storage tg;
double canspend;
time_t now, tleft;
int bid;
double tally;
int i;
char buf[1024];
if (!opt_MARKET) {
pr("The market is disabled.\n");
return RET_FAIL;
}
/* First, we execute all trades, so that we can only buy what is available. */
check_market();
check_trade();
pr("\n Empire Trade Report\n ");
prdate();
n = 0;
pr(" lot high bid by time left owner description\n");
pr(" --- -------- -- --------- ----- -------------------------\n");
snxtitem_all(&ni, EF_TRADE);
while (nxtitem(&ni, &trade)) {
if (trade.trd_owner == 0)
continue;
if (!trade_getitem(&trade, &tg)) {
continue;
};
pr(" %3d ", ni.cur);
(void)time(&now);
tleft = trade.trd_markettime + TRADE_DELAY - now;
if (tleft < 0)
tleft = 0;
pr("$%7d %2d %5.2f hrs ",
trade.trd_price, trade.trd_maxbidder, tleft / 3600.0);
trade_desc(&tg.gen); /* XXX */
pr("\n");
if (trade.trd_owner == player->cnum && !player->god)
pr(" (your own lot)\n");
n++;
}
if (n == 0) {
pr("Nothing to buy at the moment...\n");
return RET_OK;
}
p = getstring("Which lot to buy: ", buf);
if (!p || !*p)
return RET_OK;
if (isdigit(*p) == 0)
return RET_OK;
lotno = atoi(p);
if (lotno < 0 || lotno >= ni.cur) {
pr("Bad lot number\n");
return RET_OK;
}
if (!gettrade(lotno, &trade)) {
pr("No such lot number\n");
return RET_OK;
}
if (trade.trd_unitid < 0) {
pr("Invalid lot number.\n");
return RET_OK;
}
if (!trade_getitem(&trade, &tg)) {
pr("Can't find trade #%d!\n", trade.trd_unitid);
trade.trd_owner = 0;
trade.trd_unitid = -1;
if (!puttrade(lotno, &trade)) {
logerror("trad: can't write trade");
pr("Couldn't save after getitem failed; get help!\n");
return RET_FAIL;
}
return RET_OK;
}
switch (trade.trd_type) {
case EF_NUKE:
case EF_PLANE:
case EF_SHIP:
case EF_LAND:
break;
default:
pr("Bad unit type on lot number %d\n", lotno);
return RET_FAIL;
}
if (trade.trd_owner == player->cnum) {
pr("You can't buy from yourself!\n");
return RET_OK;
}
price = trade.trd_price;
natp = getnatp(player->cnum);
if (natp->nat_money < price) {
pr("You don't have %.2f to spend!\n", price);
return RET_OK;
}
tally = 0.0;
for (i = 0; gettrade(i, &tmpt); i++) {
if (tmpt.trd_maxbidder == player->cnum &&
tmpt.trd_unitid >= 0 && tmpt.trd_owner != player->cnum) {
tally += tmpt.trd_price * tradetax;
}
}
for (i = 0; getcomm(i, &comt); i++) {
if (comt.com_maxbidder == player->cnum &&
comt.com_owner != 0 && comt.com_owner != player->cnum) {
tally += (comt.com_price * comt.com_amount) * buytax;
}
}
canspend = natp->nat_money - tally;
/* Find the destination sector for the trade */
if (((trade.trd_type == EF_PLANE) && !pln_is_in_orbit(&tg.plane))
|| (trade.trd_type == EF_NUKE)) {
while (1) {
p = getstring("Destination sector: ", buf);
if (!trade_check_ok(&trade, &tg.gen))
return RET_FAIL;
if (!p) {
return RET_FAIL;
}
if (!sarg_xy(p, &sx, &sy) || !getsect(sx, sy, §)) {
pr("Bad sector designation; try again!\n");
continue;
}
if (!player->owner) {
pr("You don't own that sector; try again!\n");
continue;
}
if (!(plchr[tg.plane.pln_type].pl_flags & P_V)) {
if (!player->god && (sect.sct_type != SCT_AIRPT)) {
pr("Destination sector is not an airfield!\n");
continue;
}
if (!player->god && (sect.sct_effic < 60)) {
pr("That airport still under construction!\n");
continue;
}
}
break;
}
} else if (trade.trd_type == EF_LAND) {
while (1) {
p = getstring("Destination sector: ", buf);
if (!trade_check_ok(&trade, &tg.gen))
return RET_FAIL;
if (!p) {
return RET_FAIL;
}
if (!sarg_xy(p, &sx, &sy) || !getsect(sx, sy, §)) {
pr("Bad sector designation; try again!\n");
continue;
}
if (!player->owner) {
pr("You don't own that sector; try again!\n");
continue;
}
if (!player->god && (sect.sct_type != SCT_HEADQ)) {
pr("Destination sector is not a headquarters!\n");
continue;
}
if (!player->god && (sect.sct_effic < 60)) {
pr("That headquarters still under construction!\n");
continue;
}
break;
}
} else {
/* This trade doesn't teleport; make destination invalid */
sx = 1;
sy = 0;
}
p = getstring("How much do you bid: ", buf);
if (!p || !*p)
return RET_OK;
if (!trade_check_ok(&trade, &tg.gen))
return RET_FAIL;
bid = atoi(p);
if (bid < price)
bid = price;
if (bid > canspend) {
pr("You don't have %.2f to spend!\n", price);
return RET_OK;
}
if (bid > trade.trd_price) {
time(&now);
if (trade.trd_markettime + TRADE_DELAY - now < minutes(5) &&
trade.trd_maxbidder != player->cnum)
trade.trd_markettime = now + minutes(5) - TRADE_DELAY;
trade.trd_price = bid;
trade.trd_maxbidder = player->cnum;
trade.trd_x = sx;
trade.trd_y = sy;
pr("Your bid on lot #%d is being considered.\n", lotno);
if (!puttrade(lotno, &trade))
pr("Problems with the trade file. Get help\n");
} else
pr("Your bid wasn't high enough (you need to bid more than someone else.)\n");
check_trade();
return RET_OK;
}
int
check_trade(void)
{
int n;
struct natstr *natp;
struct trdstr trade;
union empobj_storage tg;
time_t now;
int price;
int saveid;
natid seller;
for (n = 0; gettrade(n, &trade); n++) {
if (trade.trd_unitid < 0)
continue;
if (!trade_getitem(&trade, &tg))
continue;
if (tg.gen.own == 0) {
trade.trd_owner = 0;
trade.trd_unitid = -1;
puttrade(n, &trade);
continue;
}
if (tg.gen.own != trade.trd_owner) {
logerror("Something weird, tg.gen.own != trade.trd_owner!\n");
trade.trd_owner = 0;
trade.trd_unitid = -1;
puttrade(n, &trade);
continue;
}
if (trade.trd_owner == trade.trd_maxbidder)
continue;
(void)time(&now);
if (trade.trd_markettime + TRADE_DELAY > now)
continue;
saveid = trade.trd_unitid;
seller = trade.trd_owner;
trade.trd_owner = 0;
trade.trd_unitid = -1;
if (!puttrade(n, &trade)) {
logerror("Couldn't save trade after purchase; get help!\n");
continue;
}
price = trade.trd_price;
natp = getnatp(trade.trd_maxbidder);
if (natp->nat_money < price) {
nreport(trade.trd_maxbidder, N_WELCH_DEAL, seller, 1);
wu(0, seller,
"%s tried to buy a %s #%d from you for $%.2f\n",
cname(trade.trd_maxbidder), trade_nameof(&trade, &tg.gen),
saveid, price * tradetax);
wu(0, seller, " but couldn't afford it.\n");
wu(0, seller,
" Your item was taken off the market.\n");
wu(0, trade.trd_maxbidder,
"You tried to buy %s #%d from %s for $%d\n",
trade_nameof(&trade, &tg.gen), saveid, cname(seller),
price);
wu(0, trade.trd_maxbidder, "but couldn't afford it.\n");
continue;
}
/* If we get this far, the sale will go through. */
natp->nat_money -= price;
putnat(natp);
natp = getnatp(seller);
natp->nat_money += roundavg(price * tradetax);
putnat(natp);
switch (trade.trd_type) {
case EF_NUKE:
tg.nuke.nuk_x = trade.trd_x;
tg.nuke.nuk_y = trade.trd_y;
tg.nuke.nuk_plane = -1;
break;
case EF_PLANE:
if (!pln_is_in_orbit(&tg.plane)) {
tg.plane.pln_x = trade.trd_x;
tg.plane.pln_y = trade.trd_y;
}
if (opt_MOB_ACCESS) {
tg.plane.pln_mobil = -(etu_per_update / sect_mob_neg_factor);
game_tick_to_now(&tg.plane.pln_access);
} else {
tg.plane.pln_mobil = 0;
}
tg.plane.pln_harden = 0;
tg.plane.pln_ship = -1;
tg.plane.pln_land = -1;
break;
case EF_SHIP:
break;
case EF_LAND:
tg.land.lnd_x = trade.trd_x;
tg.land.lnd_y = trade.trd_y;
if (opt_MOB_ACCESS) {
tg.land.lnd_mobil = -(etu_per_update / sect_mob_neg_factor);
game_tick_to_now(&tg.land.lnd_access);
} else {
tg.land.lnd_mobil = 0;
}
tg.land.lnd_harden = 0;
unit_drop_cargo(&tg.gen, 0);
tg.land.lnd_ship = -1;
tg.land.lnd_land = -1;
break;
default:
logerror("Bad trade type %d in trade\n", trade.trd_type);
break;
}
unit_give_away(&tg.gen, trade.trd_maxbidder, 0);
put_empobj(trade.trd_type, saveid, &tg.gen);
nreport(seller, N_MAKE_SALE, trade.trd_maxbidder, 1);
wu(0, seller, "%s bought %s #%d from you for $%.2f\n",
cname(trade.trd_maxbidder), trade_nameof(&trade, &tg.gen),
saveid, price * tradetax);
wu(0, trade.trd_maxbidder,
"The bidding is over & you bought %s #%d from %s for $%d\n",
trade_nameof(&trade, &tg.gen), saveid, cname(seller),
price);
}
return RET_OK;
}
/*
* Draw a radar map for radar at @cx,@cy.
* @eff is the radar's efficiency, @tlev its tech level, @spy its power.
* Submarines are detected at fraction @seesub of the range.
*/
void
radmap(int cx, int cy, int eff, double tlev, int spy, double seesub)
{
int visib, rng;
struct sctstr sect;
struct shpstr ship;
struct plnstr plane;
struct nstr_sect ns;
struct nstr_item ni;
int x, y;
int row;
int n;
int range = rad_range(eff, tlev, spy);
int changed = 0;
if (!radbuf)
radbuf = malloc(WORLD_Y * MAPWIDTH(1));
if (!visbuf)
visbuf = malloc(WORLD_Y * MAPWIDTH(1));
if (!rad) {
rad = malloc(WORLD_Y * sizeof(char *));
if (rad && radbuf) {
for (x = 0; x < WORLD_Y; x++)
rad[x] = &radbuf[(WORLD_X + 1) * x];
}
}
if (!vis) {
vis = malloc(WORLD_Y * sizeof(signed char *));
if (vis && visbuf) {
for (x = 0; x < WORLD_Y; x++)
vis[x] = &visbuf[(WORLD_X + 1) * x];
}
}
if (!radbuf || !visbuf || !rad || !vis) {
pr("Memory error in radmap2, tell the deity.\n");
return;
}
memset(visbuf, 0, (WORLD_Y * (WORLD_X + 1)));
pr("%s efficiency %d%%, max range %d\n",
xyas(cx, cy, player->cnum), eff, range);
snxtsct_dist(&ns, cx, cy, range);
blankfill(radbuf, &ns.range, 1);
while (nxtsct(&ns, §)) {
rad[ns.dy][ns.dx] = rad_char(§, ns.curdist, range,
player->cnum);
changed += map_set(player->cnum, ns.x, ns.y, rad[ns.dy][ns.dx], 0);
}
if (changed)
writemap(player->cnum);
snxtitem_dist(&ni, EF_PLANE, cx, cy, range);
while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
/* Used to have 'ghosts' when scanning whole world --ts */
x = deltx(&ns.range, (int)plane.pln_x);
y = delty(&ns.range, (int)plane.pln_y);
if (pln_is_in_orbit(&plane) && plane.pln_own != player->cnum) {
vis[y][x] = 100;
rad[y][x] = '$';
}
}
snxtitem_dist(&ni, EF_SHIP, cx, cy, range);
while (nxtitem(&ni, &ship)) {
if (ship.shp_own == 0)
continue;
/* Used to have 'ghosts' when scanning whole world --ts */
x = deltx(&ns.range, (int)ship.shp_x);
y = delty(&ns.range, (int)ship.shp_y);
visib = shp_visib(&ship);
rng = (int)(range * visib / 20.0);
if (ni.curdist > rng)
continue;
if ((mchr[(int)ship.shp_type].m_flags & M_SUB) &&
ni.curdist > rng * seesub)
continue;
if (visib > vis[y][x]) {
vis[y][x] = visib;
/* &~0x20 makes it a cap letter */
rad[y][x] = (*mchr[(int)ship.shp_type].m_name) & ~0x20;
}
}
/*
* make the center of the display 0
* so ve et al can find it.
*/
rad[delty(&ns.range, cy)][deltx(&ns.range, cx)] = '0';
n = ns.range.height;
for (row = 0; row < n; row++)
pr("%s\n", rad[row]);
pr("\n");
}
static int
pupgr(void)
{
struct sctstr sect;
struct natstr *natp;
struct nstr_item ni;
struct plnstr plane;
struct plchrstr *pp;
int n;
int tlev;
int avail, cost;
int cash;
if (!snxtitem(&ni, EF_PLANE, player->argp[2], NULL))
return RET_SYN;
natp = getnatp(player->cnum);
cash = natp->nat_money;
tlev = (int)natp->nat_level[NAT_TLEV];
n = 0;
while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
getsect(plane.pln_x, plane.pln_y, §);
if (sect.sct_own != player->cnum)
continue;
if (sect.sct_type != SCT_AIRPT || sect.sct_effic < 60)
continue;
if (relations_with(plane.pln_own, sect.sct_own) < FRIENDLY) {
pr("You are not on friendly terms with the owner of plane %d!\n",
plane.pln_uid);
continue;
}
if (pln_is_in_orbit(&plane)) {
pr("Plane %s is in orbit!\n", prplane(&plane));
continue;
}
if (plane.pln_flags & PLN_LAUNCHED)
continue;
n++;
pp = &plchr[(int)plane.pln_type];
avail = (PLN_BLD_WORK(pp->pl_lcm, pp->pl_hcm) * UPGR_COST + 99) / 100;
if (sect.sct_avail < avail) {
pr("Not enough available work in %s to upgrade a %s\n",
xyas(sect.sct_x, sect.sct_y, player->cnum), pp->pl_name);
pr(" (%d available work required)\n", avail);
continue;
}
if (plane.pln_effic < 60) {
pr("%s is too damaged to upgrade!\n", prplane(&plane));
continue;
}
if (plane.pln_tech >= tlev) {
pr("%s tech: %d, yours is only %d\n",
prplane(&plane), plane.pln_tech, tlev);
continue;
}
cost = pp->pl_cost * UPGR_COST / 100;
if (cost + player->dolcost > cash) {
pr("You don't have enough money to upgrade %s!\n",
prplane(&plane));
continue;
}
sect.sct_avail -= avail;
plane.pln_effic -= UPGR_EFF;
pln_set_tech(&plane, tlev);
plane.pln_harden = 0;
plane.pln_mission = 0;
putplane(plane.pln_uid, &plane);
putsect(§);
player->dolcost += cost;
pr("%s upgraded to tech %d, at a cost of %d\n",
prplane(&plane), plane.pln_tech, cost);
if (plane.pln_own != player->cnum)
wu(0, plane.pln_own,
"%s upgraded by %s to tech %d, at a cost of %d\n",
prplane(&plane), cname(player->cnum), plane.pln_tech, cost);
}
if (n == 0) {
pr("No planes.\n");
return RET_SYN;
}
return RET_OK;
}
/*
* format: skywatch [<SECTS>]
*/
int
skyw(void)
{
struct sctstr sect;
struct nstr_sect nstr;
struct sky *skyp;
struct sky *list[TSIZE];
int i, n;
int vrange, see;
int x, y, dx, dy, dxmax;
int nsat = 0;
double tech;
struct nstr_item ni;
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
for (i = 0; i < TSIZE; i++)
list[i] = NULL;
skyp = malloc(sizeof(*skyp));
snxtitem_all(&ni, EF_PLANE);
while (nxtitem(&ni, &skyp->s_sat)) {
if (!skyp->s_sat.pln_own)
continue;
if (!pln_is_in_orbit(&skyp->s_sat))
continue;
getsect(skyp->s_sat.pln_x, skyp->s_sat.pln_y, §);
n = scthash(skyp->s_sat.pln_x, skyp->s_sat.pln_y, TSIZE);
skyp->s_spotted = 0;
skyp->s_next = list[n];
list[n] = skyp;
skyp = malloc(sizeof(*skyp));
nsat++;
}
/* get that last one! */
free(skyp);
pr("- = [ Skywatch report for %s ] = -\n", cname(player->cnum));
pr(" Country Satellite Location\n");
tech = tfact(player->cnum, 1.0);
while (nxtsct(&nstr, §) && nsat) {
if (sect.sct_own != player->cnum)
continue;
see = sect.sct_type == SCT_RADAR ? 14 : 4;
vrange = (int)(sect.sct_effic / 100.0 * see * tech);
if (vrange < 1)
vrange = 1;
for (dy = -vrange; dy <= vrange; dy++) {
y = ynorm(sect.sct_y + dy);
dxmax = 2 * vrange - abs(dy);
for (dx = -dxmax; dx <= dxmax; dx += 2) {
x = xnorm(sect.sct_x + dx);
n = scthash(x, y, TSIZE);
if (!list[n])
continue;
nsat -= showsat(&list[n], x, y);
}
}
}
/* free up the sky structs calloc'ed above */
for (i = 0; i < TSIZE; i++) {
while (NULL != (skyp = list[i])) {
list[i] = skyp->s_next;
free(skyp);
}
}
return RET_OK;
}
