The 25 Cards from Wolfenstein: The New Order

All data here is measured against Retail files (Steam, id Tech 5, .index/.resources). Tool used: tools/entities.py. Reading occurs exclusively from base/_wolfsdk_backup/ — the installation is patched, and therefore pristine() from tools/build_gore_deep.py provides the originals. Statements without measurement are marked as unverified.

Read-only. This document describes no write operation. No mod was created, nothing applied, nothing reset. The cost accounting in Section 3 is purely theoretical: the modified card bytes were compressed and measured in memory, never written to disk.

1. What an .entities File Is

Each card lies as a file asset in the archive, uncompressed plaintext in Decl dialect:

Version 3
entity {
    entityDef pick_up_prop_weapon_shotgun_1 {
    inherit = "prop/weapon/shotgun";
    class = "idItem";
    expandInheritance = false;
    edit = {
        spawnPosition = { x = -23388.927734375; y = -396.16; z = 2403.78; }
    }
}
}

Three fields carry the entire placement information:

• inherit — what is there. ai/… an enemy, prop/weapon/… a weapon, prop/ammo/… ammunition, prop/health/… a medipack, prop/secret/… a collectible, player/start a spawn point.
• class — the engine class that instantiates the block (idAI, idItem, idLight, idTarget_Count, …).
• edit.spawnPosition — where. If an axis is missing, it does not appear in the file; tools/entities.py displays it as ?. That the engine reads a missing axis as 0 is plausible but unverified.

Parsing with wolfsdk/decl.py — No Second Parser Needed

The dialect is identical to that of the entityDef decls which Decl already handles. Three places deviate, and Decl tolerates all three instead of aborting:

