A new weapon class should change a player's decision, not just add more particles. In a bullet-hell shooter, every projectile competes for the player's attention. Define when the weapon is useful, how it spends space or resources, and what it leaves readable before asking AI to touch the combat code.

This page uses an invented “Arc Fan” example to explain the workflow. Its firing pattern and values are not measured, and it does not describe a real build. The goal is to keep the existing shooter intact while creating one reviewable weapon behavior.
Define a combat choice before choosing numbers
List the weapons the game already has and what situation each one serves. A direct shot may reward precise aim; a wide spread may help with nearby targets; a charge attack may trade time for damage. A new class needs a different trade-off. If it only raises damage while keeping the same range and timing, it may be a stat variant rather than a new decision.
For the fictional Arc Fan, the player briefly sweeps a short arc across an approaching lane. That could help clear a side corridor, but its limited reach and committed firing moment leave another lane uncovered. This describes a design question, not a proven balance outcome. The existing game determines whether the idea is useful or fair.
Write the weapon contract in plain language: trigger input, target or direction, projectile pattern, duration, cooldown, resource cost, cancellation behavior, and how it interacts with existing upgrades. Include what should not change, such as movement acceleration, invulnerability frames, enemy patterns, and the controls of old weapons.
Inspect the existing firing path
Trace one current weapon from input to projectile. Find where the player reads the action, selects a weapon, checks cooldown and ammunition, creates or reuses projectiles, applies damage, and triggers effects. Ask AI to map this path and identify a small extension point before it edits. A concise file map is easier to review than an assistant immediately rewriting a weapon manager.
Prefer one shared firing interface with a narrow behavior parameter over a duplicate weapon subsystem. Existing projectile pooling, collision filters, damage rules, sound hooks, and UI feedback should stay in their current owners. A new behavior may supply the pattern or a class-specific effect; it should not silently fork the rules that all weapons depend on.
If the game already uses authored data, follow that convention. Godot's stable docs describe custom Resources that can be serialized and edited through the Inspector. Unity 6.1 describes ScriptableObject as a data container independent from component instances. These are configuration options documented by the engines; the actual runtime design should follow the project that already exists.

Make the pattern easy to read
Projectile density is a budget. Consider both the new weapon's output and the effects already on screen. Reuse existing visual conventions for danger, friendly shots, hit feedback, and temporary invulnerability. A projectile that looks dangerous but cannot hurt the player trains the wrong response; a friendly projectile that resembles an enemy shot can create confusion.
Use contrast with restraint. Shape, motion, outline, and timing can help distinguish the new class, but color alone may be inaccessible or hidden by effects. Keep enough negative space to read enemy lanes and preserve the dodge decisions the game is built around. Use a real game capture for evaluation; concept art cannot validate readability.
Document the pattern using a few parameters the project can safely support. For example, a three-projectile arc might need a spread angle, speed, lifetime, and cooldown. Define units and allowed ranges once. If the editor or weapon data accepts extreme values, clamp or reject them deliberately rather than relying on accidental behavior.
Balance against a consistent encounter
Compare the new class with a current weapon in the same arena, against the same wave, at the same upgrade level and difficulty. Record build version, input device, encounter, resource loadout, and the question you are testing. “Did this create a useful lane-clearing choice?” is more actionable than “does it feel stronger?”
Start with one or two controlled variants. If a weapon fires too often, determine whether the cause is its cooldown, a repeated input event, or a projectile that persists longer than intended. If it dominates, inspect coverage, cost, uptime, and enemy behavior before simply lowering damage. Change one variable at a time so the team can tell what changed.
Watch for technical effects as well as balance. More projectiles may increase object creation, collision checks, or visual overdraw. The article makes no performance claim; measure in the project's actual target build and compare the same encounter before and after. If the existing game uses an object pool, send the new projectile through that mechanism instead of allocating a separate stream.

Constrain the AI change and keep rollback easy
Give the assistant a bounded request: add one weapon class through the current firing interface; preserve movement, old weapon behaviors, enemy patterns, collision, and input; expose only the needed pattern values; list changed files; and explain how to remove the new class cleanly. Ask it not to rebalance unrelated weapons or rewrite the projectile system.
Review the patch in small slices. Look for a second cooldown or damage formula, direct scene references that bypass existing ownership, unbounded projectile creation, and changes to old defaults. Keep a copy of the project and test loadout. If the assistant modifies old weapon files, compare each change with the agreed contract.
Separate code correctness from design success. A new weapon may compile and fire while still making patterns unreadable or undermining the role of an existing class. Treat those as separate review questions and record the evidence for each one.
Use a small verification matrix
These are proposed checks for the real project, not a report of tests run on the fictional Arc Fan:
| Case | Action | What to verify |
|---|---|---|
| Old weapon control | Use each existing weapon in a known encounter | Input, cooldown, damage, and upgrades still work |
| New class baseline | Fire at a stationary target and during movement | Pattern, direction, lifetime, and cancellation match the design contract |
| Dense encounter | Use it with the usual enemy projectile pattern | Danger lanes remain readable and the player can dodge |
| Resource boundary | Test empty, minimum, and replenished ammo states | No free shot, stuck cooldown, or double spend |
| Restart and upgrade | Restart the encounter and apply a normal upgrade | New state resets or scales according to existing rules |
| Target build | Repeat on the intended device and performance settings | Measure projectile load and responsiveness in context |
Capture the same angle before and after when evaluating readability, but do not rely on a still image alone for timing or performance. Record the project version, encounter, steps, expected observation, and result. If no build was available, keep the plan labeled as a plan.
Frequently asked questions
What makes a weapon class feel distinct in a bullet-hell shooter?
Give it a decision the existing weapons do not already cover, such as committing to a short fan burst or holding a narrow lane. Its timing, coverage, and cost should create a choice without making the screen unreadable. That definition should be visible in the combat contract before tuning begins.
Should a new weapon class have its own firing system?
Reuse the current input and projectile pipeline where possible. Add a narrow behavior or pattern data record, and avoid copying targeting, cooldown, damage, and pooling logic into a parallel weapon implementation. A shared path also makes regression checks easier when other weapons change.
What should I balance first for a new bullet-hell weapon?
Start with readable coverage, firing interval, projectile lifetime, resource cost, and the situations where the weapon is useful. Compare against existing weapons under the same encounter and platform conditions before tuning secondary effects. Keep the comparison repeatable and record what happened on the target build.
Can Godot Resources or Unity ScriptableObjects hold weapon configuration?
Both engines document authored data containers: Godot custom Resources can be serialized, and Unity describes ScriptableObject as data independent of component instances. Fit the choice to the existing project; neither reference guarantees a particular runtime weapon architecture. These references describe data containers, not a ready-made weapon architecture.
What should I verify before keeping an AI-generated weapon change?
Check the old weapons, input, cooldowns, projectile count, readable enemy patterns, restart behavior, and target build. Review changed files and compare the same encounter before and after; a design proposal alone is not a balance result. Separate observed evidence from the design target when writing review notes.
Ship one choice, then evaluate it
Keep the first increment focused on one combat decision and one safe extension point. Preserve what the existing shooter already does well, then decide whether evidence from the actual build supports keeping or revising the new class. That process is more useful than shipping a dramatic concept image or a pile of untested stats.
For a separate browser-playable prototype idea, try SEELE AI Game Maker. This is a separate prototype path, not an existing-project modification claim.


