Guide Update

<absorbdamage // When in a damage event, absorbs the max amount of damage. When the max is exceeded, passes true. Stores absorbed damage in accumulator
max="0"  // Can't be variable
/>
result: Current absorbed damage (accumulator)

<accumulatedamage // All damage done to the entity is added to this entity's accumulator at the given scale
entity="this_entity"
scale="0"   // Can't be variable
/>
result: Current accumulator

<activatemodifierkey // Activates the named modifier key on the given entity
entity="this_entity"
name="Name"
/>

<addattackpreimpactactions /> // Adds the sub actions to the current attack's preimpact

<addattackpredamageactions /> // Adds the sub actions to the current attack's predamage

<addattackdamageeventactions /> // Adds the sub actions to the current attack's damageevent

<addattackimpactactions /> // Adds the sub actions to the current attack's impact

<addattackimpactinvalidactions /> // Adds the sub actions to the current attack's impactinvalid

<addcharges // Adds count worth of charges to the entity for the given duration. Default duration is infinite.
entity="this_entity"
count="1"     // Can be variable
timed="false" // Added charges are removed after duration if true
duration="-1" // Can't be variable
/>
result: Count of entity's charges

<addcritical // Used in attack/damage event, gives a given chance to multiply damage by the multiplier
chance="1.0"            // Can be variable
multiplier="1.0"        // Can be variable
/>
result: always 1

<adjustagility // Usable only in an abilityattribute ability. Permenantly increases the entity's agility by the value.
entity="this_entity"
value="0"   // Can be variable
/>
result: Sum of current increase in agility

<adjustintelligence // Usable only in an abilityattribute ability. Permenantly increases the entity's intelligence by the value.
entity="this_entity"
value="0"  // Can be variable
/>
result: Sum of current increase in intelligence

<adjuststrength // Usable only in an abilityattribute ability. Permenantly increases the entity's strength by the value.
entity="this_entity"
value="0"  // Can be variable
/>
result: Sum of current increase in strength

<aggression // Gives sight of the source to the target as if they attacked them from fog
source="source_entity"
target="target_entity"
/>

<applystate // Applies a state with the given name to the target for the duration
name="Name"
source="source_entity"
target="target_entity"
inflictor="source_entity"
spawner="inflictor_entity"
duration="0" // Can be variable
charges="0" // Does not work :(
chargesmult="0" // Does not work :(
ischannel="false" // Used in channels to designate if this state should auto-expire when the channel ends
istoggle="false" // Used in toggles to designate if this state should auto-expire when the toggle ends
ignoreinvulnerable="false"     //Careful!; Can this state apply on invulnerable entities?
proxy="Proxy" // Sets the initial proxy of the state
pushentity="false" // Pushes this state onto the stack after it is created
stack="false" // Lets multiple copies of the same state from different source stack on the same target
continuous="false" // Makes this state have no duration, it will last until it is manually expired elsewhere
timeout="0" // How often the state checks if it should start it's expire or expire itself. Usually set to "frametime"
statelevel="0" // Sets the level of the state, can be variable
owner="this_owner_entity"
propagatecondition=""     // Sets a condition to activate state. (Based on source entity)
/>
result: 1 if state was successfully applied

<areaofeffect // Does an instant AOE with the given parameters, hitting every unit in the radius that fits the targetscheme and selection. This should be used instead of affectors for instant 0 duration AOEs.
source="source_entity"
targetscheme="TargetScheme"
effecttype="EffectType"
ignoreinvulnerable="false"     //Careful!; Can affect invulnerable entities?
center="this_entity"
targetselection="all"
radius="0"                      // Can be variable
innerradiusoffset="0"           // Does not work :(
maxtotalimpacts="0"             // Can be variable
maximpactspertarget="1"         // Can be variable
firsttarget="FirstTarget" // Given entity is the first target every time
ignore="Ignore" // Given entity is ignored
global="false"
includetrees="false"
impacteffect=""
>
// Can do more actions here, every unit hit runs through these actions in order of being hit
</areaofeffect>
result: number of units affected

<attack // Does an instant attack from the source to the target if the targetscheme and effecttype of the target are valid (from the source)
source="source_entity"
target="target_entity"
targetscheme="TargetScheme"
effecttype="EffectType"
facetarget="false" // Instantly turns the source to face the target when the attack is done
/>

///           unused, but working
<attackaction // Does an instant attack from the source to the target if the targetscheme and effecttype of the target are valid (from the source). Skips the normal attack events before the action.
source="source_entity"
target="target_entity"
targetscheme="TargetScheme"
effecttype="EffectType"
/>

<aura // Causes an aura that has radius and applies the state and/or gadget listed as long as the effecttype and targetscheme are met. The duration is how long the state stays on them outside of the aura.
state="Name"
gadget="Name"
gadgetowner="source_entity"
radius="0"
duration="0"          //How long state remains after leaving aura
continuous="false"       //State does not end once applied
targetscheme="TargetScheme"
effecttype="EffectType"
ignoreinvulnerable="false"  //Careful!; Can this state apply on invulnerable entities?
condition="" // Sets a condition for the state to be applied to targets
propagatecondition="" // Sets a condition for the aura to be active. (Based on owner of aura; state is still applied on aura's owner despite this condition)
reflexivestate="" // A state that is applied to the owner of the aura when an enemy is under its effects
stack="false" // Lets multiple aura of the same state stack
notooltip="false" // Removes the tooltip for the aura
icon=""          // Icon can be changed
proxy=""         // Set's proxy of applied state and/or gadget
timeout="0"      // How often the state checks if it should start it's expire or expire itself. Usually set to "frametime"
/>

