[Trigger] Bizzare spell behavior

[MantisHair]

This spell no longer has script error warnings (thanks, hivers) but now it behaves strangely. The first cast is totally fine, but every subsequent cast starts the movement from the wrong place.

Here's the trigger (certain people will remember this one):

show trigger

• Leap Skill 1
  • Events
    • Unit - A unit Starts the effect of an ability
  • Conditions
    • (Ability being cast) Equal to Leap (Dummy, channel, Crow transition
  • Actions
    • -------- Faces Caster Toward Target --------
    • Unit - Make (Casting unit) face (Target point of ability being cast) over 0.00 seconds
    • -------- Set Variables --------
    • Set Leaper = (Casting unit)
    • Set LeapOrigin = (Position of (Casting unit))
    • Set LeapTarget = (Target point of ability being cast)
    • Set LeapFacing = (Facing of Leaper)
    • Set LeapMoveAngle = (LeapFacing + 180.00)
    • Set LeapDist = (Distance between LeapOrigin and LeapTarget)
    • Set LeapStep[0] = (LeapDist / 10.00)
    • Set LeapStep[1] = (LeapStep[0] + LeapStep[1])
    • Set LeapStep[2] = (LeapStep[1] + LeapStep[1])
    • Set LeapStep[3] = (LeapStep[2] + LeapStep[1])
    • Set LeapStep[4] = (LeapStep[3] + LeapStep[1])
    • Set LeapStep[5] = (LeapStep[4] + LeapStep[1])
    • Set LeapStep[6] = (LeapStep[5] + LeapStep[1])
    • Set LeapStep[7] = (LeapStep[6] + LeapStep[1])
    • Set LeapStep[8] = (LeapStep[7] + LeapStep[1])
    • Set LeapStep[9] = (LeapStep[8] + LeapStep[1])
    • Set LeapStep[10] = (LeapStep[9] + LeapStep[1])
    • For each (Integer LeapInt) from 1 to 10, do (Actions)
      • Loop - Actions
        • Set LeapTemps[LeapInt] = (LeapTarget offset by LeapStep[LeapInt] towards LeapMoveAngle degrees)
    • -------- Leap Action --------
    • Unit - Pause Leaper
    • Unit - Turn collision for Leaper Off
    • Unit - Add Crow Form to Leaper
    • -------- Repeat These 3 Actions For Each "Step" --------
    • Animation - Change Leaper flying height to Leap_Height_Increment at 900.00
    • Unit - Move Leaper instantly to LeapTemps[10], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 2.00) at 900.00
    • Unit - Move Leaper instantly to LeapTemps[9], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 3.00) at 900.00
    • Unit - Move Leaper instantly to LeapTemps[8], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 4.00) at 950.00
    • Unit - Move Leaper instantly to LeapTemps[7], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 5.00) at 950.00
    • Unit - Move Leaper instantly to LeapTemps[6], facing LeapFacing degrees
    • Wait 0.20 seconds
    • Animation - Change Leaper flying height to 600.00 at 950.00
    • Wait 0.20 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 5.00) at 950.00
    • Unit - Move Leaper instantly to LeapTemps[5], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 4.00) at 950.00
    • Unit - Move Leaper instantly to LeapTemps[4], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 3.00) at 900.00
    • Unit - Move Leaper instantly to LeapTemps[3], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 3.00) at 900.00
    • Unit - Move Leaper instantly to LeapTemps[2], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to (Leap_Height_Increment x 2.00) at 900.00
    • Unit - Move Leaper instantly to LeapTemps[1], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to Leap_Height_Increment at 950.00
    • Unit - Move Leaper instantly to LeapTemps[0], facing LeapFacing degrees
    • Wait 0.01 seconds
    • Animation - Change Leaper flying height to 0.00 at 950.00
    • Unit - Move Leaper instantly to LeapTarget, facing LeapFacing degrees
    • Wait 0.20 seconds
    • Unit - Remove Crow Form from Leaper
    • Unit - Unpause Leaper
    • Unit - Turn collision for Leaper On
    • -------- Clean Leaks --------
    • For each (Integer LeapInt) from 1 to 10, do (Actions)
      • Loop - Actions
        • Custom script: call RemoveLocation(udg_LeapTemps[udg_LeapInt])
        • Custom script: call RemoveLocation(udg_LeapTemps[udg_LeapInt])
        • Custom script: set udg_LeapTemps[udg_LeapInt] = null
    • Custom script: call RemoveLocation(udg_LeapTarget)
    • Custom script: call RemoveLocation(udg_LeapOrigin)

