gistfile1.txt

   /// @name State Data
   /// Individual state data used to initialize struct array
   /// @{
   const char*             fireStateName;
   // stateName is used to denote the state we're in. One moves to a different state by
   // setting one of the following callback conditions to the new state name; 
   const char*             stateName                  [MaxStates];

   const char*             stateTransitionLoaded      [MaxStates];
   const char*             stateTransitionNotLoaded   [MaxStates];
   const char*             stateTransitionAmmo        [MaxStates];
   const char*             stateTransitionNoAmmo      [MaxStates];
   const char*             stateTransitionTarget      [MaxStates];
   const char*             stateTransitionNoTarget    [MaxStates];
   const char*             stateTransitionWet         [MaxStates];
   const char*             stateTransitionNotWet      [MaxStates];
   const char*             stateTransitionMotion      [MaxStates];
   const char*             stateTransitionNoMotion    [MaxStates];
   const char*             stateTransitionTriggerUp   [MaxStates];
   const char*             stateTransitionTriggerDown [MaxStates];
   const char*             stateTransitionAltTriggerUp[MaxStates];
   const char*             stateTransitionAltTriggerDown[MaxStates];
   const char*             stateTransitionGeneric0In  [MaxStates];
   const char*             stateTransitionGeneric0Out [MaxStates];
   const char*             stateTransitionGeneric1In  [MaxStates];
   const char*             stateTransitionGeneric1Out [MaxStates];
   const char*             stateTransitionGeneric2In  [MaxStates];
   const char*             stateTransitionGeneric2Out [MaxStates];
   const char*             stateTransitionGeneric3In  [MaxStates];
   const char*             stateTransitionGeneric3Out [MaxStates];
   const char*             stateTransitionTimeout     [MaxStates];
   
   // whether to treat it as a particularly special trye, like the point at which firing happens, ect
   bool                    stateFire                  [MaxStates];
   bool                    stateAlternateFire         [MaxStates];
   bool                    stateReload                [MaxStates];
   StateData::LoadedState  stateLoaded                [MaxStates];
   StateData::SpinState    stateSpin                  [MaxStates];
   StateData::RecoilState  stateRecoil                [MaxStates];
   
   // actual animations played
   const char*             stateSequence              [MaxStates];
   bool                    stateSequenceRandomFlash   [MaxStates];
   const char*             stateShapeSequence         [MaxStates]; //force an animaton to play on what's holding us
   bool                    stateScaleShapeSequence    [MaxStates];
   // state modifiers, such as the duration a given state takes to complete,
   // wether or not to scale the animation to that duration or leave it at the end frame, ect
   F32                     stateTimeoutValue          [MaxStates];
   bool                    stateWaitForTimeout        [MaxStates];
   bool                    stateAllowImageChange      [MaxStates];
   bool                    stateScaleAnimation        [MaxStates];
   bool                    stateScaleAnimationFP      [MaxStates];   
   bool                    stateDirection             [MaxStates];
   bool                    stateIgnoreLoadedForReady  [MaxStates];
   
   // particle emission timing modifiers
   F32                     stateEmitterTime           [MaxStates];
   const char*             stateEmitterNode           [MaxStates];
   
   // played alongside the animation(s)
   SFXTrack*               stateSound                 [MaxStates];
   ParticleEmitterData*    stateEmitter               [MaxStates];   
   bool                    stateEjectShell            [MaxStates];
   const char*             stateScript                [MaxStates];
   
   // misc
   F32                     stateEnergyDrain           [MaxStates];
   bool                    stateSequenceTransitionIn  [MaxStates];
   bool                    stateSequenceTransitionOut [MaxStates];
   bool                    stateSequenceNeverTransition [MaxStates];
   F32                     stateSequenceTransitionTime [MaxStates];   

   /// @}