arm: Rework "cannot carry nukes" test for robustness
We reject satellites, ABMs, anti-ship missiles, and SAMs. That's
enumerating badness. More robust replacement: accept only bomber,
tactical, cargo, except for anti-ship missiles.
Throw in PLN_LAUNCHED sanity checking while there.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
launch interception: Drop support for ABM, a-sat consuming shells
Their impact on the target does not depend on shell load (it sometimes
did for a-sats until commit cf960a573 "Make anti-sat launch consistent
with interception", v4.3.23). The shell use is logistical busy-work,
and economically irrelevant. Remove it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
The asat's impact on the target does not depend on its shell load (it
sometimes did until commit cf960a573 "Make anti-sat launch consistent
with interception", v4.3.23). The shell use is logistical busy-work,
and economically irrelevant. Remove it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Stale since commit 6ac9ad66e (v4.3.20) silently dropped dead code for
supply of military. Dead since commit 689f435af (v4.2.14) dropped
option GRAB_THINGS.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
assault attack board lboard paradrop: Fix defending land unit supply
get_dlist() collects defending land units in a list, and resupplies
them. Bug: it uses a local copy instead of the one in the list. When
att_fight() writes back the list, the commodities supplied get wiped
out, triggering a seqno oops. Broken in commit 62b9399cd "subs:
Factor lnd_insque() out of lnd_sel(), ask_olist(), ...", v4.3.33.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Drop macros AGREE_FREE, AGREE_PROPOSED, AGREE_SIGNED
Commit 555de3100 (v4.3.0) added these macros so xdump tables loan and
treaty can share an agreement_statuses table. Treaties are gone since
commit a109de948 (v4.3.33). Drop the macros.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
include: Move sarg.c stuff to nsc.h to avoid incomplete enum
Portability issue: prototypes.h uses enum ns_seltype, defined in
nsc.h. GCC is fine with that; it supports incomplete enum types as an
extension. Broken in commit 157ae8ec2 "Clean up superfluous include
of nsc.h in prototypes.h", v4.3.27. Moving sarg.c stuff to nsc.h
fixes it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
m4/my_lib_readline: Fix check for additional libraries
MY_LIB_READLINE tries each readline-compatible library with a sequence
of additional libraries, starting with none. If the check with none
fails, all the others checks reuse the cached result, and also fail.
Broken in commit 1cbda2c7d "client: Rewrite readline configuration",
v4.4.0.
Avoid the unwanted chaching.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
info/Empire4.3: Work around "nroff: Out of temp file space"
Solaris 10's nroff can't deal with the lengthy .NF ... .FI: it
complains, writes truncated output, and terminates
successfully (*boggle*). Split the .NF ... .FI in two.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
configure: Test GCC-specific compiler flags only when using GCC
Commit 23373d01d "configure: Test compiler flags" (v4.4.0) made
configure test whether compiler flags work, to let us use flags that
work only for some compilers.
Unfortunately, the Sun C compiler accepts invalid options with a
warning, breaking the test. Observed on Solaris 10.
Fix by testing the compiler flags only when AC_PROG_CC detected GCC.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
bomb launch interdiction: Fix crash on bombs missing target
plane damage() prints @noisy with snprintf() even when it's null. It
doesn't actually use the output then. Some systems (GNU, Windows)
deal gracefully with printing null strings, others crash. @noisy is
null when bombers or missiles miss and do collateral damage. Affects
bomb, launch, and interdiction missions. Broken in commit 820d755e5
"subs: Change pln_damage()'s parameter noisy to string prefix",
v4.3.33.
Fix by guarding the snprintf().
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Document the need for the XSI Extension. Don't list curses as
required, it's actually optional. Correct advice for Solaris. Add
advice for AIX. Drop references to C89; we actually require C99, and
POSIX.1-2001 provides it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Fix build for systems that don't provide POSIX.1-2001 by default
We require POSIX.1-2001. Some systems provide it only with feature
test macro _POSIX_C_SOURCE defined to 200112L. Since we don't define
it, the build fails there. Observed on Solaris 10.
We actually require the XSI extension. The GNU C Library provides it
by default. With _POSIX_C_SOURCE 200112L, however, you have to define
feature test macro _XOPEN_SOURCE to get it. But then _POSIX_C_SOURCE
is redundant.
Make configure put #define _XOPEN_SOURCE 600 into config.h. Drop the
two existing #define _XOPEN_SOURCE 500 in .c files.
Now Solaris cc refuses to play ball unless switched to C99. Replace
AC_PROG_CC by AC_PROG_CC_STDC to mollify it.
Unfortunately, use of _XOPEN_SOURCE exposes bugs in AIX libc and old
versions of GNU libc:
* AIX defines struct in6_addr's member s6_addr as a macro expanding
into the actual member. Without _ALL_SOURCE (the default), the
expansion is wrong and doesn't compile. Observed with AIX V7.2.
* GNU lib's IN6_IS_ADDR_V4MAPPED() is unusable without
_DEFAULT_SOURCE (default) or _GNU_SOURCE. Observed with Debian 8.
Tracked at <https://sourceware.org/bugzilla/show_bug.cgi?id=16421>,
fixed in version 2.25.
Affects just sockaddr_ntop()'s special case from commit 372cdb136 "Use
IPv4 format for IPv4-mapped addresses", v4.3.31. Disable the special
case and use IPv6 format on such systems. This is a very minor
usability regression. Could be avoided, I guess, but it's not worth
the trouble.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
getpass() is traditional Unix, but has been withdrawn from POSIX. We
still use it when it's available, and fall back to portable code only
when it's not.
The portable code behaves differently: it reads stdin instead of
/dev/tty, and in noncanonical mode.
Simplify things: always use the replacement.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
client: Make get_password() not echo with POSIX && !HAVE_GETPASS
getpass() is traditional Unix, but has been withdrawn from POSIX. We
provide a replacement in case it's missing. The one for Windows
suppresses echo, like getpass() does. Implement that for POSIX. The
other differences to getpass() remain.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
lwp: Rewrite signal wait code for portability and safety
LWP's use of sigset_t is problematic.
To iterate over a sigset_t, it uses NSIG, which is not portable: BSD
and System V provide it, but it's not POSIX.
To record signals caught, it updates a sigset_t variable from a signal
handler. The variable isn't volatile, because we'd have to cast away
volatile for sigaddset().
Replace sigset_t by an array of signal numbers terminated with 0.
Since lwpInitSigWait() needs to store the signal set for
lwpCatchAwaitedSig() anyway, there is no need to pass it to
lwpSigWait(). Drop its parameter.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
lwp: Fix signal wait screwup for multiple different signals
lwpSigWait() clears LwpSigCheck even when signals remain in
LwpSigCaught. The next empth_wait_for_signal() will then wait until
another one gets caught. Broken in commit fe2de3d74, v4.3.10.
Fix by clearing it only when LwpSigCaught is empty.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
sigismember() fails when passed an invalid or unsupported signal
number. lwpInitSigWait() and lwpGetSig() treat sigismember() failure
like "is a member". lwpInitSigWait() will then sigaction()
unsuccessfully. Harmless. lwpGetSig() returns the bad signal number
when it's greater than any caught signal's number. The bad signal
number then gets returned to main(), which shuts down the server.
Fix by treating failure like "is not a member".
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
lwpCatchAwaitedSig() is not reentrant. lwpInitSigWait() attempts to
protect it by setting an appropriate signal mask, but screws up. This
could conceivably lose signals. Messed up when it got added in commit 7183516d9, v4.3.6. Fix it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
lwpSigWait()'s contract specifies failure, which means oopsing is
wrong. Harmless, as its only caller empth_wait_for_signal() oopses on
failure. Drop it anyway.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Make: Fix build with tool chains that require depcomp
Commit fad8e7f7b "Move auxiliary build tools to build-aux/" moved
depcomp, but neglected to adjust Make.mk. This broke the build with
tool chains that actually use depcomp. Modern GCC and Clang don't.
Fix the obvious way.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
config: Enlarge configuration tables that have variable size
Configuration tables product, sect-chr, ship-chr, plane-chr, land-chr,
nuke-chr have a bit of extra space deities can use for customizing
their games. Give them more: enlarge product from 23 to 31
entries (plus one sentinel), sect-chr from 39 to 63, ship-chr from 47
to 127, plane-chr from 47 to 127, land-chr from 31 to 127, and
nuke-chr from 20 to 63.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Don't use ALL CAPS for headings. Reformat them in the style
recommended by doc/coding. Drop a few comments that aren't pulling
their weight, and fix the odd typo.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
qprint() was carelessly added at the end of the file in Empire 2,
where it's under the "Write a script for placing capitals" headline.
Move it to a more sensible place.
NUMTRIES was added behind the global variables in Empire 2. Move it
before them, and reformat its comment.
The order of forward declarations of static functions looks random.
Reorder them to match the order of definitions.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Tweak rural iron, fert, oil for simplicity
The previous commit's interpolation tables reproduce the historical
linear functions faithfully. This exact fit requires an awkward data
point in each of the tables for iron fertility and oil. Drop them.
No double-valued data points remain. Adjust struct resource_point
member @res to int.
This results in slightly less rural iron (33 elevations down one
point), fertility (10 elevations down one point) and oil (14
elevations down one point, 5 down two points). Only resource values
less than 100 are affected.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Compute resources by interpolating tables
The functions mapping elevation to resources are piecewise linear.
Replace them by linear interpolation on data points defined in tables.
Tables are easier to tweak for deities than code.
The data points are a bit awkward because the functions they replace
are. The next commit will tweak them to address that.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Tweak sea oil & mountain gold for simplicity
The functions mapping elevation to resources are piecewise linear,
except for set_oil(), which randomly adds 1 to sea oil, and
set_gold(), which is isn't linear for mountains, but very close.
Drop the random oil bit, and replace the non-liner gold function by a
linear one. Both resources decrease at most by one point.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
Land elevation is computed by first placing mountains, then elevating
land to fit.
Mountains placement is a weighted random sampling. A sector's weight
is its distance to sea capped at five and squared.
Non-mountain, non-capital sectors get assigned equidistant elevations
from 1 up to 97 rounded to integer in an order that depends on
distance to mountain and distance to sea, both capped at 5. Mountains
get equidistant elevations starting at 98 (see recent commit
"fairland: Fair mountain resources"). Capitals get 36.
Sea elevation is randomly chosen from a range that depends on the
sector's distance to land. The range increases from [-27,-1] next to
land to [-127,-1] for distance 5 and up.
Without mountains, the result is boring: elevation increases pretty
much linearly with the distance from the coast, i.e. each islands is a
single cone. With mountains, we get one cone per mountain. The sea
sea elevations are basically noise.
Worse, it's buggy: mountain placement can place fewer mountains than
requested. The weighted random sampling assigns weights even to
sectors that cannot be picked (capitals and sectors that have been
picked already). When the dice land on such a sector, it instead
picks the next one (in island growth order) that can be picked. If
there is no next one, the mountain is not placed. This is a fairness
issue.
Impact varies with fairland parameters. For 60 sector islands with 5%
mountains, around one in 10000 islands is short one mountain in my
testing. For 10 sector islands with 50% mountains, some 760 out of
10000 islands are short one sector, 80 short two, and five short
three. The numbers get worse as spikiness increases.
Undocumented misfeature: the placement loop is limited to 1000
iterations, supposedly to catch a runaway loop. Since the loop
iterates exactly once per mountain, all this accomplishes it limiting
mountains to 1000 per island.
When too few mountains are placed, the loop assigning elevations to
non-mountain, non-capital decrements elevations below 1. Since
Chainsaw 3, such elevations then get mapped to 1, plastering over the
bug. We get non-mountain sectors with elevation 1 instead of
mountains.
Rewrite as follows.
Use a simple random hill algorithm to assign raw elevations:
initialize elevation to zero, then randomly raise circular hills on
land / lower circular depressions at sea. Their size and height
depends on the distance to the coast, capped at 3. After a sufficient
number of iterations, the resulting terrain has a "natural" look.
This is elevate_prep().
elevate_land() then sorts non-capital sectors by raw elevation. The
highest become mountains. Sectors get assigned the same equidistant
elevations as before, just in raw elevation order.
elevate_sea() simply normalizes raw elevation to [-127,-1].
Elevations now show a nice undulating pattern independent of mountain
percentage.
Implementation detail: replace elev[x][y] by elev[XYOFFSET(x, y)], and
narrow the element type from int to short. Takes a fourth the space.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
elevate_land() computes the sequence of elevations 97, 97 - delta,
... in fixed point with a scaling factor of 100. Switch to
floating-point, because it's simpler. Elevations (and thus resources)
change slightly due to reduced rounding errors.
Note that we map elevations less than 1 to 1 both before and after the
patch. Odd. Turns out this mitigates a bug: mountain placement can
place fewer mountains than it should, and when that happens,
elevations go below 1 here. The next commit will fix this.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
For fairness, fairland aims to make islands of the same size consist
of the exact same sectors, just individually arranged.
It fails to achieve its aim for mountains: their elevation is random,
34 or 35 for coastal mountains, and between 98 and 254 (two dice) for
non-coastal ones. Elevation determines resources. Mountains get 89
gold on average (between 80 and 93), except for coastal mountains,
which get none. It didn't really matter until Empire 3 made mountains
produce gold dust. Since then, it's unfair.
Set mountain elevation to 98 + i * delta, where i is the mountain
number (starting at zero), delta is (127 - 98) / max_mn, and max_mn is
the maximum number of mountains an island could have. This puts the
highest mountains on the largest islands.
Non-coastal mountains have slightly less gold than before, coastal
mountains have much more.
Mountains can still be unfair, because fairland can screw up their
number. To be fixed soon.
Avoid elevations 34 and 35 for non-mountain, non-capital sectors
doesn't make sense anymore. The next commit will get rid of it.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
distance_to_land() searches for closest land sector, and
distance_to_sea() for the closest sea sector. We already have a more
efficient alternative: the breadth-first search recently added for
spheres of influence can precompute these distances. Put it to use,
and retire distance_to_land() and distance_to_sea().
distance_to_what() could now be simplified. Don't bother, because
it'll soon be deleted entirely.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Prefer placing islands away from the edge of the sphere
When an island gets placed too close to the edge of the sphere of
influence, its side facing the edge will likely be formed by the edge.
Looks unnatural, and can give a clue on the location of the other
continent.
Make place_island() prefer sectors away from the edge: instead of
picking one of the admissible sectors with equal probability, reduce
the probability as we get closer to the edge.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Try harder to deliver the requested amount of land
Planned island sizes are random with an expected value that matches
the average size requested by the user. Can be off quite a bit when
the number of islands is small. Also, actual island size can be
smaller than planned size when space is tight.
Instead of picking random island sizes independently, pick a random
split of their requested total size.
To reduce the probability of islands not growing to their planned
size, grow large islands before smaller ones.
To compensate for inability to grow, carry the difference over to the
next island size.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
The previous commit reduced the difference in island size within the
same batch of islands to at most one. Eliminate the remaining
difference by shrinking the bigger islands by one sector.
This invalidates the precomputed exclusive zones, so recompute them.
fairland-test needs a tweak to avoid loss of test coverage.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
The previous commits changed grow_island() to create islands in
batches consisting of one island per continent, all of the same
planned size. grow_island() still places and grows one island after
the other. When an island can't grow to the actual size, the others
in the same batch are not affected. Island size can therefore differ
a lot within the same batch.
Change grow_island() to interleave the work on a batch's island: first
place them all, then add one sector to each in turn. Stop after all
reached the planned size, or one or more could not be grown further.
This is similar to how we grow continents: drift() places them all,
and grow_continent() adds one sector to each continent in turn.
Island size within the same batch can now differ at most by one
sector. The next commit will eliminate that remaining difference.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
The previous two commits put the same number of islands closest to
each continent. This one makes their planned sizes match: instead of
rolling dice separately for each island's size, we roll dice only for
the first continent's islands. The other continent's islands get the
same sizes.
Actual island sizes still differ when islands can't be grown to their
planned size. To be addressed next.
fairland-test needs a tweak to avoid loss of test coverage.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Fail when island can't be placed, for fairness
The previous commit made island distribution more fair by placing
islands close to a continent in turn. This is still unfair when
fairland can't place all the islands.
Make grow_islands() fail when it can't place all islands, and main()
start over then, just like it does when grow_continents() fails.
Deities can no longer fill the world with islands by asking for a
impossibly high number of islands. Tolerable loss, I think.
fairland-test needs a tweak to avoid loss of test coverage.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Distribute islands more fairly among continents
fairland places islands of random size in random places, subject to
minimum distances. Results are often less than fair, in particular
when the number of islands per continent is low: some continents have
more land nearby than others. Increasing distances between islands
doesn't help much. Deities commonly run fairland until they find the
result acceptable.
The next few commits will tackle this issue. As a first step, this
one places islands closest to continents in turn, so that each
continent is closest to the same number of islands. A continent is
closest to an island when it is closest to each of its sectors.
The number of islands must be a multiple of the number of continents
now.
Since fairland may be unable to place all islands, a continent may
still get fewer islands than it should. The next commit will address
that.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
A continent's sphere of influence is the set of sectors closer to it
than to any other continent. The next commit needs this. Compute the
spheres with a breadth-first search.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
grow_one_sector() picks a coastal start sector, then moves along the
coast trying to add an adjacent sector to the island.
It operates in spiking mode with a chance of @sp percent.
When spiking, the neighbors with sea on both sides are preferred. For
instance, when the area around the sector being considered looks like
this
- .
- - .
- .
then the neighbor in direction j is preferred, because it has sea in
directions u and n. No other neighbor is preferred.
The start sector is the first coastal sector found in a linear search
in growth order, starting at the last sector grown when spiking, or
else at a random sector. This is new_try().
grow_one_sector() tries adding a neighbor in clockwise order, starting
with a random direction. When spiking, it goes around the clock two
times, trying only preferred sectors in the first round.
When it can't add a neighbor, it moves to the next coastal sector with
next_coast().
Taken together, this randomly picks one element from the set of
pairs (S, D) where the sector in direction D off base sector S can be
added to the island. How does the probability distribution look like?
Bias: a sector's probability to be added to the island land increases
with the number of base sectors it is adjacent to. This tends to fill
in bays and lakes, which is fine.
Bias: coastal sectors following runs of non-coastal ones are more
likely to be picked as start sector. Perhaps less of an issue when
spiking, where the pick is not intended to be random.
Bias: a pair (S, D) is more likely to be picked when base sector S
follows a run of coastal sectors that aren't base sectors, or
direction D follows a a run of directions that don't permit growth.
The impact of these two biases is not obvious. I suspect they are the
reason behind the tendency of large islands to curve around obstacles
in a counterclockwise direction. This can result in multiple islands
wrapping around a central one like layers of an onion.
Bug: the move along the coast is broken. next_coast() searches for
the first adjacent sea in clockwise order, starting in direction g,
then from there clockwise for a sector belonging to the island.
Amazingly, this does move along the coast in a clockwise direction.
It can get caught in a loop, though. Consider this island:
-
- - -
-
If we start at the central sector (marked 0), the search along the
coast progresses like this:
1
- 0 2
-
It reaches the central sector again after three moves (to 1, to 2,
back to 0), and stops without having reached the two sectors on the
left.
If we start with the leftmost sector, the search loops: 0, 1, 2, 3, 1,
...
2
0 1 3
-
grow_one_sector() ensures termination by giving up after 200 moves.
Nuts!
Because of this, grow_one_sector() can fail when it shouldn't, either
because the search along the coast stops early, or goes into a loop,
or simply because there's too much coast. The latter should not
happen in common usage, where island sizes are in the tens, not the
hundreds.
Clean up this hot mess by rewriting grow_one_sector() to pick a sector
adjacent to the island with a clearly defined probability, as follows.
Use weighted random sampling to pick one sector from the set of
possible adjacent sectors.
When spiking, a sector's weight increases with number of adjacent sea
sectors. This directs the growth away from land, resulting in spikes.
When not spiking, the weight increases with the number of adjacent
land sectors. This makes the island more rounded.
To visit the adjacent sectors, grow_one_sector() iterates over the
neighbors of all island sectors, skipping neighbors that have been
visited already.
This produces comparable results for low spike percentages. The weird
onions are gone, though.
Noticeable differences emerge as the spike percentage grows. Whereas
the old one produces long snakes that tend to curve into themselves,
the new one produces shorter spikes extending from a core, a bit like
tentacles. Moreover, islands are more centered on their first sector
now. The probability for coastal capitals is lower, in particular for
moderate spike percentages.
I consider this improvements.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
A sector is admissible for island placement when land can be grown in
every sector within a certain distance.
place_island() picks a random start sector, then searches linearly for
an admissible sector. If it finds one, it places the island there.
Else, it reduces the distance by one and tries again. It fails when
none is found even for distance zero.
Trying with extra distance is obviously meant to reduce the risk of
islands from running into each other without need. Initial distance
is @di, the minimum distance between continents, which doesn't really
make sense, and is undocumented.
Bug: place_island() never tries the start sector.
Bias: placement probability is higher for sectors immediately
following inadmissible sectors. Because of that, islands are more
often placed to the right of existing islands. Players could exploit
that to guide their search for land.
Rewrite place_island() to pick sectors with equal probability,
dropping the undocumented extra distance feature. If it's missed, we
can bring it back.
The new code visits each sector once. The old code visits only one
sector in the best case, but each sector several times in the worst
case. fairland performance improves measurably for crowded setups
with large @di, else it suffers. For instance, Hvy Fever example
given in the commit before previous runs seven times faster for me.
With @di reduced to 2, its run time more than doubles. Not that it
matters.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
grow_one_sector() and place_island() pass candidate sectors to
try_to_grow() until it succeeds.
try_to_grow() fails when the candidate isn't water, or there are
sectors belonging to other islands within a minimum distance.
It does that the obvious way: it searches for such sectors.
When there is plenty of space, try_to_grow() rarely fails when it
searches. For each land sector, we visit the sectors within minimum
distance, plus a little extra work for the rare failures.
In a more crowded setup, however, try_to_grow() fails a lot, and we
visit sectors many times more.
Example: Hvy Fever
8 continents
continent size: 60
number of islands: 64
average size of islands: 10
spike: 0%
0% of land is mountain (each continent will have 0 mountains)
minimum distance between continents: 6
minimum distance from islands to continents: 3
World dimensions: 140x68
This is a crowded setup. With -R 1, try_to_grow() fails almost
750,000 times due to minimum distance, and takes more than 18 Million
iterations.
With default minimum distances 2 and 1, it fails less than 700 times,
taking less than 14,000 iterations.
Instead of searching the surrounding sectors every time we check a
candidate, precompute an "exclusive zone" around each island where
only this island may grow the obvious way: when adding a sector, visit
the sectors within minimum distance and add them to the island's
exclusive zone.
When @extra_distance is non-zero, try_to_grow() still has to search,
Only place_island() passes non-zero @extra_distance. The next few
commits will get rid of that.
Complication: since the minimum distance for growing islands may
differ from the minimum distance for growing continents, we have to
recompute exclusive zones between growing continents and islands.
For the Hvy Fever example above, this reduces the number of sector
visits by more than 90%, and run time by more than 70% for me. With
default distances, it's a wash.
Of course, fairland performance is hardly an issue on today's
machines: it takes fairly impractical setups to push run time over a
second.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Change try_to_grow()'s last argument to extra_dist
Callers pass @di for continents, @id for islands, possibly plus some
extra distance. Pass just the extra distance, and compute the rest in
try_to_grow(). This prepares for the next commit.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Simplify search for next wilderness to elevate
To find the wilderness sector to elevate next, elevate_land() searches
the non-mountain, non-capital sectors of the island for one that
maximizes a function of its distance to mountains and to sea.
The search ignores already elevated sectors in a less than obvious
way: 1. it never picks a sector where the function yields -INFINITY or
less, and 2. when elevating a wilderness, its (cached) distances get
reset to values that make the function return a more negative value.
Use a more direct check of "not yet elevated": elevation is still the
initial -INFINITY.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Nicer & much faster replacement for next_vector()
next_vector() is kind of cute, but it is also unobvious, cumbersome to
use, and slow for arguments greater than one.
Replace it by hexagon_first(), hexagon_next(). The new code takes
O(1) time, whereas the old code takes O(n). Iterating over a hexagon
changes from
for (i = 0; i < n; ++i)
vector[i] = 0;
do {
x = x0;
y = y0;
for (i = 0; i < n; ++i) {
x = new_x(x + dirx[vector[i]]);
y = new_y(y + diry[vector[i]]);
}
do stuff with @x, @y...
} while (next_vector(n));
to
hexagon_first(&hexit, x0, y0, n, &x, &y);
do {
do stuff with @x, @y...
} while (hexagon_next(&hexit, &x, &y));
In my measurements, it's ~8% slower for n == 1, 25% faster for n == 2,
and more than three times faster for n == 6.
fairland's performance is dominated by it. Creating worlds for the
Common Fever blitz (distance arguments 3 and 2) and the Hvy Fever
Blitz (distance arguments 6 and 3) on my machine speeds up by a factor
of 1.6 and 2.1, respectively.
Of course, fairland performance is hardly an issue on today's
machines: it takes fairly impractical setups to push run time over a
second.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
fairland: Check first two continent sectors properly
grow_continents() places the first two continent sectors without
checking for collisions or minimum distance. Unlikely to be an issue
in practice, as growing such a continent will almost certainly fail.
Fix it anyway.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
grow_one_sector() sets @fl_status when it fails to grow a continent.
grow_continents() uses @fl_status to find out whether
grow_one_sector() succeeded, and main() uses it to find out whether
grow_continents() succeeded.
Change grow_continents() to return success / failure.
grow_one_sector() already does. Use the return values, and eliminate
@fl_status.
Signed-off-by: Markus Armbruster <armbru@pond.sub.org>
projects / empserver / log