None of these places lie on the path to inherit, class, or spawnPosition, and the block boundaries remain intact because Decl delimits blocks by bracket depth, not grammar. Verification: count the line starts entity { in raw text and the blocks provided by the parser — identical across all 25 cards (--summary outputs the line "Block Count Verification"). The parser swallows nothing.

Cost: c01p1.entities (2,356,914 B) yields 70,683 paths in 3.4 s with ~78 MB peak memory. All 25 cards combined: 25 s. Anyone wishing to byte-exactly address the edit internals would need to extend Decl with ! and typed keys — not with a custom parser.

2. What Is in the Cards

python tools/entities.py --summary

The category sums match exactly with docs/moddingflaeche-tno.md (1 167 / 467 / 333 / 569 / 284). The total number of blocks is 69 951, not 69 952 — the difference is a counting error in the earlier survey, which Section 1's cross-check confirms as 69 951.

Seven maps contain no enemies at all (c01p1, c02p0, c03p1, c03p3, c11p2, c12p1, c16p0). These are the intro, intermission, and transition sections. Anyone wanting to move enemies around is working on the remaining 18.

c16p2 is the exception in the other direction: 53 weapon spawn points with only 10 enemies — the final chapter dispenses supplies, no foes.

What a single map yields

python tools/entities.py --map c12p2 --stats

provides entity count, categories, the ten most frequent engine classes, and the complete species list for enemies, weapons, ammo, health, and secrets. Example c12p2:

Enemy species (89 items, 8 types)
   ai/tungsten/c12/part_02/infantry_1960                32
   ai/tungsten/c12/part_02/infantry_1960_snipertrains   31
   ai/tungsten/c12/part_02/rocket_trooper                7
   ai/tungsten/c12/part_02/supersoldat                   6
   ...
Weapon spawn points (48 items, 7 types)
   prop/weapon/handgrenadeemp                           25
   prop/weapon/assaultrifle1960                          8
   ...

Finding individual entities

python tools/entities.py --map c06p1 --find prop/weapon
python tools/entities.py --map c16p2 --find "^ai/"

The pattern is a regex and runs against inherit, the entity name, and the class. Output includes Name, inherit, the length of inherit, and spawnPosition. The length column isn't there for show — it's the key to Section 4.

3. The Cost Question

Installation.apply knows two ways to write back a modified asset (wolfsdk/patch.py):

1. In-Place. Archive.write_in_place compresses the new content with deflate_exact to exactly the old csize and overwrites the slot. Offset and csize remain untouched; only usize in the index moves. Cost: one seek and a few hundred thousand bytes.
2. Rebuild. If the new content does not fit into csize, Archive.rebuild is called and the entire chunkN.resources is rewritten, all entries are realigned, and the index is refilled.

The boundary between the two is a single number:

free = csize − length(our own Deflate of the original)

As many compressed bytes the modified card may grow. If the number is exceeded, apply falls back to the Rebuild path.

python tools/entities.py --cost

Rebuild costs per Chunk — treating a single card as "rebuilding" means rewriting the entire file, and revert must fully restore it afterwards:

What the numbers mean

The available space is better than "0–428 bytes" sounds — but only for the right kind of change. frei counts compressed bytes. Card text compresses extremely well because it consists of tens of thousands of nearly identical blocks. The "+1 character" column measures the exchange rate: if the most common enemy name becomes one character longer in all its occurrences, that costs 71 raw bytes on c13p1, but only 9 compressed. The rate varies by card between 1:1 and 15:1, with a median of about 6:1 — including an outlier in the opposite direction (c01p4, see below).

Given this, for a typical card with 400 bytes of available space: Text changes on the order of 2,000 characters fit without a rebuild. This is sufficient for dozens of reordered inherit targets or shifted coordinates. The number is a rule of thumb — for the specific change, continue to measure.

But a single additional enemy fits nowhere. The last column shows why. A real ai/ block from later cards is 6,000 to 10,000 bytes raw and 1,700 to 2,900 bytes compressed — these blocks drag entire edit sections with Scene Points, patrol paths, and animation bindings. Even the largest measured space (c13p1, 1,185 B) lies below that. Adding entities always means a rebuild. Only in enemy-free cards with small blocks (c01p1: 234 B/block) do additional entries fit — but there is nothing there one would want to add.

Four cards have exactly zero space: c02p0, c03p1, c12p1, c16p0. There, our Deflate hits the delivered csize byte-for-byte. Any change costing even a single byte forces a rebuild. All four are enemy-free and uninteresting for placement mods anyway.

The Slot column is a footnote. Archive.slot_size assigns each entry its csize plus up to 15 bytes of alignment padding. These 0–15 bytes would theoretically be additionally available, but Archive.write_in_place does not use them — it keeps csize intentionally constant because a gap in the data stream causes the engine to misaddress entries later (No address, error: 487). The column exists only to make visible that nothing can be retrieved there.

Ranking: which card is cheap?

Cheap means: lots of space and a small chunk if a rebuild does occur anyway.

1. c02p1 — 711 B free, rebuild only 121 MB. The cheapest card with enemies at all. 46 ai/, 8 weapons.
2. c12p2 — 567 B free, 140 MB. 89 enemies, 48 weapon locations: the best ratio of content to cost in the entire game.
3. c03p2 — 1,071 B free, 159 MB. 90 enemies, 37 weapons.
4. c08p1_2 — 506 B free, 161 MB.
5. c11p1 — 281 B free, 172 MB.

Expensive:

• c13p1 and c14p1 both lie in chunk12 — 466 MB per rebuild, the highest costs in the game, although c13p1 has the largest space at 1,185 B. Whoever can change c13p1 in-place saves the most here.
• c01p2, c01p3, c01p4 in chunk2 — 368 MB. c01p4 has only 34 B free for that.
• c16p2 — 77 B free at 208 MB Chunk: 53 weapon locations, but little room to move.

4. The length-preserving change

The pattern is defined as _same_width() in tools/build_gore_deep.py: a number reformatted so that it keeps exactly the same number of characters. Translated to cards means swapping an enemy type against one of equal length.

Important: equal length guarantees nothing. Deflate depends on content, not just length — two texts of equal length compress differently. Equal length keeps the difference only small. Therefore, it was actually measured for each card: apply swap, re-compress, read the difference from the original.

tools/entities.py --cost searches for this by finding the most common ai/ type per card, taking another with an identical character count (different case of the same name does not count — that would not be a swap), replacing all occurrences, and measuring again.

15 of 25 cards can be changed this way without a rebuild. The difference lies between −8 and +56 bytes and remained within the margin in every single case. Notable: four swaps make the file even smaller.

The other ten fail not due to size, but due to the lack of a partner: seven cards have no ai/ spawns at all (c01p1, c02p0, c03p1, c03p3, c11p2, c12p1, c16p0), and in c01p4, c12p2, and c13p1 there are no two enemy types with the same character count among the 5 to 9 existing ones. The solution there is: use another enemy type from a different card with matching length — the inherit path is a global Decl name and not bound to the card. Whether the engine loads an enemy from Chapter 6 into Chapter 12 without the associated models and animations is unconfirmed.

The length column in --find is exactly for that purpose:

python tools/entities.py --map c16p2 --find "^ai/"

   Name                                  inherit                                len  spawnPosition
   cb_ai_mecha_deathshead_stage2         ai/…/mecha_deathshead_stage2            47  (? 1792 ?)
   cb_ai_mecha_deathshead_stage3         ai/…/mecha_deathshead_stage3            47  (224 192 -512)
   cb_ai_prototyperobot                  ai/…/prototyperobot                     38  (-111.78 3886.07 ?)
   cb_ai_scriptedanimweb_mdh_stagger     ai/scriptedanimweb                      18  (-192 -1472 -342)

Same number in len = swappable without growth.

What else works with length preservation

• Coordinates with the same digit count. x = -23388.927734375 has 17 digits; any other 17-digit number fits. That is exactly what _same_width() is written for — it sacrifices decimal places before letting the file grow. Moving a pickup a few meters costs zero bytes this way.
• Weapons against weapons of equal length. Counted: prop/weapon/shotgun ↔ prop/weapon/handgun (both 19 characters), prop/weapon/ar60marksman ↔ prop/weapon/kitchenknife (both 24). prop/weapon/knife (17), prop/weapon/handgrenadeemp (26), and prop/weapon/assaultrifle1960 (28) stand alone. The lengths are listed in --find.
• Ammo counts, provided they appear as a number within the block and the digit count remains the same (5 → 9, not 5 → 10).

What does not work

• Add or remove entities. Adding destroys every room (Section 3). Removing makes the file smaller — it always fits in csize, because deflate_exact fills the remainder with a // comment. Whether the engine's Entities parser accepts // is unconfirmed and was not tested here; the Decl parser does.
• Extend names. The 5:1 exchange rate works in both directions, but c01p4 shows the outlier: +11 raw bytes cost +52 compressed there — more than the 34 bytes of room. A well-compressed file can react to a small change with a large jump if it causes a Deflate block to be re-partitioned. Measure, not estimate.

5. Open Risks

• None of this has been tested in-game. The cost calculation is byte-exact and reproducible; whether the engine accepts a modified .entities file is not demonstrated. From particle experiences in tools/build_gore_deep.py, it is known that streamed resources are silently rejected if something is wrong when their pre-calculated size does not match. For .entities, it is unconfirmed whether they follow the same streaming path.
• The // padding mechanism of deflate_exact depends on the reader skipping comments. For Decls, this is confirmed; for .entities, it is unconfirmed.
• Rebuild is slow and risky. Writing 466 MB anew, and revert must copy back the same amount. An interruption mid-way leaves a half-written .resources file — Archive.rebuild writes to a .wolfsdk_tmp file and replaces it only at the end, which covers this case.
• Enemies from foreign chapters (the solution for the ten maps without an equally long partner) assume that models, animations, and sounds are in the same chunk or loaded subsequently. Unconfirmed.

6. Tool

python tools/entities.py                      # Card list
python tools/entities.py --summary            # all 25, ~25 s
python tools/entities.py --map c12p2 --stats  # what is inside
python tools/entities.py --map c12p2 --find "prop/weapon" [--limit N]
python tools/entities.py --cost               # Cost calculation, ~2 min

All read-only. The tool does not open any file for writing and creates no mods.