<bind // Binds the target to the entity
target="target_entity"
entity="this_entity"
vertical="false" // When true, the bound target retains it's z position instead of snapping to the projectile's
turn="false" // Turns the target to face in the direction the projectile is traveling
unbindondeath="false" // Unbinds the target when it dies
nopush="false" // When true, when the to a projectile will not break channeling
position="false"   // true means using positionoverride attribute
positionoverride="0 0 0" // position offset
/>

<bonusdamageadd // Adds the listed damage (a, or a / b with the operator) to the next attack, uses source if the target is blank
source="source_entity"
target=""
a="0"          //Can be variable
b="0"         // Can be variable, e.g. source_agility
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: calculated damage addition

<bonusdamagemult // Used in <onattack />, multiplies the attackdamage by the value (a, or a / b with the operator), uses source if the target is blank
source="source_entity"
target=""
a="0"        //Can be variable
b="0"        //Can be variable
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: calculated damage multiplier

<bounce // Causes the current attack or projectile to bounce the count number of times, searching the range around the bounce-off-of target, multiplying damage by damagemult and only hitting the targets of the fitting targetscheme.
count="0"   // Can't be variable
range="0"   // Can't be variable
damagemult="0"    // Can't be variable
targetscheme="TargetScheme"
seek="random" // Controls how the bounce target is choosen. Can also be closest or farthest
maxbouncespertarget="1"
effecttype=""             // normally inherited from owner, can be changed
/>
result: current bounce index         //So, 1st hit results 1.0, 2nd 2.0 up to bounces count. Last bounce's result is 0 (So it's 1->2->3->...->n->0)

<breakchannel // Breaks any current channeling abilities of the entity
entity="this_entity"
/>
result: 1 if any channel was broken; otherwise 0

<broadcastmessage // Broadcasts the type of message at the source entity's position, used right now to alert the team when a courier dies based on type
source="source_entity"
type="Type" // Currently can only be either "walkingcourier" or "flyingcourier"
/>

<calculatedamage // Returns the damage after reduction calculations from the source to the target of the given amount, effecttype, and supertype.
source="source_entity"
target="target_entity"
amount="0"       //Can be variable
effecttype="EffectType"
supertype="SuperType"         //attack or spell
/>
result: calculated damage

<canactivate /> // Returns true if the ability can be activated. For example, if the target is stunned, it will return false since you can't use abilities while stunned.

<canattack /> // Runs the same check that your auto attack. Basically a <cantarget /> using your attack target scheme automatically.

<cancel // Used in orders, cancel the entity (order) when called
entity="this_entity"
/>

<cantarget // Checks if the source can hit the target given the parameters. Example: If targetscheme is enemy_units and you attack an allied creep, it will return false, but if you attack an enemy creep it's true.
source="source_entity"
target="target_entity"
targetscheme="TargetScheme"
effecttype="EffectType"
ignoreinvulnerable="false"  //Careful!; Does it ignore ignoreinvulnerablity of entities?
/>

<casteffecttype // Used to check if the current ability in the event caused by the entity has the selected effecttype. For example, can be used to check if someone uses an attack ability so power supply won't gain charges.
entity="this_entity"
effecttype="EffectType"
/>

<chain // Used in affectors, when the onimpact is hit and this is inside, will basically call the affector again on top of the current target (excluding it from possible targets) as many times as chained. Example, chain lightning
count="0"   // Can't be variable
/>
result: current chain index         //So, 1st hit results 1.0, 2nd 2.0 up to count. Last hit's result is 0 (So it's 1->2->3->...->n->0)


<chance // Passes the call if it randoms past the chance value
threshold="0"     // Can't be variable
/>

<changeaccumulator // Sets the accumulator of the entity to a and b using the op. a in this action is always accumulator of the entity before the change.
entity="this_entity"
b="0"          //Can be variable
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: current entity's accumulator value

// UNUSED
<changecurrentcombatdamage // Used in a combat event to change the current combat damage. Takes the combat damage before change as a and sets it using b and op.
b="0"
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>

<changedamage // Used to change the current damage. Takes the damage before change as a and sets it using b and op. Example is setting the incoming damage to 1 so a pet can take a certain number of hits.
b="0"        // Can be variable
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: Calculated damage

<changeduration // Used to set the new (local) duration. Takes the total duration (<applystate>'s one) as a and sets new using b and op. It does not overwrite total duration. New duration is returned in result variable
b="0"            // Can be variable
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: New duration value
//######       State can't refresh if current applied state's duration is longer than <applystate>'s one. Even state's level is not rised! Use careful with refreshing states


<changehealth // Used to change the current target's health by +- the value set by a/b/op.
source="source_entity"
target="target_entity"
a="0"       // Can be variable
b="0"       // Can be variable
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: Calculated value

<changeteam     // Changes team of target. Used in tutorial
target="target_entity"
team="0"        // team's value
/>

<changetotalduration // Used to set the new, total duration. Takes the total duration before change as a and sets it using b and op. If a state is half done, it will still be half done after this. It DOES overwrite base duration.
b="0"       // Can be variable
op="ValueOp"
/>
result: New total duration