Any ideas on what's not right? (things you find obvious are not usually obvious to me, who is used to *simple* triggering. I only learned to fix leaks/use custom scripts this week.)

 

[Paulus]

I think you should redesigning your spell. Use a extra trigger thats loops at 0.03 instead of using waits. This is more accurate.
And instead of setting a new hight every period, you can design a formula for the height of the leap and the rate of it going to that height. So instead of 5 times setting the units hight up with 20 for 0,2 sec you can do 5x20=100 height at a rate of 5x0,2 sec= 1sec. Raise unit to 100 at 100. And the same for going to the ground.

 

[BloodDrunk]

I would completely redesign your spell since it's not MUI.
Can you briefly explain what do you want to achieve with your spell?
And then I'll bear with you when I get home on creating that spell the way it should be.
Using waits in spell is no good. =)

 

[venger07]

" Unit - Make (Casting unit) face (Target point of ability being cast) over 0.00 seconds"

You obviously leak at the first part of the trigger.. move the LeapTarget variable before making the unit face a point..

" Unit - Make (Casting unit) face LeapTarget over 0.00 seconds"

The first cast is totally fine, but every subsequent cast starts the movement from the wrong place.

the first cast will always be fine because you haven't override the variables yet.. but when you cast it subsequently, all variables you stored will malfunction and will not work properly because of using "wait" action plus your trigger is not in MUI

• Leap
• Events
  • Unit - A unit Starts the effect of an ability
• Conditions
  • (Ability being cast) Equal to Leap (Dummy, channel, Crow transition
• Actions
  • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
    • If - Conditions
      • Leap_Mui[0] Equal to 0
      • Then - Actions
        • Trigger - Turn on Leap Loop <gen>
      • Else - Actions
  • Set - Leap_Mui[0] = Leap_Mui[0] + 1
  • Set - Leap_Mui[1] = Leap_Mui[1] + 1
  • Set - Leap_Caster[Leap_Mui[1]] = (Triggering unit)
  • Unit - Turn collision for Leap_Caster[Leap_Mui[1]] Off
  • Set - Leap_Speed[Leap_Mui[1]] = 25
  • Set - Leap_Distance[Leap_Mui[1]] = 500
  • Set - Leap_Angle[Leap_Mui[1]] = (Facing of Leap_Caster[Leap_Mui[1]])
  • Set - Leap_Height[Leap_Mui[1]] = 0
  • Set - Leap_Check[Leap_Mui[1]] = False
  • Set - Leap_Height_Max[Leap_Mui[1]] = Leap_Distance[Leap_Mui[1]]/2

• Leap Loop
• Events
  • Time - Every 0.03 seconds of game time
• Conditions
• Actions
  • For each (Leap_Mui[2]) from 1 to (Leap_Mui[1]), do (Actions)
    • Loop - Actions
      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
        • If - Conditions
          • Leap_Distance[udg_Leap_Mui[2]] Greater than 0.00
        • Then - Actions
          • Set - Leap_Distance[Leap_Mui[2]] = Leap_Distance[Leap_Mui[2]] - Leap_Speed[Leap_Mui[2]]
          • Set - Leap_Point_Caster[Leap_Mui[2]] = Unit Position of Leap_Caster[Leap_Mui[2]]
          • Set - Leap_Point_Caster_Offset[Leap_Mui[2]] = Leap_Point_Caster[Leap_Mui[2]] offset with Leap_Speed[Leap_Mui[2]] towards Leap_Angle[Leap_Mui[2]]
          • Unit - Move Leap_Caster[Leap_Mui[2]] instantly to Leap_Point_Caster_Offset[Leap_Mui[2]], facing Leap_Angle[Leap_Mui[2]] degrees
          • Custom script: call RemoveLocation(udg_Leap_Point_Caster[udg_Leap_Mui[2]])
          • Custom script: call RemoveLocation(udg_Leap_Point_Caster_Offset[udg_Leap_Mui[2]])
          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
            • If - Conditions
              • Leap_Height[udg_Leap_Mui[2]] Less than Leap_Height_Max[Leap_Mui[2]]
              • Leap_Check[udg_Leap_Mui[2]] Equal to False
            • Then - Actions
              • Set - Leap_Height[Leap_Mui[2]] = Set Leap_Height[Leap_Mui[2]] + Leap_Speed[Leap_Mui[2]]
            • Else - Actions
              • Set - Leap_Check[Leap_Mui[2]] = True
              • Set - Leap_Height[Leap_Mui[2]] = Set Leap_Height[Leap_Mui[2]] - Leap_Speed[Leap_Mui[2]]
            • Animation - Change Leap_Caster[Leap_Mui[2]] flying height to Leap_Height[Leap_Mui[2]] at 0.00
          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
            • If - Conditions
              • Or - Conditions are true
                • Leap_Distance[udg_Leap_Mui[2]] Less than or Equal to 0.00
                • Leap_Caster[Leap_Mui[2]] is alive Equal to false
            • Then - Actions
              • Animation - Change Leap_Caster[Leap_Mui[2]] flying height to 0 at 0.00
              • Unit - Turn collision for Leap_Caster[Leap_Mui[2]] On
              • Set Leap_Distance[Leap_Mui[2]] = 0
              • Set - Leap_Caster[Leap_Mui[2]] = No unit
              • Set - Leap_Speed[Leap_Mui[2]] = 0
              • Set - Leap_Angle[Leap_Mui[2]] = 0
              • Set - Leap_Height[Leap_Mui[2]] = 0
              • Set - Leap_Check[Leap_Mui[2]] = False
              • Set Leap_Mui[0] = Leap_Mui[0] - 1
              • If - Conditions
                • Leap_Mui[0] Equal to 0
              • Then - Actions
                • Trigger - Turn off this trigger
                • Set Leap_Mui[0] = 0
                • Set Leap_Mui[1] = 0
              • Else - Actions
            • Else - Actions
        • Else - Actions

uncheck the "Initially On" for the Leap Loop

 

[MantisHair]

Alright. Trying a redesign.

I'll try the method posted by venger07. (I can guarantee I'll do something wrong, though)

