Mass Forge Projectiles

Mass Forge projectiles are short-lived Mass entities. Movement runs in UMF_ProjectileProcessor; UMF_ProjectileSubsystem creates projectile entities, exposes renderer-neutral snapshots, and crosses back to gameplay only after Mass processing has finished. This keeps projectile presentation replaceable and damage authoritative.

Setup

The convenience node launches a real Mass projectile. Its optional damage resolves from the projectile's impact path, never from the input event shown at the left.

1. Add Mass Forge Projectile Trait to a Mass Entity Config.

The generated projectile config is intentionally small. Transform stores its world state; Projectile stores the actorless flight and impact contract. Presentation remains a replaceable snapshot consumer. 2. Build an FMFProjectileLaunchRequest with that config, start/target locations, speed, optional arc, and optional authored release delay. 3. For a direct hit, assign a Damage Definition and FMFDamageRequest. For an area spell or project-owned effect, leave the definition empty and assign a stable ImpactCue. 4. Call Launch Projectile on UMF_ProjectileSubsystem. 5. Render Get Projectile Snapshots with Niagara, HISM, actors, or no visual representation. Gameplay does not depend on the renderer. 6. Listen to On Projectile Resolved for area queries, sound/VFX, healing, or other project-specific impact work.

Timing contract

LaunchDelaySeconds is the animation release point. A projectile remains hidden and stationary until that delay expires, then travels through the Mass processor. Optional damage is committed at impact—not at button press and not when an attack animation begins.

The included Horde Defense, Survivor Roguelite, and Battle Simulator examples all use this path:

• player fireballs, nova shards, and meteors;
• hostile horde bolts;
• battle ranger volleys;
• battle support/healing bolts.

Battle melee contacts also use the same impact queue on a renderer-free presentation channel. That keeps damage ordering symmetric between the two armies without drawing a fake projectile for a sword strike.

Their sample renderer uses three HISM batches and a bounds-stable sphere reference mesh. Each visible snapshot becomes a large core plus seven tapering trail beads, so direction remains readable without stretching a sphere into a distorted capsule. The renderer keeps instance slots stable and updates their transforms in place; it does not clear and recreate the HISM hierarchy each frame. Player shots select an enemy near the reticle ray instead of stopping on decorative props, clamp travel to at least 0.90 seconds, and leave an expanding 0.70-second twelve-bead impact ring. Hostile impacts use a much smaller six-bead ring so incoming fire remains legible without covering the player. Damage and the impact presentation are both triggered by the same resolved Mass projectile; neither occurs at button press. Renderer-free channel 3 carries deferred melee/contact transactions without pretending that a sword strike is a ranged shot. The same projectile entities can instead feed a project Niagara renderer without changing combat code.

The examples bind authored animation events to the launch delay: the player Cast clip releases at frame 13/30, while the 10 Hz enemy simulation quantizes its frame-10/30 Attack contact to the closest fixed step. Animation begins first, the projectile becomes visible at release, and damage is committed only at impact.

The large core and tapering beads make travel direction readable in the sample HISM renderer. This presentation can be replaced without changing launch timing, impact authority, or Damage Definition evaluation.

The Survivor example uses the same projectile API for automatic attacks. Allocation, active simulation, representation, and rendering remain separate scale decisions.

Scale and boundaries

This first-release implementation is a deterministic point-to-point/arc flight model. It is intentionally not a physics projectile or a swept collision system. Projects that need walls, ricochet, prediction, homing, or spatial collision can extend the processor/fragment while retaining the same launch, snapshot, safe-impact, and damage contracts.

Projectile entities are destroyed after impact or lifetime expiry. Pending impacts are bounded, map/reset boundaries clear active projectile entities, and gameplay damage is processed only while the Mass entity manager is idle.

The showcase audit publishes ProjectileVisibleSamples and PlayerProjectileImpacts. Both must be nonzero in Third-Person Horde Defense, its VAT duplicate, and Survivor Roguelite, preventing a transaction-only implementation from passing when the player cannot actually see projectile travel and impact feedback.