<clearcriticals /> // Removes all current criticals out of the current combat event

<clearteamtarget/>  // Clears current team's target (Hero/building selected; "Attack X now")

<clearproxy // Clears the current proxy of given index of the current entity
index="0"
/>

<clonebackpack // Clones the source's backpack into the target's
source="source_entity"
target="target_entity"
/>

<combatevent    // Creates new combat event with defined effecttype, which automaticly impacts target
source="source_entity"
target="target_entity"
effecttype=""
>
    <onimpact>      // Can be used any event, usually it's <onimpact>
        ...         // Do something here
    </onimpact>
</combatevent>

<combatsupertype // When used inside of a combat Event, checks if the current supertype matches. If so, it passes true. (Can only be spell or attack)
supertype="SuperType"
/>

<combateffecttype // When used inside of a combat Event, checks if the current effecttype matches. If so, passes true. Can be any effecttype.
effecttype="EffectType"
/>

<compare // Compares two values, A and B, using the operator choosen. Passes to below when true.
a="ValueA"
b="ValueB"
op="Operator"
source="this_entity"  //Can be used to change source of variables (source_gold,...), but not charges nor accumulator :(
/>

<complete // Used in orders, completes the current order when called
entity="this_entity"
/>

<condition // Used to check against certain conditions or compare two values. Passes to below if returns true
source="source_entity"
target="target_entity"
test="" // Valid operators are EQUALS "eq", NOT_EQUALS "ne", LESS_THAN "lt", LESS_THAN_OR_EQUALS "le", GREATER_THAN "gt", GREATER_THAN_OR_EQUALS "ge". Can also check for "isready", which returns true if the ability is ready to activate.
/>

<consume // Checks for the given item and tries to consumes it. Passes true if item is consumed (it's condition-like tag). Charges of item may be condition.
item="Item"
count="1"       //
userecipe="false"  // When true can consume full item or recipe, when false can consume only full item
ignorecharge="false"
/>

<currentdamagesupertype // Only used in <ondamage /> and <ondamaged />. Checks if the current supertype matches. If so, passes true. (Can only be spell or attack)
supertype="SuperType"
/>

<currentdamageeffecttype // Only used in <ondamage /> and <ondamaged />. Checks if the current effecttype matches. If so, passes true. Can be any effecttype.
effecttype="EffectType"
/>

<damage // Deals the given damage from the source to the target of the given effecttype. Can change the damage based on b/op.
source="source_entity"
target="target_entity"
min="0" // Has to be a number, cannot be a variable
max="0" // Has to be a number, cannot be a variable
amount="0" // Has to be a number, cannot be a variable. CAN ONLY USE MIN/MAX OR AMOUNT, NOT BOTH.
effecttype="EffectType"
nonlethal="false" // Can this damage kill?
b="0" // CAN be a variable - use this to change damage on the fly
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max"
inflictor="this_entity"
supertype="SuperType"  // attack or spell
/>
result: Calculated value

<damagesupertype // When used inside of a damage Event, checks if the current supertype matches. If so, it passes true. (Can only be spell or attack)
supertype="SuperType"
/>

<damageeffecttype // When used inside of a damage Event, checks if the current effecttype matches. If so, passes true. Can be any effecttype.
effecttype="EffectType"
/>

<deactivatemodifierkey // Turns off the named modifier key of the entity
entity="this_entity"
name="Name"
/>

// UNUSED, does not work
<defer // Defers the application of a state for a set amoutn of time
time="Time"
mult="0"
/>

<delete // The source deletes the target entity from the world
source="source_entity"
target="target_entity"
/>

<disjoint // Disjoints the target entity, causing any midair projectiles to not hit this target
source="source_entity"
target="target_entity"
/>

<dispel // Removes all of the states with the type given off the target
source="source_entity"
target="target_entity"
type="Type"
/>

<distance // Returns the distance between the source and target (in units)
source="source_entity"
target="target_entity"
/>
result: distance value

<else /> // Everything that can return true/false causes an else to happen after the tag close. For example, can be used to cover situations outside of the condition you are testing. Only usable AFTER something that would return it anyawy.

<elsecondition // Used to check against certain conditions or compare two values. Passes to below if returns true. Replaces an else command.
source="source_entity"
target="target_entity"
test="" // Valid operators are EQUALS "eq", NOT_EQUALS "ne", LESS_THAN "lt", LESS_THAN_OR_EQUALS "le", GREATER_THAN "gt", GREATER_THAN_OR_EQUALS "ge". Can also check for "isready", which returns true if the ability is ready to activate.
/>

<entitytype // Checks if the target is the given entity type. If it is, passes true.
source="source_entity"
target="target_entity"
type="Type"
/>

<evaluate // Evaluates the given math and returns it as the result.
a="0"
b="0"
op="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: evaluated value

<expire // Expires the entity (a state) immediately
entity="this_entity"
/>

<expirestate // The source expires a state named Name off the target
source="source_entity"
target="target_entity"
name="Name"
/>

<forgetattacks // Causes the target to stop current attacks and remove current aquired targets. Used when a hero goes stealth mainly so they do not finish an attack and break the stealth
source="source_entity"
target="target_entity"
/>

<forceimpact/>    // Forces event <onimpact> for projectiles, which is normally called when projectile reached target

<foreachproxy  // Execute some script with target_entity = proxy for each proxy
entity="this_entity"
/>

