Markus Armbruster
b80fd4e982
Civilians, military and uw work only up to their sector's population
limit. The population limit depends on the sector type's maximum
population, research if RES_POP is enabled, and the sector's
efficiency for big cities.
The population limit may decrease between computation of work in
do_feed() and the end of the update:
* Research declines (only relevant with RES_POP). Work is not
corrected. The declined research will apply at the next update.
Since levels age after production is done, any work corrections
could only affect leftover available work. Wouldn't make sense.
The effect is negligible anyway. Even with an insanely fast decline
of 60% (level_age_rate = 1, etu_per_update = 60), the population
limit decreases by less than 10% in the worst case.
* upd_buildeff() changes sector type and efficiency. Work is
corrected only when this changes the sector type from big city to
not big city.
It isn't corrected on other sector type changes. These can affect
maximum population since the sector type's maximum became
configurable in commit 153527a (v4.2.20). Sane configurations don't
let players redesignate sectors to a type with different maximum
population. The server doesn't enforce this, though.
It isn't corrected when a big city's efficiency decreases, but
sector type change isn't achieved. Harmless, because tearing down a
city takes very little work (25 for 100%), so efficiency decrease
without type change means the work we have must be safely below any
sane population limit's work.
Good enough. However, the code implementing the work correction for
big cities is unclean. Get rid of it by tweaking the rules: a big
city's extra population does not work. City slickers, tsk, tsk, tsk.
At least they still pay their taxes.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
147 lines
3.7 KiB
C
147 lines
3.7 KiB
C
/*
|
|
* Empire - A multi-player, client/server Internet based war game.
|
|
* Copyright (C) 1986-2016, Dave Pare, Jeff Bailey, Thomas Ruschak,
|
|
* Ken Stevens, Steve McClure, Markus Armbruster
|
|
*
|
|
* Empire is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* ---
|
|
*
|
|
* 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.
|
|
*
|
|
* ---
|
|
*
|
|
* newe.c: Show new sector efficiency (projected)
|
|
*
|
|
* Known contributors to this file:
|
|
* Thomas Ruschak, 1993
|
|
* Markus Armbruster, 2004-2016
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "commands.h"
|
|
#include "item.h"
|
|
#include "optlist.h"
|
|
|
|
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 maxworkers;
|
|
|
|
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);
|
|
maxworkers = max_workers(natp->nat_level[NAT_RLEV], §);
|
|
work = new_work(§,
|
|
total_work(sect.sct_work, etu_per_update,
|
|
civs, sect.sct_item[I_MILIT], uws,
|
|
maxworkers));
|
|
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;
|
|
}
|