//GENERATED CODE====================================================================================
//  
//  Copyright Blizzard Entertainment 2003+
//  
//  ActorSupportHints.txt generated from ActorSupport.xml using HintText.xtc
//  
//  !!! WARNING !!! This is generated code. Changes made here will be overwritten.
//  
//GENERATED CODE====================================================================================
EDSTR_ENUMHINT_e_actorMsgAbil=Sent whenever a game ability does something that might want to modify actors, such as playing a spell on the caster when the ability starts.
EDSTR_ENUMHINT_e_actorMsgActionDamage=Target: CActorAction.  Enables game effects to trigger damage FX (impact squibs, blood, sounds, etc.) on each unit that is struck by AoE.  The damage FX are configured in the target CActorAction.
EDSTR_ENUMHINT_e_actorMsgActionDamagePhysics=Target: CActorAction.  Enables game effects to trigger damage physics FX (impact squibs, blood, etc.) on each unit that is struck by AoE.  The damage physics FX are configured in the target CActorAction.  It is separate from the ActionDamage message, because the ActionDamage message is typically applied at the start of an effect, whereas the physics are typically applied at the end of the effect, after the effect has had a chance to kill a target.  (It is common for live units to have no physics associated with them, whereas unit death models frequently do have physics.  Thus, it is necessary to send ActionDamagePhysics after the effect has killed the target and swapped in the physics-ready death model.)  Damage physics are far less common than impact physics, because it is frequently better to create a single large physics force for an AoE effect rather than a smaller physics force for each target struck by the AoE.
EDSTR_ENUMHINT_e_actorMsgActionImpact=Target: CActorAction.  Enables game effects to trigger impact FX (impact squibs, blood, sounds, etc.) for the unit that is the target of an attack.  The impact FX are configured in the target CActorAction.
EDSTR_ENUMHINT_e_actorMsgActionImpactPhysics=Target: CActorAction.  Enables game effects to trigger damage physics FX (impact squibs, blood, etc.) on each unit that is struck by AoE.  The impact physics FX are configured in the target CActorAction.  It is separate from the ActionImpact message, because the ActionImpact message is typically applied at the start of an effect, whereas the physics are typically applied at the end of the effect, after the effect has had a chance to kill a target.  (It is common for live units to have no physics associated with them, whereas unit death models frequently do have physics.  Thus, it is necessary to send ActionImpactPhysics after the effect has killed the target and swapped in the physics-ready death model.)
EDSTR_ENUMHINT_e_actorMsgActorSiteOpDump=Dumps the site ops and their bearings for a specified host variable on a target actor.  If no host is specified, the message dumps the site ops on all the hosts possessed by the actor.  Useful for debugging position and rotation issues with site op chains.
EDSTR_ENUMHINT_e_actorMsgAliasAdd=Adds an alias to an actor.  An alias is a name that can be used to refer to the actor.  Multiple actors can be given the same alias, so that a single message can automatically target every actor in that group.  A single alias can point to a succession of actors, so that client data does not have to care about specific actor names when trying to send a message.  (In this regard, aliases can be used as a form of indirection.)
EDSTR_ENUMHINT_e_actorMsgAliasDump=Lists all the aliases currently associated with the target actor.
EDSTR_ENUMHINT_e_actorMsgAliasRemove=Removes an alias from an actor.
EDSTR_ENUMHINT_e_actorMsgAnimBaselineStart=Target: CActorUnit.  Starts the baseline animation for a CActorUnit.  There are two main baseline anims -- Walk and Stand, which play continuously, depending on whether the unit is moving or standing still.  Other higher priority animations may play on top of the CActorUnit's baseline animations, depending on the situation.
EDSTR_ENUMHINT_e_actorMsgAnimBaselineStop=Target: CActorUnit.  Stops the baseline animation for a CActorUnit.  This is not a common operation, because a unit without a baseline or any other animations appears in a rigid default pose and can look visually jarring.  However, it can be useful to temporarily not have a baseline animation if it causes specific animations (such as Birth) to blend in awkwardly.
EDSTR_ENUMHINT_e_actorMsgAnimBaselineSuppressWalk=Target: CActorUnit.  Prevents the baseline from playing the Walk anim even while the unit is walking; the unit will only ever play Stand anims as its baseline while SuppressWalk is active.
EDSTR_ENUMHINT_e_actorMsgAnimBlendTimeApply=Target: CActorModel.  Sets the default blend in and blend out times for all subsequent animations played on the model.
EDSTR_ENUMHINT_e_actorMsgAnimBlendTimeRemove=Target: CActorModel.  Removes any user-set blend in and blend out times for all animations played on the model and restores the blend times to the default 150 ms.
EDSTR_ENUMHINT_e_actorMsgAnimBracketClear=Target: CActorModel.  Clears an anim bracket.  Unlike the AnimBracketStop message, this removes the bracket immediately, rather than letting it transition out with a closing animation.  In this regard, it is the anim bracket version of the AnimClear message.
EDSTR_ENUMHINT_e_actorMsgAnimBracketResume=Target: CActorModel.  Restarts an already running anim bracket with the same parameters specified for the bracket when it was originally started.  Typically used when an anim bracket has been stopped and is in the process of playing its closing animation.  The resume operation will play the opening animation considering the closing animation's progress, such that an animated closing door will appear to smoothly reopen from its animated closing position (provided the underlying animations are designed to support this).
EDSTR_ENUMHINT_e_actorMsgAnimBracketStart=Target: CActorModel.  Specifies the parameters for an anim bracket and starts it.  An anim bracket automates a very common animation pattern: when an animated action has three parts - a beginning (opening), a middle (content) and an end (closing).  The middle is commonly of indeterminate length, and therefore loops repeatedly, until the anim bracket is stopped, at which point the end animation plays and completes the anim bracket.
EDSTR_ENUMHINT_e_actorMsgAnimBracketStop=Target: CActorModel.  Stops an anim bracket by blending out the middle content animation and ending the bracket with a closing animation.
EDSTR_ENUMHINT_e_actorMsgAnimCancelActiveBlends=Target: CActorModel.  Completes all animation blends instantly, either blending in the animation completely or fully clearing it.
EDSTR_ENUMHINT_e_actorMsgAnimClear=Target: CActorModel.  Clears an animation, either with the default or a supplied blend out time.  If no animation name is supplied, the message clears all animations.  Cannot be used to stop a CActorUnit's baseline animation.
EDSTR_ENUMHINT_e_actorMsgAnimClearAllBut=Target: CActorModel.  Clears all animations on the model but the one specified, either with the default or a supplied blend out time.
EDSTR_ENUMHINT_e_actorMsgAnimClearTimeScaleGlobal=Target: CActorModel.  Clears the global time scale that is being factored into all animations played on the model.  Animation time scale is a hosted prop, so this may additionally clear the global time on relevantly configured child actors.
EDSTR_ENUMHINT_e_actorMsgAnimContinue=Target: CActorModel.  Supports several operations.  Can jump within an animation by clearing and replaying the animation, thereby blending out the old animation position and blending in the new one as a means of smoothing the transition.  Can also transition from one animation to another, while keep the animation variations the same.  In particular, this can be used for preswings, where data can start a particular preswing variation, then jump further into the animation and play the main attack swing -- all in one smooth sequence and regardless of the preswing's duration.  In order to look correct for attack swings that alternate hands, the jump must be blended and keep the same variation.
EDSTR_ENUMHINT_e_actorMsgAnimCopy=Target: CActorModel.  Copies the entire animation stack from a source model and attempts to replicate it on the CActorModel that is the target of the message.  The copy operation attempts to play the exact same animation for each entry in the source animation stack.  If a given animation does not exist in the target model, the copy attempts to best match search for a new animation using the anim props of the source animation.  If it cannot find a match at all, the copy plays nothing for that animation.
EDSTR_ENUMHINT_e_actorMsgAnimDumpDB=Target: CActorModel.  Lists all of the animations available in the current model, along with their durations and whether they are marked as looping.
EDSTR_ENUMHINT_e_actorMsgAnimGlobalLoopsClear=Target: CActorModel.  Clears all of the global loop animations that are playing on the current model.  A flag enables the global loops to be either stopped instantly or blended out.
EDSTR_ENUMHINT_e_actorMsgAnimGlobalLoopsStart=Target: CActorModel.  Starts all of the global loop animations built into the current model.  Global loops are animation brackets with GLbirth, GLstand, GLdeath and/or GLdead animations that can be played automatically when a model is created.  They are typically used for continuous 'background' anims that need to play regardless of what the unit is doing.  The spinning rotor blades on the Banshee are an example.
EDSTR_ENUMHINT_e_actorMsgAnimGlobalLoopsStop=Target: CActorModel.  Stops all of the global loop animations that are playing on the current model.  This causes global loops to start playing GLdeath and then either finish altogether or play GLdead from then on (if it exists).
EDSTR_ENUMHINT_e_actorMsgAnimGroupApply=Target: CActorModel.  Adds a global anim prop to the CActorModel.  This global anim prop becomes a part of the anim props associated with each animation playing currently and in the future.  The addition of the new prop can automatically change each animation that is playing, for example: changing a Stand animation to Stand, Work if the unit suddenly starts performing a work action.  The AnimGroupApply message also optionally creates an anim bracket so that the model can smoothly transition to and from the altered animation state.  The name of this bracket automatically comes from the prop that is being applied.  For instance, the 'AnimGroupApply Fly Fly,Start Fly,Stop' message sent to a standing unit plays an animation called Fly that plays a Fly, Start animation during the opening phase, while the underlying Stand baseline animation changes to Stand, Fly with the addition of the new Fly global prop.  Then, when the opening animation finishes, it reveals the underlying Stand, Fly animation that had already started playing.  Finally, when the global anim prop is later removed via AnimGroupRemove, the associated anim bracket plays a Fly, Stop animation.  When this is complete, the model is again playing a normal Stand animation.  As such, the anim bracket created by the AnimGroupApply message does not contain a content animation (the middle part), because it is expected that the changed animations that are already playing will serve as the content animation instead.
EDSTR_ENUMHINT_e_actorMsgAnimGroupRemove=Target: CActorModel.  Removes a global anim prop and plays a transition out animation to cover the change, if such an animation has been specified in a prior AnimGroupApply message.
EDSTR_ENUMHINT_e_actorMsgAnimGroupRemoveAll=Target: CActorModel.  Removes all global anim props and instantly clears all anim brackets that were created by AnimGroupApply messages.
EDSTR_ENUMHINT_e_actorMsgAnimHookClear=Target: CActorModel.  Clears a named anim hook that has previously been set.
EDSTR_ENUMHINT_e_actorMsgAnimHookDump=Target: CActorModel.  Lists the anim hooks on the target actor.
EDSTR_ENUMHINT_e_actorMsgAnimHookSet=Target: CActorModel.  Creates an animation that mimics the anim props, play position and timescale of another animation on a target actor.
EDSTR_ENUMHINT_e_actorMsgAnimPlay=Target: CActorModel.  Plays an animation on the target model.  Every animation created by this animation requires a name, so that client data and code can easily refer to the animation for subsequent operations.  Supports a number of parameters for specifying blend times, play rate and other animation behaviors.
EDSTR_ENUMHINT_e_actorMsgAnimPlaySequence=Target: CActorModel.  Plays an animation on the target model, but unlike AnimPlay, specifies the animation name directly, rather than using anim props.  Supports a similar set of parameters to the AnimPlay message.
EDSTR_ENUMHINT_e_actorMsgAnimSetCompletion=Target: CActorModel.  Sets the play position of an animation via percentage completion time.  Expects values between 0.0 and 100.0.  A value of 75 indicates that the message should set the animation position to be 3/4 of the way to done.
EDSTR_ENUMHINT_e_actorMsgAnimSetDuration=Target: CActorModel.  Specifies how long an animation should take to play.  In this way, the AnimSetDuration message is another way of setting an animation's time scale.  A 2.0 second animation played across a duration of 4.0 seconds would effectively have a time scale of 0.5
EDSTR_ENUMHINT_e_actorMsgAnimSetLockedAll=Target: CActorModel.  Toggles the animation lock state.  While locked, a CActorModel ignores all incoming animation messages, though it continues to play whatever animations it has currently.
EDSTR_ENUMHINT_e_actorMsgAnimSetPaused=Target: CActorModel.  Toggles the pause state of the specified animation.  A paused animation holds its current frame until it is unpaused.
EDSTR_ENUMHINT_e_actorMsgAnimSetPausedAll=Target: CActorModel.  Toggles the pause state of all animations on the target CActorModel.  When pausing animations, the message additionally pauses all particle systems on the model in accordance with the PausedParticleSystemBehavior field in the ModelData.xml entry for the model contained by the target CActorModel.
EDSTR_ENUMHINT_e_actorMsgAnimSetTime=Target: CActorModel.  Sets the play position of the specified animation.  Supports flags for specifying how to interpret the time scale of the play time and for controlling whether animation events are triggered by time jumps within an already playing animation.
EDSTR_ENUMHINT_e_actorMsgAnimSetTimeScale=Target: CActorModel.  Sets the time scale of the specified animation.  Time scale is the rate at which the animation plays relative to normal game world time.  A time scale of 0.5 means the animation takes twice as long to complete, while a time scale of 3.0 means the animation finishes in one-third the normal time.
EDSTR_ENUMHINT_e_actorMsgAnimSetTimeScaleAbsolute=Target: CActorModel.  Sets the time scale of the specified animation, but unlike normal time scale, absolute time scale does not incorporate a model's global time scale into the final timing result for the animation.  This makes it possible to run an animation at a constant rate, regardless of how the global time scale of the unit is affected.
EDSTR_ENUMHINT_e_actorMsgAnimSetTimeScaleGlobal=Target: CActorModel.  Sets the global time scale for the entire model.  This time scale is multiplied with the time scale of each animation in the model, in order to determine that animation's final play speed.  Global time scale is also a hosted prop, which means that it can be inherited by child models.
EDSTR_ENUMHINT_e_actorMsgAnimSetUserWeight=Target: CActorModel.  Enables client code to scale the contribution of a particular animation with respect to other animations on the model.  The animation system multiplies user blend weight with a blend weight that is managed automatically by the animation system on a per animation basis, as a given animation blends in and out.  The system adds the final blend values of the animations on the top of the stack until a cutoff of 1.0, and then plays every animation incorporated into the calculation before the cutoff at a contribution level that corresponds to the animation's blend weight.  If the sum of the blend weights of all the animations on the animation stack does not reach 1.0, the blend weights are normalized, such that they add up to 1.0.
EDSTR_ENUMHINT_e_actorMsgArcSetAngle=Target: CActorArc, CActorRegionArc.  Sets the arc of a CActorArc, to control the angle covered by the pie-wedged model it contains.  For CActorRegionArc, controls the area covered by the region.
EDSTR_ENUMHINT_e_actorMsgAttach=Target: CActorModel.  Attaches a specified child CActorModel to the target parent CActorModel, using a supplied set of attach methods to specify the attach point, and an optional set of site ops to further configure the position and rotation of the child CActorModel (beyond simply using the attach point's built in position and rotation).  The SiteOps data field does not need to include a CActorSiteOpAttach, as that is automatically created, configured and placed at the head of the site op chain by the system.  A simplified version of the AttachOffset message.
EDSTR_ENUMHINT_e_actorMsgAttachDump=Target: CActorModel.  Lists all of the attach points in the target model, along with many of their details.  This includes (but is not limited to) each attach point's: internal name, attach method-compliant name and index, current position, current rotation, target attach volume details and visibility state.
EDSTR_ENUMHINT_e_actorMsgAttachModel=Target: CActorModel.  Creates a specified CActorModel with a given model and attaches it to a target CActorModel, in a manner similar to the Attach message.  This can be more convenient than the Attach message, since it does not require a separate actor to be defined for each type of model that is created.  This message is a simplified version of the AttachModelOffset message.
EDSTR_ENUMHINT_e_actorMsgAttachModelOffset=Target: CActorModel.  Creates a specified CActorModel with a given model and attaches it to a target CActorModel, like the AttachModel message.  Additionally supports a custom position and rotation offset from the attach point.
EDSTR_ENUMHINT_e_actorMsgAttachOffset=Target: CActorModel.  Attaches a specified child CActorModel to the target parent CActorModel, like the Attach message.  Additionally supports a custom position and rotation offset from the attach point.
EDSTR_ENUMHINT_e_actorMsgAttachSetBearings=Target: CActorModel.  Sets the bearings of a specified attach point to an explicit world bearings value.
EDSTR_ENUMHINT_e_actorMsgAttachSetBearingsFrom=Target: CActorModel.  Sets the bearings of a specified attach point to the bearings of a specified actor, with an optional set of temporary site ops to transform the value before it is set.
EDSTR_ENUMHINT_e_actorMsgAttachSetPosition=Target: CActorModel.  Sets the position of a specified attach point to an explicit world position value.
EDSTR_ENUMHINT_e_actorMsgAttachSetPositionFrom=Target: CActorModel.  Sets the position of a specified attach point to the position of a specified actor, with an optional set of temporary site ops to transform the value before it is set.
EDSTR_ENUMHINT_e_actorMsgAttachSetRotation=Target: CActorModel.  Sets the rotation of a specified attach point to an explicit world orientation value.
EDSTR_ENUMHINT_e_actorMsgAttachSetRotationFrom=Target: CActorModel.  Sets the rotation of a specified attach point to the rotation of a specified actor, with an optional set of temporary site ops to transform the value before it is set.
EDSTR_ENUMHINT_e_actorMsgBillboardSetTowardsCameraDistance=Target: CActorSiteBillboard.  Specifies how far towards the camera the billboarded model moves from the its input position (which comes from either its host actor, site ops, or a combination of the two).  Objects that are farther towards the camera appear larger.
EDSTR_ENUMHINT_e_actorMsgCameraSetActive=Target: CActorCamera.  If the Active parameter is 1, the message makes the target CActorCamera the active camera for the containing scene.  If the Active parameter is 0, it sets the camera back the default camera for the scene.
EDSTR_ENUMHINT_e_actorMsgCameraSetClipToBounds=Target: CActorCamera.  Toggles whether the camera's position (i.e. the position that the camera is looking at) is clipped to the camera bounds of its containing scene.  For the game camera, this is the edges of the map terrain.  Toggling clipping on immediately jumps the camera if it is looking at a point outside the camera bounds.
EDSTR_ENUMHINT_e_actorMsgCameraSetEyePosition=Target: CActorCamera.  Sets the position of the camera's eye.  The ray between the camera's eye position and the target position forms the direction the camera is looking.
EDSTR_ENUMHINT_e_actorMsgCameraSetLink=Target: CActorCamera.  Specifies the camera for the target CActorCamera to use.  Includes parameters for controlling the transition to the camera's initial camera param values.
EDSTR_ENUMHINT_e_actorMsgCameraSetParam=Target: CActorCamera.  Sets any of a number of different camera parameters such as field of view, distance, focal depth, yaw, pitch, roll, near and far clip planes, etc...  Includes parameters for controlling how the camera smoothly transitions to the new parameter value.
EDSTR_ENUMHINT_e_actorMsgCameraShakeStart=Starts a screen shake.  Parameters control who sees the screen shake, its intensity and duration, and how long it takes to blend in and out.
EDSTR_ENUMHINT_e_actorMsgCameraShakeStop=Stops the current screen shake.
EDSTR_ENUMHINT_e_actorMsgClearFilter=Clears the filter value applied to the actor via the Filter field and the SetFilter message.
EDSTR_ENUMHINT_e_actorMsgClearFilterPlayers=Clears all player id-specific filters on the target actor.  In other words, this message would clear a filter applied to player 3, but not a filter applied to all enemy players.
EDSTR_ENUMHINT_e_actorMsgClearLocalTintColor=Clears any local tint color that has been set on the target actor.  Does not affect any other blended tint colors applied to the actor.  Supports an optional blend out duration.
EDSTR_ENUMHINT_e_actorMsgClearOpacity=Clears a specific named opacity value or all externally set opacities, if no name is supplied.  Supports an optional blend out duration.
EDSTR_ENUMHINT_e_actorMsgClearScale=Clears a specific named scale value or all externally set scales, if no name is supplied.  Supports an optional blend out duration.
EDSTR_ENUMHINT_e_actorMsgClearTeamColor=Clears a specific named team color or all externally set team colors, if no name is supplied.  Supports an optional blend out duration.
EDSTR_ENUMHINT_e_actorMsgClearTintColor=Clears a specific named tint color or all externally set tint colors, if no name is supplied.  Supports an optional blend out duration.
EDSTR_ENUMHINT_e_actorMsgCombatRevealClearTimers=Target: CActorUnit.  Clears all sources of combat reveal on a target CActorUnit.  Combat reveal occurs when an enemy unit (like a sieged Siege Tank) attacks a player's unit from under the fog of war.  The game reveals the attacker temporarily, so the defending player can better understand why his units are taking damage.  This message is typically sent just before a unit teleports so that it does not temporarily stay combat revealed at its arrival location; this might reveal information that defender should not be privvy to.
EDSTR_ENUMHINT_e_actorMsgCombatRevealComplete=Target: CActorUnit.  Clears a particular named source of combat revelation on a target actor.  Enables tentacled-based attacks to clear combat reveal when the tentacle dies.  Spells such as the Infestor's Neural Parasite need to reveal the Infestor while it is controlling a player's unit and the victim player can still see the mind controlled unit.  Otherwise, the tentacle appears to be floating in space, disconnected from a mind controlling Infestor that is under the fog of war.
EDSTR_ENUMHINT_e_actorMsgCreate=Creates a named actor in the scope of the actor to which the message is sent.  Supports up to three optional content parameters that can dynamically configure the actor that the Create message spawns.  For a CActorModel, the first content parameter is a ModelLink specifying the model the CActorModel should create, instead of using whatever value, if any, is in the CActorModel's Model field.  The interpretation of content parameters varies by type of actor, but the first parameter for any asset-managing actor is always a catalog link that specifies the corresponding asset for that actor.
EDSTR_ENUMHINT_e_actorMsgCreateCopy=Like the Create message, the CreateCopy message creates a named actor in the scope of the actor to which the message is sent.  However, the CreateCopy message additionally configures the new actor by copying various specified fields from a source actor.  Data can specify what components of the source actor get duplicated via the newly created actor's AcceptedTransfers and AcceptedHostedPropTransfers fields.
EDSTR_ENUMHINT_e_actorMsgCreepEngulfmentStart=Target: CActorModel.  Tells a CActorModel to begin applying the creep engulfment visual FX.  Creep engulfment causes creep textures to appear to cover the bottom of models (e.g. buildings and sieged Siege Tanks) when they are on terrain that has been covered with creep.  The message includes parameters for configuring where creep engulfment starts vertically, what distance it covers, and then what distance across which it fades away.  This enables data to configure creep engulfment on a per-model basis, so that it crawls dramatically higher on large buildings, while leaving very short buildings (such as a retracted SupplyDepot) with some visually identifying elements not covered by creep.
EDSTR_ENUMHINT_e_actorMsgCreepEngulfmentStartTransition=Target: CActorModel.  Like the CreepEngulfmentStart message, but causes creep engulfment to proceed up the model with a specified rate.  Normally, creep appears on buildings at exactly the rate that the creep spreads to the surrounding vicinity.  In other words, when creep expands into a cell, it covers a building in that cell exactly as the terrain texture appears.  But in cases like a Siege Tank deploying on creep, this would lead to the creep instantly appearing on the tank as soon as it deployed, because the creep is already totally present on that cell.  In these situations, it is preferable to use the CreepEngulfmentStartTransition message to show the creep crawling up the Siege Tank as soon as it is done deploying.
EDSTR_ENUMHINT_e_actorMsgCreepEngulfmentStop=Target: CActorModel.  Tells a CActorModel to stop applying the creep engulfment visual FX.  Typically sent to a unit when creep recedes out of its vicinity, so as to not waste resources on FX that are no longer able to appear.
EDSTR_ENUMHINT_e_actorMsgCreepEngulfmentStopTransition=Target: CActorModel.  Tells a CActorModel to stop applying the creep engulfment visual FX, but with a transition that causes the creep to slide down the side of the model into the ground.  For instance, this message causes creep to appear to slide off of Terran buildings that lift of from a creep covered area.
EDSTR_ENUMHINT_e_actorMsgDeathCustomize=Target: CActorUnit.  Sent as a response to the UnitDeathCustomize message, as a way to pick a specific named custom death that matches the circumstances of the unit's death.  For example, to specify a specific blood burst death model for biological units that are killed while being held aloft by the Phoenix's Graviton Beam spell (without this, some units would appear to fall over in the middle of the air).
EDSTR_ENUMHINT_e_actorMsgDeathCustomsDump=Target: CActorUnit.  Lists all of the custom deaths that are associated with the target CActorUnit.  Useful for seeing the actual list of deaths applicable to a unit, given that the deaths can come from a range of sources, including the CActorUnit's definition, its parent actor definitions, or from a global list in CActorGlobalConfig.
EDSTR_ENUMHINT_e_actorMsgDeathCustomsEnablePhysics=Target: CActorUnit.  Turns physics deaths off (or back on) on the target CActorUnit.  For instance, this message is used to prevent campaign Dark Protoss units from triggering physics deaths with regular (light) Protoss death models.
EDSTR_ENUMHINT_e_actorMsgDeathSequencePrepare=Target: CActorUnit.  Enables triggers to manually trigger a CActorUnit's death sequence for cases where the unit appears to die, but is actually merely inactive and will potentially later be resurrected (e.g. a zombie that gets up after being 'killed', or a hero unit that later returns after being killed).  In this custom death case, the death sequence as is follows:  1) client code sends the DeathSequencePrepare message to the target CActorUnit from triggers, 2) the system sends the UnitDeathCustomize to the dying unit's CActorUnit, 3) client data responds by selecting the desired death via the DeathCustomize message from the CActorUnit's data (or even from triggers), 4) client code sends the DeathSequenceExecute message from triggers, and 5) the system sends the UnitDeath message to the dying CActorUnit, officially triggering the specified custom death art and FX.  The DeathSequencePrepare message and the entire custom death sequences are typically unnecessary when using revive-related functionality such as the UnitRevive trigger, since routines such as these can be used even when a unit dies normally.
EDSTR_ENUMHINT_e_actorMsgDeathSequenceExecute=Target: CActorUnit.  Tells the target CActorUnit to execute a manual death sequence because the appropriate specific custom death has been chosen and it is time to trigger its associated death models and FX.  See the DeathSequencePrepare message tooltip for an enumeration of the steps in the custom death sequence and where the DeathSequenceExecute message fits within that sequence.
EDSTR_ENUMHINT_e_actorMsgDestroy=Destroys the target actor.  This sends the ActorDestruction message to data and then purges the actor from memory soon afterwards.  The optional parameter to the message controls the timing of the actual destruction or the removal of assets controlled by the target actor.
EDSTR_ENUMHINT_e_actorMsgDestroyParticles=Target: CActorModel.  Immediately removes all of the individual particles created by particle systems within the model owned by the target CActorModel.  Used to clear extraneous FX in cinematics before a camera cut, for instance, when a scene displays a burning building, and then immediately afterwards shows the building several hours later after the fire has burned out.  Without being able to immediately eliminate particles, the building in the second shot might appear with several lingering bits of fire in the air near it.
EDSTR_ENUMHINT_e_actorMsgDestroyRibbons=Target: CActorModel.  Immediately removes all of the individual ribbons created within the model owned by the target CActorModel.  As with the DestroyParticles message, this message is frequently used to clear extraneous FX in cinematics before a camera cut.
EDSTR_ENUMHINT_e_actorMsgDoodadPreserve=Target: CActorDoodad.  Tells a doodad that is going to be visually changed (e.g. trees being set on fire by Nukes or bushes being poisoned by creep) to preserve its exact appearance if it is under the fog of war.  This causes the doodad to be appear unmolested to players with no nearby units, so that those players cannot unfairly know where Zerg creep is spreading through the fog of war (for instance).  Doodads that a player can see are unaffected by this message.
EDSTR_ENUMHINT_e_actorMsgEventMacroRun=Executes the messages in a CActorEventMacroRunnable macro.  The terms field enables the macro to test conditions to determine whether to send a given message.
EDSTR_ENUMHINT_e_actorMsgExternalFinderAdd=Adds an actor to the external finder, which enables it to be seen by actor requests from any actor in any actor scope anywhere within the same scene.  This is useful for enabling any actor to get references to well known global actors without having to maintain separate global references.  When added to the external finder, the actor can be referenced by its link name or any of its aliases, as long as they are prefaced with '::external.' (e.g. '::external.SMRaynor').
EDSTR_ENUMHINT_e_actorMsgExternalFinderRemove=Removes an actor from the external finder, so that it can no longer be found via that system.  Useful for ensuring that the external finder namespace does not become polluted by names referring to actors that no longer exist.
EDSTR_ENUMHINT_e_actorMsgFilterUpdate=Manually commands an actor to update its visibility filters, almost always in response to a UnitPlayerChange message.  Visibility filters control which players can see a particular actor, which is useful for spell AoE indicators (such as the Nuke AoE) that should only be visible to the casting player or some other subset of players.  Actors can be marked to automatically respond to this message via the 'RespondsToUnitPlayerChange' EActorFlag value.
EDSTR_ENUMHINT_e_actorMsgForceSetAngle=Target: CActorForceConeRoundedEnd.  Controls the arc covered by a target CActorForceConeRoundedEnd.  The CActorForceConeRoundedEnd actor applies a physics force in a volume shaped like an ice cream cone, where the point of the cone is at the center of an imaginary sphere with a radius equivalent to the height of the cone, and the rounded part of the cone is a circular region on the surface of the sphere.  The angle directly controls the radius of this circular region.
EDSTR_ENUMHINT_e_actorMsgForceSetHeight=Target: CActorForceBox.  Sets the height of the box, which is its size from end-to-end along the Z axis.  An optional blend parameter enables the force to transition to this height smoothly over time.
EDSTR_ENUMHINT_e_actorMsgForceSetLength=Target: CActorForceBox.  Sets the length of the box, which is its size from end-to-end along the Y axis.  An optional blend parameter enables the force to transition to this length smoothly over time.
EDSTR_ENUMHINT_e_actorMsgForceSetMagnitude=Target: CActorForce.  Sets the maximum strength of the force field, which is how much push it exerts on physics objects caught in its field.  A force with the FallOff ForceFlag exhibits diminishing force strengths that are less than the magnitude specified by this message at points that are increasingly distant from the force field's center (this varies across force types).
EDSTR_ENUMHINT_e_actorMsgForceSetRadius=Target: CActorCylinder, CActorSphere.  Sets the radius of the target force actor, which controls how much volume is affected by the force field emitted by the actor.
EDSTR_ENUMHINT_e_actorMsgForceSetWidth=Target: CActorForceBox.  Sets the width of the box, which is its size from end-to-end along the X axis.  An optional blend parameter enables the force to transition to this width smoothly over time.
EDSTR_ENUMHINT_e_actorMsgGlowStart=Target: CActorModel.  Starts a pulsing light and dark tinting cycle on the target model.  Useful for highlighting models to the player.
EDSTR_ENUMHINT_e_actorMsgGlowStop=Target: CActorModel.  Stops a glow started by the GlowStart message.
EDSTR_ENUMHINT_e_actorMsgHaloClearColor=Target: CActorModel.  Reverts an individual model's override halo color back to the default halo color for all models.  The default halo color is set by the engine to gold, but this can be overridden by sending the SceneHaloSetColor message to the ::Scene actor.
EDSTR_ENUMHINT_e_actorMsgHaloSetColor=Target: CActorModel.  Sets the color of the halo on an individual model.  Without sending this message, a model's halo uses the default global halo color.
EDSTR_ENUMHINT_e_actorMsgHaloSetColorFromAllianceType=Target: CActorModel.  Sets the color of the halo on the model based on the relationship between its owning player id and the player id of the local player.  For instance, 'HaloSetColorFromAllianceType Enemy' typically sets the halo color to red.  The colors chosen by each filter type can be modified from the defaults via the OverrideColors field in GameUIData.xml.  If color blind mode is on, the colors this message chooses are from the ColorBlindColors field in GameUIData.xml, but only when the game is in alliance color mode.
EDSTR_ENUMHINT_e_actorMsgHaloStart=Target: CActorModel.  Starts displaying a halo on the target model.  A halo is a colored outline that wraps around the edges of the owning model, which can sidestep the visual clutter associated with selection circles.  Various SceneHaloSet messages can be used to specify the width, color and strobe frequency used by all halos, in the absence of more specific settings having been applied on a per-model basis.
EDSTR_ENUMHINT_e_actorMsgHaloStop=Target: CActorModel.  Stops a halo started by the HaloStart message from displaying on the target model.
EDSTR_ENUMHINT_e_actorMsgHideWorkerCount=Target: CActorUnit.  Prevents units like the Command Center and Vespene Geyser harvesting buildings from displaying the number of workers using them for harvesting.
EDSTR_ENUMHINT_e_actorMsgHostedPropDump=Outputs the specified hosted prop's details on the target actor.  When true, the IncludeChildren parameter specifies to output the hosted prop details for the target actor and all its children.
EDSTR_ENUMHINT_e_actorMsgHostedPropDumpAll=Outputs the current details for all hosted props on the target actor.  When true, the IncludeChildren parameter specifies to output hosted prop values for the target actor and all its children.
EDSTR_ENUMHINT_e_actorMsgHostSetOffset=Target: CActorBearings.  Configures a host field on the target actor to host off the actor specified in the message parameters, but with extra parameters that make it easy to add position and rotation offsets without additional data.  An optional final parameter allows the addition of further siteOps after the position and rotation offsets, as necessary.
EDSTR_ENUMHINT_e_actorMsgHostSiteOpsSet=Target: CActorBearings.  Dynamically sets or replaces the siteOps on a host.  For instance, this enables client data to remove a weapon model attached to a unit's hand and position it on the ground.
EDSTR_ENUMHINT_e_actorMsgHostSiteOpsAdd=Target: CActorBearings.  Dynamically adds a siteOp to the head or tail of an existing siteOp chain on the specified host.
EDSTR_ENUMHINT_e_actorMsgHostSiteOpsRemove=Target: CActorBearings.  Dynamically removes a siteOp from the head or tail of an existing siteOp chain on the specified host.
EDSTR_ENUMHINT_e_actorMsgLightSetAmbientOcclusion=Target: CActorLight.  Determines whether a light is affected by ambient occlusion when it produces shadows.  This applies to both static texture-based ambient occlusion as well as dynamic screen space ambient occlusion (SSAO).  Ambient occlusion of any kind requires the extreme shaders graphics setting.
EDSTR_ENUMHINT_e_actorMsgLightSetAttenuationStart=Target: CActorLight.  Sets the distance at from the light source point at which which the light begins to fade away from maximum brightness.  Attenuation starts before the light's Range value and causes light intensity to reach zero at the Range of the light.
EDSTR_ENUMHINT_e_actorMsgLightSetColorMultiplier=Target: CActorLight.  Effectively sets the intensity of the light.  A value of zero disables the light, values below 1.0 are dim, and values above 1.0 have extra intensity.
EDSTR_ENUMHINT_e_actorMsgLightSetFalloff=Target: CActorLight.  Only applies to spot lights.  Sets the distance radially at which the spot light is fully dimmed.  In other words, attenuation affects the intensity of the light when moving parallel to the direction of the light, whereas falloff affects the intensity of the light when moving perpendicular to the direction of the light.
EDSTR_ENUMHINT_e_actorMsgLightSetHotspot=Target: CActorLight.  Only applies to spot lights.  Sets the size of the bright spot in the center of the spot light before the light begins to fall off.
EDSTR_ENUMHINT_e_actorMsgLightSetLightOpaque=Target: CActorLight.  Determines whether the light affects opaque materials.
EDSTR_ENUMHINT_e_actorMsgLightSetLightTransparent=Target: CActorLight.  Determines whether the light affects transparent materials.
EDSTR_ENUMHINT_e_actorMsgLightSetRange=Target: CActorLight.  For omni lights, sets the radius within which objects are affected by the light.  For spot lights, sets the distance between the point and end cap of the light's cone of effect.
EDSTR_ENUMHINT_e_actorMsgLightSetShadowCasting=Target: CActorLight.  Only applies to spot lights.  Determines whether the light casts shadows.  Requires the medium lighting setting or higher.
EDSTR_ENUMHINT_e_actorMsgLightSetSpecular=Target: CActorLight.  Determines whether light causes specular highlights.  Requires the ultra lighting setting.
EDSTR_ENUMHINT_e_actorMsgLightSetSpecularColor=Target: CActorLight.  Sets the color of the specular highlight created by the light.  This requires the specular setting to be enabled on the light as well as the ultra lighting setting.
EDSTR_ENUMHINT_e_actorMsgMessageForward=Target: CActor.  Sends whatever message was received to the target actor.  Useful for things like forwarding animation messages to child actors.
EDSTR_ENUMHINT_e_actorMsgSetFilter=Dynamically sets the filter value applied to the actor via the Filter field at creation time.  The filter value is one of a number of contributing values (including VisibleTo, FilterPlayers, VisibleToPlayers, FilterAtCreation, VisibleToAtCreation) that specifies how an actor will appear to its owner, allies, neutrals and enemies and/or individual players.
EDSTR_ENUMHINT_e_actorTermPlayerId=Returns true if the target actor's controlling player Id falls within the specified range (inclusive).  An optional actor refKey can be provided to test against an arbitrary actor rather than the one with the event containing the term.
EDSTR_ENUMHINT_e_actorFilterSelf=When on, prevents the actor from being seen by its owning player.
EDSTR_ENUMHINT_e_actorFilterAlly=When on, prevents the actor from being seen by allied players.
EDSTR_ENUMHINT_e_actorFilterNeutral=When on, prevents the actor from being seen by neutral players.
EDSTR_ENUMHINT_e_actorFilterEnemy=When on, prevents the actor from being seen by enemy players.
EDSTR_ENUMHINT_e_actorFilterAll=When on, prevents the actor from being seen by anyone.  Typically used to mask an actor from everyone, followed by several player-specific unmask operations.  (It is less data to filter out all players and then un-filter two than it is to filter 14 players individually.)
EDSTR_ENUMHINT_e_actorVisibilityAtCreationCaster=The effect caster.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationSource=The effect source.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationTarget=The effect target.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationCasterAlly=Allies of the effect caster.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationSourceAlly=Allies of the effect source.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationTargetAlly=Allies of the effect target.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationCasterNeutral=Players that are neutral to the effect caster.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationSourceNeutral=Players that are neutral to the effect source.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationTargetNeutral=Players that are neutral to the effect target.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationCasterEnemy=Enemies of the effect caster.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationSourceEnemy=Enemies of the effect source.
EDSTR_ENUMHINT_e_actorVisibilityAtCreationTargetEnemy=Enemies of the effect target.
EDSTR_ENUMHINT_e_animSetTimeFromCloakChangeStart=Set the animation time to progress into the animation by the amount of time that has elapsed since the last cloak change on the CActorUnit.
EDSTR_ENUMHINT_e_animSetTimeFromMorphStart=Set the animation time to progress into the animation by the amount of time that has elapsed since the commencement of the last morph on the CActorUnit.
EDSTR_ENUMHINT_e_animSetTimeFlagScaled=When on, the time that is being sent is already in scaled time.  So a time of one second that is scaled sent into an animation that is two seconds long unscaled, but has a time scale of 0.5, means that the animation will be set to have progressed 25% of its duration.  When off, this option means that time is being sent into the animation unscaled.  So, a time of one second sent into an animation that is two seconds long would set the animation to have progressed 50% of its duration, regardless of what its time scale is.
EDSTR_ENUMHINT_e_animSetTimeFlagTriggerEventsOnScrub=When on, triggers any intervening events (such as ModelData events) built into the animation when it play time is changed.  In other words, when an animation play time is changed from A to B, this option ensures that the animation system fires off all that animation's events between A and B.  When off, changing the animations play time does not fire any events.
EDSTR_ENUMHINT_e_animTimeVariantAsAutomatic=Ignore the TimeVariant field and simply play the animation without any animation-specific time scaling.
EDSTR_ENUMHINT_e_animTimeVariantAsDuration=Interpret the TimeVariant field as a duration.  When the number in the TimeVariant field is twice as long as the duration of the animation being played, it effectively means to play the animation with a time scale of 0.5.
EDSTR_ENUMHINT_e_animTimeVariantAsTimeScale=Interpret the TimeVariant field as a time scale.  A fractional time scale means time is traveling at fractional speed, so it takes longer for the animation to complete.
EDSTR_ENUMHINT_e_animTimeVariantAsTimeScaleAbsolute=Interpret the TimeVariant field as an absolute time scale.  An animation played with an absolute time scale plays at that time scale regardless of the global time scale applied to the model.
EDSTR_ENUMHINT_e_animTransitionFlagInstant=When on, means transition the animation in or out instantly.  For instance, when on in the AnimBracketStart message, it means jump immediately to the end of the Opening animation and start playing the Content animation immediately.
EDSTR_ENUMHINT_e_animBracketStartFlagClosingFull=When on, specifies that the bracket animation should play its closing animation fully, regardless of whether it was still in its opening animation.  Useful when opening and closing animations are not mirror images of one another.  When off, a bracket animation plays its closing animation starting at a point that matches its progress into the opening animation (known as a rebounding bracket animation).  If the bracket got 25% of the way into opening a door, when it was told to close, a rebound bracket animation would start its closing door animation 75% of the way to completion.
EDSTR_ENUMHINT_e_animBracketStartFlagContentNonLooping=When on in conjunction with the ContentPlayOnce flag being off, indicates that the content animation is to play once and then hold in place on the final frame of the animation, until an AnimBracketStop message is sent.
EDSTR_ENUMHINT_e_animBracketStartFlagContentPlayOnce=When on, signifies that the content animation should be played just once.  When off, the content animation plays until the AnimBracketStop message is sent.
EDSTR_ENUMHINT_e_animBracketStartFlagOpeningPlayForever=When on, plays the opening animation until an AnimBracketStop message is sent.  Serves as a way to make bracket animations without a content animation; instead, the opening animation holds on its last frame and serves as a makeshift content animation.  When off, the opening animation finishes as normal and transitions to whatever animation is next, whether content or closing.
EDSTR_ENUMHINT_e_animBracketStartFlagInstant=When on, skips the opening animation and jumps straight to the content animation.  Useful in situations like when a map creates a flying Barracks at map initialization -- in this scenario the Barracks needs to appear to be flying instantly, rather than appearing as if it is transitioning to flying by lifting off.  This would not be possible without the ability to suppress the transitioning open animation that shows the Barracks lifting off and starting to fly.
EDSTR_ENUMHINT_e_animBracketStartFlagFullMatch=When on, indicates that the anim props specified in the anim bracket are to find matching animations with FullMatch semantics.  This means that a bracket animation must have exactly the same props, excluding variations, as the props in the anim bracket messages.  This makes it possible to avoid accidentally matching unintended animations.  For example, when a model has an animation like GLstand, B, and no GLstand, and the situation calls for playing a GLstand animation if it is there, but not GLstand, B unless a global anim prop B has specifically been added.  Without FullMatch, it would not be possible for GLstand to avoid GLstand, B if no B global anim group prop had been added.
EDSTR_ENUMHINT_e_animBracketStartFlagNoMismatchQueryProps=When on, indicates that the anim props specified in the anim bracket are to find matching animations with NoMismatchQueryProps semantics.  This means that a bracket animation is an animation where the resulting animation doesn't have any props that aren't specified in the query anim props (disregarding variation props), but the query anim props may have anim props that are not present in the resulting animation.
EDSTR_ENUMHINT_e_animBracketStateExitReasonCleared=The animation bracket state finished because the actor received the AnimBracketClear message.
EDSTR_ENUMHINT_e_animBracketStateExitReasonComplete=The animation bracket state finished because it completed normally.
EDSTR_ENUMHINT_e_animBracketStateExitReasonModelSwap=The animation bracket state finished because a model swap canceled the animation.  This case is not treated as a clear, because it is frequently necessary to keep the bracket animation running after the model swap.  It is common for data to kill an actor when its bracket animation is done, and it is necessary to be able to differentiate the model swap case so as not to do this.
EDSTR_ENUMHINT_e_animGroupApplyFlagClosingFull=When on, specifies that the bracket animation should play its closing animation fully, regardless of whether it was still in its opening animation.  Useful when opening and closing animations are not mirror images of one another.  When off, a bracket animation plays its closing animation starting at a point that matches its progress into the opening animation (known as a rebounding bracket animation).  If the bracket got 25% of the way into opening a door, when it was told to close, a rebound bracket animation would start its closing door animation 75% of the way to completion.
EDSTR_ENUMHINT_e_animGroupApplyFlagInstant=When on, skips the opening animation and jumps straight to whatever animations are trigged by the addition of the new animation property group.  Useful in situations like when a map creates a flying Barracks at map initialization -- in this scenario the Barracks needs to appear to be flying instantly, rather than appearing as if it is transitioning to flying by lifting off.  This would not be possible without the ability to suppress the transitioning open animation that shows the Barracks lifting off and starting to fly.
EDSTR_ENUMHINT_e_actorBaselineStateStand=Any standing baseline.
EDSTR_ENUMHINT_e_actorBaselineStateWalk=Any walking baseline, whether WalkIntro (Walk Start), WalkMiddle or WalkOutro (Walk Stop).
EDSTR_ENUMHINT_e_actorBaselineStateWalkIntro=The Walk Start part of the Walk baseline animation.
EDSTR_ENUMHINT_e_actorBaselineStateWalkMiddle=The middle part of the walk animation that is neither the Walk Start nor the Walk Stop.
EDSTR_ENUMHINT_e_actorBaselineStateWalkOutro=The Walk Stop part of the Walk baseline animation.
EDSTR_ENUMHINT_e_actorBlendBounce=The color blend bounces back and forth between two colors, for example by shifting gradually from red to blue and then shifting gradually back to red again.
EDSTR_ENUMHINT_e_actorBlendCycle=The color blend cycles between two colors, for example by shifting from red to blue, then jumping immediately back to red and starting the process again.
EDSTR_ENUMHINT_e_actorBlendOneShot=The color blend happens a single time gradually from one color to the next.
EDSTR_ENUMHINT_e_textureSelectByUpdateLinkOpAppend=Append a string to the TextureLink currently assigned to a texture slot.  This changes the texture link, which causes a different texture to be loaded.
EDSTR_ENUMHINT_e_textureSelectByUpdateLinkOpReplace=Replaces a substring in the TextureLink currently assigned to a texture slot with another substring, changing the texture link and causing a different texture to be loaded.  Example: changing 'Decal_0001' to 'Background_0001'.
EDSTR_ENUMHINT_e_texturePropsOpContainsAll=True if a set of texture props contains all of the submitted texture props.
EDSTR_ENUMHINT_e_texturePropsOpContainsAny=True if a set of texture props contains all of the submitted texture props.
EDSTR_ENUMHINT_e_texturePropsOpEquals=True if a set of texture props has exactly the same props (no more, and no less) as the submitted texture props.
EDSTR_ENUMHINT_e_textureVideoPlayFlagLooping=Play the texture video in a continuous loop, repeating after each play through.
EDSTR_ENUMHINT_e_textureVideoPlayFlagSynced=Configures the texture video to skip frames if it cannot keep up with the rate at which sounds (or the game in general) are playing.
EDSTR_ENUMHINT_e_textureVideoSound2D=Play sound without any spatialization FX.
EDSTR_ENUMHINT_e_textureVideoSound3DAtAttach=Sound plays at the position of a specified attach point (via an associated attach query) on the containing model.
EDSTR_ENUMHINT_e_textureVideoSound3DAtOrigin=Sound plays at the origin of the containing model.
EDSTR_ENUMHINT_e_textureVideoSoundNone=Sound is muted on the texture video.
EDSTR_ENUMHINT_e_timeSourceGameTime=Game time drives the property's animation.  When the game is paused, the animation is paused.
EDSTR_ENUMHINT_e_timeSourceRealTime=Real world time drives the property's animation.  When the game is paused, the animation is not paused.
EDSTR_ENUMHINT_e_actorResponseScopeQueryDirector=Send the response message to the actor that received the query message.
EDSTR_ENUMHINT_e_actorResponseScopeQuerySubject=Send the response message to the actors that are the results of the query.
EDSTR_ENUMHINT_e_actorScopeFlagDisableSoundEmitters=Tests the corresponding scope flag, which enables an editor user to turn off sound emitters on specific doodads.
EDSTR_ENUMHINT_e_actorThresholdTestBelow=Return true if value the term is testing is below the term's input value.
EDSTR_ENUMHINT_e_actorThresholdTestAbove=Return true if value the term is testing is equal to or above the term's input value.
EDSTR_ENUMHINT_e_actorRefSpaceAny=Intended to represent any ref space.  Not currently used.
EDSTR_ENUMHINT_e_actorRefSpaceGlobal=Refers to the global ref table, which is a single ref space that any actor can reference at any time.
EDSTR_ENUMHINT_e_actorRefSpaceScope=Refers to a scope's ref table, which is a ref space that is shared by all actors within the scope.
EDSTR_ENUMHINT_e_actorRefSpaceActor=Refers to an actor's ref table, which is a ref space that enables an actor to store references to other actors within itself.
EDSTR_ENUMHINT_e_actorHostSiteOpsRemoveDelayDelay=Delay the removal of the site op until it is ready to be removed.  This can prevent visual glitches in some circumstance, like when CActorSiteOpTilter needs to finish tilting a unit upright for a brief moment after an ability that causes tilting is complete.
EDSTR_ENUMHINT_e_actorHostSiteOpsRemoveDelayImmediate=Removes the site op immediately, regardless of whether it causes visual glitches.  The preferred option for the vast majority of site ops.
EDSTR_ENUMHINT_e_actorHostSiteOpsListPositionTail=Add or remove the site op at the end of the site op chain.
EDSTR_ENUMHINT_e_actorHostSiteOpsListPositionHead=Add or remove the site op at the beginning of the site op chain.
EDSTR_ENUMHINT_e_actorIntersectAgainstCenter=An actor is found by the query if its center is within the query region.
EDSTR_ENUMHINT_e_actorIntersectAgainstRadiusContact=An actor is found by the query if its contact radius intersects the query region.  (For a tree, the contact radius might be the radius of its trunk, instead of the radius of its crown of leaves, since the trunk is what game units would 'contact'.)
EDSTR_ENUMHINT_e_actorIntersectAgainstRadiusGame=An actor is found by the query if its synchronous game radius intersects the query region.
EDSTR_ENUMHINT_e_actorIntersectAgainstRadiusVisual=An actor is found by the query if its visual radius intersects the query region.  (For a tree, the visual radius might be its crown of leaves, since it would be useful to treat the tree as 'seen' as soon as one of its leaves came into view.)
EDSTR_ENUMHINT_e_actorScopeEffect=A scope containing all the FX for a game Effect tree triggered by an ability, a behavior, or some other source.
EDSTR_ENUMHINT_e_actorScopePortrait=A scope containing actors that display the visuals of a portrait window, whether it is the game portrait at the bottom of a screen or a popup portrait during the campaign.
EDSTR_ENUMHINT_e_actorScopeSnapshot=A scope the contains a snapshot and all the relevant visuals copied from the corresponding unit's scope.  Maintained separately from the unit scope for clarity, simplicity and cleanliness.
EDSTR_ENUMHINT_e_actorScopeStandalone=A catch-all scope category for a variety of scopes created throughout the game.  Examples includes scope that contain cursors, waypoints, placeholders, and the like.
EDSTR_ENUMHINT_e_actorScopeUnit=A scope associated with a game unit that contains a variety of unit-related actors like the unit itself, selection cursors, auras, buff art, unit sounds, death models and many others.
EDSTR_ENUMHINT_e_actorScopeUnitEditor=A scope that contains the representation of an actor in the Editor.
EDSTR_ENUMHINT_e_actorRequestScopeImplicit=When a request's Actor field is 'Create': this creates the actor in the creating actor's scope.  When the request's Actor field is 'Find': the behavior is as follows.  If the requesting actor was not created by an effect, the request looks in the requestor's owning scope.  If the requestor was created by an effect, the request looks in the effect tree's scope and all of its 'friend' scopes (friend scopes are the scopes of units that are somehow connected to the effect, typically because they are its targets).  It is possible to match against actors that are neither main actors, nor created by effects, but not actors created by other effects, unless they are missiles that are targets of an effect like a point defense laser.  While complex sounding, this option usually 'just works' and returns the most expected actor.
EDSTR_ENUMHINT_e_actorRequestScopeCaster=When a request's Actor field is 'Create': requires the creator to have been created by an effect.  Creates the actor in the caster scope of the effect that created the requesting actor, unless an Effect value is specified, then it can be any caster scope in the effect tree with respect to that effect name.  The effect must be in the requestor's effect ancestry, or it is ambiguous.  When the request's Actor field is 'Find': looks across all caster scopes in the effect tree.
EDSTR_ENUMHINT_e_actorRequestScopeCasterOuter=When a request's Actor field is 'Create': similar to 'Caster' but specifies the containing scope (i.e. a Medivac or a Bunker's scope, as opposed to the Marines inside it), if it exists.  When the request's Actor field is 'Find': similar to 'Caster', but specifies the containing scope.
EDSTR_ENUMHINT_e_actorRequestScopeEffect=When a request's Actor field is 'Create': creates the actor in the effect effect scope.  The request Effect field is unnecessary, since there is only one effect tree scope.  When the request's Actor field is 'Find': requires the requestor to have been created by an effect.  Looks only in the effect tree scope itself.
EDSTR_ENUMHINT_e_actorRequestScopeMissile=When a request's Actor field is 'Create': same as 'Caster', but only creates in missile scopes.  When the request's Actor field is 'Find': same as 'Caster', but only looks in missile scopes.
EDSTR_ENUMHINT_e_actorRequestScopeOuter=Same as 'SourceOuter'.  When a request's Actor field is 'Create': same as 'Caster', but only creates in source outer scopes.  When the request's Actor field is 'Find': same as 'Caster', but only looks in source outer scopes.
EDSTR_ENUMHINT_e_actorRequestScopeSource=When a request's Actor field is 'Create': same as 'Caster', but only creates in source scopes.  When the request's Actor field is 'Find': same as 'Caster', but only looks in source scopes.
EDSTR_ENUMHINT_e_actorRequestScopeTarget=When a request's Actor field is 'Create': same as 'Caster', but only creates in target scopes.  When the request's Actor field is 'Find': same as 'Caster', but only looks in target scopes.
EDSTR_ENUMHINT_e_actorRequestScopeTargetOuter=When a request's Actor field is 'Create': same as 'Caster', but only creates in target outer scopes.  When the request's Actor field is 'Find': same as 'Caster', but only looks in target outer scopes.
EDSTR_ENUMHINT_e_actorRequestActorImplicit=Identical to the Find option.  It is more common to find actors through requests than to create them.
EDSTR_ENUMHINT_e_actorRequestActorCreate=Create the specified actor in whatever scope is specified by the other parameters in the request.
EDSTR_ENUMHINT_e_actorRequestActorFind=Find the specified actor in whatever scopes are specified by the other parameters in the request.
EDSTR_ENUMHINT_e_actorHostedPropBaseModelScale=BaseModelScale enables artists and designers to quickly modify the scale of an in game model by modifying its ModelData.xml entry, rather than going to MAX and re-exporting the art.  This is very useful, though it has some unexpected consequences.  For instance, it would be useful to have a model with a baseModelScale be treated as if it were the 'real' object at scale 1; i.e. if a user sets its scale to 2 the system should not lose the baseModelScale if the user decides to scale of the object's CActorModel back to 1.  The user would expect the model to go back to its original baseModelScale scale, not the actual MAX scale of 1.  This means it is not possible to simply incorporate BaseModelScale into the main Scale hosted prop -- it must be kept separate, so it can easily be removed or added as necessary.  As an other example, if the user hosts a Zealot of of itself, he'd expect the models to both be the same size, rather than having the hosted one be a different size -- but this is exactly what happens if baseModelScale isn't stripped from the multiplication chain -- the child Zealot model is a different size than the parent model.   On the other hand, inheriting baseModelScale is perfectly appropriate for cases like splats, where the user typically wants to scale the splat to the model above it, including baseModelScale.
EDSTR_ENUMHINT_e_actorHostedPropCastShadows=Determines whether a model casts shadows or not.  This is useful for UI-oriented models in the game world, since it can be visually confusing if they cast shadows.
EDSTR_ENUMHINT_e_actorHostedPropCloakEffect=Determines the kind of cloaking FX displayed by the model.  A cloaked unit looks different to allies and enemies, and has another set of visuals when it is detected by enemies.
EDSTR_ENUMHINT_e_actorHostedPropCreepEngulfment=Controls whether a model has creep appear on its surface, if creep is on the terrain beneath the model.
EDSTR_ENUMHINT_e_actorHostedPropDecal=Enables hosted models to inherit the decal textures of the models off of which they are hosted.
EDSTR_ENUMHINT_e_actorHostedPropLocalTintColor=Adds a tint color to an actor that only shows for the local player.
EDSTR_ENUMHINT_e_actorHostedPropOpacity=Controls the alpha value of the actor.  Supports multiple parallel named animated opacities simultaneously, so that multiple clients (engine code or user data) can affect an actor's transparency without interfering with one another.
EDSTR_ENUMHINT_e_actorHostedPropScale=Controls the scale of the actor.  Supports multiple parallel named, animated, blended scales simultaneously, so that multiple clients (engine code or user data) can affect an actor's scale without interfering with one another.
EDSTR_ENUMHINT_e_actorHostedPropTeamColor=Controls the team color of the actor.  Supports multiple parallel named, animated, blended team colors simultaneously, so that multiple clients (engine code or user data) can affect an actor's team color without interfering with one another.
EDSTR_ENUMHINT_e_actorHostedPropTimeScale=Enables an actor to inherit the global animation time scale from another actor.  Supports multiple parallel named global time scales simultaneously, so that multiple clients (engine code or user data) can affect the actor's animation time scale without interfering with one another.  This means a spell can temporarily increase a unit's apparent speed without having to restore upon completion whatever time scale existed on the actor before the spell was cast.
EDSTR_ENUMHINT_e_actorHostedPropTintColor=Controls the tint color of the actor.  Supports multiple parallel named, animated, blended tint colors simultaneously, so that multiple clients (engine code or user data) can affect an actor's tint color without interfering with one another.  Can be used to create many types of exotic strobing visual FX.
EDSTR_ENUMHINT_e_actorHostedPropVisibility=Determines whether a model appears or not.  An invisible unit does not render at all.
EDSTR_ENUMHINT_e_actorHostedPropWarpGroup=Enables a child actor in a unit's scope to be warped by the Vortex distortion FX, if it inherits from its parent CActorUnit.
EDSTR_ENUMHINT_e_actorViewerTreatsAsDetected=Returns true if the unit in the scope in which the ViewerTreatsUnitAs term is run is being observed as detected from the viewing player's perspective.  Used to tint detected Hallucinations.
EDSTR_ENUMHINT_e_actorValidateUnitFlagIncludeDerivedSnapshot=Enables the ValidateUnit term to function even when the underlying synchronous game unit is not present.  It is probably always better to use this flag, but it is optional to ensure legacy compatibility.
EDSTR_ENUMHINT_e_actorTransitionIn=Transition in the rocking motion, increasing it from nonexistent to fully in effect.
EDSTR_ENUMHINT_e_actorTransitionOut=Transition out the rocking motion, decreasing it from full effect to nonexistent.
EDSTR_ENUMHINT_e_actorEffectScopeCaster=Returns true if used the caster's scope.
EDSTR_ENUMHINT_e_actorEffectScopeCasterOuter=Returns true if used in either the caster's container's scope (e.g. a Bunker's scope instead of the scope of the Marine inside the Bunker), if it exists, or the caster's scope itself.
EDSTR_ENUMHINT_e_actorEffectScopeEffect=Returns true if used in the effect tree's scope.
EDSTR_ENUMHINT_e_actorEffectScopeMissile=Returns true if used in the missile's unit scope, provided the corresponding effect fired a missile.
EDSTR_ENUMHINT_e_actorEffectScopeOuter=Returns true if used in either the source's container's scope (e.g. a Bunker or a Medivac) scope, if it exists, or the source's scope itself.
EDSTR_ENUMHINT_e_actorEffectScopeOuterContainer=Returns true if used in the source's container's scope.
EDSTR_ENUMHINT_e_actorEffectScopeSource=Returns true if used in the source's scope.
EDSTR_ENUMHINT_e_actorEffectScopeSourceInside=Returns true if used inside the source's scope, but only if the source is currently inside a container, like a Bunker or a Medivac.
EDSTR_ENUMHINT_e_actorEffectScopeSourceOutside=Returns true if used inside the source's scope, but only if the source is currently not inside any container units, like a Bunker or a Medivac.
EDSTR_ENUMHINT_e_actorEffectScopeTarget=Returns true if used in the target's scope.
EDSTR_ENUMHINT_e_actorEffectScopeTargetOuter=Returns true if used in either the target's container's scope (e.g. a Bunker's scope instead of the scope of the Marine inside the Bunker), if it exists, or the target's scope itself.
EDSTR_ENUMHINT_e_actorCameraShakeTargetPlayerOwner=The owner of the actor receiving the camera shake message is the only player to witness the camera shake.
EDSTR_ENUMHINT_e_actorCameraShakeTargetPlayerAll=All players witness the camera shake.
EDSTR_ENUMHINT_e_actorGameLocal=Confirmation message is asynchronous.
EDSTR_ENUMHINT_e_actorGameSync=Confirmation message is synchronous.
EDSTR_ENUMHINT_e_actorPropertyCurveCameraEyePosition=The position of the scene's camera.
EDSTR_ENUMHINT_e_actorPropertyCurveCameraParams=Any of a range of parameters governing the camera's operation, as specified by the ECameraParams enum.  Include values like FieldOfView, DepthOfField, FocalDepth, and orientation Yaw, Pitch, and Roll.
EDSTR_ENUMHINT_e_actorPropertyCurveOffset=The x, y and z components of an offset to the actor's current position.
EDSTR_ENUMHINT_e_actorPropertyCurvePosition=The x, y and z components of the actor's position.
EDSTR_ENUMHINT_e_actorPropertyCurveRotation=The yaw, pitch and roll components of the actor's rotation.
EDSTR_ENUMHINT_e_actorPropertyCurveScale=The x, y and z components of the actor's scale.
EDSTR_ENUMHINT_e_actorPropertyCurveTeamColor=The various components of an actor's team color, including diffuse RGB, diffuse HDR RGB, emissive RGB and emissive HDR RGB.
EDSTR_ENUMHINT_e_actorPropertyCurveTintColor=The various components of an actor's tint color, including RGB and HDR RGB.
EDSTR_ENUMHINT_e_actorPropertyCurveSoundParams=The volume and pitch of a sound.
EDSTR_ENUMHINT_e_actorPropertyCurveFlagLooping=Specifies that the added curve will loop to the beginning and play again upon completion.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentCustom=The client data specifies the tangent values directly in data.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentFast=Specifies a tangent that causes the animated value to approach (in) or leave (out) the control point quickly.  This is the opposite of the Slow value.  Example:  Animated value is position with an 'in' tangent set to fast.  The moving object accelerates towards the control point.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentFlat=Specifies a tangent that causes the animated value to remain constant whether approaching (in) or leaving (out) the control point.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentLinear=Specifies a tangent that points towards the previous (in) or next (out) control point.  This creates a linear change in the animated value as it moves into or out of the control point.  It results in sawtooth-like curves comprised of straight line segments.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentSlow=Specifies a tangent that causes the animated value to approach (in) or leave (out) the control point slowly.  This is the opposite of the Fast value.  Example:  Animated value is position with an 'in' tangent set to slow.  The moving object decelerates as it moves into the control point.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentSmooth=Specifies a tangent that causes the animated value to move into or out of the control point with no sudden changes in direction or velocity.  The most commonly used option.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentStep=Specifies a tangent that causes the animated value to jump in a disjointed way to or from the control point.  The animated value only ever changes once per segment.
EDSTR_ENUMHINT_e_actorPropertyCurveTangentAuto=Generates tangents that are similar to those created by the 3ds Max 'Auto Tangent' algorithm.
EDSTR_ENUMHINT_e_uiStatusFlagTypeIncapacitated=Marks a CActorUnit as belonging to a unit that has been incapacitated.
EDSTR_ENUMHINT_e_unitStatusShields=The unit's current shield level.
EDSTR_ENUMHINT_e_unitStatusLife=The unit's current hit points.
EDSTR_ENUMHINT_e_unitStatusEnergy=The unit's current casting energy (mana) level.
EDSTR_ENUMHINT_e_unitStatusCargo=The unit's cargo capacity and how much of it is full.
EDSTR_ENUMHINT_e_unitStatusProgress=The unit's construction progress.
EDSTR_ENUMHINT_e_unitStatusDuration=The remaining life span of a unit with an expiration timer.
EDSTR_ENUMHINT_e_unitStatusMagazine=The amount of ammo available to a unit with a limited quantity.
EDSTR_ENUMHINT_e_unitStatusWorkers=For resources, the ideal and current number of workers that should be assigned to harvest the resource.
EDSTR_ENUMHINT_e_unitStatusCustom=Display a custom unit status frame, as specified by the CustomUnitStatusFrame field in CActorUnit.
EDSTR_ENUMHINT_e_unitStatusCharges=Displays the charges for a unit's abilities that have them.  An ability with charges can be used multiple times before cooldown occurs.
EDSTR_ENUMHINT_e_actorDestroyTypeNormal=Destroy the actor normally.  For a CActorModel, this means that a model's particles may remain briefly after destruction, so that the model appears to fade out smoothly rather than simply blinking off.
EDSTR_ENUMHINT_e_actorDestroyTypeImmediate=Immediately destroys the actor and any of its subcomponents.  Prevents particles from lingering afterwards, which may be necessary, for instance, to prevent cutscene transitions from seeing particles from models that were just removed prior to the camera's arrival.
EDSTR_ENUMHINT_e_actorDestroyTypeWhenReady=Commands the actor to destroy itself as soon as it has finished some kind of important processing.
EDSTR_ENUMHINT_e_flyerDisplayNone=The player does not see any flier helpers.
EDSTR_ENUMHINT_e_flyerDisplaySelected=The player only sees flier helpers on the units he has selected.
EDSTR_ENUMHINT_e_flyerDisplayAll=The player sees flier helpers on all flying units.
EDSTR_ENUMHINT_e_AIUIModeHidden=AI Beacons are not visible in the given situation, for example because there are no AI players.
EDSTR_ENUMHINT_e_AIUIModeVisible=AI Beacons are visible on the map, but the player is not currently interacting with them.
EDSTR_ENUMHINT_e_AIUIModeSelectable=AI Beacons are visible on the map, and the player is currently communicating with the AI, meaning that the beacons are available for selection.
EDSTR_ENUMHINT_e_actorModelSwapFlagPreventAllDynamicTextureTransfers=Prevents any dynamic textures from being copied over from the original model to the new model.
EDSTR_ENUMHINT_e_actorPhysicsImpactMemberSelf=Specifies the collision participant from whose perspective a given term test is occurring.
EDSTR_ENUMHINT_e_actorPhysicsImpactMemberOther=Specifies the collision participant that is not the participant considered Self.  Example: If A and B have collided, and A is testing with a term against the PhysicsImpact message, then, for that Term, A is Self and B is Other.
EDSTR_ENUMHINT_e_actorPhysicsImpactSpyOff=Do not monitor any physics impacts.
EDSTR_ENUMHINT_e_actorPhysicsImpactSpyAutomatic=Specifies that the ScenePhysicsImpactSpy message toggles between no spying and spying on both terrain and model impacts at once.
EDSTR_ENUMHINT_e_actorPhysicsImpactSpyTerrainOnly=Only monitors the terrain side of impacts between models and terrain.  This is often sufficient, and even preferred, for tracking what impact particles and sounds appear when a physics body strikes the terrain.  (ModelsOnly spying sees these impacts on the model side of the impact, as well, but mixes these impacts in with model-on-model collisions, which can make the model-on-terrain impacts more difficult to spot.
EDSTR_ENUMHINT_e_actorPhysicsImpactSpyModelsOnly=Only monitors the PhysicsImpact messages that are seen by models, whether they are colliding with one another or with the terrain.
EDSTR_ENUMHINT_e_actorPhysicsImpactEnvironmentOnLand=Chooses physics impacts that occur on land or in the air.
EDSTR_ENUMHINT_e_actorPhysicsImpactEnvironmentUnderwater=Chooses physics impacts that occur underneath the water's surface.
EDSTR_ENUMHINT_e_actorPhysicsImpactEnvironmentAny=Chooses any physics impact.  Ignores environment as a means of selecting them.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessDontCare=Hardness does not matter for filtering physics impacts.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessSofter=The impacted material type of the testing actor's model is softer than the material it struck on the other model that participated in the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessSofterOrEqual=The impacted material type of the testing actor's model is softer or equal in hardness to the material it struck on the other model that participated in the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessEqual=The impacted material type of the testing actor's model is equal in hardness to the material it struck on the other model that participated in the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessHarderOrEqual=The impacted material type of the testing actor's model is harder or equal in hardness to the material it struck on the other model that participated in the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactMaterialRelativeHardnessHarder=The impacted material type of the testing actor's model is harder than the material it struck on the other model that participated in the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactRangeDontCare=Specifies that the data is not interested in any additional kinds of physics impact classifications.
EDSTR_ENUMHINT_e_actorPhysicsImpactRangeCollisionArea=Filter a physics impact by the surface area between the two collision participants at the time of collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactRangeImpulse=Filter a physics impact by strength of the impulse transmitted by the collision.
EDSTR_ENUMHINT_e_actorPhysicsImpactRangeRelativeApproachSpeed=Filter a physics impact by the combined approach speed between the two collision participants.
EDSTR_ENUMHINT_e_actorDeathSequenceFlagPreventKill=Prevents unit death from automatically killing the unit's current CActorUnit, possibly so that it can be killed manually at a later time.
EDSTR_ENUMHINT_e_actorOverkillDamagePastRemainingHealth=Specifies that a unit was overkilled if the killing blow inflicted greater than or equal to X amount of damage more than was necessary to kill the unit.
EDSTR_ENUMHINT_e_actorOverkillDamageOverInterval=Specifies that a unit was overkilled if it was taking greater than or equal to X amount of damage over Y time interval at its time of death.
EDSTR_ENUMHINT_e_participantParticipant=The local player is a participant in the game.
EDSTR_ENUMHINT_e_participantObserver=The local player is an observer watching the game.  An observer can be either a referee or a a spectator.
EDSTR_ENUMHINT_e_participantReferee=The local player is refereeing a match and has abilities beyond a regular spectator, including the ability to pause/resume the game and chat with participants.
EDSTR_ENUMHINT_e_participantSpectator=The local player is a spectator watching the game.  Spectators can chat among themselves, but not with players.
EDSTR_ENUMHINT_e_unitSoundBirth=Plays when a unit is done being created.  For units, this is when the unit first appears on the map.  For buildings, it is when the building has completed construction.
EDSTR_ENUMHINT_e_unitSoundReady=Plays when a unit is done being created, but only for the player that owns the unit.  For units, this is when the unit first appears on the map.  For buildings, it is when the building has completed construction.
EDSTR_ENUMHINT_e_unitSoundHelp=Periodically plays when a player's units are taking damage while off screen.
EDSTR_ENUMHINT_e_unitSoundWhat=Plays when the player selects the unit.
EDSTR_ENUMHINT_e_unitSoundYes=Plays when the player commands a unit to perform an action like moving to a new location or construct a new building.
EDSTR_ENUMHINT_e_unitSoundAttack=Plays when the player commands a unit to attack another unit.
EDSTR_ENUMHINT_e_unitSoundPissed=Plays when a user has clicked on a selected unit repeatedly without giving the unit a meaningful command.
EDSTR_ENUMHINT_e_unitSoundMovement=Plays when the unit is moving from one location to another.
EDSTR_ENUMHINT_e_unitSoundTurning=Plays when the unit is turning in place.
EDSTR_ENUMHINT_e_unitSoundBoard=Plays when a unit is commanded to board a transport.
EDSTR_ENUMHINT_e_unitSoundConstruction=Plays when a unit is selected while under construction.
EDSTR_ENUMHINT_e_unitSoundClick=In story mode, plays when the the player clicks on the unit.
EDSTR_ENUMHINT_e_unitSoundClickError=In story mode, plays when the player clicks on a unit that is not highlightable.
EDSTR_ENUMHINT_e_unitSoundHighlight=In story mode, plays when the player hovers over the unit with the cursor, unless the unit not highlightable.
EDSTR_ENUMHINT_e_animMatchTypeBest=Uses best match semantics.  The animation system finds an animation with the first requested anim prop and then attempts to match as many remaining anim props in the request to whatever anim props are present in the animation.  The animation(s) with the most matches and fewest mismatches wins.
EDSTR_ENUMHINT_e_animMatchTypeFull=Uses full match semantics.  The animation system finds an animation with exactly the specified request anim props.  Variations do not disqualify a request unless the request itself has a variation anim prop in it.  In other words, Stand, Start matches Stand, Start, 01 and Stand, Start, 02, but Stand, Start, 01 only matches Stand, Start, 01.
EDSTR_ENUMHINT_e_animMatchTypeNoMismatchQueryProps=Uses NoMismatchQueryProps semantics.  The animation system finds an animation where the resulting animation doesn't have any props that aren't specified in the query anim props (disregarding variation props), but the query anim props may have anim props that are not present in the resulting animation.  This rule is applied on top of best match semantics.