<getyaw      // Returns angle between 2 positions/entities
source="source_entity"
target="target_entity"
>
result: angle

<givegold               //Gives gold to player owning target
source="source_entity"          // "source of gold", entity from which pops gold number
target="target_entity"
amount="0"              // Can be variable
/>
result: amount of given gold

<giveitem          // Give an item to the target unit or its stash.
target="target_entity"
name="" // The item name that will be given to the unit.
pushentity="false"  // Pushes this item into the stack when created
stash="false"    // Does item needs to be put in the stash?
/>

<giveexperience       //Gives experience to target
target="this_entity"
position="this_position"   // Position of experience popup
amount="0"        // Can be variable
/>
result: amount of given experience

<givemana // The source gives the target the amount worth of mana after the b/op operation
source="source_entity"
target="target_entity"
amount="0" // Cannot be a variable, has to be a number
b="0"         // Can be variable
op="none" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: amount of given mana

<hasmodifier // Checks if the target entity has the named modifier active. If yes, passes true
entity="this_entity"
name="Name"
/>

<heal // The source heals the target the amount worth of health after the a/b/op
source="source_entity"
target="target_entity"
a="0"     //Can be variable
b="0"     //Can be variable
op="AmountOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: amount of healed health

<hidechannelbar/>    // Hides channel bar

<invalidate /> // Used in <checkcost /> and <activatecost /> to invalidate the cast of an ability if certain conditions are met. When called, just cancels the cast of the ability as if it never happened.

<isitem //  Checks if the entity is item. If yes, passes true
entity="this_entity"
/>

<isready //  Checks if the entity (ability or item) is ready. If yes, passes true
entity="this_entity"
/>

<kill // The source kills the target instantly.
source="source_entity"
target="target_entity"
experiencebountymult="1.0" // Experience the target gives when it dies from this action, can't be variable
goldbountymult="1.0" // Gold the target gives when it dies from this action, can't be variable
nocorpse="false"
nodeathanim="false"
/>

<killillusions /> // If the current target was an illusion, kills it instantly
result: 0 or 1

<killtrees // Kills all the trees in the radius
radius="0" // No radius means to kill the target entity if it is a tree, can't be variable
target="target_position"         // centre position
usealtdeathanims="false"
/>
result: number of killed trees

<levelpets // Levels the named pets to the value level
name="Name"
value="0" // Usually this is "level", so when an ability levels up it transfers it's current level to the pet
/>
result: Always 1

<lineofeffect // Does an instant LOE with the given parameters, hitting every unit in the radius that fits the targetscheme and selection. This should be used instead of linearaffectors for instant 0 duration LOEs.
targetscheme="TargetScheme"
effecttype="EffectType"
ignoreinvulnerable="false"     //Careful!; Can effect invulnerable entities?
targetselection="all"
radius="0"                      // Can be variable
ignore="Ignore" // Given entity is ignored
includetrees="false"
target="target_entity"
targetorigin="target_entity"
targetvalue=""
targetmodifier="" // can be "pointpastline" for example
direction="source_entity"
directionorigin="target_position"
directionvalue=""
directionmodifier="" // can be "pointpastline" for example
>
// Can do more actions here, every unit hit runs through these actions in order of being hit
</lineofeffect>
result: number of units affected

<lockbackpack // Locks the entity's backpack so any items in it cannot be dropped, sold or moved and that entity cannot purchase more into the backpack
entity="this_entity"
/>

<morph // The source morphs the target into the named entity. Usually a self cast
source="source_entity"
target="target_entity"
name="Name"
/>

<multcharges // Multiplies the entity's charges by the value and sets that as the new number of charges
entity="this_entity"
value="0"          // Can be variable
/>
result: new charges count

<negate // Negates the effects of an offensive spell targetted at the owner when triggered.
immunitytype="ImmunityType" // Only negates spells of the given immunity type
/>

<order // The source issues an order of the given command to the target unit.
source="source_entity"
target="target_entity"
command="Command" // Can be such things as attack, wander, stop, assist, follow, hold, etc. Can also be "event" which calls an order.entity of the given OrderName
parameter="Parameter" // Unused
queue="back" // Can be set to front or back
force="false" // Forces the entity to do this order and nothing else for the duration
forceduration="0" // Only used if force is true, and says how long it lasts
restrict="false" // Sets to true if the event order is used
ordername="Name" // Name of the order.entity to use
value0="Value0" // Used only in command="assist"
duration="0" // Duration of the order
block="Block" // Used in tutorial, unused
duration=""     // Duration of order if it's not forced
range=""         // Used in command="assist"  (but it works same as value0)
triggerrange=""     // ?
/>

<orderdisjoint  // Removes all orders from target entity
target="target_entity"
/>

<pausetimer  //Switch "paused" for timer for this entity
paused="false" // Can be true or false
/>

<peekstack /> // Sets the current stack as the result

<ping // Issues a map ping of the given name at the target position
name="Name"
position="target_position"
/>

<playanim // Plays the animation of given Name with X variations included at the given speed and length
source="source_entity"
target="target_entity"
name="Name"
variations="0"
channel="Channel" // Artisty-Thing, UNUSED
speed="1.0"       //Can be variable
length="Length"   //UNUSED
seq="Seq" // Used in animations used in quick succession that you don't want reset between  UNUSED
/>

