mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-08-15 14:43:32 -07:00
Compare commits
24 commits
db6507a698
...
865ca4cd55
| Author | SHA1 | Date | |
|---|---|---|---|
|
865ca4cd55 | ||
|
|
dcb7cef308 | ||
|
|
71be79791f | ||
|
|
9ab89b01c2 | ||
|
|
dcce6666ae | ||
|
|
202bdb133a | ||
|
|
46981d2b90 | ||
|
|
49c887b7ca | ||
|
|
91a37e32f6 | ||
|
|
139b08fe6d | ||
|
|
dc6da217fd | ||
|
|
e41dd2d3a4 | ||
|
|
c7953026dd | ||
|
|
0340cc9abd | ||
|
|
aeeda05433 | ||
|
|
0da1e0c398 | ||
|
|
dc1e7179a3 | ||
|
|
b6d9d87ba9 | ||
|
|
839226d542 | ||
|
|
4125e5b645 | ||
|
|
f781181899 | ||
|
|
e2f5b20922 | ||
|
|
b3165505b6 | ||
|
|
15b9a39b00 |
99 changed files with 1993 additions and 392 deletions
|
|
@ -7,17 +7,17 @@ jobs:
|
|||
build:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-python@v5
|
||||
- uses: actions/checkout@v7
|
||||
- uses: actions/setup-python@v7
|
||||
with:
|
||||
python-version: "3.11"
|
||||
- id: restore-pip-cache
|
||||
uses: actions/cache/restore@v4
|
||||
uses: actions/cache/restore@v6
|
||||
with:
|
||||
key: pip-cache-v1-${{ github.workflow }}
|
||||
path: ~/.cache/pip
|
||||
- uses: pre-commit/action@v3.0.1
|
||||
- uses: actions/cache/save@v4
|
||||
- uses: actions/cache/save@v6
|
||||
if: steps.restore-pip-cache.outcome == 'success'
|
||||
with:
|
||||
key: pip-cache-v1-${{ github.workflow }}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ repos:
|
|||
\.patch$
|
||||
)
|
||||
- repo: https://github.com/astral-sh/ruff-pre-commit
|
||||
rev: v0.12.9
|
||||
rev: v0.16.0
|
||||
hooks:
|
||||
- id: ruff-check
|
||||
args:
|
||||
|
|
@ -56,7 +56,7 @@ repos:
|
|||
files: ^binaries/
|
||||
exclude: (^binaries/data/mods/(mod|public)/art/.*\.xml|\.dae$)
|
||||
- repo: https://github.com/scop/pre-commit-shfmt
|
||||
rev: v3.12.0-2
|
||||
rev: v3.13.1-1
|
||||
hooks:
|
||||
- id: shfmt
|
||||
args:
|
||||
|
|
@ -67,7 +67,7 @@ repos:
|
|||
hooks:
|
||||
- id: shellcheck
|
||||
- repo: https://github.com/igorshubovych/markdownlint-cli
|
||||
rev: v0.45.0
|
||||
rev: v0.47.0
|
||||
hooks:
|
||||
- id: markdownlint
|
||||
language_version: 22.14.0
|
||||
|
|
@ -77,13 +77,13 @@ repos:
|
|||
^source/third_party/
|
||||
)
|
||||
- repo: https://github.com/adrienverge/yamllint
|
||||
rev: v1.37.1
|
||||
rev: v1.38.0
|
||||
hooks:
|
||||
- id: yamllint
|
||||
args:
|
||||
- --strict
|
||||
- repo: https://github.com/eslint/eslint
|
||||
rev: v9.39.2
|
||||
rev: v10.8.0
|
||||
hooks:
|
||||
- id: eslint
|
||||
language_version: 22.14.0
|
||||
|
|
|
|||
|
|
@ -78,6 +78,9 @@
|
|||
<optional>
|
||||
<attribute name="define"/>
|
||||
</optional>
|
||||
<optional>
|
||||
<attribute name="srgb"/>
|
||||
</optional>
|
||||
</element>
|
||||
</zeroOrMore>
|
||||
</interleave>
|
||||
|
|
|
|||
|
|
@ -12,10 +12,10 @@
|
|||
layout(set = 2, binding = LOCATION, FORMAT) uniform image2D NAME
|
||||
#if USE_DESCRIPTOR_INDEXING
|
||||
#define STORAGE_BUFFER(LOCATION) \
|
||||
layout(set = 2, binding = LOCATION)
|
||||
layout(std430, set = 2, binding = LOCATION)
|
||||
#else
|
||||
#define STORAGE_BUFFER(LOCATION) \
|
||||
layout(set = 1, binding = LOCATION)
|
||||
layout(std430, set = 1, binding = LOCATION)
|
||||
#endif
|
||||
#else
|
||||
// We use offset to the binding slot for OpenGL to avoid overlapping with other
|
||||
|
|
@ -23,7 +23,7 @@
|
|||
#define STORAGE_2D(LOCATION, FORMAT, NAME) \
|
||||
layout(binding = LOCATION, FORMAT) uniform image2D NAME
|
||||
#define STORAGE_BUFFER(LOCATION) \
|
||||
layout(binding = LOCATION)
|
||||
layout(std430, binding = LOCATION)
|
||||
#endif
|
||||
|
||||
#endif // STAGE_COMPUTE
|
||||
|
|
|
|||
|
|
@ -51,6 +51,18 @@
|
|||
</textures>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="ungarrisoned" frequency="1" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_achaemenids.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -33,6 +33,18 @@
|
|||
</textures>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant frequency="1" name="ungarrisoned" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_celt.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -53,6 +53,18 @@
|
|||
</textures>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="ungarrisoned" frequency="1" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_celt.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -134,6 +134,20 @@
|
|||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
|
||||
<group>
|
||||
<variant frequency="1" name="ungarrisoned" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_germ.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -106,6 +106,18 @@
|
|||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="ungarrisoned" frequency="1" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_iber.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -47,6 +47,18 @@
|
|||
</textures>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="ungarrisoned" frequency="1" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_rome.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/destruction_small.xml"/>
|
||||
|
|
|
|||
|
|
@ -43,6 +43,18 @@
|
|||
</textures>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant frequency="1" name="ungarrisoned" />
|
||||
<variant name="garrisoned">
|
||||
<props>
|
||||
<prop
|
||||
actor="props/special/common/garrison_flag_seleucids.xml"
|
||||
attachpoint="garrisoned"
|
||||
selectable="false"
|
||||
/>
|
||||
</props>
|
||||
</variant>
|
||||
</group>
|
||||
<group>
|
||||
<variant name="alive" frequency="1"/>
|
||||
<variant file="structures/sele/light_damage.xml"/>
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:995da95e21261ae0a2718baee69d76ae5f6823d21eaefaa708a89651f2099bb0
|
||||
size 586243
|
||||
oid sha256:ed243a229225ec51ee090588a63307cbd2efedecca06f4f1a0922a4d51ee3967
|
||||
size 586427
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:d8e022a3ac132a32061583743d1322fc8792cdd6e7be57857547a8ed3cefbed6
|
||||
size 525300
|
||||
oid sha256:3ce649aa943771357d7c19f48294af719c50ca14178c32be60992f17845d685d
|
||||
size 525483
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:21971f20f5567f820e0f3fffdd21015e2a5ffaee309be7b6efc38d3fc56aecd3
|
||||
size 503936
|
||||
oid sha256:d1d867c2e9f3db233847da547c466325ba9f0a9e7478175281f3538cbb694709
|
||||
size 504112
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:3c37b1b7f12a429cd07873d0fdb7cc8692f6578b3e5320a6be0e68420fb4688e
|
||||
size 780868
|
||||
oid sha256:cc9c95992889a4c2930a39bd20f7c86b73f7c7ddb3b36492650afae2ae424641
|
||||
size 781051
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:1230a92373c4e4684f791594efb35bb7d6c091377a11bd8f0daafd13816d04ec
|
||||
size 56755
|
||||
oid sha256:6779d6ca2067d6dd5594b3d2e5ef82d08de97ad058ce7084eb0bf8ae3290f4c2
|
||||
size 56953
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:30a395c3b5a50214a689abe968ad15edb60212c3ea14041a2edc07295a4462c6
|
||||
size 45317
|
||||
oid sha256:9e6aca91d66df31b5820f39025c57937ce6a1593199b8a068722fdec5b0675f6
|
||||
size 45523
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:ce554ad452cf75bd4dbb9da5de9830309a1dccf72f72f6a74475078af7f0e1c4
|
||||
size 42851
|
||||
oid sha256:07013561c7e46b020acbd03d4f371300c38d3e364c99a1e7bbcf7467aa8a34e6
|
||||
size 43041
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:60f0614c1092395065c4ba8fe6bed64da873d38c579c9cbc400e9a9b8f30f3a8
|
||||
size 272099
|
||||
oid sha256:1416efa429cd64471d50e969c43ee723382c031c676414433f8fcd58176cfa77
|
||||
size 272274
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:c6e7d6264d7b3e03466bf1de58ab366a023120c6f78142aebc6570218a4803d9
|
||||
size 274339
|
||||
oid sha256:9f9e6debd5f2a9659e19e74b5826d3488167edb9a897ae1ed6e4db10742d94e8
|
||||
size 274543
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:0624fc07116aa70c14527457fced3afcf7b36df1535bbf10250455e6254aeed6
|
||||
size 372821
|
||||
oid sha256:091d68b7800d9141e87ba8aaf0fa93c5bc7d260dd459774075de610ca34855e2
|
||||
size 372997
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:6ef199b28b9d9ef19e0817b189d9e6f1e2f9861ca211890b8d714f9fe05f5c61
|
||||
size 420601
|
||||
oid sha256:c1413de5371443f1249d87fa40a821c880c749513a0347d9128a99472bec7b33
|
||||
size 420808
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:adf219c08e65bd7a149726d325b6f2b4fd67effc3dd1bc211c3163774ac8308e
|
||||
size 201143
|
||||
oid sha256:8aba3f3dc5a909ddadd9af5e7abfe9094f55ed6c97b39e7f97b09dc1cb951f4d
|
||||
size 201315
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:f8c688df60c4880dc92b6898728d4cef443c86831a2a2e87e61dd44661b58240
|
||||
size 205000
|
||||
oid sha256:0c3298efebf687a07d4693d9014c51e1e870e95fb9d9024c9126b40adfec75a5
|
||||
size 205172
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:9d86be00b7e911108e6666422a56eb061a996e6cf0bfe489d6c99f84be752444
|
||||
size 216525
|
||||
oid sha256:b97f6dff13f4639e746e1ce79c120169bccb2e09d4507dc900075cf85e788590
|
||||
size 216697
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:5e258d0b3a7b5c3fe2275c2816c636b7478ee1051df31a2cbe2f516465c692f9
|
||||
size 239166
|
||||
oid sha256:8d764a2d5a712f53f08560504f6841ed00b5268fea2a283d2d5254d57ce1df76
|
||||
size 239339
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:82ff53473c25d6e17aeb97f795b543df3ec1c423e8ecb8398d0d014beac57f4e
|
||||
size 101895
|
||||
oid sha256:dccc1521e6e626e75ac2f05d2c8b2c2963ee751da08a9e819e4c28954b19f01a
|
||||
size 102099
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:2377bddedc6251acbe8f03bf1820d368b21cbf88fc2783695ff31036af8ed4e3
|
||||
size 82812
|
||||
oid sha256:ae1042461639bca3d3d73fb3e723ca404c8a897ee0e2ad417af1eebb5849d23f
|
||||
size 83027
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:b5f1530adecb42af05b6b81719a5c4d00fa06a5eff33f50eda8312ce2e0fcd5f
|
||||
size 77866
|
||||
oid sha256:b71b8848a0a2e503adbff9c1e09c06c1e76e16537f38af5b35395a04f11b365a
|
||||
size 78066
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:c393e007e24473c1332c7d0c3a8093e0b542974da00b51b853ee413e45818ade
|
||||
size 91109
|
||||
oid sha256:256b3864edc754955814d5eec113e73fded49525d2e855a1171a4e4b495ffcc4
|
||||
size 91304
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:e8fb0f356f48284704d81b601c7947f32e91995757e8c2fc390ecaf772fbd950
|
||||
size 84604
|
||||
oid sha256:4ef0415cce15f4d1ff4e342c23a995ee5081d21b7f84eb6c19fb89c1d63f84a7
|
||||
size 84789
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:7c2b0d0a461535e0802d2a07395afb4546515ef4d3ccc3eab18d55a0993bc165
|
||||
size 184407
|
||||
oid sha256:2ab540ad518de662ba9a4dbe4d0d0590b6ee0b771bc482073296c949ee33d571
|
||||
size 184610
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:828e2e63b9686a601b3641be10f26e3b099ced5b8dc8d453ab94d41270f22b39
|
||||
size 213385
|
||||
oid sha256:39a6a575b8bbb0f82ed8cf4056e0df932a59fd6e3343005625b3b76644c6879c
|
||||
size 213561
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:4825c81a245ddae5637f3b2dee78f7749e27a48d2efa244bc95af075ddabcd1a
|
||||
size 144598
|
||||
oid sha256:93341f17ad185e28ce62a533f1db457aec4b69bb2f67c98e4b89e4bcf9503b6a
|
||||
size 144784
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:427f9512af696afaae0721374a86ceb0e1432602013cb3dde818bfcd2791c163
|
||||
size 212264
|
||||
oid sha256:dc27dba302816891bb8f33bc65d9d68b2b330f946256aa966e5d684714af9fe2
|
||||
size 212447
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:19ca2828e5e6b99065d3d901c1a90f1b73df065dc94b3a4b76b4e5804890c137
|
||||
size 349847
|
||||
oid sha256:270fe9095c3894fb448cb91668ad48d886088006c689f0efa148e8a78a3de043
|
||||
size 350053
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:57039fff36fbba71de79b89614fea988a98bdc85b2bdc5ef88ce3a632da95a55
|
||||
size 340693
|
||||
oid sha256:977b2ffb5dc9cf0364d125f0b3dd17e1fb0cd482b5c96fbf7c61b6e6a030db86
|
||||
size 340906
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:221eeca4ee2e46023d346e80c7a3b4b3852699e0c193e31fa58e0619e858f7a2
|
||||
size 272252
|
||||
oid sha256:f177172ef923455050064af60377f2e1b171ff4ec72fa9aa5fdc5c4c28000550
|
||||
size 272435
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:afc01d8e7e7efc988b2f78b58cfb6b48b5453b8786609e9ce5db38bc617a7984
|
||||
size 279942
|
||||
oid sha256:acdaaf09848dc5cb7cf207c7bb535865aa4199a5a50609ca3b632ce5d88d95a2
|
||||
size 280139
|
||||
|
|
|
|||
|
|
@ -330,3 +330,20 @@ Math.euclidDistance3D = function(x1, y1, z1, x2, y2, z2)
|
|||
{
|
||||
return Math.sqrt(Math.euclidDistance3DSquared(x1, y1, z1, x2, y2, z2));
|
||||
};
|
||||
|
||||
/**
|
||||
* Clamps a value between a minimum and maximum range.
|
||||
*
|
||||
* @param {number} value - The value to clamp
|
||||
* @param {number} min - Minimum allowed value
|
||||
* @param {number} max - Maximum allowed value
|
||||
* @returns {number} The clamped value (min <= result <= max)
|
||||
*/
|
||||
Math.clamp = function(value, min, max)
|
||||
{
|
||||
if (value < min)
|
||||
return min;
|
||||
if (value > max)
|
||||
return max;
|
||||
return value;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -442,3 +442,17 @@ Vector3D.div = function(v, f)
|
|||
{
|
||||
return new Vector3D(v.x / f, v.y / f, v.z / f);
|
||||
};
|
||||
|
||||
/**
|
||||
* Linear interpolation between this vector and another.
|
||||
* @param {Vector2D} v - The target vector.
|
||||
* @param {number} t - Interpolation factor (0 = this, 1 = v).
|
||||
* @returns {Vector2D} A new vector at the interpolated position.
|
||||
*/
|
||||
Vector2D.prototype.lerp = function(v, t)
|
||||
{
|
||||
return new Vector2D(
|
||||
this.x + (v.x - this.x) * t,
|
||||
this.y + (v.y - this.y) * t
|
||||
);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -72,6 +72,7 @@
|
|||
"List": [
|
||||
{ "nick": "Alexandermb", "name": "Daniel Morgado" },
|
||||
{ "nick": "Athos" },
|
||||
{ "nick": "Atrik" },
|
||||
{ "nick": "Basshunter", "name": "Sebastián Gómez" },
|
||||
{ "nick": "BigTiger", "name": "Nathanael P. Moore" },
|
||||
{ "nick": "Brightgalrs", "name": "Robert D. Schultz" },
|
||||
|
|
@ -80,6 +81,7 @@
|
|||
{ "nick": "Enrique", "name": "Enrique Keykens Espolio" },
|
||||
{ "nick": "Gen.Kenobi", "name": "Daniel Schubert" },
|
||||
{ "nick": "Historicity", "name": "Shane" },
|
||||
{ "nick": "Langbart" },
|
||||
{ "nick": "Leyto", "name": "Valentin Levalet" },
|
||||
{ "nick": "LordGood", "name": "Johnathan B. Good" },
|
||||
{ "nick": "m7600" },
|
||||
|
|
|
|||
|
|
@ -507,6 +507,49 @@ var unitFilters = {
|
|||
}
|
||||
};
|
||||
|
||||
// Choose, inside a list of entities, which ones are targetable foes for boxtargeting.
|
||||
// We also filter out entities that aren't visible, or low priority like livestocks
|
||||
function getTargetableEntities(ents)
|
||||
{
|
||||
const player = g_ViewedPlayer;
|
||||
const simState = GetSimState();
|
||||
const isEnemy = simState.players[player].isEnemy;
|
||||
|
||||
// Filter valid target candidates
|
||||
const candidates = ents.filter(entity =>
|
||||
{
|
||||
const entState = GetEntityState(entity);
|
||||
return entState &&
|
||||
unitFilters.isUnit(entity) &&
|
||||
entState.visibility != "hidden";
|
||||
});
|
||||
|
||||
// Enemy players
|
||||
const enemyPlayers = candidates.filter(entity =>
|
||||
{
|
||||
const entState = GetEntityState(entity);
|
||||
return isEnemy[entState.player] && entState.player !== 0 && !hasClass(entState, "Domestic");
|
||||
});
|
||||
if (enemyPlayers.length > 0)
|
||||
return enemyPlayers;
|
||||
|
||||
// Gaia
|
||||
const gaiaUnits = candidates.filter(entity =>
|
||||
{
|
||||
const entState = GetEntityState(entity);
|
||||
return entState.player === 0;
|
||||
});
|
||||
if (gaiaUnits.length > 0)
|
||||
return gaiaUnits;
|
||||
|
||||
// Domestic animals
|
||||
return candidates.filter(entity =>
|
||||
{
|
||||
const entState = GetEntityState(entity);
|
||||
return hasClass(entState, "Domestic");
|
||||
});
|
||||
}
|
||||
|
||||
// Choose, inside a list of entities, which ones will be selected.
|
||||
// We may use several entity filters, until one returns at least one element.
|
||||
function getPreferredEntities(ents)
|
||||
|
|
@ -572,16 +615,19 @@ function handleInputBeforeGui(ev, hoveredObject)
|
|||
case INPUT_BANDBOXING:
|
||||
{
|
||||
const bandbox = Engine.GetGUIObjectByName("bandbox");
|
||||
const isAttackMode = Engine.HotkeyIsPressed("session.attack") && !g_IsObserver;
|
||||
switch (ev.type)
|
||||
{
|
||||
case "mousemotion":
|
||||
{
|
||||
const rect = updateBandbox(bandbox, ev, false);
|
||||
|
||||
const ents = Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], g_ViewedPlayer);
|
||||
const preferredEntities = getPreferredEntities(ents);
|
||||
g_Selection.setHighlightList(preferredEntities);
|
||||
const player = isAttackMode ? -1 : g_ViewedPlayer;
|
||||
|
||||
const ents = Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], player);
|
||||
const highlightEntities = isAttackMode ? getTargetableEntities(ents) : getPreferredEntities(ents);
|
||||
|
||||
g_Selection.setHighlightList(highlightEntities);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -589,6 +635,30 @@ function handleInputBeforeGui(ev, hoveredObject)
|
|||
if (ev.button == SDL_BUTTON_LEFT)
|
||||
{
|
||||
const rect = updateBandbox(bandbox, ev, true);
|
||||
if (isAttackMode)
|
||||
{
|
||||
// Box attack behavior
|
||||
const ents = Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], -1);
|
||||
|
||||
// Filter to only enemy units
|
||||
const enemyUnits = getTargetableEntities(ents);
|
||||
|
||||
// Get currently selected friendly units
|
||||
const selectedUnits = g_Selection.toList();
|
||||
|
||||
if (selectedUnits.length && enemyUnits.length)
|
||||
{
|
||||
// Sort entities by position
|
||||
const sortedCombattants = sortEntitiesForEngagement(selectedUnits, enemyUnits);
|
||||
// Distribute attack orders
|
||||
distributeAttackOrders(sortedCombattants.attackers, sortedCombattants.targets);
|
||||
}
|
||||
g_Selection.setHighlightList([]);
|
||||
inputState = INPUT_NORMAL;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
const ents = getPreferredEntities(Engine.PickPlayerEntitiesInRect(rect[0], rect[1], rect[2], rect[3], g_ViewedPlayer));
|
||||
g_Selection.setHighlightList([]);
|
||||
|
||||
|
|
@ -1371,6 +1441,7 @@ function positionUnitsFreehandSelectionMouseUp(ev)
|
|||
for (let i = 1; i < inputLine.length; ++i)
|
||||
lengthOfLine += inputLine[i].distanceTo(inputLine[i - 1]);
|
||||
|
||||
// Filter units that can move
|
||||
const selection = g_Selection.filter(ent => !!GetEntityState(ent).unitAI).sort((a, b) => a - b);
|
||||
|
||||
// Checking the line for a minimum length to save performance.
|
||||
|
|
@ -1380,39 +1451,43 @@ function positionUnitsFreehandSelectionMouseUp(ev)
|
|||
return !!action && doAction(action, ev);
|
||||
}
|
||||
|
||||
// Even distribution of the units on the line.
|
||||
let p0 = inputLine[0];
|
||||
let entityDistribution = [p0];
|
||||
const distanceBetweenEnts = lengthOfLine / (selection.length - 1);
|
||||
let freeDist = -distanceBetweenEnts;
|
||||
// Sort units by their projection onto the line direction (parallel sorting)
|
||||
const sortedSelection = sortEntitiesAlongLine(selection, inputLine[0], inputLine[inputLine.length - 1], true);
|
||||
|
||||
for (let i = 1; i < inputLine.length; ++i)
|
||||
const selectionCount = sortedSelection.length;
|
||||
const targetPositions = [];
|
||||
|
||||
// Distribute units evenly along the polyline
|
||||
for (let i = 0; i < selectionCount; ++i)
|
||||
{
|
||||
const p1 = inputLine[i];
|
||||
freeDist += inputLine[i - 1].distanceTo(p1);
|
||||
const t = i / (selectionCount - 1);
|
||||
const targetDistance = t * lengthOfLine;
|
||||
|
||||
while (freeDist >= 0)
|
||||
let accumulated = 0;
|
||||
let targetPoint = inputLine[0];
|
||||
for (let j = 1; j < inputLine.length; ++j)
|
||||
{
|
||||
p0 = Vector2D.sub(p0, p1).normalize().mult(freeDist).add(p1);
|
||||
entityDistribution.push(p0);
|
||||
freeDist -= distanceBetweenEnts;
|
||||
const segStart = inputLine[j - 1];
|
||||
const segEnd = inputLine[j];
|
||||
const segLength = segEnd.distanceTo(segStart);
|
||||
|
||||
if (accumulated + segLength >= targetDistance)
|
||||
{
|
||||
// Interpolate within this segment
|
||||
const remaining = targetDistance - accumulated;
|
||||
const frac = remaining / segLength;
|
||||
targetPoint = segStart.lerp(segEnd, frac);
|
||||
break;
|
||||
}
|
||||
accumulated += segLength;
|
||||
}
|
||||
targetPositions.push(targetPoint);
|
||||
}
|
||||
|
||||
// Rounding errors can lead to missing or too many points.
|
||||
entityDistribution = entityDistribution.slice(0, selection.length);
|
||||
entityDistribution = entityDistribution.concat(new Array(selection.length - entityDistribution.length).fill(inputLine[inputLine.length - 1]));
|
||||
|
||||
if (Vector2D.from3D(GetEntityState(selection[0]).position).distanceTo(entityDistribution[0]) +
|
||||
Vector2D.from3D(GetEntityState(selection[selection.length - 1]).position).distanceTo(entityDistribution[selection.length - 1]) >
|
||||
Vector2D.from3D(GetEntityState(selection[0]).position).distanceTo(entityDistribution[selection.length - 1]) +
|
||||
Vector2D.from3D(GetEntityState(selection[selection.length - 1]).position).distanceTo(entityDistribution[0]))
|
||||
entityDistribution.reverse();
|
||||
|
||||
Engine.PostNetworkCommand({
|
||||
"type": isAttackMovePressed() ? "attack-walk-custom" : "walk-custom",
|
||||
"entities": selection,
|
||||
"targetPositions": entityDistribution.map(pos => pos.toFixed(2)),
|
||||
"entities": sortedSelection,
|
||||
"targetPositions": targetPositions.map(pos => pos.toFixed(2)),
|
||||
"targetClasses": Engine.HotkeyIsPressed("session.attackmoveUnit") ? { "attack": ["Unit"] } : { "attack": ["Unit", "Structure"] },
|
||||
"queued": Engine.HotkeyIsPressed("session.queue"),
|
||||
"pushFront": Engine.HotkeyIsPressed("session.pushorderfront"),
|
||||
|
|
@ -1420,9 +1495,10 @@ function positionUnitsFreehandSelectionMouseUp(ev)
|
|||
});
|
||||
|
||||
// Add target markers with a minimum distance of 5 to each other.
|
||||
const entitiesBetweenMarker = Math.ceil(5 / distanceBetweenEnts);
|
||||
for (let i = 0; i < entityDistribution.length; i += entitiesBetweenMarker)
|
||||
DrawTargetMarker({ "x": entityDistribution[i].x, "z": entityDistribution[i].y });
|
||||
const stepDistance = lengthOfLine / (selectionCount - 1);
|
||||
const entitiesBetweenMarker = Math.max(1, Math.ceil(5 / stepDistance));
|
||||
for (let i = 0; i < targetPositions.length; i += entitiesBetweenMarker)
|
||||
DrawTargetMarker({ "x": targetPositions[i].x, "z": targetPositions[i].y });
|
||||
|
||||
Engine.GuiInterfaceCall("PlaySound", {
|
||||
"name": "order_walk",
|
||||
|
|
@ -1929,3 +2005,108 @@ function clearSelection()
|
|||
g_Selection.reset();
|
||||
preSelectedAction = ACTION_NONE;
|
||||
}
|
||||
|
||||
function distributeAttackOrders(attackers, targets)
|
||||
{
|
||||
if (targets.length < 1)
|
||||
return;
|
||||
|
||||
// Play attack sounds from a sample of units in selection
|
||||
const soundCount = Math.min(3, attackers.length);
|
||||
for (let i = 0; i < soundCount; i++)
|
||||
{
|
||||
const t = soundCount === 1 ? 0 : i / (soundCount - 1);
|
||||
const attackerIndex = Math.floor(t * (attackers.length - 1));
|
||||
|
||||
setTimeout(() =>
|
||||
{
|
||||
Engine.GuiInterfaceCall("PlaySound", {
|
||||
"name": "order_attack",
|
||||
"entity": attackers[attackerIndex]
|
||||
});
|
||||
}, i * 180);
|
||||
}
|
||||
|
||||
Engine.PostNetworkCommand({
|
||||
"type": "attack-group",
|
||||
"entities": attackers,
|
||||
"targets": targets,
|
||||
"queued": Engine.HotkeyIsPressed("session.queue"),
|
||||
"allowCapture": false
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sorts attackers and targets for left-to-right engagement across the battle line.
|
||||
*
|
||||
* Entities are sorted by their perpendicular distance to the line connecting the
|
||||
* two army centers, creating natural pairings across the battle front.
|
||||
*
|
||||
* @param {number[]} attackers - Array of attacking entity IDs.
|
||||
* @param {number[]} targets - Array of target entity IDs.
|
||||
* @returns {Object} { attackers: number[], targets: number[] } - Both arrays sorted
|
||||
* for cross-line engagement (targets automatically reversed).
|
||||
*/
|
||||
function sortEntitiesForEngagement(attackers, targets)
|
||||
{
|
||||
const getPosition = (id) => GetEntityState(id).position;
|
||||
|
||||
const computeAveragePosition = (entities) =>
|
||||
{
|
||||
if (entities.length === 0) return new Vector2D(0, 0);
|
||||
const vectors = entities.map(id => Vector2D.from3D(getPosition(id)));
|
||||
return Vector2D.average(vectors);
|
||||
};
|
||||
|
||||
// Calculate the axis of engagement - the line between the groups' average positions
|
||||
const avgAttackers = computeAveragePosition(attackers);
|
||||
const avgTargets = computeAveragePosition(targets);
|
||||
|
||||
// Sort each group by perpendicular distance to the engagement line
|
||||
const sortedAttackers = sortEntitiesAlongLine(attackers, avgAttackers, avgTargets);
|
||||
const sortedTargets = sortEntitiesAlongLine(targets, avgAttackers, avgTargets);
|
||||
|
||||
// Reverse targets so the leftmost attacker pairs with leftmost target
|
||||
return {
|
||||
"attackers": sortedAttackers,
|
||||
"targets": sortedTargets.reverse()
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Sorts entity IDs by their projection onto a line's direction or perpendicular axis.
|
||||
*
|
||||
* @param {number[]} entities - Array of entity IDs.
|
||||
* @param {Vector2D} lineStart - Start point of the reference line.
|
||||
* @param {Vector2D} lineEnd - End point of the reference line.
|
||||
* @param {boolean} sortByDirection - If true, sort by parallel projection (along line);
|
||||
* If false, sort by perpendicular distance (default).
|
||||
* @returns {number[]} Sorted entity IDs.
|
||||
*/
|
||||
function sortEntitiesAlongLine(entities, lineStart, lineEnd, sortByDirection = false)
|
||||
{
|
||||
const dir = lineEnd.sub(lineStart);
|
||||
const length = dir.length();
|
||||
if (length === 0)
|
||||
return entities.slice();
|
||||
|
||||
// Choose basis vector: either parallel or perpendicular to the line
|
||||
let basis;
|
||||
if (sortByDirection)
|
||||
basis = dir.mult(1 / length); // Unit direction vector
|
||||
else
|
||||
basis = new Vector2D(-dir.y, dir.x).normalize(); // Perpendicular
|
||||
|
||||
const withCoord = entities.map(id =>
|
||||
{
|
||||
const pos = GetEntityState(id).position;
|
||||
const point2D = Vector2D.from3D(pos);
|
||||
const rel = point2D.sub(lineStart);
|
||||
const coord = rel.dot(basis); // Project onto basis vector
|
||||
return { id, coord };
|
||||
});
|
||||
|
||||
// Sort by that coordinate
|
||||
withCoord.sort((a, b) => a.coord - b.coord);
|
||||
return withCoord.map(item => item.id);
|
||||
}
|
||||
|
|
@ -603,4 +603,147 @@ TriggerHelper.SpawnAndTurretAtClasses = function(playerID, classes, templates, c
|
|||
return results;
|
||||
};
|
||||
|
||||
/**
|
||||
* Makes an entity permanently visible to all players by:
|
||||
* - Setting alwaysVisible flag
|
||||
* - Deactivating fogging (no mirages)
|
||||
* - Exploring the surrounding area
|
||||
* - Forcing a visibility update
|
||||
*
|
||||
* @param {number} ent - Entity ID to make permanently visible
|
||||
*/
|
||||
TriggerHelper.MakeEntityPermanentlyVisible = function(ent)
|
||||
{
|
||||
const cmpVisibility = Engine.QueryInterface(ent, IID_Visibility);
|
||||
if (cmpVisibility)
|
||||
{
|
||||
cmpVisibility.alwaysVisible = true;
|
||||
cmpVisibility.SetActivated(true);
|
||||
}
|
||||
|
||||
const cmpFogging = Engine.QueryInterface(ent, IID_Fogging);
|
||||
if (cmpFogging)
|
||||
cmpFogging.PermanentlyReveal("all");
|
||||
|
||||
const cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
|
||||
const cmpPosition = Engine.QueryInterface(ent, IID_Position);
|
||||
if (cmpRangeManager && cmpPosition && cmpPosition.IsInWorld())
|
||||
{
|
||||
const pos = cmpPosition.GetPosition2D();
|
||||
const numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
|
||||
|
||||
const exploreRadius = TriggerHelper.CalculateExplorationRadius(ent);
|
||||
|
||||
for (let i = 1; i < numPlayers; ++i)
|
||||
cmpRangeManager.ExploreCircle(i, pos.x, pos.y, exploreRadius);
|
||||
|
||||
cmpRangeManager.RequestVisibilityUpdate(ent);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculate a reasonable exploration radius from an entity's footprint.
|
||||
* Calculates the radius as the entity's full extent to reveal the surrounding area.
|
||||
* This is equivalent to (extent/2) * 2, giving a 2x margin around the entity.
|
||||
*/
|
||||
TriggerHelper.CalculateExplorationRadius = function(ent)
|
||||
{
|
||||
const cmpFootprint = Engine.QueryInterface(ent, IID_Footprint);
|
||||
if (!cmpFootprint)
|
||||
return 50;
|
||||
|
||||
const shapeInfo = cmpFootprint.GetShape();
|
||||
|
||||
let halfExtent; // The radius of the entity (half its size)
|
||||
if (shapeInfo && shapeInfo.type === "circle")
|
||||
halfExtent = shapeInfo.radius || shapeInfo.size0;
|
||||
else if (shapeInfo && shapeInfo.type === "square")
|
||||
halfExtent = Math.max(shapeInfo.width || shapeInfo.size0, shapeInfo.depth || shapeInfo.size1) / 2;
|
||||
else
|
||||
return 50;
|
||||
|
||||
// Use 2x the entity's radius to reveal surrounding area
|
||||
// This gives a comfortable margin around the entity
|
||||
const radius = halfExtent * 2;
|
||||
return radius;
|
||||
};
|
||||
|
||||
/**
|
||||
* Sends a notification to specific players.
|
||||
*
|
||||
* @param {string} message - The message to display (use markForTranslation)
|
||||
* @param {number[]} players - Array of player IDs to send the notification to
|
||||
* @param {number} duration - Duration in milliseconds
|
||||
* @param {Object} parameters - Translation parameters (optional)
|
||||
*/
|
||||
TriggerHelper.SendNotification = function(message, players, duration = 30000, parameters = {}, translateParameters = [])
|
||||
{
|
||||
const cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
|
||||
if (!cmpGuiInterface)
|
||||
return;
|
||||
|
||||
// Ensure all parameter values are primitive types
|
||||
const primitiveParameters = {};
|
||||
for (const key in parameters)
|
||||
{
|
||||
const value = parameters[key];
|
||||
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
|
||||
primitiveParameters[key] = value;
|
||||
else
|
||||
primitiveParameters[key] = String(value);
|
||||
}
|
||||
|
||||
cmpGuiInterface.AddTimeNotification(
|
||||
{
|
||||
"message": message,
|
||||
"players": players,
|
||||
"parameters": primitiveParameters,
|
||||
"translateMessage": true,
|
||||
"translateParameters": translateParameters
|
||||
},
|
||||
duration
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Sends a notification to a specific player and a different notification to all other active players.
|
||||
*
|
||||
* @param {number} player - The player ID who gets the 'owner' message
|
||||
* @param {string} ownerMessage - Message for the specified player (use markForTranslation)
|
||||
* @param {string} othersMessage - Message for all other active players (use markForTranslation)
|
||||
* @param {number} duration - Duration in milliseconds
|
||||
* @param {Object} parameters - Translation parameters shared by both messages (optional)
|
||||
* @param {Object} ownerParameters - Additional parameters for the owner message (optional)
|
||||
* @param {Object} othersParameters - Additional parameters for the others message (optional)
|
||||
*/
|
||||
TriggerHelper.SendDualNotification = function(player, ownerMessage, othersMessage, duration = 30000, parameters = {}, ownerParameters = {}, othersParameters = {})
|
||||
{
|
||||
const numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
|
||||
|
||||
const others = [-1]; // Include observers (player id -1)
|
||||
for (let playerID = 1; playerID < numPlayers; ++playerID)
|
||||
{
|
||||
if (playerID == player)
|
||||
continue;
|
||||
const cmpPlayer = QueryPlayerIDInterface(playerID);
|
||||
if (cmpPlayer && cmpPlayer.GetState() == "defeated")
|
||||
continue;
|
||||
others.push(playerID);
|
||||
}
|
||||
|
||||
const mergedOwnerParams = Object.assign({}, parameters, ownerParameters);
|
||||
const mergedOthersParams = Object.assign({}, parameters, othersParameters);
|
||||
|
||||
// Auto-detect translatable parameters (those starting with "_" or named "player")
|
||||
const translateParameters = Object.keys(mergedOthersParams).filter(key => key.startsWith("_") || key == "player");
|
||||
|
||||
TriggerHelper.SendNotification(ownerMessage, [player], duration, mergedOwnerParams, translateParameters);
|
||||
TriggerHelper.SendNotification(othersMessage, others, duration, mergedOthersParams, translateParameters);
|
||||
};
|
||||
|
||||
TriggerHelper.SendWonderNotifications = function(owner, othersMessage, ownerMessage)
|
||||
{
|
||||
TriggerHelper.SendDualNotification(owner, ownerMessage, othersMessage, 30000, { "_player_": owner });
|
||||
};
|
||||
|
||||
Engine.RegisterGlobal("TriggerHelper", TriggerHelper);
|
||||
|
|
|
|||
|
|
@ -1,16 +1,42 @@
|
|||
Trigger.prototype.WonderVictoryEntityRenamed = function(data)
|
||||
{
|
||||
if (this.wonderVictoryMessages[data.entity] && Engine.QueryInterface(data.newentity, IID_Wonder))
|
||||
{
|
||||
// When an entity is renamed, we first create a new entity,
|
||||
// which in case it is a wonder will receive a timer.
|
||||
// However on a rename we want to use the timer from the old entity,
|
||||
// so we need to remove the timer of the new entity.
|
||||
this.WonderVictoryDeleteTimer(data.newentity);
|
||||
if (!Engine.QueryInterface(data.newentity, IID_Wonder))
|
||||
return;
|
||||
|
||||
// Check if wonder victory is enabled
|
||||
const cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
|
||||
if (!cmpEndGameManager)
|
||||
return;
|
||||
|
||||
const victoryConditions = cmpEndGameManager.GetVictoryConditions();
|
||||
if (!victoryConditions || !victoryConditions.includes("wonder"))
|
||||
return;
|
||||
|
||||
// Handle timer transfer (only if old entity had the timer)
|
||||
if (this.wonderVictoryMessages[data.entity])
|
||||
{
|
||||
this.WonderVictoryDeleteTimer(data.newentity);
|
||||
this.wonderVictoryMessages[data.newentity] = this.wonderVictoryMessages[data.entity];
|
||||
delete this.wonderVictoryMessages[data.entity];
|
||||
}
|
||||
|
||||
// Make the completed wonder permanently visible
|
||||
TriggerHelper.MakeEntityPermanentlyVisible(data.newentity);
|
||||
|
||||
// Send "wonder completed" notifications (only for non-Gaia wonders)
|
||||
const cmpOwnership = Engine.QueryInterface(data.newentity, IID_Ownership);
|
||||
if (cmpOwnership)
|
||||
{
|
||||
const owner = cmpOwnership.GetOwner();
|
||||
if (owner > 0)
|
||||
{
|
||||
TriggerHelper.SendWonderNotifications(
|
||||
owner,
|
||||
markForTranslation("%(_player_)s has built a Wonder!"),
|
||||
markForTranslation("You have built a Wonder!")
|
||||
);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Trigger.prototype.WonderVictoryOwnershipChanged = function(data)
|
||||
|
|
@ -18,6 +44,15 @@ Trigger.prototype.WonderVictoryOwnershipChanged = function(data)
|
|||
if (!Engine.QueryInterface(data.entity, IID_Wonder))
|
||||
return;
|
||||
|
||||
// Check if wonder victory is enabled
|
||||
const cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
|
||||
if (!cmpEndGameManager)
|
||||
return;
|
||||
|
||||
const victoryConditions = cmpEndGameManager.GetVictoryConditions();
|
||||
if (!victoryConditions || !victoryConditions.includes("wonder"))
|
||||
return;
|
||||
|
||||
this.WonderVictoryDeleteTimer(data.entity);
|
||||
|
||||
if (data.to > 0)
|
||||
|
|
@ -146,11 +181,69 @@ Trigger.prototype.WonderVictorySetWinner = function(playerID)
|
|||
n));
|
||||
};
|
||||
|
||||
Trigger.prototype.WonderStartNotification = function(data)
|
||||
{
|
||||
// Check if wonder victory is enabled in game settings
|
||||
const cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
|
||||
if (!cmpEndGameManager)
|
||||
return;
|
||||
|
||||
// Don't show the wonder foundation if it's not a wonder victory game
|
||||
const victoryConditions = cmpEndGameManager.GetVictoryConditions();
|
||||
if (!victoryConditions || !victoryConditions.includes("wonder"))
|
||||
return;
|
||||
|
||||
const cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
|
||||
if (!cmpTemplateManager)
|
||||
return;
|
||||
|
||||
const template = cmpTemplateManager.GetTemplate(data.template);
|
||||
|
||||
if (!template || !("Wonder" in template))
|
||||
return;
|
||||
|
||||
const owner = TriggerHelper.GetOwner(data.foundation);
|
||||
if (owner <= 0)
|
||||
return;
|
||||
|
||||
TriggerHelper.MakeEntityPermanentlyVisible(data.foundation);
|
||||
|
||||
TriggerHelper.SendWonderNotifications(
|
||||
owner,
|
||||
markForTranslation("%(_player_)s has started building a Wonder."),
|
||||
markForTranslation("You have started building a Wonder.")
|
||||
);
|
||||
};
|
||||
|
||||
Trigger.prototype.RevealGaiaWonders = function()
|
||||
{
|
||||
Engine.ProfileStart("RevealGaiaWonders");
|
||||
const cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
|
||||
if (!cmpEndGameManager)
|
||||
return;
|
||||
|
||||
const victoryConditions = cmpEndGameManager.GetVictoryConditions();
|
||||
if (!victoryConditions || !victoryConditions.includes("wonder"))
|
||||
return;
|
||||
|
||||
// Find and reveal all Gaia wonders
|
||||
const gaiaWonders = Engine.GetEntitiesWithInterface(IID_Wonder).filter(
|
||||
ent => TriggerHelper.GetOwner(ent) === 0
|
||||
);
|
||||
|
||||
for (const ent of gaiaWonders)
|
||||
TriggerHelper.MakeEntityPermanentlyVisible(ent);
|
||||
|
||||
Engine.ProfileStop();
|
||||
};
|
||||
|
||||
{
|
||||
const cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
|
||||
cmpTrigger.RegisterTrigger("OnEntityRenamed", "WonderVictoryEntityRenamed", { "enabled": true });
|
||||
cmpTrigger.RegisterTrigger("OnOwnershipChanged", "WonderVictoryOwnershipChanged", { "enabled": true });
|
||||
cmpTrigger.RegisterTrigger("OnDiplomacyChanged", "WonderVictoryDiplomacyChanged", { "enabled": true });
|
||||
cmpTrigger.RegisterTrigger("OnPlayerWon", "WonderVictoryPlayerWon", { "enabled": true });
|
||||
cmpTrigger.RegisterTrigger("OnConstructionStarted", "WonderStartNotification", { "enabled": true });
|
||||
cmpTrigger.DoAfterDelay(0, "RevealGaiaWonders", {});
|
||||
cmpTrigger.wonderVictoryMessages = {};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ Fogging.prototype.Init = function()
|
|||
this.mirages = [];
|
||||
this.miraged = [];
|
||||
this.seen = [];
|
||||
this.revealed = [];
|
||||
|
||||
const numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
|
||||
for (let player = 0; player < numPlayers; ++player)
|
||||
|
|
@ -36,6 +37,7 @@ Fogging.prototype.Init = function()
|
|||
this.mirages.push(INVALID_ENTITY);
|
||||
this.miraged.push(false);
|
||||
this.seen.push(false);
|
||||
this.revealed.push(false);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -169,6 +171,45 @@ Fogging.prototype.WasSeen = function(player)
|
|||
return this.seen[player];
|
||||
};
|
||||
|
||||
/**
|
||||
* Permanently reveal this entity to one or all players.
|
||||
* Destroys existing mirages and optionally deactivates fogging entirely.
|
||||
* @param {number|string} player - Player ID to reveal to, or "all" for all players.
|
||||
*/
|
||||
Fogging.prototype.PermanentlyReveal = function(player = "all")
|
||||
{
|
||||
const cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
|
||||
|
||||
// Validate single player case
|
||||
if (player !== "all" && (player < 0 || player >= this.mirages.length))
|
||||
return;
|
||||
|
||||
// Determine which players to reveal
|
||||
const startPlayer = (player === "all") ? 0 : player;
|
||||
const endPlayer = (player === "all") ? this.mirages.length : player + 1;
|
||||
|
||||
// Reveal each player in the range
|
||||
for (let i = startPlayer; i < endPlayer; ++i)
|
||||
{
|
||||
if (this.mirages[i] != INVALID_ENTITY)
|
||||
{
|
||||
Engine.DestroyEntity(this.mirages[i]);
|
||||
this.mirages[i] = INVALID_ENTITY;
|
||||
this.miraged[i] = false;
|
||||
}
|
||||
this.revealed[i] = true;
|
||||
this.seen[i] = true;
|
||||
}
|
||||
|
||||
// Deactivate fogging if revealing to all players
|
||||
if (player === "all")
|
||||
this.activated = false;
|
||||
|
||||
// Request visibility update
|
||||
if (cmpRangeManager)
|
||||
cmpRangeManager.RequestVisibilityUpdate(this.entity);
|
||||
};
|
||||
|
||||
Fogging.prototype.OnOwnershipChanged = function(msg)
|
||||
{
|
||||
// Always activate fogging for non-Gaia entities.
|
||||
|
|
@ -209,7 +250,8 @@ Fogging.prototype.OnVisibilityChanged = function(msg)
|
|||
this.seen[msg.player] = true;
|
||||
}
|
||||
|
||||
if (msg.newVisibility == VIS_FOGGED && this.activated)
|
||||
// Only create a mirage if the player hasn’t been permanently revealed
|
||||
if (msg.newVisibility == VIS_FOGGED && this.activated && !this.revealed[msg.player])
|
||||
this.LoadMirage(msg.player);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -424,10 +424,42 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
|
||||
"Order.Attack": function(msg)
|
||||
{
|
||||
const type = this.GetBestAttackAgainst(msg.data.target, msg.data.allowCapture);
|
||||
if (!type)
|
||||
return this.FinishOrder();
|
||||
// Check if this is a group attack
|
||||
const isGroupAttack = !!msg.data.targetArray;
|
||||
|
||||
// For group attacks with invalid initial target, find one from the array
|
||||
if (isGroupAttack && (!msg.data.target || msg.data.target === INVALID_ENTITY))
|
||||
{
|
||||
if (!this.FindAndSetNextTarget(msg.data))
|
||||
{
|
||||
this.FinishOrder();
|
||||
return ACCEPT_ORDER;
|
||||
}
|
||||
}
|
||||
|
||||
// Get the attack type for the current target
|
||||
const type = this.GetBestAttackAgainst(msg.data.target, msg.data.allowCapture);
|
||||
|
||||
if (!type)
|
||||
{
|
||||
// Current target can't be attacked
|
||||
if (isGroupAttack)
|
||||
{
|
||||
if (this.FindAndSetNextTarget(msg.data))
|
||||
{
|
||||
msg.data.attackType = this.GetBestAttackAgainst(msg.data.target, msg.data.allowCapture);
|
||||
if (msg.data.attackType)
|
||||
{
|
||||
this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
|
||||
return ACCEPT_ORDER;
|
||||
}
|
||||
}
|
||||
}
|
||||
this.FinishOrder();
|
||||
return ACCEPT_ORDER;
|
||||
}
|
||||
|
||||
// Set attackType before range check
|
||||
msg.data.attackType = type;
|
||||
|
||||
this.RememberTargetPosition();
|
||||
|
|
@ -1366,6 +1398,12 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
// Wait for individual members to finish
|
||||
"enter": function(msg)
|
||||
{
|
||||
if (this.order.data.targetArray)
|
||||
{
|
||||
// For group attacks, we're done once we distributed targets
|
||||
this.FinishOrder();
|
||||
return true;
|
||||
}
|
||||
const target = this.order.data.target;
|
||||
if (!this.CheckFormationTargetAttackRange(target))
|
||||
{
|
||||
|
|
@ -1602,6 +1640,26 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
"INDIVIDUAL": {
|
||||
"Attacked": function(msg)
|
||||
{
|
||||
// First, check if we have a group attack order and the attacker is in our target array
|
||||
if (this.order?.type === "Attack" &&
|
||||
this.order.data?.targetArray?.includes(msg.data.attacker))
|
||||
{
|
||||
// Switch to attack the entity that's attacking us
|
||||
this.order.data.target = msg.data.attacker;
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(msg.data.attacker, this.order.data.allowCapture);
|
||||
|
||||
// Update the current target index
|
||||
const currentIndex = this.order.data.targetArray.indexOf(msg.data.attacker);
|
||||
if (currentIndex !== -1)
|
||||
this.order.data.currentTargetIndex = currentIndex;
|
||||
|
||||
// Make sure we're in the right state to handle this
|
||||
const currentState = this.GetCurrentState();
|
||||
if (currentState === "INDIVIDUAL.IDLE" || currentState === "INDIVIDUAL.WALKING")
|
||||
this.SetNextState("INDIVIDUAL.COMBAT.APPROACHING");
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.GetStance().targetAttackersAlways || !this.order || !this.order.data || !this.order.data.force)
|
||||
this.RespondToTargetedEntities([msg.data.attacker]);
|
||||
},
|
||||
|
|
@ -2150,6 +2208,35 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
|
||||
"Attacked": function(msg)
|
||||
{
|
||||
// Check if we're doing a group attack and the attacker is in our target array
|
||||
if (!this.order.data.targetArray ||
|
||||
!this.order.data.targetArray.includes(msg.data.attacker) ||
|
||||
msg.data.attacker === this.order.data.target)
|
||||
return;
|
||||
|
||||
// Switch to attack the entity that's attacking us
|
||||
this.order.data.target = msg.data.attacker;
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(msg.data.attacker, this.order.data.allowCapture);
|
||||
|
||||
// Update the current target index
|
||||
const currentIndex = this.order.data.targetArray.indexOf(msg.data.attacker);
|
||||
if (currentIndex !== -1)
|
||||
this.order.data.currentTargetIndex = currentIndex;
|
||||
|
||||
// Re-evaluate our approach to the new target
|
||||
if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
{
|
||||
if (this.CanUnpack())
|
||||
{
|
||||
this.PushOrderFront("Unpack", { "force": true });
|
||||
return;
|
||||
}
|
||||
this.SetNextState("ATTACKING");
|
||||
}
|
||||
// Continue approaching the new target
|
||||
else if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
this.FinishOrder();
|
||||
|
||||
// If we're already in combat mode, ignore anyone else who's attacking us
|
||||
// unless it's a melee attack since they may be blocking our way to the target
|
||||
if (msg.data.type == "Melee" && (this.GetStance().targetAttackersAlways || !this.order.data.force))
|
||||
|
|
@ -2209,7 +2296,23 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
|
||||
"MovementUpdate": function(msg)
|
||||
{
|
||||
if (msg.likelyFailure)
|
||||
if (!msg.likelyFailure)
|
||||
{
|
||||
if (!this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
return;
|
||||
|
||||
if (this.CanUnpack())
|
||||
{
|
||||
this.PushOrderFront("Unpack", { "force": true });
|
||||
return;
|
||||
}
|
||||
|
||||
this.SetNextState("ATTACKING");
|
||||
return;
|
||||
}
|
||||
|
||||
// For group attacks, try next target instead of moving to last position
|
||||
if (!this.order.data.targetArray || this.order.data.currentTargetIndex === undefined)
|
||||
{
|
||||
// This also handles hunting.
|
||||
if (this.orderQueue.length > 1)
|
||||
|
|
@ -2217,11 +2320,13 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
this.FinishOrder();
|
||||
return;
|
||||
}
|
||||
else if (!this.order.data.force || !this.order.data.lastPos)
|
||||
|
||||
if (!this.order.data.force || !this.order.data.lastPos)
|
||||
{
|
||||
this.SetNextState("COMBAT.FINDINGNEWTARGET");
|
||||
return;
|
||||
}
|
||||
|
||||
// If the order was forced, try moving to the target position,
|
||||
// under the assumption that this is desirable if the target
|
||||
// was somewhat far away - we'll likely end up closer to where
|
||||
|
|
@ -2234,21 +2339,30 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
return;
|
||||
}
|
||||
|
||||
if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
// Handle group attack case
|
||||
// Remove current unreachable target from array
|
||||
const currentIndex = this.order.data.currentTargetIndex;
|
||||
if (currentIndex < this.order.data.targetArray.length)
|
||||
this.order.data.targetArray.splice(currentIndex, 1);
|
||||
|
||||
// Try to find next valid target
|
||||
if (this.order.data.targetArray.length === 0 || !this.FindAndSetNextTarget(this.order.data))
|
||||
{
|
||||
if (this.CanUnpack())
|
||||
{
|
||||
this.PushOrderFront("Unpack", { "force": true });
|
||||
return;
|
||||
}
|
||||
this.SetNextState("ATTACKING");
|
||||
this.FinishOrder();
|
||||
return;
|
||||
}
|
||||
else if (msg.likelySuccess)
|
||||
// Try moving again,
|
||||
// attack range uses a height-related formula and our actual max range might have changed.
|
||||
if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
this.FinishOrder();
|
||||
},
|
||||
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
|
||||
|
||||
// Try approaching the new target
|
||||
if (this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
|
||||
return;
|
||||
|
||||
// If we can't approach the new target either, remove it and continue
|
||||
this.order.data.targetArray.splice(this.order.data.currentTargetIndex, 1);
|
||||
if (this.order.data.targetArray.length === 0)
|
||||
this.FinishOrder();
|
||||
}
|
||||
},
|
||||
|
||||
"ATTACKING": {
|
||||
|
|
@ -2322,6 +2436,18 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
|
||||
"OutOfRange": function()
|
||||
{
|
||||
// Check if the target is garrisoned or in a turret (turreted entities cannot be attacked by melee units)
|
||||
const cmpTargetUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
|
||||
const isTargetGarrisoned = cmpTargetUnitAI && cmpTargetUnitAI.isGarrisoned;
|
||||
const isTargetInTurret = cmpTargetUnitAI && cmpTargetUnitAI.IsTurret();
|
||||
|
||||
// If target is garrisoned or in a turret (and we're not ranged), treat as invalid
|
||||
if (isTargetGarrisoned || (isTargetInTurret && this.order.data.attackType !== "Ranged"))
|
||||
{
|
||||
this.ProcessMessage("TargetInvalidated");
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.ShouldChaseTargetedEntity(this.order.data.target, this.order.data.force))
|
||||
{
|
||||
if (this.CanPack())
|
||||
|
|
@ -2332,11 +2458,53 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
this.SetNextState("CHASING");
|
||||
return;
|
||||
}
|
||||
|
||||
// For group attacks, try next target instead of finding new ones
|
||||
if (this.order.data.targetArray && this.order.data.currentTargetIndex !== undefined)
|
||||
{
|
||||
const currentIndex = this.order.data.currentTargetIndex;
|
||||
|
||||
// Remove current target since it's out of range and we can't chase
|
||||
this.order.data.targetArray.splice(currentIndex, 1);
|
||||
|
||||
// Try to find next valid target in sequence
|
||||
if (this.order.data.targetArray.length > 0 && this.FindAndSetNextTarget(this.order.data))
|
||||
{
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
|
||||
this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
this.SetNextState("FINDINGNEWTARGET");
|
||||
},
|
||||
|
||||
"TargetInvalidated": function()
|
||||
{
|
||||
// For group attacks, remove current target and move to next in array
|
||||
if (this.order.data.targetArray && this.order.data.currentTargetIndex !== undefined)
|
||||
{
|
||||
// Remove the current target from the array
|
||||
const currentIndex = this.order.data.currentTargetIndex;
|
||||
if (currentIndex < this.order.data.targetArray.length)
|
||||
{
|
||||
this.order.data.targetArray.splice(currentIndex, 1);
|
||||
|
||||
// If we have more targets, continue with the next one
|
||||
if (this.order.data.targetArray.length > 0)
|
||||
{
|
||||
// Try to find next valid target in sequence
|
||||
if (this.FindAndSetNextTarget(this.order.data))
|
||||
{
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
|
||||
this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// No more targets or not a group attack - use original behavior
|
||||
this.SetNextState("FINDINGNEWTARGET");
|
||||
},
|
||||
|
||||
|
|
@ -2360,7 +2528,26 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
|
||||
"enter": function()
|
||||
{
|
||||
// Check if we are attacking a formation.
|
||||
// First, check if we have pending targets in a group attack
|
||||
if (this.order.data.targetArray && this.order.data.currentTargetIndex !== undefined)
|
||||
{
|
||||
// Try to find next valid target from the array
|
||||
if (this.FindAndSetNextTarget(this.order.data))
|
||||
{
|
||||
this.order.data.attackType = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
|
||||
this.SetNextState("COMBAT.ATTACKING");
|
||||
return true;
|
||||
}
|
||||
|
||||
// No valid targets in array - clean up and continue with normal behavior
|
||||
this.order.data.targetArray = [];
|
||||
this.order.data.currentTargetIndex = undefined;
|
||||
}
|
||||
|
||||
if (!this.order.data.target)
|
||||
return false;
|
||||
|
||||
// Try to find the formation the target was a part of.
|
||||
let cmpFormation = Engine.QueryInterface(this.order.data.target, IID_Formation);
|
||||
if (cmpFormation)
|
||||
this.order.data.formationTarget = this.order.data.target;
|
||||
|
|
@ -2468,6 +2655,12 @@ UnitAI.prototype.UnitFsmSpec = {
|
|||
{
|
||||
if (msg.likelyFailure)
|
||||
{
|
||||
// If this is a group attack with pending targets, try the next one
|
||||
if (this.order.data.targetArray && this.order.data.targetArray.length > 0)
|
||||
{
|
||||
this.SetNextState("COMBAT.FINDINGNEWTARGET");
|
||||
return;
|
||||
}
|
||||
// This also handles hunting.
|
||||
if (this.orderQueue.length > 1)
|
||||
{
|
||||
|
|
@ -3887,6 +4080,9 @@ UnitAI.prototype.OnOwnershipChanged = function(msg)
|
|||
|
||||
UnitAI.prototype.OnDestroy = function()
|
||||
{
|
||||
// Clean up all group attack states before destruction
|
||||
this.CleanupAllGroupAttackStates();
|
||||
|
||||
// Switch to an empty state to let states execute their leave handlers.
|
||||
this.UnitFsm.SwitchToNextState(this, "");
|
||||
|
||||
|
|
@ -4093,6 +4289,9 @@ UnitAI.prototype.FsmStateNameChanged = function(state)
|
|||
*/
|
||||
UnitAI.prototype.FinishOrder = function()
|
||||
{
|
||||
// Clean up any group attack state before removing order
|
||||
this.CleanupGroupAttackState(this.order);
|
||||
|
||||
if (!this.orderQueue.length)
|
||||
{
|
||||
const stack = new Error().stack.trimRight().replace(/^/mg, ' '); // indent each line
|
||||
|
|
@ -4318,15 +4517,24 @@ UnitAI.prototype.ReplaceOrder = function(type, data)
|
|||
const idx = this.orderQueue.findIndex(o => o.type == "LeaveFormation");
|
||||
if (idx === -1)
|
||||
{
|
||||
// Clean up all queued orders before clearing them
|
||||
this.CleanupAllGroupAttackStates();
|
||||
this.orderQueue = [];
|
||||
this.order = undefined;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Clean up orders being discarded
|
||||
for (let i = 0; i < idx; ++i)
|
||||
this.CleanupGroupAttackState(this.orderQueue[i]);
|
||||
this.orderQueue.splice(0, idx);
|
||||
}
|
||||
this.PushOrderFront(type, data);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Clean up all queued orders before clearing them
|
||||
this.CleanupAllGroupAttackStates();
|
||||
this.orderQueue = [];
|
||||
this.PushOrder(type, data);
|
||||
}
|
||||
|
|
@ -4405,6 +4613,7 @@ UnitAI.prototype.BackToWork = function()
|
|||
if (this.IsTurret(cmpTurretable) && !cmpTurretable.LeaveTurret())
|
||||
return false;
|
||||
|
||||
this.CleanupAllGroupAttackStates();
|
||||
this.orderQueue = [];
|
||||
|
||||
this.AddOrders(this.workOrders);
|
||||
|
|
@ -5060,6 +5269,9 @@ UnitAI.prototype.CheckTargetRange = function(target, iid, type)
|
|||
*/
|
||||
UnitAI.prototype.CheckTargetAttackRange = function(target, type)
|
||||
{
|
||||
if (!target || target === INVALID_ENTITY || !type)
|
||||
return false;
|
||||
|
||||
// for formation members, the formation will take care of the range check
|
||||
if (this.IsFormationMember())
|
||||
{
|
||||
|
|
@ -5793,6 +6005,75 @@ UnitAI.prototype.Attack = function(target, allowCapture = this.DEFAULT_CAPTURE,
|
|||
this.AddOrder("Attack", order, queued, pushFront);
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds a group attack order to the queue.
|
||||
* Used when some unit(s) are ordered to attack multiple targets.
|
||||
* Each unit receives the full target list (from Commands) but starts at a different position
|
||||
* based on the startingIndex in the attacking group.
|
||||
*
|
||||
* @param {Array} targets - Array of target entity IDs to attack (pre-sorted by distance)
|
||||
* @param {number} startingIndex - This unit's position in the attacking group (0-based)
|
||||
* @param {number} unitCount - Total number of units in the attacking group
|
||||
* @param {boolean} allowCapture - Whether capturing is allowed
|
||||
* @param {boolean} queued - If true, add to end of queue instead of replacing current order
|
||||
* @param {boolean} pushFront - If true, add to front of queue (interrupt current order)
|
||||
*/
|
||||
UnitAI.prototype.AttackGroup = function(targets, startingIndex, unitCount, allowCapture = this.DEFAULT_CAPTURE, queued = false, pushFront = false)
|
||||
{
|
||||
if (!targets?.length)
|
||||
return;
|
||||
|
||||
// Check if adding these targets would exceed the limit
|
||||
const currentTotal = this.CountTotalTargetsInQueue();
|
||||
const newTargetCount = targets.length;
|
||||
|
||||
if (currentTotal + newTargetCount > this.MAX_TOTAL_TARGETS)
|
||||
{
|
||||
// Trim the targets to fit within the limit
|
||||
const allowedNewTargets = Math.max(0, this.MAX_TOTAL_TARGETS - currentTotal);
|
||||
if (allowedNewTargets === 0)
|
||||
return;
|
||||
|
||||
// Trim the target array
|
||||
targets = targets.slice(0, allowedNewTargets);
|
||||
|
||||
// If trimming results in no targets, just return
|
||||
if (targets.length === 0)
|
||||
return;
|
||||
}
|
||||
|
||||
// If this unit is in a formation, move the formation controller out of the world
|
||||
// This prevents the controller from staying at the coordinates where the units received the order
|
||||
// That can potentially be far apart from where the fighting will occur.
|
||||
// Result: The formation will reform into a more logical position once members are done (idle).
|
||||
this.MoveFormationControllerOutOfWorld();
|
||||
|
||||
const stride = targets.length / unitCount;
|
||||
const startIdx = Math.min(Math.round((startingIndex + 0.5) * stride), targets.length - 1);
|
||||
|
||||
const order = {
|
||||
"force": true,
|
||||
"allowCapture": allowCapture,
|
||||
"targetArray": targets.slice(),
|
||||
"target": INVALID_ENTITY,
|
||||
"currentTargetIndex": startIdx,
|
||||
"originalFirstTarget": targets[0],
|
||||
};
|
||||
|
||||
this.RememberTargetPosition(order);
|
||||
this.AddOrder("Attack", order, queued, pushFront);
|
||||
};
|
||||
|
||||
UnitAI.prototype.MoveFormationControllerOutOfWorld = function()
|
||||
{
|
||||
if (!this.IsFormationMember() || !this.formationController)
|
||||
return;
|
||||
|
||||
const cmpControllerPosition = Engine.QueryInterface(this.formationController, IID_Position);
|
||||
if (cmpControllerPosition?.IsInWorld())
|
||||
cmpControllerPosition.MoveOutOfWorld();
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds garrison order to the queue, forced by the player.
|
||||
*/
|
||||
|
|
@ -6726,6 +7007,72 @@ UnitAI.prototype.AttackEntitiesByPreference = function(ents)
|
|||
return this.RespondToTargetedEntities(entsWithoutPref);
|
||||
};
|
||||
|
||||
UnitAI.prototype.FindAndSetNextTarget = function(data)
|
||||
{
|
||||
if (!this.EnsureValidTargetIndex(data))
|
||||
return false;
|
||||
|
||||
const startIdx = data.currentTargetIndex;
|
||||
const currentTarget = data.targetArray[startIdx];
|
||||
|
||||
// First check the starting target
|
||||
if (this.CanAttack(currentTarget) && this.CheckTargetVisible(currentTarget))
|
||||
return this.SetNextTarget(data, startIdx);
|
||||
|
||||
// Search forward using find
|
||||
const forwardFound = data.targetArray
|
||||
.slice(startIdx + 1)
|
||||
.findIndex((target, i) =>
|
||||
this.CanAttack(target) && this.CheckTargetVisible(target)
|
||||
);
|
||||
|
||||
if (forwardFound !== -1)
|
||||
return this.SetNextTarget(data, startIdx + 1 + forwardFound);
|
||||
|
||||
// Search backward using find
|
||||
const backwardFound = data.targetArray
|
||||
.slice(0, startIdx)
|
||||
.reverse()
|
||||
.findIndex((target, i) =>
|
||||
this.CanAttack(target) && this.CheckTargetVisible(target)
|
||||
);
|
||||
|
||||
if (backwardFound !== -1)
|
||||
{
|
||||
// Convert reverse index back to original index
|
||||
const originalIndex = startIdx - 1 - backwardFound;
|
||||
return this.SetNextTarget(data, originalIndex);
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
UnitAI.prototype.SetNextTarget = function(data, index)
|
||||
{
|
||||
const target = data.targetArray[index];
|
||||
data.target = target;
|
||||
data.attackType = this.GetBestAttackAgainst(target, data.allowCapture);
|
||||
data.currentTargetIndex = index;
|
||||
return true;
|
||||
};
|
||||
|
||||
UnitAI.prototype.EnsureValidTargetIndex = function(data)
|
||||
{
|
||||
if (!data.targetArray || data.currentTargetIndex === undefined)
|
||||
return false;
|
||||
|
||||
// If array is empty, clear the index
|
||||
if (data.targetArray.length === 0)
|
||||
{
|
||||
data.currentTargetIndex = undefined;
|
||||
return false;
|
||||
}
|
||||
|
||||
data.currentTargetIndex = Math.clamp(data.currentTargetIndex, 0, data.targetArray.length - 1);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Call UnitAI.funcname(args) on all formation members.
|
||||
* @param resetFinishedEntities - If true, call ResetFinishedEntities first.
|
||||
|
|
@ -6837,6 +7184,50 @@ UnitAI.prototype.ResetObstructionMitigationFlag = function()
|
|||
delete this.obstructionMitigationAttempted;
|
||||
};
|
||||
|
||||
/**
|
||||
* Counts the total number of target entities across all queued orders.
|
||||
* This includes targetArray from group attacks and single targets.
|
||||
* Each target reference is counted separately, even if the same entity
|
||||
* appears in multiple orders or in both targetArray and target.
|
||||
* @returns {number} - Total number of target entity references in the order queue
|
||||
*/
|
||||
UnitAI.prototype.CountTotalTargetsInQueue = function()
|
||||
{
|
||||
let total = 0;
|
||||
for (const order of this.orderQueue)
|
||||
{
|
||||
if (order.data)
|
||||
{
|
||||
// Count group attack targets
|
||||
if (order.data.targetArray && Array.isArray(order.data.targetArray))
|
||||
total += order.data.targetArray.length;
|
||||
|
||||
// Add single target for consistency
|
||||
if (order.data.target && order.data.target !== INVALID_ENTITY)
|
||||
total++;
|
||||
}
|
||||
}
|
||||
return total;
|
||||
};
|
||||
|
||||
UnitAI.prototype.CleanupGroupAttackState = function(order)
|
||||
{
|
||||
if (order?.data?.targetArray)
|
||||
{
|
||||
delete order.data.targetArray;
|
||||
delete order.data.currentTargetIndex;
|
||||
}
|
||||
};
|
||||
|
||||
UnitAI.prototype.CleanupAllGroupAttackStates = function()
|
||||
{
|
||||
for (const order of this.orderQueue)
|
||||
this.CleanupGroupAttackState(order);
|
||||
};
|
||||
|
||||
// Maximum number of target entities allowed across all queued orders
|
||||
UnitAI.prototype.MAX_TOTAL_TARGETS = 1000;
|
||||
|
||||
UnitAI.prototype.UnitFsm = new FSM(UnitAI.prototype.UnitFsmSpec);
|
||||
|
||||
Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);
|
||||
|
|
|
|||
|
|
@ -138,6 +138,7 @@ function TestFormationExiting(mode)
|
|||
"ResetActiveQuery": function(id) { if (mode == 0) return []; return [enemy]; },
|
||||
"DisableActiveQuery": function(id) { },
|
||||
"GetEntityFlagMask": function(identifier) { },
|
||||
"GetLosVisibility": (ent, player) => "visible"
|
||||
});
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_TemplateManager, {
|
||||
|
|
@ -319,8 +320,11 @@ function TestMoveIntoFormationWhileAttacking()
|
|||
"ResetActiveQuery": function(id) { return [enemy]; },
|
||||
"DisableActiveQuery": function(id) { },
|
||||
"GetEntityFlagMask": function(identifier) { },
|
||||
"GetLosVisibility": (target, player) => "visible",
|
||||
"GetLosVisibilityPosition": (x, z, player) => "visible"
|
||||
});
|
||||
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_TemplateManager, {
|
||||
"GetCurrentTemplateName": function(ent) { return "special/formations/line_closed"; },
|
||||
});
|
||||
|
|
@ -406,6 +410,10 @@ function TestMoveIntoFormationWhileAttacking()
|
|||
"GetHitpoints": function() { return 40; },
|
||||
});
|
||||
|
||||
AddMock(enemy, IID_Ownership, {
|
||||
"GetOwner": () => 2 // Different player ID (enemy)
|
||||
});
|
||||
|
||||
const controllerFormation = ConstructComponent(controller, "Formation", {
|
||||
"FormationShape": "square",
|
||||
"ShiftRows": "false",
|
||||
|
|
@ -421,6 +429,10 @@ function TestMoveIntoFormationWhileAttacking()
|
|||
"DefaultStance": "aggressive"
|
||||
});
|
||||
|
||||
AddMock(controller, IID_Ownership, {
|
||||
"GetOwner": () => 1
|
||||
});
|
||||
|
||||
AddMock(controller, IID_Position, {
|
||||
"GetTurretParent": () => INVALID_ENTITY,
|
||||
"JumpTo": function(x, z) { this.x = x; this.z = z; },
|
||||
|
|
@ -458,7 +470,7 @@ function TestMoveIntoFormationWhileAttacking()
|
|||
|
||||
controllerFormation.SetMembers(units);
|
||||
|
||||
controllerAI.Attack(enemy, []);
|
||||
controllerAI.Attack(enemy);
|
||||
|
||||
for (const ent of unitAIs)
|
||||
TS_ASSERT_EQUALS(unitAI.fsmStateName, "INDIVIDUAL.COMBAT.ATTACKING");
|
||||
|
|
@ -889,4 +901,362 @@ function TestAttemptObstructionMitigation()
|
|||
})();
|
||||
}
|
||||
|
||||
TestAttemptObstructionMitigation();
|
||||
TestAttemptObstructionMitigation();
|
||||
function TestFindAndSetNextTargetBehavior()
|
||||
{
|
||||
ResetState();
|
||||
|
||||
const attacker = 10;
|
||||
const targets = [20, 21, 22, 23, 24]; // Multiple targets for comprehensive testing
|
||||
|
||||
// Basic mocks needed for unitAI creation
|
||||
AddMock(SYSTEM_ENTITY, IID_Timer, {
|
||||
"SetInterval": () => {},
|
||||
"SetTimeout": () => {}
|
||||
});
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_RangeManager, {
|
||||
"CreateActiveQuery": () => 1,
|
||||
"EnableActiveQuery": () => {},
|
||||
"ResetActiveQuery": () => [],
|
||||
"DisableActiveQuery": () => {},
|
||||
"GetEntityFlagMask": () => 0
|
||||
});
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
|
||||
"IsInTargetRange": () => false
|
||||
});
|
||||
|
||||
// Create the unitAI component
|
||||
const unitAI = ConstructComponent(attacker, "UnitAI", {
|
||||
"FormationController": "false",
|
||||
"DefaultStance": "aggressive"
|
||||
});
|
||||
|
||||
AddMock(attacker, IID_Attack, {
|
||||
"GetBestAttackAgainst": () => "Melee"
|
||||
});
|
||||
|
||||
unitAI.OnCreate();
|
||||
|
||||
// Mock the visibility and attackability checks
|
||||
unitAI.CanAttack = (target) =>
|
||||
{
|
||||
// Target 21 is always unattackable (e.g., garrisoned, dead, etc.)
|
||||
return target !== 21;
|
||||
};
|
||||
|
||||
unitAI.CheckTargetVisible = (target) =>
|
||||
{
|
||||
// Target 22 is always not visible
|
||||
return target !== 22;
|
||||
};
|
||||
|
||||
// First target is valid
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [20, 21, 22, 23, 24],
|
||||
"currentTargetIndex": 0, // Currently targeting 20
|
||||
"target": 20,
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(found);
|
||||
TS_ASSERT_EQUALS(data.target, 20);
|
||||
TS_ASSERT_EQUALS(data.currentTargetIndex, 0);
|
||||
})();
|
||||
|
||||
// End of array behavior
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [18, 19, 20, 21, 22],
|
||||
"currentTargetIndex": 2, // Currently targeting 22
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
// 21 and 22 are invalid, should go backward and find 20
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(found);
|
||||
TS_ASSERT_EQUALS(data.target, 20); // Should be assigned targetArray[initialTarget - 1]
|
||||
})();
|
||||
|
||||
// No valid targets found
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [21, 22], // Both are invalid (21 unattackable, 22 not visible)
|
||||
"currentTargetIndex": 0,
|
||||
"target": 21,
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(!found);
|
||||
TS_ASSERT_EQUALS(data.target, 21); // Should remain unchanged
|
||||
TS_ASSERT_EQUALS(data.currentTargetIndex, 0);
|
||||
})();
|
||||
|
||||
// Empty target array
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [],
|
||||
"currentTargetIndex": 0,
|
||||
"target": 20,
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(!found);
|
||||
TS_ASSERT_EQUALS(data.target, 20); // Should remain unchanged
|
||||
TS_ASSERT_EQUALS(data.currentTargetIndex, void 0); // Should nullify currentTargetIndex
|
||||
})();
|
||||
|
||||
// Current target is last in array
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [20, 21, 22, 23, 24],
|
||||
"currentTargetIndex": 4, // Currently targeting 24 (last element)
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(found);
|
||||
TS_ASSERT_EQUALS(data.target, 24); // Should remain unchanged
|
||||
TS_ASSERT_EQUALS(data.currentTargetIndex, 4);
|
||||
})();
|
||||
|
||||
// Single invalid target
|
||||
(function()
|
||||
{
|
||||
const data = {
|
||||
"targetArray": [21], // Only one target, which is invalid
|
||||
"currentTargetIndex": 0,
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(!found);
|
||||
})();
|
||||
|
||||
// Verify if we don't do more calls then necessary
|
||||
(function()
|
||||
{
|
||||
const searchOrder = [];
|
||||
|
||||
unitAI.CanAttack = (target) =>
|
||||
{
|
||||
searchOrder.push(target);
|
||||
return target == 20;
|
||||
};
|
||||
|
||||
unitAI.CheckTargetVisible = (target) => true; // All visible
|
||||
|
||||
const data = {
|
||||
"targetArray": [20, 21, 22, 23],
|
||||
"currentTargetIndex": 1, // Currently targeting 21
|
||||
"allowCapture": false
|
||||
};
|
||||
|
||||
const found = unitAI.FindAndSetNextTarget(data);
|
||||
TS_ASSERT(found);
|
||||
TS_ASSERT_EQUALS(searchOrder.length, 4); // Should find at 20 (4 calls)
|
||||
|
||||
})();
|
||||
}
|
||||
|
||||
TestFindAndSetNextTargetBehavior();
|
||||
|
||||
function TestAttackGroupBehavior()
|
||||
{
|
||||
ResetState();
|
||||
|
||||
const attacker1 = 100;
|
||||
const attacker2 = 101;
|
||||
const targets = [200, 201, 202, 203, 204];
|
||||
|
||||
// Basic mocks needed for unitAI creation
|
||||
AddMock(SYSTEM_ENTITY, IID_Timer, {
|
||||
"SetInterval": () => {},
|
||||
"SetTimeout": () => {}
|
||||
});
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_RangeManager, {
|
||||
"CreateActiveQuery": () => 1,
|
||||
"EnableActiveQuery": () => {},
|
||||
"ResetActiveQuery": () => [],
|
||||
"DisableActiveQuery": () => {},
|
||||
"GetEntityFlagMask": () => 0
|
||||
});
|
||||
|
||||
AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
|
||||
"IsInTargetRange": () => false
|
||||
});
|
||||
|
||||
// Create two unitAI components
|
||||
const unitAI1 = ConstructComponent(attacker1, "UnitAI", {
|
||||
"FormationController": "false",
|
||||
"DefaultStance": "aggressive"
|
||||
});
|
||||
|
||||
const unitAI2 = ConstructComponent(attacker2, "UnitAI", {
|
||||
"FormationController": "false",
|
||||
"DefaultStance": "aggressive"
|
||||
});
|
||||
|
||||
AddMock(attacker1, IID_Attack, {
|
||||
"GetBestAttackAgainst": () => "Melee"
|
||||
});
|
||||
|
||||
AddMock(attacker2, IID_Attack, {
|
||||
"GetBestAttackAgainst": () => "Melee"
|
||||
});
|
||||
|
||||
unitAI1.OnCreate();
|
||||
unitAI2.OnCreate();
|
||||
|
||||
// Basic AttackGroup distribution
|
||||
(function()
|
||||
{
|
||||
let orderAdded1 = null;
|
||||
let orderAdded2 = null;
|
||||
|
||||
// Mock AddOrder to capture what orders are created
|
||||
unitAI1.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded1 = { type, data, queued, pushFront };
|
||||
};
|
||||
|
||||
unitAI2.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded2 = { type, data, queued, pushFront };
|
||||
};
|
||||
|
||||
// Call AttackGroup for both units
|
||||
unitAI1.AttackGroup(targets, 0, 2, false, false, false);
|
||||
unitAI2.AttackGroup(targets, 1, 2, false, false, false);
|
||||
|
||||
// Verify unit1's order
|
||||
TS_ASSERT(orderAdded1);
|
||||
TS_ASSERT_EQUALS(orderAdded1.type, "Attack");
|
||||
TS_ASSERT_EQUALS(orderAdded1.data.targetArray.length, 5);
|
||||
TS_ASSERT_EQUALS(orderAdded1.data.target, INVALID_ENTITY);
|
||||
// Unit 0 should start at position 1 ==> Math.round((0 + 0.5) * 2.5) = Math.round(1.25) = 1
|
||||
TS_ASSERT_EQUALS(orderAdded1.data.currentTargetIndex, 1);
|
||||
|
||||
// Verify unit2's order
|
||||
TS_ASSERT(orderAdded2);
|
||||
TS_ASSERT_EQUALS(orderAdded2.type, "Attack");
|
||||
TS_ASSERT_EQUALS(orderAdded2.data.targetArray.length, 5);
|
||||
TS_ASSERT_EQUALS(orderAdded2.data.target, INVALID_ENTITY);
|
||||
// Unit 1 should start at position 4 ==> Math.round((1 + 0.5) * 2.5) = Math.round(3.75) = 4
|
||||
TS_ASSERT_EQUALS(orderAdded2.data.currentTargetIndex, 4);
|
||||
})();
|
||||
|
||||
// More units than targets
|
||||
(function()
|
||||
{
|
||||
let orderAdded1 = null;
|
||||
let orderAdded2 = null;
|
||||
let orderAdded3 = null;
|
||||
|
||||
const unitAI3 = ConstructComponent(102, "UnitAI", {
|
||||
"FormationController": "false",
|
||||
"DefaultStance": "aggressive"
|
||||
});
|
||||
AddMock(102, IID_Attack, { "GetBestAttackAgainst": () => "Melee" });
|
||||
unitAI3.OnCreate();
|
||||
|
||||
unitAI1.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded1 = { type, data, queued, pushFront };
|
||||
};
|
||||
unitAI2.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded2 = { type, data, queued, pushFront };
|
||||
};
|
||||
unitAI3.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded3 = { type, data, queued, pushFront };
|
||||
};
|
||||
|
||||
const smallTargets = [300, 301];
|
||||
|
||||
unitAI1.AttackGroup(smallTargets, 0, 3, true, true, false);
|
||||
unitAI2.AttackGroup(smallTargets, 1, 3, true, true, false);
|
||||
unitAI3.AttackGroup(smallTargets, 2, 3, true, true, false);
|
||||
|
||||
// Verify distribution when more units than targets
|
||||
TS_ASSERT(orderAdded1);
|
||||
TS_ASSERT_EQUALS(orderAdded1.data.currentTargetIndex, 0); // 0 * 2 / 3 = 0
|
||||
TS_ASSERT_EQUALS(orderAdded1.data.allowCapture, true);
|
||||
TS_ASSERT_EQUALS(orderAdded1.queued, true);
|
||||
|
||||
TS_ASSERT(orderAdded2);
|
||||
TS_ASSERT_EQUALS(orderAdded2.data.currentTargetIndex, 1); // 1 * 2 / 3 = 0.66, round = 1
|
||||
TS_ASSERT(orderAdded2.data.currentTargetIndex < smallTargets.length);
|
||||
|
||||
TS_ASSERT(orderAdded3);
|
||||
TS_ASSERT_EQUALS(orderAdded3.data.currentTargetIndex, 1); // 2 * 2 / 3 = 1.33, round = 1
|
||||
TS_ASSERT(orderAdded3.data.currentTargetIndex < smallTargets.length);
|
||||
})();
|
||||
|
||||
// Edge case - single target
|
||||
(function()
|
||||
{
|
||||
let orderAdded = null;
|
||||
unitAI1.AddOrder = (type, data, queued, pushFront) =>
|
||||
{
|
||||
orderAdded = { type, data, queued, pushFront };
|
||||
};
|
||||
|
||||
const singleTarget = [400];
|
||||
|
||||
unitAI1.AttackGroup(singleTarget, 0, 1, false, false, true);
|
||||
|
||||
TS_ASSERT(orderAdded);
|
||||
TS_ASSERT_EQUALS(orderAdded.data.targetArray.length, 1);
|
||||
TS_ASSERT_EQUALS(orderAdded.data.currentTargetIndex, 0);
|
||||
TS_ASSERT_EQUALS(orderAdded.pushFront, true);
|
||||
})();
|
||||
|
||||
// Empty targets array should do nothing
|
||||
(function()
|
||||
{
|
||||
let callCount = 0;
|
||||
unitAI1.AddOrder = () => { callCount++; };
|
||||
|
||||
unitAI1.AttackGroup([], 0, 1);
|
||||
TS_ASSERT_EQUALS(callCount, 0);
|
||||
|
||||
unitAI1.AttackGroup(null, 0, 1);
|
||||
TS_ASSERT_EQUALS(callCount, 0);
|
||||
|
||||
unitAI1.AttackGroup(undefined, 0, 1);
|
||||
TS_ASSERT_EQUALS(callCount, 0);
|
||||
})();
|
||||
|
||||
// Verify RememberTargetPosition is called
|
||||
(function()
|
||||
{
|
||||
let rememberedOrder = null;
|
||||
unitAI1.RememberTargetPosition = (order) =>
|
||||
{
|
||||
rememberedOrder = order;
|
||||
};
|
||||
|
||||
unitAI1.AddOrder = () => {};
|
||||
|
||||
const testTargets = [500, 501];
|
||||
unitAI1.AttackGroup(testTargets, 0, 1);
|
||||
|
||||
TS_ASSERT(rememberedOrder);
|
||||
TS_ASSERT_EQUALS(rememberedOrder.targetArray.length, 2);
|
||||
})();
|
||||
}
|
||||
|
||||
TestAttackGroupBehavior();
|
||||
|
|
|
|||
|
|
@ -179,6 +179,28 @@ var g_Commands = {
|
|||
});
|
||||
},
|
||||
|
||||
"attack-group": function(player, cmd, data)
|
||||
{
|
||||
const unitAIs = data.entities.flatMap(ent =>
|
||||
{
|
||||
const cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
|
||||
const cmpAttack = Engine.QueryInterface(ent, IID_Attack);
|
||||
|
||||
// Check if unit can move and has attack capability
|
||||
const canAttack = cmpAttack && cmpAttack.GetAttackTypes().length > 0;
|
||||
return (cmpUnitAI && cmpUnitAI.AbleToMove() && canAttack) ? [cmpUnitAI] : [];
|
||||
});
|
||||
|
||||
if (!unitAIs.length || !cmd.targets?.length)
|
||||
return;
|
||||
|
||||
// Pass the entire target array and unit count to each UnitAI
|
||||
unitAIs.forEach((cmpUnitAI, index) =>
|
||||
{
|
||||
cmpUnitAI.AttackGroup(cmd.targets, index, unitAIs.length, cmd.allowCapture, cmd.queued, cmd.pushFront);
|
||||
});
|
||||
},
|
||||
|
||||
"patrol": function(player, cmd, data)
|
||||
{
|
||||
const ents = data.entities.length;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -54,7 +54,7 @@ pipeline {
|
|||
stage('Check for shader changes') {
|
||||
when {
|
||||
anyOf {
|
||||
changeset 'binaries/data/mods/**/shaders/**/*.xml'
|
||||
changeset 'binaries/data/mods/**/shaders/**/*'
|
||||
changeset 'source/tools/spirv/compile.py'
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ ignore = [
|
|||
"ANN",
|
||||
"C90",
|
||||
"COM812",
|
||||
"CPY001",
|
||||
"D10",
|
||||
"EM",
|
||||
"FIX002",
|
||||
|
|
|
|||
|
|
@ -92,12 +92,12 @@ void CCinemaManager::DrawSpline(Renderer::Backend::IDeviceCommandContext& device
|
|||
if (spline.GetAllNodes().size() == 2)
|
||||
smoothness = 2;
|
||||
|
||||
const float start = spline.MaxDistance.ToFloat() / smoothness;
|
||||
const float start = spline.GetMaxDistance().ToFloat() / smoothness;
|
||||
|
||||
std::vector<CVector3D> line;
|
||||
for (int i = 0; i <= smoothness; ++i)
|
||||
{
|
||||
const float time = start * i / spline.MaxDistance.ToFloat();
|
||||
const float time = start * i / spline.GetMaxDistance().ToFloat();
|
||||
line.emplace_back(spline.GetPosition(time));
|
||||
}
|
||||
|
||||
|
|
@ -108,7 +108,7 @@ void CCinemaManager::DrawSpline(Renderer::Backend::IDeviceCommandContext& device
|
|||
{
|
||||
for (int i = 0; i <= smoothness; ++i)
|
||||
{
|
||||
const float time = start * i / spline.MaxDistance.ToFloat();
|
||||
const float time = start * i / spline.GetMaxDistance().ToFloat();
|
||||
const CVector3D tmp = spline.GetPosition(time);
|
||||
const float groundY = g_Game->GetWorld()->GetTerrain().GetExactGroundLevel(tmp.X, tmp.Z);
|
||||
g_Renderer.GetDebugRenderer().DrawLine(deviceCommandContext, tmp, CVector3D(tmp.X, groundY, tmp.Z), splineColor, 0.1f, false);
|
||||
|
|
|
|||
|
|
@ -62,8 +62,7 @@ void CMaterial::AddRenderQuery(const char* key)
|
|||
m_RenderQueries.Add(key);
|
||||
}
|
||||
|
||||
void CMaterial::AddRequiredSampler(const CStr& samplerName)
|
||||
void CMaterial::AddRequiredSampler(RequiredSampler sampler)
|
||||
{
|
||||
CStrIntern string(samplerName);
|
||||
m_RequiredSamplers.push_back(string);
|
||||
m_RequiredSamplers.emplace_back(std::move(sampler));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,6 +53,12 @@ public:
|
|||
CTexturePtr Sampler;
|
||||
};
|
||||
|
||||
struct RequiredSampler
|
||||
{
|
||||
CStrIntern name;
|
||||
bool sRGB;
|
||||
};
|
||||
|
||||
typedef std::vector<TextureSampler> SamplersVector;
|
||||
|
||||
CMaterial();
|
||||
|
|
@ -82,8 +88,8 @@ public:
|
|||
void AddRenderQuery(const char* key);
|
||||
const CShaderRenderQueries& GetRenderQueries() const { return m_RenderQueries; }
|
||||
|
||||
void AddRequiredSampler(const CStr& samplerName);
|
||||
const std::vector<CStrIntern>& GetRequiredSampler() const { return m_RequiredSamplers; }
|
||||
void AddRequiredSampler(RequiredSampler sampler);
|
||||
const std::vector<RequiredSampler>& GetRequiredSamplers() const { return m_RequiredSamplers; }
|
||||
|
||||
private:
|
||||
|
||||
|
|
@ -92,7 +98,7 @@ private:
|
|||
CTexturePtr m_DiffuseTexture;
|
||||
|
||||
SamplersVector m_Samplers;
|
||||
std::vector<CStrIntern> m_RequiredSamplers;
|
||||
std::vector<RequiredSampler> m_RequiredSamplers;
|
||||
|
||||
std::array<CStrIntern, static_cast<size_t>(Pass::COUNT)> m_ShaderEffects;
|
||||
CShaderDefines m_ShaderDefines;
|
||||
|
|
|
|||
|
|
@ -103,6 +103,7 @@ CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
|
|||
AT(material);
|
||||
AT(name);
|
||||
AT(pass);
|
||||
AT(srgb);
|
||||
AT(value);
|
||||
#undef AT
|
||||
#undef EL
|
||||
|
|
@ -161,7 +162,8 @@ CMaterial CMaterialManager::LoadMaterial(const VfsPath& pathname)
|
|||
}
|
||||
else if (token == el_required_texture)
|
||||
{
|
||||
material.AddRequiredSampler(attrs.GetNamedItem(at_name));
|
||||
const bool sRGB{attrs.GetNamedItem(at_srgb) == "true"};
|
||||
material.AddRequiredSampler({CStrIntern{attrs.GetNamedItem(at_name)}, sRGB});
|
||||
if (!attrs.GetNamedItem(at_define).empty())
|
||||
material.AddShaderDefine(CStrIntern(attrs.GetNamedItem(at_define)), str_1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,6 +51,22 @@
|
|||
#include <sstream>
|
||||
#include <utility>
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
bool ShouldInterpretTextureAsSRGB(const CObjectBase::Samp& sampler, const CMaterial& material)
|
||||
{
|
||||
const auto requiredSamplers{material.GetRequiredSamplers()};
|
||||
auto it{std::find_if(requiredSamplers.begin(), requiredSamplers.end(),
|
||||
[&](const CMaterial::RequiredSampler& requiredSampler)
|
||||
{
|
||||
return requiredSampler.name == sampler.m_SamplerName;
|
||||
})};
|
||||
return it != requiredSamplers.end() && it->sRGB;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
CObjectEntry::CObjectEntry(const std::shared_ptr<CObjectBase>& base, const CSimulation2& simulation) :
|
||||
m_Base(base), m_Color(1.0f, 1.0f, 1.0f, 1.0f), m_Simulation(simulation)
|
||||
{
|
||||
|
|
@ -155,6 +171,7 @@ bool CObjectEntry::BuildVariation(const std::vector<const std::set<CStr>*>& comp
|
|||
{
|
||||
CTextureProperties textureProps(samp.m_SamplerFile);
|
||||
textureProps.SetAddressMode(Renderer::Backend::Sampler::AddressMode::CLAMP_TO_EDGE);
|
||||
textureProps.SetSRGB(ShouldInterpretTextureAsSRGB(samp, material));
|
||||
CTexturePtr texture = g_Renderer.GetTextureManager().CreateTexture(textureProps);
|
||||
// if we've loaded this model we're probably going to render it soon, so prefetch its texture.
|
||||
// All textures are prefetched even in the fixed pipeline, including the normal maps etc.
|
||||
|
|
@ -167,11 +184,14 @@ bool CObjectEntry::BuildVariation(const std::vector<const std::set<CStr>*>& comp
|
|||
CModel* model = newModel.get();
|
||||
m_Model = std::move(newModel);
|
||||
|
||||
for (const CStrIntern& requSampName : model->GetMaterial().GetRequiredSampler())
|
||||
for (const auto& requiredSampler : model->GetMaterial().GetRequiredSamplers())
|
||||
{
|
||||
if (std::find_if(m_Samplers.begin(), m_Samplers.end(),
|
||||
[&](const CObjectBase::Samp& sampler) { return sampler.m_SamplerName == requSampName; }) == m_Samplers.end())
|
||||
LOGERROR("Actor %s: required texture sampler %s not found (material %s)", m_Base->GetIdentifier(), requSampName.string().c_str(), m_Base->m_Material.string8().c_str());
|
||||
[&](const CObjectBase::Samp& sampler) { return sampler.m_SamplerName == requiredSampler.name; }) == m_Samplers.end())
|
||||
{
|
||||
LOGERROR("Actor %s: required texture sampler %s not found (material %s)",
|
||||
m_Base->GetIdentifier(), requiredSampler.name.string().c_str(), m_Base->m_Material.string8().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
// calculate initial object space bounds, based on vertex positions
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -60,7 +60,7 @@ namespace
|
|||
{
|
||||
|
||||
Renderer::Backend::Format ChooseFormatAndTransformTextureDataIfNeeded(
|
||||
Renderer::Backend::IDevice* device, Tex& textureData, const bool hasS3TC)
|
||||
Renderer::Backend::IDevice* device, Tex& textureData, const bool hasS3TC, const bool sRGB)
|
||||
{
|
||||
const bool alpha = (textureData.m_Flags & TEX_ALPHA) != 0;
|
||||
const bool grey = (textureData.m_Flags & TEX_GREY) != 0;
|
||||
|
|
@ -81,13 +81,13 @@ Renderer::Backend::Format ChooseFormatAndTransformTextureDataIfNeeded(
|
|||
switch (dxt)
|
||||
{
|
||||
case DXT1A:
|
||||
return Renderer::Backend::Format::BC1_RGBA_UNORM;
|
||||
return sRGB ? Renderer::Backend::Format::BC1_RGBA_SRGB : Renderer::Backend::Format::BC1_RGBA_UNORM;
|
||||
case 1:
|
||||
return Renderer::Backend::Format::BC1_RGB_UNORM;
|
||||
return sRGB ? Renderer::Backend::Format::BC1_RGB_SRGB : Renderer::Backend::Format::BC1_RGB_UNORM;
|
||||
case 3:
|
||||
return Renderer::Backend::Format::BC2_UNORM;
|
||||
return sRGB ? Renderer::Backend::Format::BC2_SRGB : Renderer::Backend::Format::BC2_UNORM;
|
||||
case 5:
|
||||
return Renderer::Backend::Format::BC3_UNORM;
|
||||
return sRGB ? Renderer::Backend::Format::BC3_SRGB : Renderer::Backend::Format::BC3_UNORM;
|
||||
default:
|
||||
LOGERROR("Unknown DXT compression.");
|
||||
return Renderer::Backend::Format::UNDEFINED;
|
||||
|
|
@ -101,9 +101,12 @@ Renderer::Backend::Format ChooseFormatAndTransformTextureDataIfNeeded(
|
|||
{
|
||||
case 8:
|
||||
ENSURE(grey);
|
||||
ENSURE(!sRGB);
|
||||
return Renderer::Backend::Format::L8_UNORM;
|
||||
case 24:
|
||||
ENSURE(grey);
|
||||
ENSURE(!alpha);
|
||||
ENSURE(!sRGB);
|
||||
if (device->IsTextureFormatSupported(Renderer::Backend::Format::R8G8B8_UNORM))
|
||||
return Renderer::Backend::Format::R8G8B8_UNORM;
|
||||
else
|
||||
|
|
@ -114,7 +117,7 @@ Renderer::Backend::Format ChooseFormatAndTransformTextureDataIfNeeded(
|
|||
}
|
||||
case 32:
|
||||
ENSURE(alpha);
|
||||
return Renderer::Backend::Format::R8G8B8A8_UNORM;
|
||||
return sRGB ? Renderer::Backend::Format::R8G8B8A8_SRGB : Renderer::Backend::Format::R8G8B8A8_UNORM;
|
||||
default:
|
||||
LOGERROR("Unsupported BPP: %zu", textureData.m_Bpp);
|
||||
}
|
||||
|
|
@ -336,6 +339,7 @@ struct TPhash
|
|||
hash_combine(seed, textureProperties.m_AnisotropicFilterEnabled);
|
||||
hash_combine(seed, textureProperties.m_FormatOverride);
|
||||
hash_combine(seed, textureProperties.m_IgnoreQuality);
|
||||
hash_combine(seed, textureProperties.m_SRGB);
|
||||
return seed;
|
||||
}
|
||||
|
||||
|
|
@ -358,7 +362,8 @@ struct TPequal_to
|
|||
lhs.m_AddressModeV == rhs.m_AddressModeV &&
|
||||
lhs.m_AnisotropicFilterEnabled == rhs.m_AnisotropicFilterEnabled &&
|
||||
lhs.m_FormatOverride == rhs.m_FormatOverride &&
|
||||
lhs.m_IgnoreQuality == rhs.m_IgnoreQuality;
|
||||
lhs.m_IgnoreQuality == rhs.m_IgnoreQuality &&
|
||||
lhs.m_SRGB == rhs.m_SRGB;
|
||||
}
|
||||
|
||||
bool operator()(const CTexturePtr& lhs, const CTexturePtr& rhs) const
|
||||
|
|
@ -526,7 +531,8 @@ public:
|
|||
}
|
||||
else
|
||||
{
|
||||
format = ChooseFormatAndTransformTextureDataIfNeeded(m_Device, textureData, m_HasS3TC);
|
||||
format = ChooseFormatAndTransformTextureDataIfNeeded(
|
||||
m_Device, textureData, m_HasS3TC, texture->m_Properties.m_SRGB);
|
||||
}
|
||||
|
||||
if (format == Renderer::Backend::Format::UNDEFINED)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -245,6 +245,8 @@ public:
|
|||
|
||||
void SetIgnoreQuality(bool ignore) { m_IgnoreQuality = ignore; }
|
||||
|
||||
void SetSRGB(const bool sRGB) { m_SRGB = sRGB; }
|
||||
|
||||
private:
|
||||
// Must update TPhash, TPequal_to when changing these fields
|
||||
VfsPath m_Path;
|
||||
|
|
@ -257,6 +259,7 @@ private:
|
|||
Renderer::Backend::Format m_FormatOverride =
|
||||
Renderer::Backend::Format::UNDEFINED;
|
||||
bool m_IgnoreQuality = false;
|
||||
bool m_SRGB{false};
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -52,114 +52,111 @@ CVector3D GetPositionOnCubic(const CVector3D& startPos, const CVector3D& startVe
|
|||
|
||||
/*********************************** R N S **************************************************/
|
||||
|
||||
RNSpline::RNSpline()
|
||||
: NodeCount(0)
|
||||
{
|
||||
}
|
||||
RNSpline::RNSpline() = default;
|
||||
|
||||
RNSpline::~RNSpline() = default;
|
||||
|
||||
// adds node and updates segment length
|
||||
void RNSpline::AddNode(const CFixedVector3D& pos)
|
||||
{
|
||||
if (NodeCount >= MAX_SPLINE_NODES)
|
||||
if (m_NodeCount >= MAX_SPLINE_NODES)
|
||||
return;
|
||||
if (NodeCount == 0)
|
||||
MaxDistance = fixed::Zero();
|
||||
if (m_NodeCount == 0)
|
||||
m_MaxDistance = fixed::Zero();
|
||||
else
|
||||
{
|
||||
Node[NodeCount-1].Distance = (Node[NodeCount-1].Position - pos).Length();
|
||||
MaxDistance += Node[NodeCount-1].Distance;
|
||||
m_Nodes[m_NodeCount-1].Distance = (m_Nodes[m_NodeCount-1].Position - pos).Length();
|
||||
m_MaxDistance += m_Nodes[m_NodeCount-1].Distance;
|
||||
}
|
||||
SplineData temp;
|
||||
temp.Position = pos;
|
||||
Node.push_back(temp);
|
||||
++NodeCount;
|
||||
m_Nodes.push_back(temp);
|
||||
++m_NodeCount;
|
||||
}
|
||||
|
||||
|
||||
// called after all nodes added. This function calculates the node velocities
|
||||
void RNSpline::BuildSpline()
|
||||
{
|
||||
if (NodeCount == 2)
|
||||
if (m_NodeCount == 2)
|
||||
{
|
||||
Node[0].Velocity = GetStartVelocity(0);
|
||||
Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
|
||||
m_Nodes[0].Velocity = GetStartVelocity(0);
|
||||
m_Nodes[m_NodeCount-1].Velocity = GetEndVelocity(m_NodeCount-1);
|
||||
return;
|
||||
}
|
||||
else if (NodeCount < 2)
|
||||
else if (m_NodeCount < 2)
|
||||
return;
|
||||
|
||||
for (int i = 1; i < NodeCount-1; ++i)
|
||||
for (int i = 1; i < m_NodeCount-1; ++i)
|
||||
{
|
||||
CVector3D Next = Node[i+1].Position - Node[i].Position;
|
||||
CVector3D Previous = Node[i-1].Position - Node[i].Position;
|
||||
CVector3D Next = m_Nodes[i+1].Position - m_Nodes[i].Position;
|
||||
CVector3D Previous = m_Nodes[i-1].Position - m_Nodes[i].Position;
|
||||
Next.Normalize();
|
||||
Previous.Normalize();
|
||||
|
||||
// split the angle (figure 4)
|
||||
Node[i].Velocity = Next - Previous;
|
||||
Node[i].Velocity.Normalize();
|
||||
m_Nodes[i].Velocity = Next - Previous;
|
||||
m_Nodes[i].Velocity.Normalize();
|
||||
}
|
||||
// calculate start and end velocities
|
||||
Node[0].Velocity = GetStartVelocity(0);
|
||||
Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
|
||||
m_Nodes[0].Velocity = GetStartVelocity(0);
|
||||
m_Nodes[m_NodeCount-1].Velocity = GetEndVelocity(m_NodeCount-1);
|
||||
}
|
||||
|
||||
// spline access function. time is 0 -> 1
|
||||
CVector3D RNSpline::GetPosition(float time) const
|
||||
{
|
||||
if (NodeCount < 2)
|
||||
if (m_NodeCount < 2)
|
||||
return CVector3D(0.0f, 0.0f, 0.0f);
|
||||
if (time < 0.0f)
|
||||
time = 0.0f;
|
||||
if (time > 1.0f)
|
||||
time = 1.0f;
|
||||
float Distance = time * MaxDistance.ToFloat();
|
||||
float Distance = time * m_MaxDistance.ToFloat();
|
||||
float CurrentDistance = 0.f;
|
||||
int i = 0;
|
||||
|
||||
// Find which node we're on
|
||||
while (CurrentDistance + Node[i].Distance.ToFloat() < Distance && i < NodeCount - 2)
|
||||
while (CurrentDistance + m_Nodes[i].Distance.ToFloat() < Distance && i < m_NodeCount - 2)
|
||||
{
|
||||
CurrentDistance += Node[i].Distance.ToFloat();
|
||||
CurrentDistance += m_Nodes[i].Distance.ToFloat();
|
||||
++i;
|
||||
}
|
||||
ENSURE(i < NodeCount - 1);
|
||||
ENSURE(i < m_NodeCount - 1);
|
||||
float t = Distance - CurrentDistance;
|
||||
// TODO: reimplement CVector3D comparator (float comparing is bad without EPS)
|
||||
if (Node[i].Position == Node[i+1].Position || Node[i].Distance.ToFloat() < 1e-7) // distance too small or zero
|
||||
if (m_Nodes[i].Position == m_Nodes[i+1].Position || m_Nodes[i].Distance.ToFloat() < 1e-7) // distance too small or zero
|
||||
{
|
||||
return Node[i+1].Position;
|
||||
return m_Nodes[i+1].Position;
|
||||
}
|
||||
t /= Node[i].Distance.ToFloat(); // scale t in range 0 - 1
|
||||
CVector3D startVel = Node[i].Velocity * Node[i].Distance.ToFloat();
|
||||
CVector3D endVel = Node[i+1].Velocity * Node[i].Distance.ToFloat();
|
||||
return GetPositionOnCubic(Node[i].Position, startVel,
|
||||
Node[i+1].Position, endVel, t);
|
||||
t /= m_Nodes[i].Distance.ToFloat(); // scale t in range 0 - 1
|
||||
CVector3D startVel = m_Nodes[i].Velocity * m_Nodes[i].Distance.ToFloat();
|
||||
CVector3D endVel = m_Nodes[i+1].Velocity * m_Nodes[i].Distance.ToFloat();
|
||||
return GetPositionOnCubic(m_Nodes[i].Position, startVel,
|
||||
m_Nodes[i+1].Position, endVel, t);
|
||||
}
|
||||
|
||||
const std::vector<SplineData>& RNSpline::GetAllNodes() const
|
||||
{
|
||||
return Node;
|
||||
return m_Nodes;
|
||||
}
|
||||
|
||||
// internal. Based on Equation 14
|
||||
CVector3D RNSpline::GetStartVelocity(int index)
|
||||
{
|
||||
if (index >= NodeCount - 1 || index < 0)
|
||||
if (index >= m_NodeCount - 1 || index < 0)
|
||||
return CVector3D(0.0f, 0.0f, 0.0f);
|
||||
CVector3D temp = CVector3D(Node[index+1].Position - Node[index].Position) * 3.0f * (1.0f / Node[index].Distance.ToFloat());
|
||||
return (temp - Node[index+1].Velocity)*0.5f;
|
||||
CVector3D temp = CVector3D(m_Nodes[index+1].Position - m_Nodes[index].Position) * 3.0f * (1.0f / m_Nodes[index].Distance.ToFloat());
|
||||
return (temp - m_Nodes[index+1].Velocity)*0.5f;
|
||||
}
|
||||
|
||||
// internal. Based on Equation 15
|
||||
CVector3D RNSpline::GetEndVelocity(int index)
|
||||
{
|
||||
if (index >= NodeCount || index < 1)
|
||||
if (index >= m_NodeCount || index < 1)
|
||||
return CVector3D(0.0f, 0.0f, 0.0f);
|
||||
CVector3D temp = CVector3D(Node[index].Position - Node[index-1].Position) * 3.0f * (1.0f / Node[index-1].Distance.ToFloat());
|
||||
return (temp - Node[index-1].Velocity) * 0.5f;
|
||||
CVector3D temp = CVector3D(m_Nodes[index].Position - m_Nodes[index-1].Position) * 3.0f * (1.0f / m_Nodes[index-1].Distance.ToFloat());
|
||||
return (temp - m_Nodes[index-1].Velocity) * 0.5f;
|
||||
}
|
||||
|
||||
/*********************************** S N S **************************************************/
|
||||
|
|
@ -176,21 +173,21 @@ void SNSpline::BuildSpline()
|
|||
// smoothing filter.
|
||||
void SNSpline::Smooth()
|
||||
{
|
||||
if (NodeCount < 3)
|
||||
if (m_NodeCount < 3)
|
||||
return;
|
||||
|
||||
CVector3D newVel;
|
||||
CVector3D oldVel = GetStartVelocity(0);
|
||||
for (int i = 1; i < NodeCount-1; ++i)
|
||||
for (int i = 1; i < m_NodeCount-1; ++i)
|
||||
{
|
||||
// Equation 12
|
||||
newVel = GetEndVelocity(i) * Node[i].Distance.ToFloat() + GetStartVelocity(i) * Node[i-1].Distance.ToFloat();
|
||||
newVel = newVel * (1 / (Node[i-1].Distance + Node[i].Distance).ToFloat());
|
||||
Node[i-1].Velocity = oldVel;
|
||||
newVel = GetEndVelocity(i) * m_Nodes[i].Distance.ToFloat() + GetStartVelocity(i) * m_Nodes[i-1].Distance.ToFloat();
|
||||
newVel = newVel * (1 / (m_Nodes[i-1].Distance + m_Nodes[i].Distance).ToFloat());
|
||||
m_Nodes[i-1].Velocity = oldVel;
|
||||
oldVel = newVel;
|
||||
}
|
||||
Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
|
||||
Node[NodeCount-2].Velocity = oldVel;
|
||||
m_Nodes[m_NodeCount-1].Velocity = GetEndVelocity(m_NodeCount-1);
|
||||
m_Nodes[m_NodeCount-2].Velocity = oldVel;
|
||||
}
|
||||
|
||||
/*********************************** T N S **************************************************/
|
||||
|
|
@ -201,15 +198,15 @@ TNSpline::~TNSpline() = default;
|
|||
// ie time period is time from last node to this node
|
||||
void TNSpline::AddNode(const CFixedVector3D& pos, const CFixedVector3D& rotation, fixed timePeriod)
|
||||
{
|
||||
if (NodeCount >= MAX_SPLINE_NODES)
|
||||
if (m_NodeCount >= MAX_SPLINE_NODES)
|
||||
return;
|
||||
|
||||
if (NodeCount == 0)
|
||||
MaxDistance = fixed::Zero();
|
||||
if (m_NodeCount == 0)
|
||||
m_MaxDistance = fixed::Zero();
|
||||
else
|
||||
{
|
||||
Node[NodeCount-1].Distance = timePeriod;
|
||||
MaxDistance += Node[NodeCount-1].Distance;
|
||||
m_Nodes[m_NodeCount-1].Distance = timePeriod;
|
||||
m_MaxDistance += m_Nodes[m_NodeCount-1].Distance;
|
||||
}
|
||||
|
||||
SplineData temp;
|
||||
|
|
@ -219,56 +216,56 @@ void TNSpline::AddNode(const CFixedVector3D& pos, const CFixedVector3D& rotation
|
|||
temp.Distance = fixed::Zero();
|
||||
temp.Velocity = CVector3D(0.0f, 0.0f, 0.0f);
|
||||
temp.Rotation = rotation;
|
||||
Node.push_back(temp);
|
||||
++NodeCount;
|
||||
m_Nodes.push_back(temp);
|
||||
++m_NodeCount;
|
||||
}
|
||||
|
||||
//Inserts node before position
|
||||
void TNSpline::InsertNode(const int index, const CFixedVector3D& pos, const CFixedVector3D& /*rotation*/,
|
||||
fixed timePeriod)
|
||||
{
|
||||
if (NodeCount >= MAX_SPLINE_NODES || index < 0 || index > NodeCount)
|
||||
if (m_NodeCount >= MAX_SPLINE_NODES || index < 0 || index > m_NodeCount)
|
||||
return;
|
||||
|
||||
if (NodeCount == 0)
|
||||
MaxDistance = fixed::Zero();
|
||||
if (m_NodeCount == 0)
|
||||
m_MaxDistance = fixed::Zero();
|
||||
else
|
||||
MaxDistance += timePeriod;
|
||||
m_MaxDistance += timePeriod;
|
||||
|
||||
SplineData temp;
|
||||
temp.Position = pos;
|
||||
temp.Distance = timePeriod;
|
||||
Node.insert(Node.begin() + index, temp);
|
||||
m_Nodes.insert(m_Nodes.begin() + index, temp);
|
||||
if (index > 0)
|
||||
std::swap(Node[index].Distance, Node[index - 1].Distance);
|
||||
++NodeCount;
|
||||
std::swap(m_Nodes[index].Distance, m_Nodes[index - 1].Distance);
|
||||
++m_NodeCount;
|
||||
}
|
||||
|
||||
//Removes node at index
|
||||
void TNSpline::RemoveNode(const int index)
|
||||
{
|
||||
if (NodeCount == 0 || index > NodeCount - 1)
|
||||
if (m_NodeCount == 0 || index > m_NodeCount - 1)
|
||||
return;
|
||||
|
||||
MaxDistance -= Node[index].Distance;
|
||||
Node.erase(Node.begin() + index);
|
||||
--NodeCount;
|
||||
m_MaxDistance -= m_Nodes[index].Distance;
|
||||
m_Nodes.erase(m_Nodes.begin() + index);
|
||||
--m_NodeCount;
|
||||
}
|
||||
|
||||
void TNSpline::UpdateNodeTime(const int index, fixed time)
|
||||
{
|
||||
if (NodeCount == 0 || index > NodeCount - 1)
|
||||
if (m_NodeCount == 0 || index > m_NodeCount - 1)
|
||||
return;
|
||||
|
||||
Node[index].Distance = time;
|
||||
m_Nodes[index].Distance = time;
|
||||
}
|
||||
|
||||
void TNSpline::UpdateNodePos(const int index, const CFixedVector3D& pos)
|
||||
{
|
||||
if (NodeCount == 0 || index > NodeCount - 1)
|
||||
if (m_NodeCount == 0 || index > m_NodeCount - 1)
|
||||
return;
|
||||
|
||||
Node[index].Position = pos;
|
||||
m_Nodes[index].Position = pos;
|
||||
}
|
||||
|
||||
void TNSpline::BuildSpline()
|
||||
|
|
@ -289,15 +286,15 @@ void TNSpline::Smooth()
|
|||
|
||||
void TNSpline::Constrain()
|
||||
{
|
||||
if (NodeCount < 3)
|
||||
if (m_NodeCount < 3)
|
||||
return;
|
||||
|
||||
for (int i = 1; i < NodeCount-1; ++i)
|
||||
for (int i = 1; i < m_NodeCount-1; ++i)
|
||||
{
|
||||
// Equation 13
|
||||
float r0 = (Node[i].Position - Node[i - 1].Position).Length().ToFloat() / Node[i-1].Distance.ToFloat();
|
||||
float r1 = (Node[i+1].Position - Node[i].Position).Length().ToFloat() / Node[i].Distance.ToFloat();
|
||||
Node[i].Velocity *= 4.0f*r0*r1 / ((r0 + r1)*(r0 + r1));
|
||||
float r0 = (m_Nodes[i].Position - m_Nodes[i - 1].Position).Length().ToFloat() / m_Nodes[i-1].Distance.ToFloat();
|
||||
float r1 = (m_Nodes[i+1].Position - m_Nodes[i].Position).Length().ToFloat() / m_Nodes[i].Distance.ToFloat();
|
||||
m_Nodes[i].Velocity *= 4.0f*r0*r1 / ((r0 + r1)*(r0 + r1));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -63,12 +63,12 @@ public:
|
|||
CVector3D GetRotation(float time) const;
|
||||
const std::vector<SplineData>& GetAllNodes() const;
|
||||
|
||||
fixed MaxDistance;
|
||||
int NodeCount;
|
||||
fixed GetMaxDistance() const { return m_MaxDistance; }
|
||||
|
||||
protected:
|
||||
|
||||
std::vector<SplineData> Node;
|
||||
fixed m_MaxDistance;
|
||||
int m_NodeCount{0};
|
||||
std::vector<SplineData> m_Nodes;
|
||||
CVector3D GetStartVelocity(int index);
|
||||
CVector3D GetEndVelocity(int index);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ void CNetClientTurnManager::PostCommand(JS::HandleValue data)
|
|||
// TODO: we should do this when the server stops sending our commands back to us
|
||||
}
|
||||
|
||||
void CNetClientTurnManager::NotifyFinishedOwnCommands(u32 turn)
|
||||
void CNetClientTurnManager::NotifyFinishedOwnCommands(turn_id_t turn)
|
||||
{
|
||||
NETCLIENTTURN_LOG("NotifyFinishedOwnCommands(%d)\n", turn);
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ void CNetClientTurnManager::NotifyFinishedOwnCommands(u32 turn)
|
|||
m_NetClient.SendMessage(&msg);
|
||||
}
|
||||
|
||||
void CNetClientTurnManager::NotifyFinishedUpdate(u32 turn, const UpdateCallback&)
|
||||
void CNetClientTurnManager::NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback&)
|
||||
{
|
||||
bool quick = !TurnNeedsFullHash(turn);
|
||||
std::string hash;
|
||||
|
|
@ -110,10 +110,10 @@ void CNetClientTurnManager::OnDestroyConnection()
|
|||
void CNetClientTurnManager::OnSimulationMessage(CSimulationMessage* msg)
|
||||
{
|
||||
// Command received from the server - store it for later execution
|
||||
AddCommand(msg->m_Client, msg->m_Player, msg->m_Data, msg->m_Turn);
|
||||
AddCommand(msg->m_Client, msg->m_Player, msg->m_Data, static_cast<turn_id_t>(msg->m_Turn));
|
||||
}
|
||||
|
||||
void CNetClientTurnManager::OnSyncError(u32 turn, const CStr& expectedHash, const std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
|
||||
void CNetClientTurnManager::OnSyncError(turn_id_t turn, const CStr& expectedHash, const std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
|
||||
{
|
||||
CStr expectedHashHex(Hexify(expectedHash));
|
||||
NETCLIENTTURN_LOG("OnSyncError(%d, %hs)\n", turn, expectedHashHex.c_str());
|
||||
|
|
|
|||
|
|
@ -49,12 +49,12 @@ public:
|
|||
*/
|
||||
void OnDestroyConnection();
|
||||
|
||||
void OnSyncError(u32 turn, const CStr& expectedHash, const std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames);
|
||||
void OnSyncError(turn_id_t turn, const CStr& expectedHash, const std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames);
|
||||
|
||||
private:
|
||||
void NotifyFinishedOwnCommands(u32 turn) override;
|
||||
void NotifyFinishedOwnCommands(turn_id_t turn) override;
|
||||
|
||||
void NotifyFinishedUpdate(u32 turn, const UpdateCallback& sendEventToAll) override;
|
||||
void NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback& sendEventToAll) override;
|
||||
|
||||
CNetClient& m_NetClient;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ public:
|
|||
|
||||
u32 m_Client;
|
||||
i32 m_Player;
|
||||
u32 m_Turn;
|
||||
i32 m_Turn;
|
||||
JS::PersistentRooted<JS::Value> m_Data;
|
||||
private:
|
||||
const Script::Interface& m_ScriptInterface;
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ u8* CSimulationMessage::Serialize(u8* pBuffer) const
|
|||
CBufferBinarySerializer serializer(m_ScriptInterface, pos);
|
||||
serializer.NumberU32_Unbounded("client", m_Client);
|
||||
serializer.NumberI32_Unbounded("player", m_Player);
|
||||
serializer.NumberU32_Unbounded("turn", m_Turn);
|
||||
serializer.NumberI32_Unbounded("turn", m_Turn);
|
||||
|
||||
serializer.ScriptVal("command", const_cast<JS::PersistentRootedValue*>(&m_Data));
|
||||
return serializer.GetBuffer();
|
||||
|
|
@ -165,7 +165,7 @@ const u8* CSimulationMessage::Deserialize(const u8* pStart, const u8* pEnd)
|
|||
CStdDeserializer deserializer(m_ScriptInterface, stream);
|
||||
deserializer.NumberU32_Unbounded("client", m_Client);
|
||||
deserializer.NumberI32_Unbounded("player", m_Player);
|
||||
deserializer.NumberU32_Unbounded("turn", m_Turn);
|
||||
deserializer.NumberI32_Unbounded("turn", m_Turn);
|
||||
deserializer.ScriptVal("command", &m_Data);
|
||||
return pEnd;
|
||||
}
|
||||
|
|
@ -177,7 +177,7 @@ size_t CSimulationMessage::GetSerializedLength() const
|
|||
CLengthBinarySerializer serializer(m_ScriptInterface);
|
||||
serializer.NumberU32_Unbounded("client", m_Client);
|
||||
serializer.NumberI32_Unbounded("player", m_Player);
|
||||
serializer.NumberU32_Unbounded("turn", m_Turn);
|
||||
serializer.NumberI32_Unbounded("turn", m_Turn);
|
||||
|
||||
// TODO: The cast can probably be removed if and when ScriptVal can take a JS::HandleValue instead of
|
||||
// a JS::MutableHandleValue (relies on JSAPI change). Also search for other casts like this one in that case.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
|
||||
#define PS_PROTOCOL_MAGIC 0x5073013f // 'P', 's', 0x01, '?'
|
||||
#define PS_PROTOCOL_MAGIC_RESPONSE 0x50630121 // 'P', 'c', 0x01, '!'
|
||||
#define PS_PROTOCOL_VERSION 0x01010019 // Arbitrary protocol
|
||||
#define PS_PROTOCOL_VERSION 0x0101001A // Arbitrary protocol
|
||||
#define PS_DEFAULT_PORT 0x5073 // 'P', 's'
|
||||
|
||||
// Set when lobby authentication is required. Used in the SrvHandshakeResponseMessage.
|
||||
|
|
@ -231,7 +231,7 @@ START_NMT_CLASS_(ClientPaused, NMT_CLIENT_PAUSED)
|
|||
END_NMT_CLASS()
|
||||
|
||||
START_NMT_CLASS_(LoadedGame, NMT_LOADED_GAME)
|
||||
NMT_FIELD_INT(m_CurrentTurn, u32, 4)
|
||||
NMT_FIELD_INT(m_CurrentTurn, i32, 4)
|
||||
END_NMT_CLASS()
|
||||
|
||||
START_NMT_CLASS_(GameStart, NMT_GAME_START)
|
||||
|
|
@ -243,17 +243,17 @@ START_NMT_CLASS_(GameSavedStart, NMT_SAVED_GAME_START)
|
|||
END_NMT_CLASS()
|
||||
|
||||
START_NMT_CLASS_(EndCommandBatch, NMT_END_COMMAND_BATCH)
|
||||
NMT_FIELD_INT(m_Turn, u32, 4)
|
||||
NMT_FIELD_INT(m_Turn, i32, 4)
|
||||
NMT_FIELD_INT(m_TurnLength, u32, 2)
|
||||
END_NMT_CLASS()
|
||||
|
||||
START_NMT_CLASS_(SyncCheck, NMT_SYNC_CHECK)
|
||||
NMT_FIELD_INT(m_Turn, u32, 4)
|
||||
NMT_FIELD_INT(m_Turn, i32, 4)
|
||||
NMT_FIELD(CStr, m_Hash)
|
||||
END_NMT_CLASS()
|
||||
|
||||
START_NMT_CLASS_(SyncError, NMT_SYNC_ERROR)
|
||||
NMT_FIELD_INT(m_Turn, u32, 4)
|
||||
NMT_FIELD_INT(m_Turn, i32, 4)
|
||||
NMT_FIELD(CStr, m_HashExpected)
|
||||
NMT_START_ARRAY(m_PlayerNames)
|
||||
NMT_FIELD(CStrW, m_Name)
|
||||
|
|
|
|||
|
|
@ -49,6 +49,7 @@
|
|||
#include "scriptinterface/Context.h"
|
||||
#include "scriptinterface/Interface.h"
|
||||
#include "scriptinterface/Request.h"
|
||||
#include "simulation2/helpers/SimulationCommand.h"
|
||||
#include "simulation2/system/TurnManager.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
|
@ -1172,9 +1173,9 @@ bool CNetServerWorker::OnSimulationCommand(CNetServerSession* session, CFsmEvent
|
|||
server.Multicast(message, { NSS_INGAME });
|
||||
|
||||
// Save all the received commands
|
||||
if (server.m_SavedCommands.size() < message->m_Turn + 1)
|
||||
server.m_SavedCommands.resize(message->m_Turn + 1);
|
||||
server.m_SavedCommands[message->m_Turn].push_back(*message);
|
||||
if (server.m_SavedCommands.size() < static_cast<size_t>(message->m_Turn) + 1)
|
||||
server.m_SavedCommands.resize(static_cast<size_t>(message->m_Turn) + 1);
|
||||
server.m_SavedCommands[static_cast<size_t>(message->m_Turn)].push_back(*message);
|
||||
|
||||
// TODO: we shouldn't send the message back to the client that first sent it
|
||||
return true;
|
||||
|
|
@ -1396,14 +1397,14 @@ bool CNetServerWorker::OnJoinSyncingLoadedGame(CNetServerSession* session, CFsmE
|
|||
|
||||
CLoadedGameMessage* message = (CLoadedGameMessage*)event->GetParamRef();
|
||||
|
||||
u32 turn = message->m_CurrentTurn;
|
||||
u32 readyTurn = server.m_ServerTurnManager->GetReadyTurn();
|
||||
turn_id_t turn = message->m_CurrentTurn;
|
||||
turn_id_t readyTurn = server.m_ServerTurnManager->GetReadyTurn();
|
||||
|
||||
// Send them all commands received since their saved state,
|
||||
// and turn-ended messages for any turns that have already been processed
|
||||
for (size_t i = turn + 1; i < std::max(readyTurn+1, (u32)server.m_SavedCommands.size()); ++i)
|
||||
for (turn_id_t i = turn + 1; i < std::max(readyTurn + 1, static_cast<turn_id_t>(server.m_SavedCommands.size())); ++i)
|
||||
{
|
||||
if (i < server.m_SavedCommands.size())
|
||||
if (static_cast<size_t>(i) < server.m_SavedCommands.size())
|
||||
for (size_t j = 0; j < server.m_SavedCommands[i].size(); ++j)
|
||||
session->SendMessage(&server.m_SavedCommands[i][j]);
|
||||
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@
|
|||
#include "network/NetServerSession.h"
|
||||
#include "ps/CLogger.h"
|
||||
#include "ps/ConfigDB.h"
|
||||
#include "simulation2/helpers/SimulationCommand.h"
|
||||
#include "simulation2/system/TurnManager.h"
|
||||
|
||||
#include <limits>
|
||||
|
|
@ -50,7 +51,7 @@ CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server)
|
|||
m_SavedTurnLengths.push_back(m_TurnLength);
|
||||
}
|
||||
|
||||
void CNetServerTurnManager::NotifyFinishedClientCommands(CNetServerSession& session, u32 turn)
|
||||
void CNetServerTurnManager::NotifyFinishedClientCommands(CNetServerSession& session, turn_id_t turn)
|
||||
{
|
||||
int client = session.GetHostID();
|
||||
|
||||
|
|
@ -105,11 +106,11 @@ void CNetServerTurnManager::CheckClientsReady()
|
|||
msg.m_Turn = m_ReadyTurn;
|
||||
m_NetServer.Multicast(&msg, { NSS_INGAME });
|
||||
|
||||
ENSURE(m_SavedTurnLengths.size() == m_ReadyTurn);
|
||||
ENSURE(std::cmp_equal(m_SavedTurnLengths.size(), m_ReadyTurn));
|
||||
m_SavedTurnLengths.push_back(m_TurnLength);
|
||||
}
|
||||
|
||||
void CNetServerTurnManager::NotifyFinishedClientUpdate(CNetServerSession& session, u32 turn, const CStr& hash)
|
||||
void CNetServerTurnManager::NotifyFinishedClientUpdate(CNetServerSession& session, turn_id_t turn, const CStr& hash)
|
||||
{
|
||||
|
||||
int client = session.GetHostID();
|
||||
|
|
@ -138,13 +139,13 @@ void CNetServerTurnManager::NotifyFinishedClientUpdate(CNetServerSession& sessio
|
|||
m_ClientStateHashes[turn][client] = hash;
|
||||
|
||||
// Find the newest turn which we know all clients have simulated
|
||||
u32 newest = std::numeric_limits<u32>::max();
|
||||
turn_id_t newest = std::numeric_limits<turn_id_t>::max();
|
||||
for (const std::pair<const int, Client>& clientData : m_ClientsData)
|
||||
if (clientData.second.simulatedTurn < newest)
|
||||
newest = clientData.second.simulatedTurn;
|
||||
|
||||
// For every set of state hashes that all clients have simulated, check for OOS
|
||||
for (const std::pair<const u32, std::map<int, std::string>>& clientStateHash : m_ClientStateHashes)
|
||||
for (const std::pair<const turn_id_t, std::map<int, std::string>>& clientStateHash : m_ClientStateHashes)
|
||||
{
|
||||
if (clientStateHash.first > newest)
|
||||
break;
|
||||
|
|
@ -187,7 +188,7 @@ void CNetServerTurnManager::NotifyFinishedClientUpdate(CNetServerSession& sessio
|
|||
m_ClientStateHashes.erase(m_ClientStateHashes.begin(), m_ClientStateHashes.lower_bound(newest+1));
|
||||
}
|
||||
|
||||
void CNetServerTurnManager::InitialiseClient(int client, u32 turn, bool observer)
|
||||
void CNetServerTurnManager::InitialiseClient(int client, turn_id_t turn, bool observer)
|
||||
{
|
||||
NETSERVERTURN_LOG("InitialiseClient(client=%d, turn=%d)\n", client, turn);
|
||||
|
||||
|
|
@ -206,7 +207,7 @@ void CNetServerTurnManager::UninitialiseClient(int client)
|
|||
bool checkOOS = m_ClientsData[client].isOOS;
|
||||
m_ClientsData.erase(client);
|
||||
|
||||
for (std::pair<const u32, std::map<int, std::string>>& clientStateHash : m_ClientStateHashes)
|
||||
for (std::pair<const turn_id_t, std::map<int, std::string>>& clientStateHash : m_ClientStateHashes)
|
||||
clientStateHash.second.erase(client);
|
||||
|
||||
// Check whether we're ready for the next turn now that we're not
|
||||
|
|
@ -228,8 +229,8 @@ void CNetServerTurnManager::SetTurnLength(u32 msecs)
|
|||
m_TurnLength = msecs;
|
||||
}
|
||||
|
||||
u32 CNetServerTurnManager::GetSavedTurnLength(u32 turn)
|
||||
u32 CNetServerTurnManager::GetSavedTurnLength(turn_id_t turn)
|
||||
{
|
||||
ENSURE(turn <= m_ReadyTurn);
|
||||
return m_SavedTurnLengths.at(turn);
|
||||
return m_SavedTurnLengths.at(static_cast<size_t>(turn));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -21,6 +21,7 @@
|
|||
#include "lib/code_annotation.h"
|
||||
#include "lib/types.h"
|
||||
#include "ps/CStr.h"
|
||||
#include "simulation2/helpers/SimulationCommand.h"
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
|
@ -44,15 +45,15 @@ class CNetServerTurnManager
|
|||
public:
|
||||
CNetServerTurnManager(CNetServerWorker& server);
|
||||
|
||||
void NotifyFinishedClientCommands(CNetServerSession& session, u32 turn);
|
||||
void NotifyFinishedClientCommands(CNetServerSession& session, turn_id_t turn);
|
||||
|
||||
void NotifyFinishedClientUpdate(CNetServerSession& session, u32 turn, const CStr& hash);
|
||||
void NotifyFinishedClientUpdate(CNetServerSession& session, turn_id_t turn, const CStr& hash);
|
||||
|
||||
/**
|
||||
* Inform the turn manager of a new client
|
||||
* @param observer - whether this client is an observer.
|
||||
*/
|
||||
void InitialiseClient(int client, u32 turn, bool observer);
|
||||
void InitialiseClient(int client, turn_id_t turn, bool observer);
|
||||
|
||||
/**
|
||||
* Inform the turn manager that a previously-initialised client has left the game.
|
||||
|
|
@ -65,13 +66,13 @@ public:
|
|||
* Returns the latest turn for which all clients are ready;
|
||||
* they will have already been told to execute this turn.
|
||||
*/
|
||||
u32 GetReadyTurn() { return m_ReadyTurn; }
|
||||
turn_id_t GetReadyTurn() { return m_ReadyTurn; }
|
||||
|
||||
/**
|
||||
* Returns the turn length that was used for the given turn.
|
||||
* Requires turn <= GetReadyTurn().
|
||||
*/
|
||||
u32 GetSavedTurnLength(u32 turn);
|
||||
u32 GetSavedTurnLength(turn_id_t turn);
|
||||
|
||||
private:
|
||||
void CheckClientsReady();
|
||||
|
|
@ -80,9 +81,9 @@ private:
|
|||
{
|
||||
CStrW playerName;
|
||||
// Latest turn for which all commands have been received.
|
||||
u32 readyTurn;
|
||||
turn_id_t readyTurn;
|
||||
// Last known simulated turn.
|
||||
u32 simulatedTurn;
|
||||
turn_id_t simulatedTurn;
|
||||
bool isObserver;
|
||||
bool isOOS = false;
|
||||
};
|
||||
|
|
@ -93,10 +94,10 @@ private:
|
|||
bool m_HasSyncError = false;
|
||||
|
||||
// Map of turn -> {Client ID -> state hash}; old indexes <= min(m_ClientsSimulated) are deleted
|
||||
std::map<u32, std::map<int, std::string>> m_ClientStateHashes;
|
||||
std::map<turn_id_t, std::map<int, std::string>> m_ClientStateHashes;
|
||||
|
||||
/// The latest turn for which we have received all commands from all clients
|
||||
u32 m_ReadyTurn;
|
||||
turn_id_t m_ReadyTurn;
|
||||
|
||||
// Current turn length
|
||||
u32 m_TurnLength;
|
||||
|
|
|
|||
|
|
@ -826,7 +826,7 @@ bool Autostart(const CmdLineArgs& args)
|
|||
Script::GetPropertyInt(rq, pageData, 1, &pageArgs);
|
||||
Script::StructuredClone clonedpageArgs{Script::WriteStructuredClone(rq, pageArgs)};
|
||||
|
||||
g_GUI->OpenChildPage(pageName, std::move(clonedpageArgs));
|
||||
g_GUI->SwitchPage(pageName, &scriptInterface, pageArgs);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -215,7 +215,7 @@ void CPostprocManager::InitializePBR()
|
|||
LOGWARNING("%s is unsupported", framebufferFormatName);
|
||||
}
|
||||
|
||||
if (m_Device->GetCapabilities().computeShaders && m_Device->GetCapabilities().storage)
|
||||
if (m_Device->GetCapabilities().computeShaders)
|
||||
{
|
||||
m_ResolvePBRComputeTech = g_Renderer.GetShaderManager().LoadEffect(str_compute_resolve_pbr);
|
||||
if (m_ResolvePBRComputeTech)
|
||||
|
|
|
|||
|
|
@ -32,8 +32,10 @@ enum class Format
|
|||
R8G8_UINT,
|
||||
R8G8B8_UNORM,
|
||||
R8G8B8A8_UNORM,
|
||||
R8G8B8A8_SRGB,
|
||||
R8G8B8A8_UINT,
|
||||
B8G8R8A8_UNORM,
|
||||
B8G8R8A8_SRGB,
|
||||
|
||||
// TODO: we need to drop legacy A8 and L8 formats as soon as we have proper
|
||||
// channel swizzling.
|
||||
|
|
@ -65,9 +67,13 @@ enum class Format
|
|||
D32_SFLOAT_S8_UINT,
|
||||
|
||||
BC1_RGB_UNORM,
|
||||
BC1_RGB_SRGB,
|
||||
BC1_RGBA_UNORM,
|
||||
BC1_RGBA_SRGB,
|
||||
BC2_UNORM,
|
||||
BC3_UNORM
|
||||
BC2_SRGB,
|
||||
BC3_UNORM,
|
||||
BC3_SRGB,
|
||||
};
|
||||
|
||||
inline bool IsDepthFormat(const Format format)
|
||||
|
|
|
|||
|
|
@ -352,11 +352,11 @@ std::unique_ptr<IDevice> CDevice::Create(SDL_Window* window)
|
|||
#if CONFIG2_GLES
|
||||
// Some GLES implementations have GL_EXT_texture_compression_dxt1
|
||||
// but that only supports DXT1 so we can't use it.
|
||||
capabilities.S3TC = GLAD_GL_EXT_texture_compression_s3tc;
|
||||
capabilities.S3TC = GLAD_GL_EXT_texture_compression_s3tc && GLAD_GL_EXT_texture_compression_s3tc_srgb;
|
||||
#else
|
||||
// Note: we don't bother checking for GL_S3_s3tc - it is incompatible
|
||||
// and irrelevant (was never widespread).
|
||||
capabilities.S3TC = GLAD_GL_EXT_texture_compression_s3tc;
|
||||
capabilities.S3TC = GLAD_GL_EXT_texture_compression_s3tc && GLAD_GL_EXT_texture_sRGB;
|
||||
#endif
|
||||
#if CONFIG2_GLES
|
||||
capabilities.multisampling = false;
|
||||
|
|
@ -738,6 +738,7 @@ bool CDevice::IsTextureFormatSupported(const Format format) const
|
|||
|
||||
case Format::R8G8B8_UNORM:
|
||||
case Format::R8G8B8A8_UNORM:
|
||||
case Format::R8G8B8A8_SRGB:
|
||||
case Format::A8_UNORM:
|
||||
case Format::L8_UNORM:
|
||||
supported = true;
|
||||
|
|
@ -763,9 +764,13 @@ bool CDevice::IsTextureFormatSupported(const Format format) const
|
|||
break;
|
||||
|
||||
case Format::BC1_RGB_UNORM:
|
||||
case Format::BC1_RGB_SRGB:
|
||||
case Format::BC1_RGBA_UNORM:
|
||||
case Format::BC1_RGBA_SRGB:
|
||||
case Format::BC2_UNORM:
|
||||
case Format::BC2_SRGB:
|
||||
case Format::BC3_UNORM:
|
||||
case Format::BC3_SRGB:
|
||||
supported = m_Capabilities.S3TC;
|
||||
break;
|
||||
|
||||
|
|
|
|||
|
|
@ -348,7 +348,8 @@ void CDeviceCommandContext::UploadTextureRegion(
|
|||
GLenum pixelFormat = GL_RGBA;
|
||||
switch (dataFormat)
|
||||
{
|
||||
case Format::R8G8B8A8_UNORM:
|
||||
case Format::R8G8B8A8_UNORM: [[fallthrough]];
|
||||
case Format::R8G8B8A8_SRGB:
|
||||
break;
|
||||
case Format::R8G8B8_UNORM:
|
||||
pixelFormat = GL_RGB;
|
||||
|
|
@ -381,9 +382,13 @@ void CDeviceCommandContext::UploadTextureRegion(
|
|||
}
|
||||
else if (
|
||||
texture->GetFormat() == Format::BC1_RGB_UNORM ||
|
||||
texture->GetFormat() == Format::BC1_RGB_SRGB ||
|
||||
texture->GetFormat() == Format::BC1_RGBA_UNORM ||
|
||||
texture->GetFormat() == Format::BC1_RGBA_SRGB ||
|
||||
texture->GetFormat() == Format::BC2_UNORM ||
|
||||
texture->GetFormat() == Format::BC3_UNORM)
|
||||
texture->GetFormat() == Format::BC2_SRGB ||
|
||||
texture->GetFormat() == Format::BC3_UNORM ||
|
||||
texture->GetFormat() == Format::BC3_SRGB)
|
||||
{
|
||||
ENSURE(xOffset == 0 && yOffset == 0);
|
||||
ENSURE(texture->GetFormat() == dataFormat);
|
||||
|
|
@ -392,15 +397,27 @@ void CDeviceCommandContext::UploadTextureRegion(
|
|||
GLenum internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
|
||||
switch (texture->GetFormat())
|
||||
{
|
||||
case Format::BC1_RGB_SRGB:
|
||||
internalFormat = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
|
||||
break;
|
||||
case Format::BC1_RGBA_UNORM:
|
||||
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
|
||||
break;
|
||||
case Format::BC1_RGBA_SRGB:
|
||||
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
|
||||
break;
|
||||
case Format::BC2_UNORM:
|
||||
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
|
||||
break;
|
||||
case Format::BC2_SRGB:
|
||||
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
|
||||
break;
|
||||
case Format::BC3_UNORM:
|
||||
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
||||
break;
|
||||
case Format::BC3_SRGB:
|
||||
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -174,6 +174,12 @@ std::unique_ptr<CTexture> CTexture::Create(
|
|||
// pixel format.
|
||||
GLenum pixelFormat = GL_RGBA;
|
||||
GLenum pixelType = GL_UNSIGNED_BYTE;
|
||||
#if !CONFIG2_GLES
|
||||
// load/store operation requires sized formats. See Table 8.25:
|
||||
// https://registry.khronos.org/OpenGL/specs/gl/glspec43.core.pdf
|
||||
if (usage & ITexture::Usage::STORAGE)
|
||||
internalFormat = GL_RGBA8;
|
||||
#endif
|
||||
switch (format)
|
||||
{
|
||||
case Format::UNDEFINED:
|
||||
|
|
@ -181,6 +187,9 @@ std::unique_ptr<CTexture> CTexture::Create(
|
|||
break;
|
||||
case Format::R8G8B8A8_UNORM:
|
||||
break;
|
||||
case Format::R8G8B8A8_SRGB:
|
||||
internalFormat = GL_SRGB_ALPHA_EXT;
|
||||
break;
|
||||
case Format::R8G8B8_UNORM:
|
||||
internalFormat = GL_RGB;
|
||||
pixelFormat = GL_RGB;
|
||||
|
|
@ -248,9 +257,13 @@ std::unique_ptr<CTexture> CTexture::Create(
|
|||
break;
|
||||
#endif
|
||||
case Format::BC1_RGB_UNORM:
|
||||
case Format::BC1_RGB_SRGB:
|
||||
case Format::BC1_RGBA_UNORM:
|
||||
case Format::BC1_RGBA_SRGB:
|
||||
case Format::BC2_UNORM:
|
||||
case Format::BC2_SRGB:
|
||||
case Format::BC3_UNORM:
|
||||
case Format::BC3_SRGB:
|
||||
compressedFormat = true;
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -847,9 +847,13 @@ bool CDevice::IsTextureFormatSupported(const Format format) const
|
|||
return false;
|
||||
|
||||
case Format::BC1_RGB_UNORM:
|
||||
case Format::BC1_RGB_SRGB:
|
||||
case Format::BC1_RGBA_UNORM:
|
||||
case Format::BC1_RGBA_SRGB:
|
||||
case Format::BC2_UNORM:
|
||||
case Format::BC2_SRGB:
|
||||
case Format::BC3_UNORM:
|
||||
case Format::BC3_SRGB:
|
||||
if (m_Capabilities.S3TC)
|
||||
return true;
|
||||
else
|
||||
|
|
|
|||
|
|
@ -174,8 +174,10 @@ VkFormat FromFormat(const Format format)
|
|||
CASE(R8G8_UNORM)
|
||||
CASE(R8G8_UINT)
|
||||
CASE(R8G8B8A8_UNORM)
|
||||
CASE(R8G8B8A8_SRGB)
|
||||
CASE(R8G8B8A8_UINT)
|
||||
CASE(B8G8R8A8_UNORM)
|
||||
CASE(B8G8R8A8_SRGB)
|
||||
|
||||
CASE(R16_UNORM)
|
||||
CASE(R16_UINT)
|
||||
|
|
@ -204,9 +206,13 @@ VkFormat FromFormat(const Format format)
|
|||
CASE(D32_SFLOAT)
|
||||
|
||||
CASE2(BC1_RGB_UNORM, BC1_RGB_UNORM_BLOCK)
|
||||
CASE2(BC1_RGB_SRGB, BC1_RGB_SRGB_BLOCK)
|
||||
CASE2(BC1_RGBA_UNORM, BC1_RGBA_UNORM_BLOCK)
|
||||
CASE2(BC1_RGBA_SRGB, BC1_RGBA_SRGB_BLOCK)
|
||||
CASE2(BC2_UNORM, BC2_UNORM_BLOCK)
|
||||
CASE2(BC2_SRGB, BC2_SRGB_BLOCK)
|
||||
CASE2(BC3_UNORM, BC3_UNORM_BLOCK)
|
||||
CASE2(BC3_SRGB, BC3_SRGB_BLOCK)
|
||||
|
||||
#undef CASE
|
||||
#undef CASE2
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -179,13 +179,18 @@ void CRingCommandContext::ScheduleUpload(
|
|||
|
||||
const bool isCompressedFormat =
|
||||
format == Format::BC1_RGB_UNORM ||
|
||||
format == Format::BC1_RGB_SRGB ||
|
||||
format == Format::BC1_RGBA_UNORM ||
|
||||
format == Format::BC1_RGBA_SRGB ||
|
||||
format == Format::BC2_UNORM ||
|
||||
format == Format::BC3_UNORM;
|
||||
format == Format::BC2_SRGB ||
|
||||
format == Format::BC3_UNORM ||
|
||||
format == Format::BC3_SRGB;
|
||||
ENSURE(
|
||||
format == Format::R8_UNORM ||
|
||||
format == Format::R8G8_UNORM ||
|
||||
format == Format::R8G8B8A8_UNORM ||
|
||||
format == Format::R8G8B8A8_SRGB ||
|
||||
format == Format::A8_UNORM ||
|
||||
format == Format::L8_UNORM ||
|
||||
isCompressedFormat);
|
||||
|
|
|
|||
|
|
@ -92,13 +92,13 @@ public:
|
|||
return serializationTestOption ? serializationTestOption->turn :
|
||||
std::max(CConfigDB::GetIfInitialised("serializationtest", -1), -1);
|
||||
}()},
|
||||
m_RejoinTestTurn{[&]() -> std::optional<int>
|
||||
m_RejoinTestTurn{[&]() -> std::optional<turn_id_t>
|
||||
{
|
||||
const auto* rejoinTestOption{
|
||||
std::get_if<SimulationDebugOptions::RejoinTest>(&debugOptions.test)};
|
||||
if (rejoinTestOption)
|
||||
return rejoinTestOption->turn;
|
||||
const int configVal{CConfigDB::GetIfInitialised("rejointest", -1)};
|
||||
const turn_id_t configVal{CConfigDB::GetIfInitialised("rejointest", -1)};
|
||||
if (configVal >= 0)
|
||||
return configVal;
|
||||
return std::nullopt;
|
||||
|
|
@ -163,17 +163,17 @@ public:
|
|||
|
||||
std::set<VfsPath> m_LoadedScripts;
|
||||
|
||||
uint32_t m_TurnNumber;
|
||||
turn_id_t m_TurnNumber;
|
||||
|
||||
bool m_EnableOOSLog{false};
|
||||
OsPath m_OOSLogPath;
|
||||
|
||||
// Functions and data for the serialization test mode: (see Update() for relevant comments)
|
||||
|
||||
std::optional<int> m_SerializationTestTurn;
|
||||
std::optional<turn_id_t> m_SerializationTestTurn;
|
||||
bool m_TestingSerialization{false};
|
||||
bool m_EnableSerializationTest{false};
|
||||
std::optional<int> m_RejoinTestTurn;
|
||||
std::optional<turn_id_t> m_RejoinTestTurn;
|
||||
bool m_TestingRejoin{false};
|
||||
|
||||
// Secondary simulation (NB: order matters for destruction).
|
||||
|
|
@ -383,7 +383,7 @@ void CSimulation2Impl::InitRNGSeedAI()
|
|||
void CSimulation2Impl::Update(int turnLength, const std::vector<SimulationCommand>& commands)
|
||||
{
|
||||
PROFILE3("sim update");
|
||||
PROFILE2_ATTR("turn %d", (int)m_TurnNumber);
|
||||
PROFILE2_ATTR("turn %d", m_TurnNumber);
|
||||
|
||||
fixed turnLengthFixed = fixed::FromInt(turnLength) / 1000;
|
||||
|
||||
|
|
@ -408,11 +408,11 @@ void CSimulation2Impl::Update(int turnLength, const std::vector<SimulationComman
|
|||
const Script::Interface& scriptInterface = m_ComponentManager.GetScriptInterface();
|
||||
|
||||
const bool startSerializationTest = m_SerializationTestTurn.has_value() &&
|
||||
std::cmp_equal(m_SerializationTestTurn.value(), m_TurnNumber);
|
||||
m_SerializationTestTurn.value() == m_TurnNumber;
|
||||
if (startSerializationTest)
|
||||
m_TestingSerialization = true;
|
||||
const bool startRejoinTest = m_RejoinTestTurn.has_value() &&
|
||||
static_cast<int64_t>(m_RejoinTestTurn.value()) == m_TurnNumber;
|
||||
m_RejoinTestTurn.value() == m_TurnNumber;
|
||||
if (startRejoinTest)
|
||||
m_TestingRejoin = true;
|
||||
|
||||
|
|
@ -891,11 +891,11 @@ bool CSimulation2::DeserializeState(std::istream& stream)
|
|||
return m->m_ComponentManager.DeserializeState(stream);
|
||||
}
|
||||
|
||||
void CSimulation2::ActivateRejoinTest(int turn)
|
||||
void CSimulation2::ActivateRejoinTest(turn_id_t turn)
|
||||
{
|
||||
if (m->m_RejoinTestTurn.has_value())
|
||||
return;
|
||||
LOGMESSAGERENDER("Rejoin test will activate in %i turns", turn - m->m_TurnNumber);
|
||||
LOGMESSAGERENDER("Rejoin test will activate in %d turns", turn - m->m_TurnNumber);
|
||||
m->m_RejoinTestTurn = turn;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include "lib/file/vfs/vfs_path.h"
|
||||
#include "lib/status.h"
|
||||
#include "ps/Loader.h"
|
||||
#include "simulation2/helpers/SimulationCommand.h"
|
||||
#include "simulation2/system/DebugOptions.h"
|
||||
#include "simulation2/system/Entity.h"
|
||||
|
||||
|
|
@ -240,7 +241,7 @@ public:
|
|||
/**
|
||||
* Activate the rejoin-test feature for turn @param turn.
|
||||
*/
|
||||
void ActivateRejoinTest(int turn);
|
||||
void ActivateRejoinTest(turn_id_t turn);
|
||||
|
||||
std::string GenerateSchema();
|
||||
|
||||
|
|
|
|||
|
|
@ -277,6 +277,35 @@ struct EntityData
|
|||
|
||||
static_assert(sizeof(EntityData) == 24);
|
||||
|
||||
// Convert world-space circle to tile-space bounds
|
||||
struct TileCircle
|
||||
{
|
||||
std::int32_t centerX, centerZ;
|
||||
std::int32_t radius;
|
||||
std::int32_t squaredRadius;
|
||||
std::int32_t minX, maxX, minZ, maxZ;
|
||||
};
|
||||
|
||||
// Apply an action to every tile within the circle
|
||||
template<typename Func>
|
||||
void ForEachTileInCircle(const TileCircle& circle, Func&& func)
|
||||
{
|
||||
for (std::int32_t tileZ = circle.minZ; tileZ <= circle.maxZ; ++tileZ)
|
||||
{
|
||||
const std::int32_t deltaZ{tileZ - circle.centerZ};
|
||||
const std::int32_t squaredDeltaZ{deltaZ * deltaZ};
|
||||
|
||||
for (std::int32_t tileX = circle.minX; tileX <= circle.maxX; ++tileX)
|
||||
{
|
||||
const std::int32_t deltaX{tileX - circle.centerX};
|
||||
if (deltaX * deltaX + squaredDeltaZ > circle.squaredRadius)
|
||||
continue;
|
||||
|
||||
func(tileX, tileZ);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Functor for sorting entities by distance from a source point.
|
||||
* It must only be passed entities that are in 'entities'
|
||||
|
|
@ -2130,6 +2159,50 @@ public:
|
|||
SeeExploredEntities(p);
|
||||
}
|
||||
|
||||
TileCircle WorldToTileCircle(entity_pos_t worldX, entity_pos_t worldZ, fixed radius)
|
||||
{
|
||||
const std::int32_t centerTileX{(worldX / LOS_TILE_SIZE).ToInt_RoundToNearest()};
|
||||
const std::int32_t centerTileZ{(worldZ / LOS_TILE_SIZE).ToInt_RoundToNearest()};
|
||||
const std::int32_t tileRadius{(radius / LOS_TILE_SIZE).ToInt_RoundToInfinity()};
|
||||
|
||||
return TileCircle{
|
||||
.centerX = centerTileX,
|
||||
.centerZ = centerTileZ,
|
||||
.radius = tileRadius,
|
||||
.squaredRadius = tileRadius * tileRadius,
|
||||
.minX = std::max(centerTileX - tileRadius, 0),
|
||||
.maxX = std::min(centerTileX + tileRadius, m_LosVerticesPerSide - 1),
|
||||
.minZ = std::max(centerTileZ - tileRadius, 0),
|
||||
.maxZ = std::min(centerTileZ + tileRadius, m_LosVerticesPerSide - 1)
|
||||
};
|
||||
}
|
||||
|
||||
void ExploreCircle(player_id_t playerId, entity_pos_t worldX, entity_pos_t worldZ, fixed radius) override
|
||||
{
|
||||
if (playerId <= 0 || playerId > MAX_LOS_PLAYER_ID)
|
||||
return;
|
||||
|
||||
const TileCircle circle{WorldToTileCircle(worldX, worldZ, radius)};
|
||||
const u32 exploredBitMask{static_cast<u32>(LosState::EXPLORED) << (2 * (playerId - 1))};
|
||||
u32& exploredCount = m_ExploredVertices.at(playerId);
|
||||
|
||||
ForEachTileInCircle(circle,
|
||||
[&](std::int32_t tileX, std::int32_t tileZ)
|
||||
{
|
||||
if (LosIsOffWorld(tileX, tileZ))
|
||||
return;
|
||||
|
||||
u32& losState = m_LosState.get(tileX, tileZ);
|
||||
if (losState & exploredBitMask)
|
||||
return;
|
||||
|
||||
losState |= exploredBitMask;
|
||||
++exploredCount;
|
||||
MarkVisibilityDirtyAroundTile(playerId, tileX, tileZ);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Force any entity in explored territory to appear for player p.
|
||||
* This is useful for miraging entities inside the territory borders at the beginning of a game,
|
||||
|
|
|
|||
|
|
@ -62,6 +62,7 @@ DEFINE_INTERFACE_METHOD("GetGaiaAndNonGaiaEntities", ICmpRangeManager, GetGaiaAn
|
|||
DEFINE_INTERFACE_METHOD("SetDebugOverlay", ICmpRangeManager, SetDebugOverlay)
|
||||
DEFINE_INTERFACE_METHOD("ExploreMap", ICmpRangeManager, ExploreMap)
|
||||
DEFINE_INTERFACE_METHOD("ExploreTerritories", ICmpRangeManager, ExploreTerritories)
|
||||
DEFINE_INTERFACE_METHOD("ExploreCircle", ICmpRangeManager, ExploreCircle)
|
||||
DEFINE_INTERFACE_METHOD("SetLosRevealWholeMap", ICmpRangeManager, SetLosRevealWholeMap)
|
||||
DEFINE_INTERFACE_METHOD("GetLosRevealWholeMap", ICmpRangeManager, GetLosRevealWholeMap)
|
||||
DEFINE_INTERFACE_METHOD("SetLosRevealWholeMapForAll", ICmpRangeManager, SetLosRevealWholeMapForAll)
|
||||
|
|
|
|||
|
|
@ -333,6 +333,12 @@ public:
|
|||
*/
|
||||
virtual void ExploreTerritories() = 0;
|
||||
|
||||
/**
|
||||
* Explore a circular area of the map for the given player.
|
||||
* This marks the tiles as explored (fogged) but not necessarily visible.
|
||||
*/
|
||||
virtual void ExploreCircle(player_id_t p, entity_pos_t x, entity_pos_t z, fixed radius) = 0;
|
||||
|
||||
/**
|
||||
* Reveal the shore for specified player p.
|
||||
* This works like for entities: if RevealShore is called multiple times with enabled, it
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
#include "simulation2/components/ICmpVision.h"
|
||||
#include "simulation2/helpers/Player.h"
|
||||
#include "simulation2/helpers/Position.h"
|
||||
#include "simulation2/helpers/Los.h"
|
||||
#include "simulation2/system/Component.h"
|
||||
#include "simulation2/system/ComponentTest.h"
|
||||
#include "simulation2/system/Entity.h"
|
||||
|
|
@ -331,4 +332,39 @@ public:
|
|||
range = fixed::FromInt(260);
|
||||
TS_ASSERT_EQUALS(cmp->GetEffectiveParabolicRange(source, target, range, yOrigin), fixed::FromFloat(264.952820f));
|
||||
}
|
||||
|
||||
void test_ExploreCircle()
|
||||
{
|
||||
ComponentTestHelper test(*g_ScriptContext);
|
||||
|
||||
ICmpRangeManager* cmp = test.Add<ICmpRangeManager>(CID_RangeManager, "", SYSTEM_ENTITY);
|
||||
|
||||
// Set up map bounds (256x256)
|
||||
cmp->SetBounds(entity_pos_t::FromInt(0), entity_pos_t::FromInt(0), entity_pos_t::FromInt(256), entity_pos_t::FromInt(256));
|
||||
cmp->Verify();
|
||||
|
||||
// Initially, no tiles should be explored
|
||||
TS_ASSERT_EQUALS(cmp->GetPercentMapExplored(1), 0);
|
||||
|
||||
// Explore a circle at the center of the map with radius 50
|
||||
cmp->ExploreCircle(1, entity_pos_t::FromInt(128), entity_pos_t::FromInt(128), fixed::FromInt(50));
|
||||
|
||||
// Check that some tiles were explored (not 0%, not 100%)
|
||||
u8 percentExplored = cmp->GetPercentMapExplored(1);
|
||||
TS_ASSERT(percentExplored > 0 && percentExplored < 100);
|
||||
|
||||
// Test invalid player (should do nothing)
|
||||
cmp->ExploreCircle(0, entity_pos_t::FromInt(128), entity_pos_t::FromInt(128), fixed::FromInt(50));
|
||||
cmp->ExploreCircle(99, entity_pos_t::FromInt(128), entity_pos_t::FromInt(128), fixed::FromInt(50));
|
||||
// No crash, no changes - verify still works
|
||||
cmp->Verify();
|
||||
|
||||
// Explore the entire map
|
||||
cmp->ExploreCircle(1, entity_pos_t::FromInt(128), entity_pos_t::FromInt(128), fixed::FromInt(1000));
|
||||
|
||||
// The entire map should be explored
|
||||
TS_ASSERT_EQUALS(cmp->GetPercentMapExplored(1), 100);
|
||||
|
||||
cmp->Verify();
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -80,22 +80,22 @@ CCinemaPath::CCinemaPath(const CCinemaData& data, const TNSpline& spline, const
|
|||
|
||||
CVector3D CCinemaPath::GetNodePosition(const int index) const
|
||||
{
|
||||
return Node[index].Position;
|
||||
return m_Nodes[index].Position;
|
||||
}
|
||||
|
||||
fixed CCinemaPath::GetNodeDuration(const int index) const
|
||||
{
|
||||
return Node[index].Distance;
|
||||
return m_Nodes[index].Distance;
|
||||
}
|
||||
|
||||
fixed CCinemaPath::GetDuration() const
|
||||
{
|
||||
return MaxDistance;
|
||||
return GetMaxDistance();
|
||||
}
|
||||
|
||||
float CCinemaPath::GetNodeFraction() const
|
||||
{
|
||||
return (m_TimeElapsed - m_PreviousNodeTime) / Node[m_CurrentNode].Distance.ToFloat();
|
||||
return (m_TimeElapsed - m_PreviousNodeTime) / m_Nodes[m_CurrentNode].Distance.ToFloat();
|
||||
}
|
||||
|
||||
float CCinemaPath::GetElapsedTime() const
|
||||
|
|
@ -121,14 +121,14 @@ void CCinemaPath::MoveToPointAt(float t, float nodet, const CVector3D& startRota
|
|||
|
||||
if (m_LookAtTarget)
|
||||
{
|
||||
if (m_TimeElapsed <= m_TargetSpline.MaxDistance.ToFloat())
|
||||
camera.LookAt(pos, m_TargetSpline.GetPosition(m_TimeElapsed / m_TargetSpline.MaxDistance.ToFloat()), CVector3D(0, 1, 0));
|
||||
if (m_TimeElapsed <= m_TargetSpline.GetMaxDistance().ToFloat())
|
||||
camera.LookAt(pos, m_TargetSpline.GetPosition(m_TimeElapsed / m_TargetSpline.GetMaxDistance().ToFloat()), CVector3D(0, 1, 0));
|
||||
else
|
||||
camera.LookAt(pos, m_TargetSpline.GetAllNodes().back().Position, CVector3D(0, 1, 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
CVector3D nodeRotation = Node[m_CurrentNode + 1].Rotation;
|
||||
CVector3D nodeRotation = m_Nodes[m_CurrentNode + 1].Rotation;
|
||||
CQuaternion start, end;
|
||||
start.FromEulerAngles(DEGTORAD(startRotation.X), DEGTORAD(startRotation.Y), DEGTORAD(startRotation.Z));
|
||||
end.FromEulerAngles(DEGTORAD(nodeRotation.X), DEGTORAD(nodeRotation.Y), DEGTORAD(nodeRotation.Z));
|
||||
|
|
@ -220,17 +220,17 @@ bool CCinemaPath::Validate()
|
|||
float previousTime = 0.0f, cumulation = 0.0f;
|
||||
|
||||
// Ignore the last node, since it is a blank (node time values are shifted down one from interface)
|
||||
for (size_t i = 0; i < Node.size() - 1; ++i)
|
||||
for (size_t i = 0; i < m_Nodes.size() - 1; ++i)
|
||||
{
|
||||
cumulation += Node[i].Distance.ToFloat();
|
||||
cumulation += m_Nodes[i].Distance.ToFloat();
|
||||
if (m_TimeElapsed <= cumulation)
|
||||
{
|
||||
m_PreviousNodeTime = previousTime;
|
||||
m_PreviousRotation = Node[i].Rotation;
|
||||
m_PreviousRotation = m_Nodes[i].Rotation;
|
||||
m_CurrentNode = i; // We're moving toward this next node, so use its rotation
|
||||
return true;
|
||||
}
|
||||
previousTime += Node[i].Distance.ToFloat();
|
||||
previousTime += m_Nodes[i].Distance.ToFloat();
|
||||
}
|
||||
debug_warn("validation of cinema path is wrong\n");
|
||||
return false;
|
||||
|
|
@ -248,7 +248,7 @@ bool CCinemaPath::Play(const float deltaRealTime, CCamera& camera)
|
|||
|
||||
bool CCinemaPath::Empty() const
|
||||
{
|
||||
return Node.empty();
|
||||
return m_Nodes.empty();
|
||||
}
|
||||
|
||||
void CCinemaPath::Reset()
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2025 Wildfire Games.
|
||||
/* Copyright (C) 2026 Wildfire Games.
|
||||
* This file is part of 0 A.D.
|
||||
*
|
||||
* 0 A.D. is free software: you can redistribute it and/or modify
|
||||
|
|
@ -24,6 +24,12 @@
|
|||
#include <js/TypeDecls.h>
|
||||
#include <js/Value.h>
|
||||
|
||||
/**
|
||||
* At 1000 turns/second, a 32-bit counter would overflow in ~49 days.
|
||||
* No overflow checks are needed.
|
||||
*/
|
||||
using turn_id_t = std::int32_t;
|
||||
|
||||
struct JSContext;
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -42,12 +42,12 @@ void CLocalTurnManager::PostCommand(JS::HandleValue data)
|
|||
AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + m_CommandDelay);
|
||||
}
|
||||
|
||||
void CLocalTurnManager::NotifyFinishedOwnCommands(u32 turn)
|
||||
void CLocalTurnManager::NotifyFinishedOwnCommands(turn_id_t turn)
|
||||
{
|
||||
FinishedAllCommands(turn, m_TurnLength);
|
||||
}
|
||||
|
||||
void CLocalTurnManager::NotifyFinishedUpdate(u32 /*turn*/, const UpdateCallback&)
|
||||
void CLocalTurnManager::NotifyFinishedUpdate(turn_id_t /*turn*/, const UpdateCallback&)
|
||||
{
|
||||
#if 0 // this hurts performance and is only useful for verifying log replays
|
||||
std::string hash;
|
||||
|
|
|
|||
|
|
@ -41,9 +41,9 @@ public:
|
|||
void PostCommand(player_id_t playerid, JS::HandleValue data);
|
||||
|
||||
protected:
|
||||
void NotifyFinishedOwnCommands(u32 turn) override;
|
||||
void NotifyFinishedOwnCommands(turn_id_t turn) override;
|
||||
|
||||
void NotifyFinishedUpdate(u32 turn, const UpdateCallback& sendEventToAll) override;
|
||||
void NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback& sendEventToAll) override;
|
||||
};
|
||||
|
||||
#endif // INCLUDED_LOCALTURNMANAGER
|
||||
|
|
|
|||
|
|
@ -47,18 +47,18 @@ CReplayTurnManager::CReplayTurnManager(CSimulation2& simulation, IReplayLogger&
|
|||
{
|
||||
}
|
||||
|
||||
void CReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
|
||||
void CReplayTurnManager::StoreReplayCommand(turn_id_t turn, int player, const std::string& command)
|
||||
{
|
||||
// Using the pair we make sure that commands per turn will be processed in the correct order
|
||||
m_ReplayCommands[turn].emplace_back(player, command);
|
||||
}
|
||||
|
||||
void CReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
|
||||
void CReplayTurnManager::StoreReplayHash(turn_id_t turn, const std::string& hash, bool quick)
|
||||
{
|
||||
m_ReplayHash[turn] = std::make_pair(hash, quick);
|
||||
}
|
||||
|
||||
void CReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
|
||||
void CReplayTurnManager::StoreReplayTurnLength(turn_id_t turn, u32 turnLength)
|
||||
{
|
||||
m_ReplayTurnLengths[turn] = turnLength;
|
||||
|
||||
|
|
@ -67,12 +67,12 @@ void CReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
|
|||
m_TurnLength = m_ReplayTurnLengths[0];
|
||||
}
|
||||
|
||||
void CReplayTurnManager::StoreFinalReplayTurn(u32 turn)
|
||||
void CReplayTurnManager::StoreFinalReplayTurn(turn_id_t turn)
|
||||
{
|
||||
m_FinalTurn = turn;
|
||||
}
|
||||
|
||||
void CReplayTurnManager::NotifyFinishedUpdate(u32 turn, const UpdateCallback& sendEventToAll)
|
||||
void CReplayTurnManager::NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback& sendEventToAll)
|
||||
{
|
||||
if (turn == 1 && m_FinalTurn == 0)
|
||||
sendEventToAll(EventNameReplayFinished, std::nullopt);
|
||||
|
|
@ -83,7 +83,7 @@ void CReplayTurnManager::NotifyFinishedUpdate(u32 turn, const UpdateCallback& se
|
|||
DoTurn(turn, sendEventToAll);
|
||||
|
||||
// Compare hash if it exists in the replay and if we didn't have an OOS already
|
||||
std::map<u32, std::pair<std::string, bool>>::iterator turnHashIt = m_ReplayHash.find(turn);
|
||||
std::map<turn_id_t, std::pair<std::string, bool>>::iterator turnHashIt = m_ReplayHash.find(turn);
|
||||
if (m_HasSyncError || turnHashIt == m_ReplayHash.end())
|
||||
return;
|
||||
|
||||
|
|
@ -119,9 +119,9 @@ void CReplayTurnManager::NotifyFinishedUpdate(u32 turn, const UpdateCallback& se
|
|||
sendEventToAll(EventNameReplayOutOfSync, paramData);
|
||||
}
|
||||
|
||||
void CReplayTurnManager::DoTurn(u32 turn, const UpdateCallback& sendEventToAll)
|
||||
void CReplayTurnManager::DoTurn(turn_id_t turn, const UpdateCallback& sendEventToAll)
|
||||
{
|
||||
debug_printf("Executing turn %u of %u\n", turn, m_FinalTurn);
|
||||
debug_printf("Executing turn %d of %d\n", turn, m_FinalTurn);
|
||||
|
||||
m_TurnLength = m_ReplayTurnLengths[turn];
|
||||
|
||||
|
|
|
|||
|
|
@ -40,18 +40,18 @@ class CReplayTurnManager : public CLocalTurnManager
|
|||
public:
|
||||
CReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay);
|
||||
|
||||
void StoreReplayCommand(u32 turn, int player, const std::string& command);
|
||||
void StoreReplayCommand(turn_id_t turn, int player, const std::string& command);
|
||||
|
||||
void StoreReplayTurnLength(u32 turn, u32 turnLength);
|
||||
void StoreReplayTurnLength(turn_id_t turn, u32 turnLength);
|
||||
|
||||
void StoreReplayHash(u32 turn, const std::string& hash, bool quick);
|
||||
void StoreReplayHash(turn_id_t turn, const std::string& hash, bool quick);
|
||||
|
||||
void StoreFinalReplayTurn(u32 turn);
|
||||
void StoreFinalReplayTurn(turn_id_t turn);
|
||||
|
||||
private:
|
||||
void NotifyFinishedUpdate(u32 turn, const UpdateCallback& sendEventToAll) override;
|
||||
void NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback& sendEventToAll) override;
|
||||
|
||||
void DoTurn(u32 turn, const UpdateCallback& sendEventToAll);
|
||||
void DoTurn(turn_id_t turn, const UpdateCallback& sendEventToAll);
|
||||
|
||||
static const CStr EventNameReplayFinished;
|
||||
static const CStr EventNameReplayOutOfSync;
|
||||
|
|
@ -59,13 +59,13 @@ private:
|
|||
bool m_HasSyncError = false;
|
||||
|
||||
// Contains the commands of every player on each turn
|
||||
std::map<u32, std::vector<std::pair<player_id_t, std::string>>> m_ReplayCommands;
|
||||
std::map<turn_id_t, std::vector<std::pair<player_id_t, std::string>>> m_ReplayCommands;
|
||||
|
||||
// Contains the length of every turn
|
||||
std::map<u32, u32> m_ReplayTurnLengths;
|
||||
std::map<turn_id_t, u32> m_ReplayTurnLengths;
|
||||
|
||||
// Contains all replay hash values and weather or not the quick hash method was used
|
||||
std::map<u32, std::pair<std::string, bool>> m_ReplayHash;
|
||||
std::map<turn_id_t, std::pair<std::string, bool>> m_ReplayHash;
|
||||
};
|
||||
|
||||
#endif // INCLUDED_REPLAYTURNMANAGER
|
||||
|
|
|
|||
|
|
@ -48,14 +48,14 @@ const CStr CTurnManager::EventNameSavegameLoaded = "SavegameLoaded";
|
|||
CTurnManager::CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, u32 commandDelay, int clientId, IReplayLogger& replay)
|
||||
: m_Simulation2(simulation), m_CurrentTurn(0), m_CommandDelay(commandDelay), m_ReadyTurn(commandDelay - 1), m_TurnLength(defaultTurnLength),
|
||||
m_PlayerId(-1), m_ClientId(clientId), m_DeltaSimTime(0), m_Replay(replay),
|
||||
m_FinalTurn(std::numeric_limits<u32>::max()), m_TimeWarpNumTurns(0)
|
||||
m_FinalTurn(std::numeric_limits<turn_id_t>::max()), m_TimeWarpNumTurns(0)
|
||||
{
|
||||
Script::Request rq(m_Simulation2.GetScriptInterface());
|
||||
m_QuickSaveMetadata.init(rq.cx);
|
||||
m_QueuedCommands.resize(1);
|
||||
}
|
||||
|
||||
void CTurnManager::ResetState(u32 newCurrentTurn, u32 newReadyTurn)
|
||||
void CTurnManager::ResetState(turn_id_t newCurrentTurn, turn_id_t newReadyTurn)
|
||||
{
|
||||
m_CurrentTurn = newCurrentTurn;
|
||||
m_ReadyTurn = newReadyTurn;
|
||||
|
|
@ -141,7 +141,7 @@ bool CTurnManager::Update(float simFrameLength, size_t maxTurns, const UpdateCal
|
|||
|
||||
// Put all the client commands into a single list, in a globally consistent order
|
||||
std::vector<SimulationCommand> commands;
|
||||
for (std::pair<const u32, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
|
||||
for (std::pair<const turn_id_t, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
|
||||
commands.insert(commands.end(), std::make_move_iterator(p.second.begin()), std::make_move_iterator(p.second.end()));
|
||||
|
||||
m_QueuedCommands.pop_front();
|
||||
|
|
@ -184,7 +184,7 @@ bool CTurnManager::UpdateFastForward()
|
|||
|
||||
// Put all the client commands into a single list, in a globally consistent order
|
||||
std::vector<SimulationCommand> commands;
|
||||
for (std::pair<const u32, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
|
||||
for (std::pair<const turn_id_t, std::vector<SimulationCommand>>& p : m_QueuedCommands[0])
|
||||
commands.insert(commands.end(), std::make_move_iterator(p.second.begin()), std::make_move_iterator(p.second.end()));
|
||||
|
||||
m_QueuedCommands.pop_front();
|
||||
|
|
@ -214,7 +214,7 @@ void CTurnManager::Interpolate(float simFrameLength, float realFrameLength)
|
|||
m_Simulation2.Interpolate(simFrameLength, offset, realFrameLength);
|
||||
}
|
||||
|
||||
void CTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32 turn)
|
||||
void CTurnManager::AddCommand(int client, int player, JS::HandleValue data, turn_id_t turn)
|
||||
{
|
||||
NETTURN_LOG("AddCommand(client=%d player=%d turn=%d current=%d, ready=%d)\n", client, player, turn, m_CurrentTurn, m_ReadyTurn);
|
||||
|
||||
|
|
@ -239,7 +239,7 @@ void CTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32
|
|||
m_QueuedCommands[turn - (m_CurrentTurn+1)][client].emplace_back(player, rq.cx, data);
|
||||
}
|
||||
|
||||
void CTurnManager::FinishedAllCommands(u32 turn, u32 turnLength)
|
||||
void CTurnManager::FinishedAllCommands(turn_id_t turn, u32 turnLength)
|
||||
{
|
||||
NETTURN_LOG("FinishedAllCommands(%d, %d)\n", turn, turnLength);
|
||||
|
||||
|
|
@ -248,7 +248,7 @@ void CTurnManager::FinishedAllCommands(u32 turn, u32 turnLength)
|
|||
m_TurnLength = turnLength;
|
||||
}
|
||||
|
||||
bool CTurnManager::TurnNeedsFullHash(u32 turn) const
|
||||
bool CTurnManager::TurnNeedsFullHash(turn_id_t turn) const
|
||||
{
|
||||
// Check immediately for errors caused by e.g. inconsistent game versions
|
||||
// (The hash is computed after the first sim update, so we start at turn == 1)
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ public:
|
|||
|
||||
virtual ~CTurnManager() { }
|
||||
|
||||
void ResetState(u32 newCurrentTurn, u32 newReadyTurn);
|
||||
void ResetState(turn_id_t newCurrentTurn, turn_id_t newReadyTurn);
|
||||
|
||||
/**
|
||||
* Set the current user's player ID, which will be added into command messages.
|
||||
|
|
@ -146,7 +146,7 @@ public:
|
|||
* Called when all commands for a given turn have been received.
|
||||
* This allows Update to progress to that turn.
|
||||
*/
|
||||
void FinishedAllCommands(u32 turn, u32 turnLength);
|
||||
void FinishedAllCommands(turn_id_t turn, u32 turnLength);
|
||||
|
||||
/**
|
||||
* Enables the recording of state snapshots every @p numTurns,
|
||||
|
|
@ -163,52 +163,52 @@ public:
|
|||
void QuickSave(JS::HandleValue GUIMetadata);
|
||||
std::optional<JS::Value> TryQuickLoad();
|
||||
|
||||
u32 GetCurrentTurn() const { return m_CurrentTurn; }
|
||||
turn_id_t GetCurrentTurn() const { return m_CurrentTurn; }
|
||||
|
||||
/**
|
||||
* @return how many turns are ready to be computed.
|
||||
* (used to detect players/observers that fall behind the live game.
|
||||
*/
|
||||
u32 GetPendingTurns() const { return m_ReadyTurn - m_CurrentTurn; }
|
||||
turn_id_t GetPendingTurns() const { return m_ReadyTurn - m_CurrentTurn; }
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Store a command to be executed at a given turn.
|
||||
*/
|
||||
void AddCommand(int client, int player, JS::HandleValue data, u32 turn);
|
||||
void AddCommand(int client, int player, JS::HandleValue data, turn_id_t turn);
|
||||
|
||||
/**
|
||||
* Called when this client has finished sending all its commands scheduled for the given turn.
|
||||
*/
|
||||
virtual void NotifyFinishedOwnCommands(u32 turn) = 0;
|
||||
virtual void NotifyFinishedOwnCommands(turn_id_t turn) = 0;
|
||||
|
||||
/**
|
||||
* Called when this client has finished a simulation update.
|
||||
*/
|
||||
virtual void NotifyFinishedUpdate(u32 turn, const UpdateCallback& sendEventToAll) = 0;
|
||||
virtual void NotifyFinishedUpdate(turn_id_t turn, const UpdateCallback& sendEventToAll) = 0;
|
||||
|
||||
/**
|
||||
* Returns whether we should compute a complete state hash for the given turn,
|
||||
* instead of a quick less-complete hash.
|
||||
*/
|
||||
bool TurnNeedsFullHash(u32 turn) const;
|
||||
bool TurnNeedsFullHash(turn_id_t turn) const;
|
||||
|
||||
CSimulation2& m_Simulation2;
|
||||
|
||||
/// The turn that we have most recently executed
|
||||
u32 m_CurrentTurn;
|
||||
turn_id_t m_CurrentTurn;
|
||||
|
||||
// Current command delay (commands are scheduled for m_CurrentTurn + m_CommandDelay)
|
||||
u32 m_CommandDelay;
|
||||
|
||||
/// The latest turn for which we have received all commands from all clients
|
||||
u32 m_ReadyTurn;
|
||||
turn_id_t m_ReadyTurn;
|
||||
|
||||
// Current turn length
|
||||
u32 m_TurnLength;
|
||||
|
||||
/// Commands queued at each turn (index 0 is for m_CurrentTurn+1)
|
||||
std::deque<std::map<u32, std::vector<SimulationCommand>>> m_QueuedCommands;
|
||||
std::deque<std::map<turn_id_t, std::vector<SimulationCommand>>> m_QueuedCommands;
|
||||
|
||||
int m_PlayerId;
|
||||
uint m_ClientId;
|
||||
|
|
@ -220,7 +220,7 @@ protected:
|
|||
IReplayLogger& m_Replay;
|
||||
|
||||
// The number of the last turn that is allowed to be executed (used for replays)
|
||||
u32 m_FinalTurn;
|
||||
turn_id_t m_FinalTurn;
|
||||
|
||||
private:
|
||||
size_t m_TimeWarpNumTurns; // 0 if disabled
|
||||
|
|
|
|||
1
source/third_party/glad/extensions/gl.txt
vendored
1
source/third_party/glad/extensions/gl.txt
vendored
|
|
@ -25,4 +25,5 @@ GL_EXT_packed_depth_stencil
|
|||
GL_EXT_texture_array
|
||||
GL_EXT_texture_compression_s3tc
|
||||
GL_EXT_texture_filter_anisotropic
|
||||
GL_EXT_texture_sRGB
|
||||
GL_KHR_debug
|
||||
|
|
|
|||
2
source/third_party/glad/extensions/gles2.txt
vendored
2
source/third_party/glad/extensions/gles2.txt
vendored
|
|
@ -1,5 +1,7 @@
|
|||
GL_EXT_discard_framebuffer
|
||||
GL_EXT_sRGB
|
||||
GL_EXT_texture_compression_s3tc
|
||||
GL_EXT_texture_compression_s3tc_srgb
|
||||
GL_EXT_texture_filter_anisotropic
|
||||
GL_EXT_texture_format_BGRA8888
|
||||
GL_KHR_debug
|
||||
|
|
|
|||
2
source/third_party/glad/include/glad/gl.h
vendored
2
source/third_party/glad/include/glad/gl.h
vendored
|
|
@ -1,5 +1,5 @@
|
|||
/**
|
||||
* Loader generated by glad 2.0.8 on 07/05/26 20:35:52
|
||||
* Loader generated by glad 2.0.8 on 07/29/26 01:24:11
|
||||
*
|
||||
* SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
|
||||
*
|
||||
|
|
|
|||
30
source/third_party/glad/include/glad/gles2.h
vendored
30
source/third_party/glad/include/glad/gles2.h
vendored
|
|
@ -1,28 +1,28 @@
|
|||
/**
|
||||
* Loader generated by glad 2.0.8 on Sat May 16 09:06:55 2026
|
||||
* Loader generated by glad 2.0.8 on 07/29/26 01:24:12
|
||||
*
|
||||
* SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
|
||||
*
|
||||
* Generator: C/C++
|
||||
* Specification: gl
|
||||
* Extensions: 9
|
||||
* Extensions: 11
|
||||
*
|
||||
* APIs:
|
||||
* - gles2=2.0
|
||||
*
|
||||
* Options:
|
||||
* - ALIAS = False
|
||||
* - DEBUG = False
|
||||
* - HEADER_ONLY = False
|
||||
* - LOADER = False
|
||||
* - MX = False
|
||||
* - ON_DEMAND = False
|
||||
* - LOADER = False
|
||||
* - ALIAS = False
|
||||
* - HEADER_ONLY = False
|
||||
* - DEBUG = False
|
||||
* - MX = False
|
||||
*
|
||||
* Commandline:
|
||||
* --api='gles2=2.0' --extensions='GL_EXT_discard_framebuffer,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_EXT_texture_format_BGRA8888,GL_KHR_debug,GL_OES_depth32,GL_OES_mapbuffer,GL_OES_rgb8_rgba8,GL_OES_texture_border_clamp' c
|
||||
* --api='gles2=2.0' --extensions='GL_EXT_discard_framebuffer,GL_EXT_sRGB,GL_EXT_texture_compression_s3tc,GL_EXT_texture_compression_s3tc_srgb,GL_EXT_texture_filter_anisotropic,GL_EXT_texture_format_BGRA8888,GL_KHR_debug,GL_OES_depth32,GL_OES_mapbuffer,GL_OES_rgb8_rgba8,GL_OES_texture_border_clamp' c
|
||||
*
|
||||
* Online:
|
||||
* http://glad.sh/#api=gles2%3D2.0&extensions=GL_EXT_discard_framebuffer%2CGL_EXT_texture_compression_s3tc%2CGL_EXT_texture_filter_anisotropic%2CGL_EXT_texture_format_BGRA8888%2CGL_KHR_debug%2CGL_OES_depth32%2CGL_OES_mapbuffer%2CGL_OES_rgb8_rgba8%2CGL_OES_texture_border_clamp&generator=c&options=
|
||||
* http://glad.sh/#api=gles2%3D2.0&extensions=GL_EXT_discard_framebuffer%2CGL_EXT_sRGB%2CGL_EXT_texture_compression_s3tc%2CGL_EXT_texture_compression_s3tc_srgb%2CGL_EXT_texture_filter_anisotropic%2CGL_EXT_texture_format_BGRA8888%2CGL_KHR_debug%2CGL_OES_depth32%2CGL_OES_mapbuffer%2CGL_OES_rgb8_rgba8%2CGL_OES_texture_border_clamp&generator=c&options=
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -224,6 +224,10 @@ typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apipro
|
|||
#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
|
||||
#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
|
||||
#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
|
||||
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D
|
||||
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E
|
||||
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F
|
||||
#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C
|
||||
#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
|
||||
#define GL_CONSTANT_ALPHA 0x8003
|
||||
#define GL_CONSTANT_COLOR 0x8001
|
||||
|
|
@ -295,6 +299,7 @@ typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apipro
|
|||
#define GL_FLOAT_VEC4 0x8B52
|
||||
#define GL_FRAGMENT_SHADER 0x8B30
|
||||
#define GL_FRAMEBUFFER 0x8D40
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT 0x8210
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
|
||||
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
|
||||
|
|
@ -435,6 +440,9 @@ typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apipro
|
|||
#define GL_SRC_ALPHA 0x0302
|
||||
#define GL_SRC_ALPHA_SATURATE 0x0308
|
||||
#define GL_SRC_COLOR 0x0300
|
||||
#define GL_SRGB8_ALPHA8_EXT 0x8C43
|
||||
#define GL_SRGB_ALPHA_EXT 0x8C42
|
||||
#define GL_SRGB_EXT 0x8C40
|
||||
#define GL_STACK_OVERFLOW_KHR 0x0503
|
||||
#define GL_STACK_UNDERFLOW_KHR 0x0504
|
||||
#define GL_STATIC_DRAW 0x88E4
|
||||
|
|
@ -608,8 +616,12 @@ typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void);
|
|||
GLAD_API_CALL int GLAD_GL_ES_VERSION_2_0;
|
||||
#define GL_EXT_discard_framebuffer 1
|
||||
GLAD_API_CALL int GLAD_GL_EXT_discard_framebuffer;
|
||||
#define GL_EXT_sRGB 1
|
||||
GLAD_API_CALL int GLAD_GL_EXT_sRGB;
|
||||
#define GL_EXT_texture_compression_s3tc 1
|
||||
GLAD_API_CALL int GLAD_GL_EXT_texture_compression_s3tc;
|
||||
#define GL_EXT_texture_compression_s3tc_srgb 1
|
||||
GLAD_API_CALL int GLAD_GL_EXT_texture_compression_s3tc_srgb;
|
||||
#define GL_EXT_texture_filter_anisotropic 1
|
||||
GLAD_API_CALL int GLAD_GL_EXT_texture_filter_anisotropic;
|
||||
#define GL_EXT_texture_format_BGRA8888 1
|
||||
|
|
|
|||
12
source/third_party/glad/include/glad/vulkan.h
vendored
12
source/third_party/glad/include/glad/vulkan.h
vendored
|
|
@ -1,5 +1,5 @@
|
|||
/**
|
||||
* Loader generated by glad 2.0.8 on Sat May 16 09:06:59 2026
|
||||
* Loader generated by glad 2.0.8 on 07/29/26 01:24:30
|
||||
*
|
||||
* SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
|
||||
*
|
||||
|
|
@ -11,12 +11,12 @@
|
|||
* - vulkan=1.1
|
||||
*
|
||||
* Options:
|
||||
* - ALIAS = False
|
||||
* - DEBUG = False
|
||||
* - HEADER_ONLY = False
|
||||
* - LOADER = False
|
||||
* - MX = False
|
||||
* - ON_DEMAND = False
|
||||
* - LOADER = False
|
||||
* - ALIAS = False
|
||||
* - HEADER_ONLY = False
|
||||
* - DEBUG = False
|
||||
* - MX = False
|
||||
*
|
||||
* Commandline:
|
||||
* --api='vulkan=1.1' --extensions='VK_EXT_debug_utils,VK_EXT_descriptor_indexing,VK_EXT_mesh_shader,VK_EXT_texture_compression_astc_hdr,VK_EXT_validation_features,VK_KHR_acceleration_structure,VK_KHR_buffer_device_address,VK_KHR_deferred_host_operations,VK_KHR_portability_subset,VK_KHR_ray_query,VK_KHR_ray_tracing_maintenance1,VK_KHR_ray_tracing_pipeline,VK_KHR_shader_float_controls,VK_KHR_spirv_1_4,VK_KHR_surface,VK_KHR_swapchain,VK_KHR_timeline_semaphore' c
|
||||
|
|
|
|||
4
source/third_party/glad/src/gles2.cpp
vendored
4
source/third_party/glad/src/gles2.cpp
vendored
|
|
@ -25,7 +25,9 @@ extern "C" {
|
|||
|
||||
int GLAD_GL_ES_VERSION_2_0 = 0;
|
||||
int GLAD_GL_EXT_discard_framebuffer = 0;
|
||||
int GLAD_GL_EXT_sRGB = 0;
|
||||
int GLAD_GL_EXT_texture_compression_s3tc = 0;
|
||||
int GLAD_GL_EXT_texture_compression_s3tc_srgb = 0;
|
||||
int GLAD_GL_EXT_texture_filter_anisotropic = 0;
|
||||
int GLAD_GL_EXT_texture_format_BGRA8888 = 0;
|
||||
int GLAD_GL_KHR_debug = 0;
|
||||
|
|
@ -479,7 +481,9 @@ static int glad_gl_find_extensions_gles2(void) {
|
|||
if (!glad_gl_get_extensions(&exts, &exts_i)) return 0;
|
||||
|
||||
GLAD_GL_EXT_discard_framebuffer = glad_gl_has_extension(exts, exts_i, "GL_EXT_discard_framebuffer");
|
||||
GLAD_GL_EXT_sRGB = glad_gl_has_extension(exts, exts_i, "GL_EXT_sRGB");
|
||||
GLAD_GL_EXT_texture_compression_s3tc = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_compression_s3tc");
|
||||
GLAD_GL_EXT_texture_compression_s3tc_srgb = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_compression_s3tc_srgb");
|
||||
GLAD_GL_EXT_texture_filter_anisotropic = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_filter_anisotropic");
|
||||
GLAD_GL_EXT_texture_format_BGRA8888 = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_format_BGRA8888");
|
||||
GLAD_GL_KHR_debug = glad_gl_has_extension(exts, exts_i, "GL_KHR_debug");
|
||||
|
|
|
|||
|
|
@ -52,42 +52,44 @@ enum {
|
|||
ID_DeletePath
|
||||
};
|
||||
|
||||
// Helper function for adding tooltips
|
||||
static wxWindow* Tooltipped(wxWindow* window, const wxString& tip)
|
||||
{
|
||||
window->SetToolTip(tip);
|
||||
return window;
|
||||
}
|
||||
|
||||
CinemaSidebar::CinemaSidebar(ScenarioEditor& scenarioEditor, wxWindow* sidebarContainer, wxWindow* bottomBarContainer)
|
||||
: Sidebar(scenarioEditor, sidebarContainer, bottomBarContainer)
|
||||
{
|
||||
wxStaticBoxSizer* commonSizer = new wxStaticBoxSizer(wxVERTICAL, this, _T("Common settings"));
|
||||
m_MainSizer->Add(commonSizer, wxSizerFlags().Expand());
|
||||
{
|
||||
auto* sizer = new wxStaticBoxSizer(wxVERTICAL, this, _T("Common settings"));
|
||||
|
||||
wxFlexGridSizer* gridSizer = new wxFlexGridSizer(1, 5, 5);
|
||||
gridSizer->AddGrowableCol(0);
|
||||
m_DrawPath = new wxCheckBox(sizer->GetStaticBox(), ID_PathsDrawing, _("Draw all paths"));
|
||||
m_DrawPath->SetToolTip(_("Display every cinematic path added to the map"));
|
||||
|
||||
gridSizer->Add(Tooltipped(m_DrawPath = new wxCheckBox(commonSizer->GetStaticBox(), ID_PathsDrawing, _("Draw all paths")),
|
||||
_("Display every cinematic path added to the map")));
|
||||
sizer->Add(m_DrawPath, wxSizerFlags().Expand().Border(wxALL, Atlas::Style::STATICBOX_PADDING));
|
||||
|
||||
commonSizer->Add(gridSizer, wxSizerFlags().Expand().Border(wxALL, Atlas::Style::STATICBOX_PADDING));
|
||||
m_MainSizer->Add(sizer, wxSizerFlags().Expand());
|
||||
}
|
||||
|
||||
// Paths list panel
|
||||
wxStaticBoxSizer* pathsBoxSizer = new wxStaticBoxSizer(wxVERTICAL, commonSizer->GetStaticBox(), _T("Paths"));
|
||||
wxStaticBox* pathsBox = pathsBoxSizer->GetStaticBox();
|
||||
gridSizer->Add(pathsBoxSizer, wxSizerFlags().Proportion(1).Expand());
|
||||
{
|
||||
auto* boxSizer = new wxStaticBoxSizer(wxVERTICAL, this, _T("Paths"));
|
||||
auto* box = boxSizer->GetStaticBox();
|
||||
|
||||
wxFlexGridSizer* pathsSizer = new wxFlexGridSizer(1, 5, 5);
|
||||
pathsSizer->AddGrowableCol(0);
|
||||
pathsBoxSizer->Add(pathsSizer, wxSizerFlags().Expand().Border(wxALL, Atlas::Style::STATICBOX_PADDING));
|
||||
m_PathList = new wxListBox(box, ID_PathsList, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_SORT);
|
||||
|
||||
pathsSizer->Add(m_PathList = new wxListBox(pathsBox, ID_PathsList, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_SORT), wxSizerFlags().Proportion(1).Expand());
|
||||
commonSizer->AddSpacer(3);
|
||||
pathsSizer->Add(Tooltipped(new wxButton(pathsBox, ID_DeletePath, _("Delete")), _T("Delete selected path")), wxSizerFlags().Expand());
|
||||
auto* deleteButton = new wxButton(box, ID_DeletePath, _("Delete"));
|
||||
deleteButton->SetToolTip(_T("Delete selected path"));
|
||||
|
||||
pathsSizer->Add(m_NewPathName = new wxTextCtrl(pathsBox, wxID_ANY), wxSizerFlags().Expand());
|
||||
pathsSizer->Add(new wxButton(pathsBox, ID_AddPath, _("Add")), wxSizerFlags().Expand());
|
||||
m_NewPathName = new wxTextCtrl(box, wxID_ANY);
|
||||
|
||||
auto* addButton = new wxButton(box, ID_AddPath, _("Add"));
|
||||
|
||||
wxFlexGridSizer* pathsSizer = new wxFlexGridSizer(1, 5, 5);
|
||||
pathsSizer->AddGrowableCol(0);
|
||||
pathsSizer->Add(m_PathList, wxSizerFlags().Proportion(1).Expand());
|
||||
pathsSizer->Add(deleteButton, wxSizerFlags().Expand());
|
||||
pathsSizer->Add(m_NewPathName, wxSizerFlags().Expand());
|
||||
pathsSizer->Add(addButton, wxSizerFlags().Expand());
|
||||
|
||||
boxSizer->Add(pathsSizer, wxSizerFlags().Expand().Border(wxALL, Atlas::Style::STATICBOX_PADDING));
|
||||
|
||||
m_MainSizer->Add(boxSizer, wxSizerFlags().Expand());
|
||||
}
|
||||
}
|
||||
|
||||
void CinemaSidebar::OnFirstDisplay()
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ class CheckRefs:
|
|||
(version,) = unpack(int_fmt, f.read(int_len))
|
||||
if version != 7:
|
||||
raise ValueError(f"Invalid PMP version ({version}) in '{ffp}'")
|
||||
(datasize,) = unpack(int_fmt, f.read(int_len))
|
||||
(datasize,) = unpack(int_fmt, f.read(int_len)) # noqa: RUF059
|
||||
(mapsize,) = unpack(int_fmt, f.read(int_len))
|
||||
f.seek(2 * (mapsize * 16 + 1) * (mapsize * 16 + 1), 1) # skip heightmap
|
||||
(numtexs,) = unpack(int_fmt, f.read(int_len))
|
||||
|
|
|
|||
Loading…
Reference in a new issue