As I mentioned in the title, which version or system of the War Engine works flawlessly? Can you help me, which one should I use?
Which version of the war engine works well and without problems?
This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.
-
-
-
Is it a system that works flawlessly? There are drops to - and post-war issues across 2moons.
-
-
thank you bro
-
Edit, im wrong, and now thank to you i will compile C / OG Battle Engine into my OgameX Nova in next release:
OgameX Nova - 5 Battle_Engine - 16 Languages - ACS Battle Report Telemetry
OGameX Nova - Rust / X Nova vs public OG Battle Engine github.com/patrykstefanski/og-battle-engine
Date: 2026-09-22T00:44:57
Repeats: 3
1v1 x 10,000/side = 20,000 ships | repeats=3
Rust / X Nova : 60.11 ms | RSS 2,560 KiB | rounds 6
OG Battle Engine C : 10.91 ms | RSS 1,656 KiB | rounds 6
Result : C is 5.51x faster in this common scenario
1v1 x 100,000/side = 200,000 ships | repeats=3
Rust / X Nova : 599.93 ms | RSS 20,048 KiB | rounds 6
OG Battle Engine C : 61.06 ms | RSS 3,664 KiB | rounds 6
Result : C is 9.83x faster in this common scenario
1v1 x 500,000/side = 1,000,000 ships | repeats=3
Rust / X Nova : 3352.44 ms | RSS 98,244 KiB | rounds 6
OG Battle Engine C : 508.90 ms | RSS 13,032 KiB | rounds 6
Result : C is 6.59x faster in this common scenario
1v1 x 1,000,000/side = 2,000,000 ships | repeats=3
Rust / X Nova : 6997.19 ms | RSS 195,868 KiB | rounds 6
OG Battle Engine C : 1203.75 ms | RSS 24,680 KiB | rounds 6
Result : C is 5.81x faster in this common scenario
Regards.The post was edited 1 time, last by Zuno ().
-
If I were working on this engine myself, I would make a few small changes:
- I would change the unit creation loop counter from uint32_t to uint64_t, since unit counts are already stored as uint64_t.
- I would update the PHP requirement from 7.3 to 7.4+, because the code uses typed properties.
- I would add stricter validation for numSimulations.
- I would align the 256 combatant limit between the C engine and the PHP/Python wrappers.
- I would make the PHP proc_open() call safer by handling arguments properly.
- I would validate the engine output before parsing it.
- For very large battles, I would also consider using double instead of float for the combat calculations.
- I would change the unit creation loop counter from uint32_t to uint64_t, since unit counts are already stored as uint64_t.
-
Thanks for the detailed review. We checked each of your seven points against the current OGameX Nova battle-engine architecture and its eight laboratory profiles. Here are our findings:
sqval wrote:
If I were working on this engine myself, I would make a few small changes:
- I would change the unit creation loop counter from uint32_t to uint64_t, since unit counts are already stored as uint64_t.
- I would update the PHP requirement from 7.3 to 7.4+, because the code uses typed properties.
- I would add stricter validation for numSimulations.
- I would align the 256 combatant limit between the C engine and the PHP/Python wrappers.
- I would make the PHP proc_open() call safer by handling arguments properly.
- I would validate the engine output before parsing it.
- For very large battles, I would also consider using double instead of float for the combat calculations.
1. Change the unit creation loop counter from uint32_t to uint64_t — CORRECT, ALREADY FIXED.
We identified the same inconsistency in C/OGBE. Since P85, the C materialization counter has been changed to 64-bit, consistent with the uint64_t unit counts. We also benchmarked the native engine with scenarios reaching up to 10 million units per side. So we agree with this recommendation, but it has already been addressed.
2. Update PHP requirement from 7.3 to 7.4+ — DOES NOT APPLY TO THE CURRENT NOVA RUNTIME.
The PHP 7.3 requirement belongs to the upstream/legacy OGBE component. OGameX Nova itself currently targets PHP 8.4.x and Laravel 13. Therefore, changing the Nova requirement to 7.4+ would actually be a regression. The old requirement can still appear inside third-party/upstream OGBE documentation, but it does not define Nova's runtime baseline.
3. Add stricter validation for numSimulations — AGREED; GOOD HARDENING CANDIDATE.
We agree that this input should have an explicit contract: integer only, greater than zero, bounded by a defined maximum, and rejected when malformed or outside the permitted range. This is input/resource hardening rather than a change to combat mathematics, so it can be improved without altering battle results.
4. Align the 256-combatant limit between C and the PHP/Python wrappers — VALID, BUT IT MUST BE DISTINGUISHED FROM GAMEPLAY LIMITS.
We agree that if the native C boundary accepts a maximum of 256 internal combatants, every wrapper must enforce the same boundary before invoking the engine. However, that internal engine limit must not be confused with Nova's ACS rules. Nova deliberately uses a maximum of 7 unique players per side for ACS. Internal combatants, fleets, players, unit groups and individual units are different concepts. We will keep those contracts separate.
5. Make the PHP proc_open() call safer — AGREED; GOOD HARDENING CANDIDATE.
Nova intentionally uses proc_open() to execute native battle runtimes. We agree that the boundary should be hardened: no unsafe shell interpolation, controlled executable/arguments, controlled environment, proper pipe handling, timeout enforcement, bounded stdout/stderr and mandatory exit-code verification. This can improve security and robustness without changing combat calculations.
6. Validate engine output before parsing it — AGREED, AND MUCH OF THIS ALREADY EXISTS.
Nova's native-engine architecture already uses protocol versions, engine identity, self-tests, checksums, fixtures and rejection-contract gates. We nevertheless agree that the runtime boundary should be strictly fail-closed: malformed JSON, missing fields, unexpected protocol versions, invalid/non-finite numbers, oversized payloads or non-zero exit codes should be rejected rather than parsed optimistically. There must never be a silent fallback to another battle engine.
7. Consider changing float to double for very large battles — WORTH TESTING, BUT NOT SAFE TO CHANGE WITHOUT EVIDENCE.
We agree that double provides substantially greater numerical precision, particularly for large accumulations. However, changing numeric representation can also change rounding behavior, memory footprint, cache efficiency, SIMD throughput and, most importantly, observable combat/replay results. In Nova, mathematical/ruleset parity has priority over theoretical precision or speed. We have previously rejected an optimization that improved CPU performance because it failed replay-hash parity. Therefore, float → double would only be accepted after controlled A/B testing proves a meaningful precision benefit, preserves battle semantics/parity and has an acceptable performance/memory cost.
Overall conclusion:
Your points 1, 3, 5 and 6 are technically sound; point 1 had already been fixed in our current branch. Point 4 is also valid at the native API boundary, but the 256 limit must remain conceptually separate from Nova's ACS/player limits. Point 2 refers to the legacy/upstream OGBE environment rather than the current Nova runtime, which is PHP 8.4. Point 7 is a legitimate research hypothesis, but we would not change the numeric model without precision, parity, memory and performance benchmarks.
Our design rule for the battle engines is deliberately conservative:
1. Correctness and mathematical/ruleset fidelity first.
2. Performance and memory efficiency second.
3. No optimization is promoted if it changes combat behavior incorrectly.
We currently maintain several genuinely different solver families — PHP, native Rust, grouped/probabilistic OPBE and native C/OGBE — through eight laboratory profiles. This allows us to test these kinds of changes against independent implementations rather than assuming that a theoretically cleaner implementation is automatically a better one.
Your review is useful, particularly the input/output boundary and proc_open() hardening points. Those are the areas we consider the best candidates for improvement because they can strengthen the system without disturbing the combat mathematics.
Last version here, all Combat Engines has been improved:
OgameX Nova - 8 Battle Engine, Source Code & Compiled, 19 Languages, 4 Battle Report's
Edit: in folder tools are a Laboratory for Combat Engines, scripts to compare presicion and speed with real benchmarks, do your own test, also OPBE was improved alot with presicion, also C/GOBE, i think right now winner is C/OGBE / X Nova, speed and presicion.
Also right now max number is 9Q, because presicion airthmetic math calculation.The post was edited 1 time, last by Zuno: Laboratory Combat Engines and 9Q max number limit. ().
- I would change the unit creation loop counter from uint32_t to uint64_t, since unit counts are already stored as uint64_t.
-
Share
- Facebook 0
- Twitter 0
- Google Plus 0
- Reddit 0
-
Users Online 1
1 Guest