<playeffect // Plays the listed effect at the source position/entity with a given owner
source="source_entity"
target=""
effect="Effect"
owner="source_entity"
occlude="false" // Should this effect hide itself in fog?
/>

<playtauntsound // The source plays his taunting sound at the target
source="source_entity"
target="target_entity"
/>

<popentity /> // Removes the top entity stack item

<popstack /> // Removes the top value stack item
result: popped value

<popup // The source plays popup Name at the target position with the value of a/b/op
source="source_entity"
target="target_entity"
name="Name"
a="0"    //Can be variable
b="0"    //Can be variable
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>

<print // Prints the text in the console when called
text="Text"
/>

<printdebuginfo /> // Prints the debug information into the console when called

<printpos // Prints the given position into the console when called
value=""
/>

<printvalue // Prints the given value with a custom label (if wanted) when called
label="Label"
value="value"
/>

<protecteddeath // The source protects the target from death, used in Aegis
source="source_entity"
target="target_entity"
/>

<push // The source pushes the target the value force/forceb/forceop for the given duration
source="source_entity"
target="target_entity"
force="0"    // Can be variable
forceb="0"   // Can be variable
forceop="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
duration="0"    // Can't be variable
frame="false" // Instead of duration, pushes every frame as long as the push is applied
perpendicular="false" // Pushes in a perpendicular direction from the source. Used as a "push to the side" movement
/>

<pushability // Pushes the given named ability onto the stack
name="Name"
source="source_entity"
/>

<pushentity // Pushes the given named entity onto the stack, OR, searches in a radius for the first available target and pushes that entity onto the tsack
entity="Entity"
searchfortarget="false"
searchorigin="source_entity"
radius="0"        // Can't be variable
targetscheme="TargetScheme"
ignoreinvulnerable="false"
/>

<pushentitybyname // Pushes the given named entity onto the stack
name="Name"
/>

<pushentityproxy // Pushes the given named entity's proxy (by index) onto the stack
entity="this_entity"
index="0"
/>

<pushentitysearch // Searches in a radius for the first available target and pushes that entity onto the tsack
origin="source_position"
radius="0"       //Can't be variable
targetscheme="TargetScheme"
ignoreinvulnerable="false"
global="false" // Sets it to a global search instead of a radius
/>

<pushhero/>  // Pushes the player's hero entity onto the stack

<pushprojectiletarget  // Pushes target of projectile
entity="this_entity"
/>

<pushstack // Pushes the given value after a/b/op onto the stack
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>

<recallpets // Causes the named pet to get a move order back to its owner
name="Name"
/>
result: Always 1

<reducecooldown // Reduces the cooldown of the entity by the duration given; Stackable
entity="this_entity"
source="source_entity"
duration="0"    // Can be variable
/>
result: new cooldown;

<refreshabilities // The source refreshes the target's abilities
source="source_entity"
target="target_entity"
/>

<refreshinventoryitems // The source refreshes the target's items in their inventory except those in the exclude line, seperated by spaces
source="source_entity"
target="target_entity"
excluded="Excluded"  // Item name that should be excluded from the refresh
/>

<releasecontrol // Releases target unit from player's control and sets its team to -4.0 (sic!)
target="target_entity"
/>

<removecharge // Removes one charge from the entity
entity="this_entity"
/>
result: new charges count

<resetattackcooldown // Resets the source's attack cooldown
source="source_entity"
/>

<resetcooldown // Resets the cooldown of the entity
entity="this_entity"
/>

<resettimer // Resets the timer of the entity
entity="this_entity"
/>

<resettouches // Resets the touches of the source
source="source_entity"
/>

<retarget // Used for projectiles, retargets it towards the target in mid-flight
source="source_entity"
target="target_entity"
/>

//UNUSED
<return /> // Causes a projectile to be returned back to its origin


<savehealth // Saves the current target's health to this entity so it can be used later through the "healthlost" variable; Uses ACCUMULATOR to save current health!
source="source_entity"
target="target_entity"
entity="this_entity"
/>
result: saved health value (accumulator)

<scaledamage // Scales the current incoming damage by the % given through scale
scale="0"        // Can't be variable
/>
result: new damage value

<selectentity // Selects target_entity for source_entity's player, bugged
source="source_entity"
target="target_entity"
request="true"   // No idea what is it
/>

<setaccumulator // Sets the entity's accumulator based on a/b/op. Accumulator is a permenant value that persists through all events.
entity="this_entity"
value="0"     // Can be variable
valueb="0"    // Can be variable
valueop="ValueOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max"
/>
result: new accumulator

<setactivemodifierkey // Sets the active modifier key of the entity to the name given
entity="this_entity"
name="Name"
/>

<setattackactioneffect // Overrides the current attack's action effect to the effect given
source="source_entity"
target="target_entity"
effect="Effect"
/>

<setattackimpacteffect // Overrides the current attack's impact effect to the effect given
effect="Effect"
/>

<setattackprojectile // Overrides the current attack's projectile to the one named
name="Name"
/>

<setcharges // Sets the charges of the entity to the value of a/b/op
entity="this_entity"
a="0"  // Can be variable
b="0"  // Can be variable
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max"
timed="false" // Charges are removed after duration if true
/>
result: new charges count

//unused, seems it does not work :(
<setdamage // Sets the damage of the current event to the value of a/b/op
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max"
/>

<setgold // Sets the gold of entity's player
entity="this_entity"
value="0"
/>

