- 0 A.D. guidelines for Ancient Greek require the removal of accents.
- A few typos and declination mistakes were addressed.
- Improved Athenian and Spartan descriptions.
- Added specific names for Ostracism, Long Walls and Arsenal of Philon.
- Changed Ploîon Phortēgikón to Holkas and Ploîon Halieutikón to Halias.
- Removed inconsistent parenthesis part from Catafalque names.
Fixes: #9308
Also DynamicArena causes an assertion when there are too many GUI
elements. LinearAllocator consumes similar amount of memory in total
but reduces a chance to get the assertion.
A command for a huge turn made the server resize saved commands and
clients their command queues to that size, running out of memory.
Reject turns below 0 or beyond MAX_COMMAND_TURN_FACTOR * COMMAND_DELAY_MP
ahead of the ready turn, before relaying, and kick the sender.
Since d18a6392b3 all resource maps were rebuilt whenever an entity in
SharedScript.resources was destroyed. As every entity was listed there,
not only resources, that happened on almost every turn and took most of
the AI time in big games.
Keep instead the influence of each resource on the maps, and subtract it
when the resource is destroyed. Like d18a6392b3, this does not need
entityObj.
assignUnit looped over all the foes of the army for every unit assigned
and, for each (unit, foe) pair, fetched the foe entity and its position,
tested its class, read its UnitAI order data (up to four times) and, when
the foe was close to saturation, tested the Hero and siege classes again.
None of this depends on the unit being assigned.
- Add the module function getFoeInfo(), which gathers once for all the
foes of the army the entity, its position, the unit it is attacking (if
any) and, lazily, whether it is a hero or a siege unit and its access
index. The army keeps the result in foeInfo, which is reset when a foe
is added, removed or renamed, and at the beginning of update(), as
positions and orders change from one turn to the next.
- assignUnit reads that table instead of querying the entities. The foes
are still visited in the same order and with the same checks, so the
chosen foe is unchanged. assignedAgainst is still read live, as it
changes while units are assigned.
- Read ent.position() only once.
This allows the same user to keep the buddy list across clients and
config resets. At the same time this allows for per lobby buddy lists
which is needed as the same nickname may refer to different people.
Use lower case comparison for buddy names. This is in line with the idea
of local part of jid should be seen as normalized nick and is used
server-side to compare user names.
The migration is kept simple. I.e. only attempted if the roster is
empty and the config indicates no migration was done before.
Fixes: #6824
Signed-off-by: Ralph Sennhauser <ralph.sennhauser@gmail.com>
It wasn't represeting maximumum or average CPU frequency. Just a
frequency calculated at the time of HW report. Also it was
working only for Windows and x86-64.
NUMA is needed for multiprocessors systems like server ones. We don't
target such platform. OS shouldn't handle that for us.
Also we had NUMA support only for Windows.
Used MAX_FAILED_MOVEMENTS (a fixed constant) instead of
m_FailedMovements, making the "every N failures" clause always
false at compile time. Alternation only ever fired once per
failure streak instead of periodically as intended.
Introduced in 70ec781.
Deduplicate the stayClasses(tileClassWater, 0) constraint by creating
it once before the placement loop, instead of constructing a new
identical one for every placed dock.
Area.getClosestPointTo scans every point of the water search area, and
it was called up to count * retryFactor times in placeDocks.
The nearest point of a set to a point outside of it is always a
boundary point, so compute the boundary once and scan only that. The
logic lives in two small helpers, getBoundaryPoints (Uint8Array mask
based) and getClosestPointInList, so it can be reused and read apart
from placeDocks. getBoundaryPoints returns the original point objects,
while getClosestPointInList returns a clone of the point it finds, so
callers cannot mutate the points stored in the list.
Create the water search area first and return before computing the land
search area if there is no water at all, so that work is not wasted.
Also return if the land search area is empty. Previously pickRandom
would have been called on an empty array and returned undefined, making
getClosestPointTo fail on an undefined position.
Cache the start points instead of calling getPoints() on every try.
areaLand and areaWater were created with a MapBoundsPlacer, which
evaluates the tileclass constraint on every tile of the map. However,
createArea only has an effect if either a painter is specified or the
returned Area is used. Here no painter was passed and the returned
values were never read, so these calls did nothing except waste time.
If a point at squared distance 0 is found, no closer point can exist, so
return it immediately instead of scanning the rest of the points. The
returned point is the same as before, since the first point with the
smallest distance was already the one kept.
Iterate with an indexed loop over a local reference to the points array
instead of for...of over this.points, which avoids iterator and property
lookup overhead in a loop that can run over thousands of points.
Every neighbor sample created a new Vector2D and went through
validHeight() and getHeight(). Use plain integer coordinates, an inline
bounds check and direct access to the height array instead, which also
removes the per-vertex allocation and the setHeight() call.
Fabio Pedretti