From Arms of God Wiki

Revision as of 16:04, 10 June 2026 by Ta1ha (talk | contribs) (bot: documentation pass — editor-facing docs (data descriptions, module comments, template usage, Help rewrite))

The one-sentence version

All data on this wiki lives in ten JSON pages — Data:Weapons.json through Data:Tags.json — and every table, infobox, navbox, tag page and stat page is computed from them by Lua modules at render time. There are no precomputed pages: edit a value once on a Data page, purge, and every view of that value updates everywhere.

Data flow

 SOURCE OF TRUTH (edit values here)
 ┌────────────────────────────────────────────────────────────────┐
 │ Data:Weapons.json   Data:Characters.json   Data:Blessings.json │
 │ Data:Upgrades.json  Data:Crux.json         Data:Passives.json  │
 │ Data:Enemies.json   Data:Achievements.json Data:Codex.json     │
 │ Data:Tags.json                                                 │
 └───────────────┬────────────────────────────────────────────────┘
                 │  read at render time by
                 ▼
 ┌─ Module:Core ──────────────────────────────────────────────────┐
 │  loads + sorts records, computes infobox values, tag links,    │
 │  stat blocks, lore joins; shared by every module below         │
 └───┬───────────┬──────────┬───────────┬───────────┬─────────────┘
     ▼           ▼          ▼           ▼           ▼
 Module:      Module:    Module:     Module:     Module:
 <Category>   Compare    Navbox      TagIndex    StatIndex
 (infobox,    (DPS,      (bottom     (tag        (per-stat +
  body,        wave-10    navboxes)   member      damage-type
  index)       tables)                pages)      lookups)
     │           │          │           │           │
     ▼           ▼          ▼           ▼           ▼
            RENDERED PAGES (recomputed on every purge)

What to edit, where

You want to change… Edit this What happens
A value: a stat number, price, tier, lore text, tag key, icon filename The record in the matching Data:<Category>.json page Every infobox, index row, comparison table, navbox and lookup that shows the value updates after a cache purge. Don't rename field keys — modules look them up by name.
Prose on one entity's page: intro text, strategy notes, screenshots, trivia The detail page itself (e.g. Cutter) Detail pages are first-write-only: the bot never overwrites them, so your edits persist across re-publishes.
How something renders: column order, section layout, sort order, labels The Lua module — Module:Core for most things (infobox field lists, index columns, stat display order, sorting); Module:Compare / Module:Navbox / etc. for their own views All affected pages re-render on purge. Note: module edits are overwritten by the next scheduled bot re-publish, so durable changes should also be reported upstream.
The infobox panel look (rows, header, fallbacks) Template:<Category>_infobox Presentation only — values are computed by Module:Core and passed in as parameters.
Site-wide look: colors, theme tokens, filter chips, hover tooltips MediaWiki:Common.css / MediaWiki:Common.js Theme tokens (--infobox-*, --table-*, --dmg-*) restyle everything at once; inline fallbacks keep pages readable without them.

Seeing your edit

MediaWiki caches rendered pages. After editing a Data page or module, other pages that use it may show the old version until their cache expires. To force it: open the page and add ?action=purge to the URL (or use the "Purge" option). The job queue eventually refreshes everything on its own.

What the bot does on re-publish

  • Overwrites the framework layer: Module:*, Template:*, Data:* pages, category index pages, comparison/stat pages, and this help page. Value edits you made on Data pages are replaced by the game's current data — report data corrections to the developers so they land in the source.
  • Never touches existing detail pages (one per weapon / hero / blessing / …). Your prose, images and trivia are safe there.

One expandable entry per module. Every module is readable on its Module: page and carries the same documentation in its header comment.