<setdeathanim  //Can disable death animation and corpse spawning. Can be used only in <onsmackdowned/> event
target="target_entity"
noanim=""
nocorpse=""
/>

<seteffecttype // Sets the effecttype of the value in name to the given type
name="Name" // An example of this is combat_damagetype in the <onpreimpact /> event to change the attacks effecttype
effecttype="Effecttype"
/>

<setent0 // Sets the entity as the ent0 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity="Entity"
name="Name"
/>

<setent1 // Sets the entity as the ent1 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity="Entity"
name="Name"
/>

<setent2 // Sets the entity as the ent2 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity="Entity"
name="Name"
/>

<setent3 // Sets the entity as the ent3 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity="Entity"
name="Name"
/>

<setexperience // Sets the entitie's experience to the value given
entity="Entity"
value="0"    // Can be variable
/>

<setgold  // Sets the gold of selected player
entity=""
value="0"    // Can be variable
/>

<setgoldlossbonus // Sets the target's bonus gold lost from death to the value given
source="source_entity"
target="target_entity"
value="0"  // Can be variable
/>

<setgoldlossmultiplier // Sets the target's gold lost from death multiplied by the value
source="source_entity"
target="target_entity"
value="0" // Can be variable
/>

<setignoreattackcooldown // Unused
source="source_entity"
target="target_entity"
value="0"
/>

<setlevel // Set the level of entity (entity can not use experience)
entity="this_entity"
value="0"  // Can be variable
/>

<setparam // Sets the parameter of the entity to the value of a/b/op. Parameter is a permenant value that persists through all events.
entity="this_entity"
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new param

<setpos0  // Sets the position as the pos0 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity=""
offset="0 0 0"
offsetspace=""
position=""
positionend=""
positionmodifier=""
positionvalue=""
name=""            // Get's position of named entity
/>

<setpos1  // Sets the position as the pos1 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity=""
offset="0 0 0"
offsetspace=""
position=""
positionend=""
positionmodifier=""
positionvalue=""
name=""            // Get's position of named entity
/>

<setpos2  // Sets the position as the pos2 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity=""
offset="0 0 0"
offsetspace=""
position=""
positionend=""
positionmodifier=""
positionvalue=""
name=""            // Get's position of named entity
/>

<setpos3  // Sets the position as the pos3 variable that can be recalled later. Only exists inside of the event it is made, so it 'expires' quickly.
entity=""
offset="0 0 0"
offsetspace=""
position=""
positionend=""
positionmodifier=""
positionvalue=""
name=""            // Get's position of named entity
/>

<setprojectilebounds   //Chages radius of projectile
entity="this_entity"
radius="0"  // Can be variable, e.g source_radius
/>

<setproxy // Sets the proxy of the entity to the target or can search for a target instead of declaring one outright. The proxy is a permenant entity that is remembered through all events of that entity
entity="this_entity"
target="target_entity"
searchfortarget="false"
searchorigin="source_entity"
radius="0"
targetscheme="TargetScheme"
ignoreinvulnerable="false"
index="0" // Index of the proxy for orders
/>

<setrespawnhealthmultiplier // Sets the health of the target when they respawn to the value as a percent
source="source_entity"
target="target_entity"
value="1.0"  // Can be variable
/>

<setrespawnmanamultiplier // Sets the mana of the target when they respawn to the value as a percent
source="source_entity"
target="target_entity"
value="1.0"  // Can be variable
/>

<setrespawnposition // Sets the respawn position of the target when they respawn to the position listed
source="source_entity"
target="target_entity"
position="target_position"
/>

<setrespawntime // Sets the whole respawn time of the target when they die to the value of a/b/op
source="source_entity"
target="target_entity"
a="0"  // Can be variable
b="0"  // Can be variable
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new respawn time

<setrespawntimebonus // Changes the bonus respawn time of the target to the value listed when they are killed (used in <onkilled /> )
source="source_entity"
target="target_entity"
value="Value"       // Can be variable
/>
result: new respawn time

<setrespawntimemultiplier // Changes the bonus respawn time of the target to their bonus time multiplied by the value listed when they are killed (used in <onkilled /> )
source="source_entity"
target="target_entity"
value="Value"   // Can be variable
/>
result: new respawn time

<setvalue // Sets the named value to the value of a/b/op. Known values list below
source="source_entity"      // Source of values used in a and b (Used in Shieldbreaker)
name="Name"
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new value

<setvar0 // Sets the value of a/b/op to the variable var0, which can be called later in the same event. Only exists inside of the event it is created.
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new var0

<setvar1 // Sets the value of a/b/op to the variable var1, which can be called later in the same event. Only exists inside of the event it is created.
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new var1

<setvar2 // Sets the value of a/b/op to the variable var2, which can be called later in the same event. Only exists inside of the event it is created.
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new var2

<setvar3 // Sets the value of a/b/op to the variable var3, which can be called later in the same event. Only exists inside of the event it is created.
a="0"
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: new var3

<showchannelbar  //Shows fake channelbar (doesn't require channeling)
duration="0" // Can be variable
/>

