Introduction

This article contains guidelines for designing weapon effects, including fire effects (muzzle flash), projectile (in-flight) effects, and hit effects.

These guidelines follow a few core principles:

Proportionality: Effects should be proportional to the damaged produced. We don't want an archcannon's effect to be smaller or less interesting than a pedestrian laser.
Distinctiveness: We want effects to be distinctive and representative of the weapon. The greater the difference between weapons (in terms of power, mechanics, or backstory) the greater the difference in effects.
Cohesiveness: At the same time, we want related weapons to have similar effects. For example, laser weapon effects should share common traits. Players should be able to find patterns that help them predict the nature of a weapon based on its effect.
Coolness: Lastly, we want effects to be visually cool and interesting.

Guidelines

This section contains specific guidelines for different categories of weapons. Consult the guidelines appropriate to the weapon you're designing.

In many cases multiple guidelines apply. For example, a KM100 missile should consult the Blast Damage guidelines and the Missile guidelines.

Antimatter Damage

Antimatter effects use a bright yellow color. Projectiles vary, but most use a flare effect (to suggest brightness) and a flickering effect. In some cases, however, we can have hard shell projectiles.

Antimatter hit effects should linger, as if they're burning through their target, and they should emit lots of bright particles.

Blast Damage

Blast effects use explosion/flame colors: yellows, oranges, and reds. Blast projectiles vary: ammo weapons are generally solid: either a missile or hard shell. Other blast projectiles are smooth, like beams, but have distinctive secondary spikes projecting backwards.

All missiles leave an exhaust trail; most ammo weapons should also leave a smoke trail of some sort.

Blast fire effect is width and bright, like a traditional muzzle flash.

Blast hit effects are explosions, using the standard colors.

Variants

Blast weapons with special damage should vary the hit effect appropriately. For example, radiation weapons use a green cloud effect.

Graviton Damage

Graviton effects should rely on expanding rings of purple/violet energy.

Ion Damage

Ion effects are similar to particle effects. Projectile effects have the same particle comet effect, but using a jagged texture and blue color.

Fire effects are like particle weapons but matching the projectile (generally blue).

Hit effects are similar to laser, but matching the projectile, and with a particle cloud explosion (also in blue).

Variants

Ion projectiles with ionizing effects (blinding, EMP, etc.) should use a fractal lightning effect in some fashion. The hit effect should also have some lightning elements.

Some ion weapons can vary color, as along as they avoid colors used by particle weapons.

Kinetic Damage

Kinetic projectiles are mostly gray with a slight blueish tint. Their width is proportional to damage while their length is proportional to speed. By default the projectiles are shaped like a squashed diamond.

The fire effect for kinetic weapons is subtle: a small flash of the same color.

Hit effect is a white flash with particle blow-back (similar to ejecta effects).

Variants

Tracking weapons should leave a trail (e.g., SmartCannon).

Laser Damage

Laser projectiles are smooth and glowing. Their size is proportional to damage. Also, their color changes as damage increases: low-power lasers are red; stronger lasers are orange, then green, and finally violet (for x-ray laser).

Most lasers are tapered, to suggest a bust of energy. But continuous beams work also.

Lasers should have a very small, but bright, fire effect (of matching color).

Laser hit effects should be fading glows of matching color; perhaps higher power lasers should produce a little bit of sparkle.

Variants

Use color variations for special weapons. For example, a special line of laser weapons could deviate from the default color scheme (and serve to differentiate them).

Similarly, the shape of the laser bolt could be altered slightly. Heavier laser bolts could be wider, while faster firing weapons could have thinner bolts.

In all cases, however, the laser bolt should be smooth and glowing.

Missiles

Any self-propelled projectile counts as a missile. For example, the KM100 is a blast-damage missile launcher by the NAMI missile launcher. The distinctive characteristic of missiles is their exhaust trail.

Missile exhaust trails depend on the propulsion system used by the missile. Heavy missiles have more exhaust than lighter missiles; faster missiles have more exhaust than slower missiles. Most human missiles (level 10 or lower) use chemical propulsion&mdash&either solid or liquid rocket fuel. Higher level missiles may use fusion drives or other exotic propulsion systems.

Other exhaust properties, such as color may depend on the manufacturer.

Missile hit effects follow the guidelines for their damage type.

Exhaust Trail Parameters

We use a <ParticleSystem> to create the exhaust trail. For example:

<ParticleSystem
   style=            "jet"
   fixedPos=         "true"
   emitRate=         "40"
   tangentSpeed=     "-3-3"
   particleLifetime= "20-60"
   XformTime=        "30"
   >
   <ParticleEffect>
      <Particle
         style=          "plain"
         minWidth=       "1"
         maxWidth=       "6"
         primaryColor=   "#ffffc0"
         secondaryColor= "#7e7e74"
         />
   </ParticleEffect>
</ParticleSystem>

Each missile family has a slightly different exhaust trail. The basic parameters can be computed using the following algorithm. First multiply the average missile mass (in kilograms) times the average missile speed (as a percent of light-speed). This is the propulsion power of the missile.

Ultra light missiles (propulsion power <= 500):

particleLifetime="10-30"
XformTime="15"
maxWidth="3"

Light missiles (500 < propulsion power <= 1,000):

particleLifetime="15-45"
XformTime="30"
maxWidth="4"

Medium missiles (1,000 < propulsion power <= 1,500):

particleLifetime="20-60"
XformTime="40"
maxWidth="5"

Heavy missiles (1,500 < propulsion power <= 2,000):

particleLifetime="20-60"
XformTime="50"
maxWidth="6"

Nano Damage

Nano damage effects generally use amorphous masses of particles. The particles themselves are often dark and monochromatic, suggesting a "gray goo." But depending on the effect, we could use different colors.

Particle Damage

Particle effects are similar to laser effects but they have a wavy/grainy textures (using a <ParticleComet> painter). Effects are generally green, but some variants might choose a different color.

Particle projectiles are similar in length to lasers, but thinner (to suggest a tighter beam). Fire effects should be like lasers (but matching color). Hit effects should have a hint of graininess.

Plasma Damage

Plasma damage effects use masses of glowing particles to simulate an incandescent blob of energy. We generally use blendMode="screen" to overlay multiple particles into a single glowing mass.

Positron Damage

Positron damage effects are similar to ion effects, except bright yellow in color, matching antimatter.

Singularity Damage

Singularly damage should suggest implosion. We use similar colors as graviton.

Thermonuclear Damage

The signature effect for themonuclear damage is the bright flash as the fusion explosion triggers. The flash is often followed by a large fireball and/or an expanding shockwave.

Implementation Notes

Procedural Parameters

Weapon effects can parameterized to avoid creating multiple similar effects. For example, rather than creating different laser projectile effects (one for each weapon) we create a single effect which changes based on the weapon damage. This is done with the <GetParameters> event.

In non-parameterized effects, we hard-code the parameters in XML. For example:

<Effect>
   <Ray ...
      length="10"
      width="3"
      ...
      />
</Effect>

The effect above will always use be the same size. A parameterized effect changes the parameter values at run-time via an event call:

<Effect>
   <Ray ...
      />
      <Events>
         <GetParameters>
            {
               length: (* (@ gData 'damageHP) 2)
               width: (@ gData 'damageHP)
               }
         </GetParameters>
      </Events>
   </Ray>
</Effect>

The GetParameters event should return a struct with fields for each parameter being assigned. In the above example, we set the length and width parameters at run-time (when the weapon is fired).

The event receives data in the gData variable. The fields depend on the context:

Fire Effect

Fire effects get the following fields:

damageHP: The average damage caused by the given projectile. Note that this is computed when we fire the weapon, not when we hit.
damageType: The type of damage.
speed: The average speed of the projectile (100 = light-speed).
weaponUNID: The UNID of the weapon firing the projectile. For missile launchers this is the missile UNID.

Projectile Effect

Projectile effects get the following fields:

damageHP: The average damage caused by the given projectile. Note that this is computed when we fire the weapon, not when we hit.
damageType: The type of damage.
speed: The average speed of the projectile (100 = light-speed).
weaponUNID: The UNID of the weapon firing the projectile. For missile launchers this is the missile UNID.

Hit Effect

Hit effects get the following fields:

objHit: The object that was hit.
cause: The object that caused the damage (generally the projectile object).
attacker: The object that fired.
orderGiver: The object that is responsible. E.g., when an auton attack, the attacker is the auton and the owner of the auton is the order giver.
damageHP: The actual amount of damage caused.
damageType: The type of damage.
hitDir: The direction of the hit, relative to the center of the object hit.
armorSeg: The armor segment that was hit, if any.
weaponUNID: THe UNID of the weapon firing the projectile.

Resolve