Module:Core — the engine room: computes every infobox value, index table, tag link, sort order and lore join
What it does The shared library every other module require()s. Loads and memoizes the ten Data pages, resolves category names, computes infobox value sets, stat blocks (with glyphs and elemental color chips), tag links and membership maps, codex lore joins, per-category sort orders, and the per-category presentation config (infobox field lists in INFOBOX_FIELD_ORDER, index columns in INDEX_OPTS, stat display order in STAT_ORDER).
Invoke Not invoked directly — the per-category modules forward to its entry points (infoboxEntry, bodyEntry, indexEntry, renderEntry).
Reads All ten Data:<Category>.json pages.
Module:Weapons … Module:Tags (per-category modules) — infobox / body / index / crossRefs for one category
What they do One tiny module per category (Module:Weapons, Module:Characters, Module:Blessings, Module:Upgrades, Module:Crux, Module:Passives, Module:Enemies, Module:Achievements, Module:Codex, Module:Tags). Each only binds its category name and forwards to Module:Core — so all rendering logic lives in ONE place. Module:Codex additionally provides the shared lore lookup (see its entry below).
Invoke {{#invoke:Weapons|infobox|id=Cutter}} — the infobox panel
{{#invoke:Weapons|body|id=Cutter|section=Tags}} — one body section (omit section for all)
{{#invoke:Weapons|index}} — the sortable category table
{{#invoke:Blessings|crossRefs|id=Blessed_Bounty}} — variant / tag-member links
{{#invoke:Weapons|render|id=Cutter}} — infobox + body + crossRefs in one call
Read The category's own Data:<Category>.json (via Module:Core).
Module:Index — generic sortable-table renderer behind every category index
What it does Pure presentation: given records + a column spec, emits one sortable wikitable. Holds no data — Module:Core's indexEntry feeds it sorted records augmented with computed infobox values. Column lists per category live in Module:Core's INDEX_OPTS.
Invoke Not invoked directly; pages use {{#invoke:<Category>|index}}.
Reads Whatever records Module:Core passes it.
Module:Compare — side-by-side comparison tables with computed DPS and wave-10 columns
What it does Builds the comparison tables on Weapons, Weapon comparison, Enemy comparison and Hero comparison. Computes columns that are stored nowhere: weapon DPS = (Damage + Holy + Fire + Electric) × Attack Speed; enemy wave-10 projections = base + per-wave × 9. Rows carry data-element/class/tier/type attributes that power the JS filter chips.
Invoke {{#invoke:Compare|render|Weapons_Melee}} · {{#invoke:Compare|render|Weapons_Ranged}} · {{#invoke:Compare|render|Enemies}} · {{#invoke:Compare|render|Characters}}
Reads Data:Weapons.json, Data:Enemies.json, Data:Characters.json.
Module:Navbox — the collapsible navigation box at the bottom of detail pages
What it does Renders a category's full member list as icon + link chains, bucketed into rows (Weapons/Blessings/Upgrades/Passives by tier, Crux/Codex by type, Characters/Enemies flat). The per-category grouping config is the CONFIG table at the top of the module.
Invoke Pages use the wrapper templates: {{Navbox_Weapons}}, {{Navbox_Crux}}, … (each wraps {{#invoke:Navbox|render|<Category>}}).
Reads The named category's Data:<Category>.json.
Module:Iconbox — an entity's small icon + linked name, anywhere
What it does Looks up an entity by category + name (or bare name) and renders its icon plus a link to its page. Icons come from each entity's own record — there is no icon lookup table. Unknown entities or missing art degrade to a plain link.
Invoke Via Template:Iconbox: {{Iconbox|Weapon|Cutter}} · {{Iconbox|Weapon|Cutter|icononly}} · {{Iconbox|Blessing|Sanctified Halo|size=32}} · bare-name fallback {{Iconbox|Cutter}}
Reads Any of the ten Data:<Category>.json pages, depending on the call.
Module:CrossRef — "related entities" sections (base ↔ Plus variants, tag members)
What it does Computes the 'Base variant' / 'Upgraded variant' links between a blessing or upgrade and its '<X> Plus' version (matched on the raw id, because Upgrades' display names can differ from ids), and delegates Tag pages' member sections to Module:TagIndex.
Invoke Wired by the category modules: {{#invoke:Blessings|crossRefs|id=Blessed_Bounty}}
Reads Data:Blessings.json, Data:Upgrades.json; tag-bearing categories via Module:TagIndex.
Module:TagIndex — "everything that carries this tag"
What it does Renders the member sections on Tag pages ('Weapons with this tag', …). Membership is never stored — it scans every tag-bearing category's tags[] arrays at render time, so adding a tag key to any record updates the tag page on purge.
Invoke {{#invoke:TagIndex|members|Melee}} (bare key or Tag-Melee slug)
Reads Data:Tags.json + Data:Weapons.json, Data:Characters.json, Data:Blessings.json, Data:Upgrades.json, Data:Passives.json, Data:Enemies.json.
Module:StatIndex — "what modifies this stat?" reverse lookups
What it does Renders the lookup tables on per-stat pages (Armor, Speed, …) and the damage-type hubs: every hero / blessing / upgrade / passive / Crux power modifying a stat (sorted by amount), and every weapon dealing an elemental damage type.
Invoke {{#invoke:StatIndex|boosters|Armor}} · {{#invoke:StatIndex|weapons|Fire Damage}}
Reads boosters: Data:Characters.json, Data:Blessings.json, Data:Upgrades.json, Data:Passives.json, Data:Crux.json — weapons: Data:Weapons.json.
Module:DamageType — readable aliases for the damage-type hub pages
What it does Thin wrappers over Module:StatIndex so the Holy Damage / Fire Damage / Electric Damage hubs read naturally. No logic of its own.
Invoke {{#invoke:DamageType|dealtBy|Fire Damage}} · {{#invoke:DamageType|boostedBy|Fire Damage}}
Reads Same as Module:StatIndex.
Module:Codex — Codex category module + the shared lore lookup
What it does Standard category rendering for Codex pages, plus the lore entry point that powers '== Lore ==' sections on weapon / enemy / character pages: it finds the matching Codex entry by normalized name at render time, falling back to the entity's own description. Edit the lore once in Data:Codex.json and every page showing it updates.
Invoke {{#invoke:Codex|lore|Cutter|Weapons}} (category-scoped) · {{#invoke:Codex|lore|Azrael}} (cross-category)
Reads Data:Codex.json + the named entity's category Data page.

One expandable entry per user-facing template (or template family). Infobox values and navbox rows are computed by the modules — these templates are the presentation wrappers.

Template:Iconbox — inline entity icon + linked name
Usage {{Iconbox|Weapon|Cutter}} → icon + linked name. Add icononly for just the glyph: {{Iconbox|Weapon|Cutter|icononly}}. Optional size=32. Category accepts singular or plural (Weapon, Character, Blessing, Upgrade, Crux, Passive, Enemy, Achievement, Codex, Tag); bare-name form {{Iconbox|Cutter}} scans all categories. The go-to template for mentioning any entity in prose.
Backed by Module:Iconbox → the entity's own record in Data:<Category>.json.
Template:Tip — highlighted gameplay-advice callout
Usage {{Tip|Pierce-heavy builds love this weapon — pair it with Penetrating Light.}} → a green-edged callout box. Use on detail pages for strategy notes that should stand out from lore.
Template:<Category>_infobox (10 templates) — the infobox panel on every detail page
Usage Never called by hand. Detail pages call {{#invoke:<Category>|infobox|id=<slug>}}; Module:Core computes the values from the Data page and passes them in. The templates (Template:Weapons_infobox, Template:Characters_infobox, Template:Blessings_infobox, Template:Upgrades_infobox, Template:Crux_infobox, Template:Passives_infobox, Template:Enemies_infobox, Template:Achievements_infobox, Template:Codex_infobox, Template:Tags_infobox) own only the presentation: row layout, tier/type-colored headers, em-dash fallbacks. Each template's own page documents its parameters and the safe row shape.
Template:Navbox_<Category> (8 templates) — bottom-of-page navigation
Usage {{Navbox_Weapons}} at the bottom of a detail page. Available: Template:Navbox_Weapons, Template:Navbox_Characters, Template:Navbox_Blessings, Template:Navbox_Upgrades, Template:Navbox_Crux, Template:Navbox_Passives, Template:Navbox_Enemies, Template:Navbox_Codex. Each wraps {{#invoke:Navbox|render|<Category>}} — rows are computed from the category's Data page, so new entities appear automatically.
Template:<Category>_Tags (5 templates) — the '== Tags ==' section on detail pages
Usage {{Weapons_Tags|Cutter}} → the tag list with effect text for one record. Available for Weapons, Characters, Blessings, Upgrades, Passives. Each wraps {{#invoke:<Category>|body|id={{{1}}}|section=Tags}} so the section can be restyled in one place.
Utility templates (general-purpose page furniture)
Template:Stub Banner for short pages needing expansion (auto-categorizes).
Template:NeedsImage Banner for pages missing art.
Template:Disambig Marks disambiguation pages.
Template:Quote Block quotation with attribution.
Template:GameVersion Inline version stamp: {{GameVersion|1.2.3}} → "As of v1.2.3".
Template:Spoiler Collapsible spoiler block.
Template:Color Inline colored text: {{Color|#ff6b35|burning}}.
Template:External External link with icon.
Template:Hover Plain-text tooltip on hover.
Template:Breadcrumb Breadcrumb navigation line.
Template:Transclude Transclude a page or labeled section: {{Transclude|PageName#Section}}.
Template:Anchor Invisible anchor target for in-page links.
Template:Clear Clears floats (e.g. below an infobox).
Template:Documentation The

Template documentation

(viewed at Help:Wiki Editing; this section is hidden when the template is transcluded onto another page)

No /doc subpage exists for this template. The template's <noinclude> block (visible here on the template's own view, hidden when transcluded) is the docs.

convention for template doc subpages.

The ten source Data pages and their REAL record fields. Every Data page also carries this documentation in its own top-level description field. Shared by all categories: id (the game's internal id), slug (the wiki page title of the entity's detail page — never recompute it from the name), name (display name), icon (File: image name; empty = no staged art).

Data:Weapons.json — one record per weapon (65)
Field Type Meaning
tier number Shop tier 1–3.
price number Shop price.
locked boolean true = must be unlocked.
tag_source string The game's raw tag family (Melee, Laser, Grenade, …). Melee here (or a Melee tag) makes the weapon class Melee; everything else is Ranged.
tags[] string list Tag KEYS — join Data:Tags.json for effect text and tag pages.
stats{} map Raw numbers keyed by stat name: Damage, Holy/Fire/Electric Damage, Attack Speed, Critical Chance (percent values stay strings like "15%"), Range, Pierce, Projectiles, Bounce. Sentinels: ≥ 1000 renders as Unlimited, ≤ −1000 is hidden. DPS is not stored — Module:Compare computes it at render time.
Consumed by Module:Core (infobox/body/index), Module:Compare, Module:Navbox, Module:StatIndex, Module:TagIndex, Module:Iconbox.
Data:Characters.json — one record per playable hero (10)
Field Type Meaning
tier, price, locked number/boolean Unlock metadata; locked drives the Availability row.
tags[] string list Tag keys → Data:Tags.json (only some heroes carry tags).
stats{} map Signed stat modifiers applied to base stats (e.g. Armor: 6, "Attack Speed": "-12%") — not absolute values.
description string Lore prose, shown under == Lore ==.
Consumed by Module:Core, Module:Compare (hero comparison), Module:StatIndex, Module:TagIndex, Module:Iconbox.
Data:Blessings.json — one record per blessing (94)
Field Type Meaning
tier, price, locked number/boolean Shop tier 1–3, price, unlock state.
tags[] string list Tag keys → Data:Tags.json.
stats{} map Signed stat modifiers; percent values stay strings ("5%").
description string Flavor prose.
<X> Plus records are upgraded variants: ids pair <x>-plus with <x>, linked by Module:CrossRef at render time. Consumed by Module:Core, Module:CrossRef, Module:Navbox, Module:StatIndex, Module:TagIndex, Module:Iconbox.
Data:Upgrades.json — one record per shop upgrade (88)
Field Type Meaning
tier, price, locked number/boolean Shop tier 1–3, price, unlock state.
tags[] string list Tag keys → Data:Tags.json.
stats{} map Signed stat modifiers.
description string Rarely present (3 of 88).
Caution: id and name can differ completely (id Shield Transform displays as Lifesteal Chamber) — that's why <X> Plus variant pairing matches on the raw id (Module:CrossRef). Consumed by Module:Core, Module:CrossRef, Module:Navbox, Module:StatIndex, Module:TagIndex, Module:Iconbox.
Data:Crux.json — one record per Crux power (34)
Field Type Meaning
tier number Tier.
type string Unique / Action / Buff / Debuff / Aura — drives index grouping, navbox rows and the infobox header color.
state string Acquired / Unlocked / Locked → rendered as the Availability row.
stats{} map Signed stat modifiers.
description string Effect prose.
Consumed by Module:Core, Module:Navbox, Module:StatIndex, Module:Iconbox.
Data:Passives.json — one record per passive (55)
Field Type Meaning
tier, price, locked number/boolean Shop tier 1–3, price; every passive starts locked.
tags[] string list Tag keys → Data:Tags.json.
stats{} map Signed stat modifiers.
description string Flavor prose.
Ranked families (Armor I/II/III) are grouped consecutively on the index by Module:Core's sort — the stored order doesn't matter. Consumed by Module:Core, Module:Navbox, Module:StatIndex, Module:TagIndex, Module:Iconbox.
Data:Enemies.json — one record per enemy type (27)
Field Type Meaning
stats{} map Health, HP per Wave, Damage, Damage per Wave, Speed, Resources. Per-wave values scale linearly; wave-10 projections are computed by Module:Compare, not stored.
tags[] string list Classification keys (Melee / Range / Big / Boss) → Data:Tags.json.
description string The enemy's own lore. When a Codex entry matches by name, Module:Codex shows the fuller codex text instead at render time.
Consumed by Module:Core, Module:Compare, Module:Navbox, Module:TagIndex, Module:Iconbox.
Data:Achievements.json — one record per Steam achievement (100)
Field Type Meaning
description string The unlock objective (e.g. "Kill 10,000 enemies") — rendered as both the infobox Objective row and the == Objective == section.
Consumed by Module:Core (infobox/index) and Module:Iconbox.
Data:Codex.json — one record per encyclopedia entry (90)
Field Type Meaning
type string Enemies / Weapons / Events / Tips — drives index grouping and navbox rows.
description string The full lore text.
redirect_slug string (optional) Present when the entry matched a weapon/enemy by name: slug then points at the ENTITY's page (which inlines this lore), and redirect_slug is the old <X>-Codex title kept as a redirect.
Tips entries named after a stat (e.g. "Holy Damage") are that stat's hub page. Module:Codex joins entries to weapons/enemies by normalized name at render time. Consumed by Module:Core, Module:Codex, Module:Navbox, Module:Iconbox.
Data:Tags.json — one record per tag / perk keyword (84)
Field Type Meaning
id string The raw tag KEY exactly as used in other categories' tags[] arrays (e.g. BreakArmor).
slug string Tag page title, always Tag-<Key>.
text string The effect text; empty when the game data ships none.
Which entities carry a tag is NOT stored here — Module:Core scans the other categories' tags[] arrays at render time (rendered by Module:TagIndex). Consumed by Module:Core (tag links + effect text everywhere), Module:TagIndex, Module:CrossRef.

Basics

Click the pencil icon at the top right of any page to open the editor. A dropdown shows the editing options available for that page.

Creating a page

To create a new page, navigate to its URL. Replace the last path segment with the new page name. Example: a new page named "Foo Bar" lives at https://armsofgod.wiki.spellsandguns.com//Foo_Bar.

The page will show "There is currently no text in this page." Click "create this page" to begin editing.

Page-name limitations apply (trailing spaces are trimmed, etc.). See MediaWiki: PAGENAMEE encoding for the full rules.

Editing a page

Visual Edit — an experimental WYSIWYG editor. For the most part the rendered content matches the live page. Has limited use on Template / Module / Data pages.

Edit Source — opens a wikitext editor with syntax highlighting. "Show preview" lets you see the effects before saving. If you enter an empty-looking page, try Edit Source — there's likely content hidden inside <includeonly> tags.

Uploading an image

Special:Upload — single-image upload. The destination filename determines what the file is called on the wiki.

Special:BatchUpload — multi-image upload. Uploaded files use their source filenames automatically. Conflicting names overwrite existing files; be careful.

Broken file links appear as grey File:missing_example.png-style links. Clicking them opens the upload page with the destination filename pre-filled.

Conventions

Most pages on this wiki are bot-published from the game's data. Modules, Templates, Data: pages, and per-instance detail pages are regenerated on a schedule (typically after game patches).

Safe-to-edit rules:

- Detail pages (one per item / character / etc.) — edits persist. First-write-only publish: once a detail page exists, the bot preserves any edits you make. Your prose, screenshots, and trivia survive every re-publish. - Module / Template / Data: pages — edits don't persist. These get overwritten on every scheduled re-publish. Cosmetic edits (formatting, comments) won't break anything but won't survive either. What gets re-emitted is the data-bound variable names, parameter lists, and JSON keys — so don't rename those, even temporarily. See the bot-published content catalog for the full list.

MediaWiki

This wiki runs on MediaWiki software. See Special:Version for installed extensions, skins, libraries, and version info.

This tab highlights MediaWiki's special pages most useful for working on this wiki.

Retrieved from "http://armsofgod.wiki.spellsandguns.com/index.php?title=Help:Wiki_Editing&oldid=2111"