<spawnaffector // Spawns a named affector at the target position or on the target entity with any number of properties
name="Name"
source="source_entity"
target="target_entity"
inflictor="inflictor_entity" // Can be used to change inflictor
direction="target_position" // Direction the affector is facing
firstimpact="target_entity" //
firsttarget="target_entity"
level="LevelProperty"
owner="source_entity"
ischannel="false"
istoggle="false"
distance="0" // Distance away from the target the affector spawns
count="1" // ?
countb="0" // ?
countop="CountOperator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
distribute="false" // Distributes the count worth of affectors evenly around the target going outwards (ex: "even")
proxy="Proxy" // Sets the proxy entity
pushentity="false" // Pushes this entity onto the stack
param="0" // Sets the parameter of this affector
positionorigin="source_entity" // Used for setting the origin for the position modifiers
positionvalue="0" // Radius
positionmodifier="" // Used to say what positional modifier to use. Can be "minonline" or "pointonline"
ignore="Ignored" // Entity to be ignored
/>
result: count of spawned affectors

<spawnillusion // Spawns count number of illusions of the target for lifetime duration. The damage they deal and take can be changed, along with the effects associated with them. Owner is who controls them.
source="source_entity"
target="target_entity"
proxy="" //  Sets the proxy entity
count="1"
lifetime="0"
receivedamagemultiplier="1.0"
inflictdamagemultiplier="1.0"
spawneffect="Effect"
deatheffect="Effect"
owner="source_entity"
uncontrollable="false"
pushentity="false" // Pushes the illusion onto the stack
playdeathanim="false" // Illusion plays the death animations of the unit copied when it is killed or not
inheritactions="false" // Smoothly inherits the actions of the unit spawned so if they were spawned on top of them, it would be impossible to tell the difference between real and illusion
spawncircular="false" // Spawns illusions in a circle instead of on top of the target, moves the target as part of the circle
spawncircularradius="0" // Radius of the circle when spawncircular is true
fixedposition="false" // // Fixes the position of the illusion to where it spawns
/>
result: count of spawned illusions

<spawnitem // The source spawns the named item at the target, offset by the distance (x/y). Offsetspace is who the offset is based off of (what direction they are facing is 'front')
source="source_entity"
target="target_entity"
name="Name"
offset="0 0"
offsetspace="target_entity"
/>
result: 1 if item was successfully spawned; otherwise 0

<spawnlinearaffector // Spawns a named linear affector at the target position or on the target entity with any number of properties. basically a line of affectors of the given name as far as the target_position
name="Name"
source="source_entity"
target="target_entity"
direction="target_position" // Direction the affector is facing
firsttarget="target_entity"
level="LevelProperty"
owner="source_entity"
ischannel="false"
istoggle="false"
pushentity="false" // Pushes this entity onto the stack
targetorigin="target_entity"
targetvalue=""
targetmodifier=""
directionorigin="target_position"
directionvalue=""
directionmodifier="" // can be "pointpastline" for example
proxy="" // Sets the proxy entity
/>
result: 1 if affector was successfully spawned; otherwise 0

<spawnprojectile // Spawns a projectile from the source (with offset) to the target, see the specific section for orbital attributes
source="source_entity"
target="target_entity"
owner=""
name="Name"
count="1"
effecttype=""
bind="" // Binds the entity listed to the projectile
bindturn="false" // Makes the bound entity turn in the direction the projectile does
bindnopush="false" // Makes it so binding to the projectile does not stop channeling
unbindondeath="false" // Unbinds the bound entity if they die
bindstate="" // A state to be on the bound target as long as they are bound
ignoretargetoffset="false" // Ignores the target's offset when it binds them
proxy="" // Sets the listed entity as the proxy of this projectile
offset="0 0 0"
offsetspace="source_entity" // Sets who the offset is based off of
ischannel="false"
istoggle="false"
pushentity="false" // Pushes this projectile onto the stack when created
param="0" // Sets the param of this projectile when created
noresponse="false" // Makes it so this projectile cannot be responded to. This involves things like Nullstone or reactionary abilities. It will not proc those
orbitstartingtheta=""
orbitstartingthetatime=""
ignore="Ignored" // Entity to be ignored
ignoreinvulnerable="false"
/>
result: count of spawned prijectiles

<spawnunit // The source spawns a unit (Name) at the target, spawning count number of them with other properties
source="source_entity"
target="target_entity"
owner="this_owner_entity"
name="Name"
count="1"
mount="entity" // Mounts (binds) the unit to the entity
bind="entity" // Binds the entity to this unit
fixedposition="false" // Fixes the position of the unit to where it spawns
inheritmodifiers="true" // Makes the unit inherit the modifiers of the source
ischannel="false"
istoggle="false"
maxactive="0" // Only this number of this unit can be active at once
facing="entity" // Sets the facing direction of the spawned unit in relation to the entity listed
angle="0" // Angle it is turned when spawned
offset="0 0 0" // Offset from the offsetspace entity
offsetspace="target_entity" // Entity is who the offset is based off of for where it spawns
pushentity="false" // Pushes this unit into the stack when created
lifetime="0" // Sets the lifetime to the value of a/b/op
lifetimeb="0"  // but recommended way to do it is setting it in unit's definition
lifetimeop="LifetimeOp" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
proxy="entity" // Sets the proxy of this unit to the entity listed
team="" // Sets the team of the spawned unit. Usually a "result" after an <evaluate a="target_team" /> call
snaptargettogrid="false" // Snaps the unit to the grid
duration="-1" //  Does not do anything
teamshare="false"
/>
result: count of spawned units