...It's been a while since I got on the Hive or did any World Editor.

EDIT: To venger: the variables you used what types are those? (reals, integers, etc.)

 

[Nichilus]

Apart from other things, your problem is here:

• Set LeapDist = (Distance between LeapOrigin and LeapTarget)
• Set LeapStep[0] = (LeapDist / 10.00)
• Set LeapStep[1] = (LeapStep[0] + LeapStep[1])
• Set LeapStep[2] = (LeapStep[1] + LeapStep[1])
• ...

You should realize you are working with global variables, not local. That means they remember the value you set in them throughout the game.

Let's show an example situation:
Cast 1:
LeapDist = e.g. 300.00
LeapStep[0] = LeapDist / 10.00 = 300.00/10.00 = 30.00
LeapStep[1] = LeapStep[0] + LeapStep[1] = 30.00 + 0.00 (Default value) = 30.00
LeapStep[2] = LeapStep[1] + LeapStep[1] = 30.00 + 30.00 = 60.00
...

Cast 2:
LeapDist = e.g. 400.00
LeapStep[0] = LeapDist / 10.00 = 400.00/10.00 = 40.00
LeapStep[1] = LeapStep[0] + LeapStep[1] = 40.00 + 30.00 (this is the value left in LeapStep[1] from previous cast) = 70.00
LeapStep[2] = LeapStep[1] + LeapStep[1] = 70.00 + 70.00 = 140.00
...

Do you see the problem now?
Still you should do what others said - remake the whole spell. The way it is now is inefficient and buggy. I just wanted to point out the reason why the every subsequent casts do not work correctly.

 

[MantisHair]

To BloodDrunk

It's a spell that leaps the user up cliffs/over terrain. No need to be able to see the target point, just click a spot (within range) and go. I used "steps" to simulate an arc of motion (I admit, an ugly arc).
It uses channel as a dummy, the max range stays the same, but higher levels reduce cooldown and mana cost.

EDIT: Oh yeah, the unit who uses this skill is unique, only one ever in the game. (Since the map is a hero RPG.)

 

[venger07]

To venger: the variables you used what types are those? (reals, integers, etc.)

