/*ARGSUSED*/
static int
infect_people(struct natstr *np, struct sctstr *sp)
{
double pop, pop_space, bad_stuff, pollution, cleanup;
double plg_chance;
if (opt_NO_PLAGUE) /* no plague nothing to do */
return PLG_HEALTHY;
if (np->nat_level[NAT_TLEV] <= 10.0)
return PLG_HEALTHY;
/*
* make plague where there was none before...
*/
pop = sp->sct_item[I_CIVIL] + sp->sct_item[I_MILIT] + sp->sct_item[I_UW];
pop_space = max_pop(np->nat_level[NAT_RLEV], sp);
bad_stuff
= sp->sct_item[I_IRON] + sp->sct_item[I_OIL] + sp->sct_item[I_RAD] * 2;
pollution = bad_stuff / 10.0 + np->nat_level[NAT_TLEV] + 100.0;
cleanup = sp->sct_effic + sp->sct_mobil + 100 + np->nat_level[NAT_RLEV];
plg_chance = ((pop / pop_space) * (pollution / cleanup) - 1.0) * 0.01;
if (chance(plg_chance))
return PLG_EXPOSED;
return PLG_HEALTHY;
}
int
newe(void)
{
struct natstr *natp;
struct sctstr sect;
struct nstr_sect nstr;
double work, lcms, hcms;
int nsect;
int civs = 0;
int uws = 0;
int bwork;
int twork;
int type;
int eff;
int maxpop;
if (!snxtsct(&nstr, player->argp[1]))
return RET_SYN;
player->simulation = 1;
prdate();
nsect = 0;
while (nxtsct(&nstr, §)) {
if (!player->owner)
continue;
if (!sect.sct_off) {
civs = (1.0 + obrate * etu_per_update) * sect.sct_item[I_CIVIL];
uws = (1.0 + uwbrate * etu_per_update) * sect.sct_item[I_UW];
natp = getnatp(sect.sct_own);
maxpop = max_pop(natp->nat_level[NAT_RLEV], §);
work = new_work(§,
total_work(sect.sct_work, etu_per_update,
civs, sect.sct_item[I_MILIT], uws,
maxpop));
bwork = work / 2;
type = sect.sct_type;
eff = sect.sct_effic;
if (sect.sct_newtype != type) {
twork = (eff + 3) / 4;
if (twork > bwork) {
twork = bwork;
}
bwork -= twork;
eff -= twork * 4;
if (eff <= 0) {
type = sect.sct_newtype;
eff = 0;
}
twork = 100 - eff;
if (twork > bwork) {
twork = bwork;
}
if (dchr[type].d_lcms > 0) {
lcms = sect.sct_item[I_LCM];
lcms = (int)(lcms / dchr[type].d_lcms);
if (twork > lcms)
twork = lcms;
}
if (dchr[type].d_hcms > 0) {
hcms = sect.sct_item[I_HCM];
hcms = (int)(hcms / dchr[type].d_hcms);
if (twork > hcms)
twork = hcms;
}
eff += twork;
} else if (eff < 100) {
twork = 100 - eff;
if (twork > bwork) {
twork = bwork;
}
if (dchr[type].d_lcms > 0) {
lcms = sect.sct_item[I_LCM];
lcms = (int)(lcms / dchr[type].d_lcms);
if (twork > lcms)
twork = lcms;
}
if (dchr[type].d_hcms > 0) {
hcms = sect.sct_item[I_HCM];
hcms = (int)(hcms / dchr[type].d_hcms);
if (twork > hcms)
twork = hcms;
}
eff += twork;
}
} else {
eff = sect.sct_effic;
type = sect.sct_type;
}
if (nsect++ == 0) {
pr("EFFICIENCY SIMULATION\n");
pr(" sect des projected eff\n");
}
prxy("%4d,%-4d", nstr.x, nstr.y);
pr(" %c", dchr[type].d_mnem);
pr(" %3d%%\n", eff);
}
player->simulation = 0;
if (nsect == 0) {
if (player->argp[1])
pr("%s: No sector(s)\n", player->argp[1]);
else
pr("%s: No sector(s)\n", "");
return RET_FAIL;
} else
pr("%d sector%s\n", nsect, splur(nsect));
return RET_OK;
}
static void
gen_power(struct powstr *powbuf, int save)
{
float upower[MAXNOC];
float *f_ptr;
float *f_pt2;
struct powstr *pow;
int i, maxpop;
struct sctstr sect;
struct dchrstr *dcp;
struct plnstr plane;
struct plchrstr *pcp;
struct shpstr ship;
struct mchrstr *mcp;
struct lndstr land;
struct lchrstr *lcp;
struct nukstr nuke;
struct nchrstr *ncp;
struct nstr_item ni;
struct nstr_sect ns;
struct natstr *natp;
player->btused += 10;
memset(powbuf, 0, MAXNOC * sizeof(*powbuf));
memset(upower, 0, sizeof(upower));
snxtsct_all(&ns);
while (nxtsct(&ns, §)) {
if (sect.sct_own == 0)
continue;
dcp = &dchr[sect.sct_type];
natp = getnatp(sect.sct_own);
pow = &powbuf[sect.sct_own];
pow->p_sects += 1.0;
pow->p_effic += sect.sct_effic;
addtopow(sect.sct_item, pow);
pow->p_power += empobj_power(sect.sct_effic,
dcp->d_mat, dcp->d_cost);
maxpop = max_pop(natp->nat_level[NAT_RLEV], §);
pow->p_power += (1.0 + maxpop / 1000.0 * 8) * sect.sct_effic / 100.0;
}
snxtitem_all(&ni, EF_LAND);
while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
lcp = &lchr[land.lnd_type];
pow = &powbuf[land.lnd_own];
addtopow(land.lnd_item, pow);
upower[land.lnd_own] += empunit_power(land.lnd_effic,
land.lnd_tech,
lcp->l_mat, lcp->l_cost);
if (!(lcp->l_flags & L_SPY))
pow->p_units += 1.0;
}
snxtitem_all(&ni, EF_SHIP);
while (nxtitem(&ni, &ship)) {
if (ship.shp_own == 0)
continue;
mcp = &mchr[ship.shp_type];
pow = &powbuf[ship.shp_own];
addtopow(ship.shp_item, pow);
upower[ship.shp_own] += empunit_power(ship.shp_effic,
ship.shp_tech,
mcp->m_mat, mcp->m_cost);
pow->p_ships += 1.0;
}
snxtitem_all(&ni, EF_PLANE);
while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
pcp = &plchr[plane.pln_type];
pow = &powbuf[plane.pln_own];
upower[plane.pln_own] += empunit_power(plane.pln_effic,
plane.pln_tech,
pcp->pl_mat, pcp->pl_cost);
pow->p_planes += 1.0;
}
snxtitem_all(&ni, EF_NUKE);
while (nxtitem(&ni, &nuke)) {
if (nuke.nuk_own == 0)
continue;
ncp = &nchr[nuke.nuk_type];
upower[nuke.nuk_own] += empunit_power(nuke.nuk_effic,
nuke.nuk_tech,
ncp->n_mat, ncp->n_cost);
}
for (i = 1; NULL != (natp = getnatp(i)); i++) {
pow = &powbuf[i];
pow->p_nation = i;
if (natp->nat_stat != STAT_ACTIVE) {
pow->p_power = 0.;
continue;
}
pow->p_money = natp->nat_money;
pow->p_power += money_power(natp->nat_money);
pow->p_power *= power_tech_factor(natp->nat_level[NAT_TLEV]);
pow->p_power += upower[i];
/* ack. add this vec to the "world power" element */
f_pt2 = &powbuf[0].p_sects;
f_ptr = &pow->p_sects;
while (f_ptr <= &pow->p_power) {
*f_pt2 += *f_ptr;
f_pt2++;
f_ptr++;
}
}
qsort(&powbuf[1], MAXNOC - 1, sizeof(*powbuf), powcmp);
if (!save)
return;
for (i = 0; i < MAXNOC; i++)
putpower(i, &powbuf[i]);
#ifdef _WIN32
/*
* At least some versions of Windows fail to update mtime on
* write(), they delay it until the write actually hits the disk.
* Bad, because `power' displays that time. Force it.
*/
_commit(empfile[EF_POWER].fd);
#endif
}