<splashdamage // Causes a splash damage call usually in <onattack /> or added as an impact action for onattackstart. It only hits the targets and effecttypes that are valid. Splash deals value of a/b/op
target="target_entity"   // Can be used to change target (and with centerontarget="true" center) of splash
targetscheme="TargetScheme"
effecttype="EffectType"
radius="0"
a="0" // Can use "total_adjusted_damage" if this is splashing normal attacks
b="0"
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
nonlethal="false" // "false" if the splash can kill
centerontarget="false" // Centers the splash circle on the target hit instead of on the attacking hero. Used for ranged splash.
supertype="SuperType"
/>
result: calculated damage

<split // Used in <onattack /> and splits the attack into different projectiles that hit units within the range/targetscheme given. Damage the split shots do is multiplied by the damagemult.
count="0"    // count of additional projectiles, can't be variable
range="0"     // range from attacking unit, can't be variable
damagemult="0.0"   // Can't be variable
targetscheme="TargetScheme"
fulldamageonmaintarget="false"     // Does main target receive full damage?
/>
result: number of additional projectiles sent

//UNUSED
<startattack // Starts an attack from the source to the target as long as the targetscheme and effecttype pass.
source="source_entity"
target="target_entity"
targetscheme="TargetScheme"
effecttype="EffectType"
facetarget="false" // Causes the source to face the target
/>

<startcooldown // Starts the cooldown of the entity listed or toolname if one is given for the duration of a/b/op
entity="this_entity"
toolname=""
duration="0"         // Can be variable
durationb="0"        // Can be variable
durationop="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: Calculated cooldown

<startexpire // Starts the expire time of the listed entity (a state) if it is continuous and has a duration that can run out
entity="this_entity"
/>

<startfade // Starts the entity listed to fade into stealth over the duration of a/b/op. If no duratoin is given, uses the fadetime of the state. Also a stealthtype is required.
entity="this_entity"
a="0"       // Can be variable
b="0"       // Can be variable
op="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: Calculated fadetime

<starttimer // Starts the timer of the entity listed for the duration of a/b/op
entity="this_entity"
duration="0"        // Can be variable
durationb="0"         // Can be variable
durationop="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: calculated value

<takecontrol // Transfers the target to be under the source's control. Maxactive limits the maximum number of units you can have active through this call.
source="source_entity"
target="target_entity"
maxactive="0"       // Can be variable
inheritmodifiers="false"    // Makes the unit inherit the modifiers of the source
/>
result: 1 if taken control on target; otherwise 0

<takegold   // Takes abount of gold from target's player
source="source_entity"
target="target_entity"
amount="0"  // Can be variable
/>
result: amount of taken gold

<takemana // The source takes the target's mana in the amount of a/b/op
source="source_entity"
target="target_entity"
amount="0" // Can only be a number, not a variable
amountb="0"  // Can be variable
amountop="Operator" // Valid operators are NONE "none", ADDITION "add", SUBTRACT "sub", MULTIPLY "mult", DIVIDE "div", MINIMUM "min", and MAXIMUM "max".
/>
result: amount of taken mana

<targettype // Checks if the target is the given target type. If it is, passes true.
source="source_entity"
target="target_entity"
type="Type"
/>

<teleport // Teleports the source to the target
source="source_entity"
target="target_entity"
interpolate="false" // Interpolates between the two points to try to make it "smoother"
facetarget="false" // Faces the source towards the target when moved
specifyangle="false" // Can specify the angle of the source at the end of the teleport. used with angle
angle="0"
positionorigin="source_entity"
positionvalue=""
positionmodifier=""
/>

<testactivate // If the target is within X distance of the source, passes true
source="source_entity"
target="target_entity"
distance="0"   // Can't be variable
/>

<testnearby // Used mainly in the <onthink /> of NPCs to make them check for conditions. Returns a number based on the valid targets in range that met the conditions of the test
radius="0"   // Can't be variable
targetscheme="TargetScheme"
ignoreinvulnerable="false"  // Should this test ignore invulnerablity of entities?
origin="source_entity"
/>
result: number of possible targets

<toggleoff // Toggles off the named ability when used
name="Name"
/>

<transferitemstohero /> // Used only by couriers at the moment, runs the source (courier) to the target (user of the ability) and tranfers the items the hero owns to him.

<transferstate // Steals the state named under entity from the target and applies it to the source (does not require allowtransfer="true")
source="source_entity"
target="target_entity"
entity="this_entity"
/>

<transferstates // Steals all states which have allowtransfer="true" from the target and applies it to the source
source="source_entity"
target="target_entity"
effecttype="EffectType"   // StatusBuff, StatusDebuff, StatusDisable
inflictor=""               // Possible change of inflictor of states
/>

<unbind // Unbinds the target from anything he is bound to
target="target_entity"
/>

<useability // Causes the source to use the ability in slot on the target. Can force this for a duration and restrict it's usage as well. Can be used with an order.entity
source="source_entity"
target="target_entity"
slot="-1"
queue="front"
force="false"
forceduration="0"
restrict="false"
ordername=""
value0="" // Unused
block="" // Unused
/>

<useitem // Causes the source to use the item on the target. Can force this for a duration and restrict it's usage as well. Can be used with an order.entity
source="source_entity"
target="target_entity"
queue="front"
force="false"
forceduration="0"
restrict="false"
ordername=""
value0="" // Unused
block="" // Unused
/>