• Variables are
  • Set - Leap_Mui[0] = (Integer - Array)
  • Set - Leap_Caster[Leap_Mui[1]] = (Unit - Array)
  • Set - Leap_Speed[Leap_Mui[1]] = (Real - Array)
  • Set - Leap_Distance[Leap_Mui[1]] = (Real - Array)
  • Set - Leap_Angle[Leap_Mui[1]] = (Real - Array)
  • Set - Leap_Height[Leap_Mui[1]] = (Real - Array)
  • Set - Leap_Check[Leap_Mui[1]] = (Boolean - Array)
  • Set - Leap_Height_Max[Leap_Mui[1]] = (Real - Array)
  • Set - Leap_Point_Caster[Leap_Mui[2]] = (Point - Array)
  • Set - Leap_Point_Caster_Offset[Leap_Mui[2]] = (Point - Array)

 

[MantisHair]

Thanks again.

Making the variables clear for me really helps me build the trigger from someone else's design.

...I think I'll try to remember to do that when I post triggers, from now on.

 

[MantisHair]

Does nothing?

It's not working.
venger07, It's your design. What am I doing wrong? (probably quite a few things. I'm not very good at using other people's designs.)

Leap trigger

show trigger

• MUI Leap
  • Events
    • Unit - A unit Starts the effect of an ability
  • Conditions
    • (Ability being cast) Equal to Leap (Dummy, channel, Crow transition
  • Actions
    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
      • If - Conditions
        • LeapMUI[0] Equal to 0
      • Then - Actions
        • Trigger - Turn on MUI Leaploop <gen>
      • Else - Actions
        • Set LeapMUI[0] = (LeapMUI[0] + 1)
        • Set LeapMUI[0] = (LeapMUI[1] + 1)
        • Set Leap_Caster[LeapMUI[1]] = (Triggering unit)
        • Unit - Turn collision for Leap_Caster[LeapMUI[1]] Off
        • Set LeapSpeed[LeapMUI[1]] = 25.00
        • Set LeapDistance[LeapMUI[1]] = 500.00
        • Set LeapAngle[LeapMUI[1]] = (Facing of Leap_Caster[LeapMUI[1]])
        • Set LeapHeight[LeapMUI[1]] = 0.00
        • Set Leap_Check[LeapMUI[1]] = False
        • Set Leap_Height_Max[LeapMUI[1]] = (LeapDistance[LeapMUI[1]] / 2.00)

Leap Loop

show trigger

• MUI Leaploop
  • Events
    • Time - Every 0.03 seconds of game time
  • Conditions
  • Actions
    • For each (Integer LeapMUI[2]) from 1 to LeapMUI[1], do (Actions)
      • Loop - Actions
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • LeapDistance[LeapMUI[2]] Greater than 0.00
          • Then - Actions
            • Set LeapDistance[LeapMUI[2]] = (LeapDistance[LeapMUI[2]] - LeapSpeed[LeapMUI[2]])
            • Set Leap_Point_Caster[LeapMUI[2]] = (Position of Leap_Caster[LeapMUI[2]])
            • Set Leap_Point_Caster_Offset[LeapMUI[2]] = (Leap_Point_Caster[LeapMUI[2]] offset by LeapSpeed[LeapMUI[2]] towards LeapAngle[LeapMUI[2]] degrees)
            • Custom script: call RemoveLocation(udg_Leap_Point_Caster[udg_LeapMUI[2]])
            • Custom script: call RemoveLocation(udg_Leap_Point_Caster_Offset[udg_LeapMUI[2]])
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • LeapHeight[LeapMUI[2]] Less than Leap_Height_Max[LeapMUI[2]]
                • Leap_Check[LeapMUI[2]] Equal to False
              • Then - Actions
                • Set LeapHeight[LeapMUI[2]] = (LeapHeight[LeapMUI[2]] + LeapSpeed[LeapMUI[2]])
              • Else - Actions
                • Set Leap_Check[LeapMUI[2]] = True
                • Set LeapHeight[LeapMUI[2]] = (LeapHeight[LeapMUI[2]] - LeapSpeed[LeapMUI[2]])
            • Animation - Change Leap_Caster[LeapMUI[2]] flying height to LeapHeight[LeapMUI[2]] at 0.00
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • Or - Any (Conditions) are true
                  • Conditions
                    • LeapDistance[LeapMUI[2]] Less than or equal to 0.00
                    • (Leap_Caster[LeapMUI[2]] is alive) Equal to False
              • Then - Actions
                • Animation - Change Leap_Caster[LeapMUI[2]] flying height to 0.00 at 0.00
                • Unit - Turn collision for Leap_Caster[LeapMUI[2]] On
                • Set LeapDistance[LeapMUI[2]] = 0.00
                • Set Leap_Caster[LeapMUI[2]] = No unit
                • Set LeapSpeed[LeapMUI[2]] = 0.00
                • Set LeapAngle[LeapMUI[2]] = 0.00
                • Set LeapHeight[LeapMUI[2]] = 0.00
                • Set Leap_Check[LeapMUI[2]] = False
                • Set LeapMUI[0] = (LeapMUI[0] - 1)
                • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                  • If - Conditions
                    • LeapMUI[0] Equal to 0
                  • Then - Actions
                    • Trigger - Turn off (This trigger)
                    • Set LeapMUI[0] = 0
                    • Set LeapMUI[1] = 0
                  • Else - Actions
              • Else - Actions
          • Else - Actions

EDIT: What should those arrays have for max index size? Does it matter?

 

[Nichilus]

The position of every action in your trigger has to remain same to venger's trigger. If you look carefully at your "MUI Leap" trigger and his "Leap" trigger, you can see that there is a difference - not in actions, but in where they are placed.

Your Leap trigger places all actions into the "Else" block of the If/Then/Else.
Your condition in the ITE is "LeapMUI[0] Equal to 0"... You never increment the value in LeapMUI[0], so it will never reach Else block - that is because the action which increments the value of LeapMUI[0] is right now in the else block.

 

[MantisHair]

One down...

Alright, initial Leap trigger looks right now.

show trigger

• MUI Leap
  • Events
    • Unit - A unit Starts the effect of an ability
  • Conditions
    • (Ability being cast) Equal to Leap (Dummy, channel, Crow transition
  • Actions
    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
      • If - Conditions
        • LeapMUI[0] Equal to 0
      • Then - Actions
        • Trigger - Turn on MUI Leaploop <gen>
      • Else - Actions
    • Set LeapMUI[0] = (LeapMUI[0] + 1)
    • Set LeapMUI[0] = (LeapMUI[1] + 1)
    • Set Leap_Caster[LeapMUI[1]] = (Triggering unit)
    • Unit - Turn collision for Leap_Caster[LeapMUI[1]] Off
    • Set LeapSpeed[LeapMUI[1]] = 25.00
    • Set LeapDistance[LeapMUI[1]] = 500.00
    • Set LeapAngle[LeapMUI[1]] = (Facing of Leap_Caster[LeapMUI[1]])
    • Set LeapHeight[LeapMUI[1]] = 0.00
    • Set Leap_Check[LeapMUI[1]] = False
    • Set Leap_Height_Max[LeapMUI[1]] = (LeapDistance[LeapMUI[1]] / 2.00)

Either my version of venger's Loop trigger is not right (likely true) or...
There is another possibility. I don't see anything that makes the unit count as flying in venger's design. This trigger uses flying heights, so (AFAIK) it only works if the trigger also temporarily makes the unit count as flying. In other words, without the Add - Crow Form the trigger won't work. Strange but possible, since WE says "only flying units use flying heights".

 

[venger07]

Either my version of venger's Loop trigger is not right (likely true) or...
There is another possibility. I don't see anything that makes the unit count as flying in venger's design. This trigger uses flying heights, so (AFAIK) it only works if the trigger also temporarily makes the unit count as flying. In other words, without the Add - Crow Form the trigger won't work. Strange but possible, since WE says "only flying units use flying heights".

oh.. i forgot to put the storm crow form.. just add and remove the storm crow form ability at the beginning of the trigger..

 

[MantisHair]

This way isn't working.

show trigger

• MUI Leaploop
  • Events
    • Time - Every 0.03 seconds of game time
  • Conditions
  • Actions
    • Unit - Add Crow Form to Leap_Caster[LeapMUI[2]]
    • Unit - Remove Crow Form from Leap_Caster[LeapMUI[2]]
    • For each (Integer LeapMUI[2]) from 1 to LeapMUI[1], do (Actions)
      • Loop - Actions
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • LeapDistance[LeapMUI[2]] Greater than 0.00
          • Then - Actions
            • Set LeapDistance[LeapMUI[2]] = (LeapDistance[LeapMUI[2]] - LeapSpeed[LeapMUI[2]])
            • Set Leap_Point_Caster[LeapMUI[2]] = (Position of Leap_Caster[LeapMUI[2]])
            • Set Leap_Point_Caster_Offset[LeapMUI[2]] = (Leap_Point_Caster[LeapMUI[2]] offset by LeapSpeed[LeapMUI[2]] towards LeapAngle[LeapMUI[2]] degrees)
            • Custom script: call RemoveLocation(udg_Leap_Point_Caster[udg_LeapMUI[2]])
            • Custom script: call RemoveLocation(udg_Leap_Point_Caster_Offset[udg_LeapMUI[2]])
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • LeapHeight[LeapMUI[2]] Less than Leap_Height_Max[LeapMUI[2]]
                • Leap_Check[LeapMUI[2]] Equal to False
              • Then - Actions
                • Set LeapHeight[LeapMUI[2]] = (LeapHeight[LeapMUI[2]] + LeapSpeed[LeapMUI[2]])
              • Else - Actions
                • Set Leap_Check[LeapMUI[2]] = True
                • Set LeapHeight[LeapMUI[2]] = (LeapHeight[LeapMUI[2]] - LeapSpeed[LeapMUI[2]])
            • Animation - Change Leap_Caster[LeapMUI[2]] flying height to LeapHeight[LeapMUI[2]] at 0.00
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • Or - Any (Conditions) are true
                  • Conditions
                    • LeapDistance[LeapMUI[2]] Less than or equal to 0.00
                    • (Leap_Caster[LeapMUI[2]] is alive) Equal to False
              • Then - Actions
                • Animation - Change Leap_Caster[LeapMUI[2]] flying height to 0.00 at 0.00
                • Unit - Turn collision for Leap_Caster[LeapMUI[2]] On
                • Set LeapDistance[LeapMUI[2]] = 0.00
                • Set Leap_Caster[LeapMUI[2]] = No unit
                • Set LeapSpeed[LeapMUI[2]] = 0.00
                • Set LeapAngle[LeapMUI[2]] = 0.00
                • Set LeapHeight[LeapMUI[2]] = 0.00
                • Set Leap_Check[LeapMUI[2]] = False
                • Set LeapMUI[0] = (LeapMUI[0] - 1)
                • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                  • If - Conditions
                    • LeapMUI[0] Equal to 0
                  • Then - Actions
                    • Trigger - Turn off (This trigger)
                    • Set LeapMUI[0] = 0
                    • Set LeapMUI[1] = 0
                  • Else - Actions
              • Else - Actions
          • Else - Actions

In my (limited) experience, the Crow form needs to be added before changing the height, and removed when the trigger has finished moving the unit around. Where exactly in your trigger does the movement begin and end?

I've also heard it helps to pause the unit, and unpause when the movement ends. Can you confirm/deny?

 

[venger07]

you're suppose to do it like this...

• Leap
• Events
  • Unit - A unit Starts the effect of an ability
• Conditions
  • (Ability being cast) Equal to Leap (Dummy, channel, Crow transition
• Actions
  • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
    • If - Conditions
      • Leap_Mui[0] Equal to 0
      • Then - Actions
        • Trigger - Turn on Leap Loop <gen>
      • Else - Actions
  • Set - Leap_Mui[0] = Leap_Mui[0] + 1
  • Set - Leap_Mui[1] = Leap_Mui[1] + 1
  • Set - Leap_Caster[Leap_Mui[1]] = (Triggering unit)
  • Unit - Turn collision for Leap_Caster[Leap_Mui[1]] Off
  • Unit - Add Crow Form to Leap_Caster[LeapMUI[1]]
  • Unit - Remove Crow Form from Leap_Caster[LeapMUI[1]]
  • Set - Leap_Speed[Leap_Mui[1]] = 25
  • Set - Leap_Distance[Leap_Mui[1]] = 500
  • Set - Leap_Angle[Leap_Mui[1]] = (Facing of Leap_Caster[Leap_Mui[1]])
  • Set - Leap_Height[Leap_Mui[1]] = 0
  • Set - Leap_Check[Leap_Mui[1]] = False
  • Set - Leap_Height_Max[Leap_Mui[1]] = Leap_Distance[Leap_Mui[1]]/2

..i told you to put it at the beginning of the trigger xD