[Trigger] Line Damage System

[aple]

So, I'm in the process of making a system where you can input whatever variables you want and then give a unit line splash damage more like in StarCraft and StarCraft II then WarCraft IIIs very hard to understand and missnamed line damage.

My problem is, the first time it is used it doesn't work. But after that, it works completely fine. As in, the first time it does not deal damage to any units but the second time I use the unit's ability it works fine. Here are my triggers:

• Lurker Attack
  • Events
    • Unit - A unit Starts the effect of an ability
  • Conditions
  • Actions
    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
      • If - Conditions
        • (Ability being cast) Equal to Attack (Lurker)
      • Then - Actions
        • Game - Display to (All players) the text: UNIT INDEXED!
        • Set L_MaxIndex = (L_MaxIndex + 1)
        • Set L_Attacker[L_MaxIndex] = (Triggering unit)
        • Set L_SpineDelay[L_MaxIndex] = 0.20
        • Set L_AttackPoint[L_MaxIndex] = (Position of (Target unit of ability being cast))
        • Set L_SpineCount[L_MaxIndex] = 9
        • Set L_SpineDistance[L_MaxIndex] = 70.00
        • Set L_AoEOfSpine[L_MaxIndex] = 80.00
        • Set L_Damage[LA_Integer] = 30.00
        • Set L_FriendlyFire[L_MaxIndex] = False
        • Set L_TargetUnit[L_MaxIndex] = (Target unit of ability being cast)
        • -------- GLOBAL --------
        • Set LA_AttackTimer[L_MaxIndex] = 0.00
        • Trigger - Turn on Lurker Attack Clock <gen>
      • Else - Actions

• Line Attack Clock
  • Events
    • Time - Every 0.01 seconds of game time
  • Conditions
  • Actions
    • For each (Integer LA_Integer) from 1 to L_MaxIndex, do (Actions)
      • Loop - Actions
        • Set LA_AttackTimer[LA_Integer] = (LA_AttackTimer[LA_Integer] + 0.01)
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • LA_AttackTimer[LA_Integer] Equal to L_SpineDelay[LA_Integer]
          • Then - Actions
            • Game - Display to (All players) the text: TIMER END!
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • LA_SpineCounter[LA_Integer] Less than L_SpineCount[LA_Integer]
              • Then - Actions
                • Set LA_AttackTimer[LA_Integer] = 0.00
                • Set LA_SpineCounter[LA_Integer] = (LA_SpineCounter[LA_Integer] + 1)
                • Set LA_SpineDistance[LA_Integer] = (LA_SpineDistance[LA_Integer] + L_SpineDistance[LA_Integer])
                • Set L_SpineTempPoint[LA_Integer] = ((Position of L_Attacker[LA_Integer]) offset by LA_SpineDistance[LA_Integer] towards (Angle from (Position of L_Attacker[LA_Integer]) to L_AttackPoint[LA_Integer]) degrees)
                • Game - Display to (All players) the text: POINT GRABBED!
                • Unit Group - Pick every unit in (Units within L_AoEOfSpine[LA_Integer] of L_SpineTempPoint[LA_Integer]) and do (Actions)
                  • Loop - Actions
                    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                      • If - Conditions
                        • L_FriendlyFire[LA_Integer] Equal to True
                      • Then - Actions
                        • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                        • Game - Display to (All players) the text: DAMAGE DEALT!
                      • Else - Actions
                        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                          • If - Conditions
                            • L_FriendlyFire[LA_Integer] Equal to False
                          • Then - Actions
                            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                              • If - Conditions
                                • Or - Any (Conditions) are true
                                  • Conditions
                                    • ((Picked unit) belongs to an enemy of (Owner of L_Attacker[LA_Integer])) Equal to True
                                    • (Picked unit) Equal to L_TargetUnit[LA_Integer]
                              • Then - Actions
                                • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                                • Game - Display to (All players) the text: DAMAGE DEALT!
                              • Else - Actions
                          • Else - Actions
                • Unit - Create 1 Lurker Attack Spine for (Owner of L_Attacker[LA_Integer]) at L_SpineTempPoint[LA_Integer] facing (Angle from L_AttackPoint[LA_Integer] to (Position of L_Attacker[LA_Integer])) degrees
                • Game - Display to (All players) the text: SPINE CREATED!
                • Custom script: call RemoveLocation (udg_L_SpineTempPoint[udg_LA_Integer])
                • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                  • If - Conditions
                    • LA_SpineCounter[LA_Integer] Equal to L_SpineCount[LA_Integer]
                  • Then - Actions
                    • -------- LOCALS --------
                    • Set LA_SpineCounter[LA_Integer] = 0
                    • Set LA_SpineDistance[LA_Integer] = 0.00
                    • -------- GLOBALS --------
                    • Set L_Attacker[LA_Integer] = No unit
                    • Set L_Attacker[LA_Integer] = L_Attacker[L_MaxIndex]
                    • Set L_TargetUnit[LA_Integer] = No unit
                    • Set L_TargetUnit[LA_Integer] = L_Attacker[L_MaxIndex]
                    • Set L_SpineDelay[LA_Integer] = 0.00
                    • Set L_SpineDelay[LA_Integer] = L_SpineDelay[L_MaxIndex]
                    • Set L_AoEOfSpine[LA_Integer] = 0.00
                    • Set L_AoEOfSpine[L_MaxIndex] = L_SpineDelay[L_MaxIndex]
                    • Custom script: call RemoveLocation (udg_L_AttackPoint[udg_LA_Integer])
                    • Set L_AttackPoint[LA_Integer] = L_AttackPoint[L_MaxIndex]
                    • Set L_SpineCount[LA_Integer] = 0
                    • Set L_SpineCount[LA_Integer] = LA_SpineCounter[L_MaxIndex]
                    • Set L_SpineDistance[LA_Integer] = 0.00
                    • Set L_SpineDistance[LA_Integer] = L_SpineDistance[L_MaxIndex]
                    • Set L_Damage[LA_Integer] = 0.00
                    • Set L_Damage[LA_Integer] = L_Damage[L_MaxIndex]
                    • Set L_FriendlyFire[LA_Integer] = False
                    • Set L_FriendlyFire[LA_Integer] = L_FriendlyFire[L_MaxIndex]
                    • Set L_MaxIndex = (L_MaxIndex - 1)
                    • Game - Display to (All players) the text: CLEAN UP FINISHED!
                  • Else - Actions
              • Else - Actions
          • Else - Actions

I know I have some obvious leaks but I'm not worried about them. I'll fix them later once the system is actually 100% operational...

 

[Wietlol]

"Time - Every 0.01 seconds of game time"
Ouch.

Does it only deal no damage or does it also not display the text?

 

[aple]

It does display the text (I assume you mean my Debug text?), but it still deals no damage the first time.

EDIT: It was my Damage Variable that was using LA_Integer for it's array index for some reason.

Need a little bit more testing now before I say my next issue in here.

 

[Wietlol]

So either Picked unit does not exists, attacking unit does not exists or the damage is zero.

Put this in the text:

• Game - Display to (All players) the text: ((Name of (L_Attacker[LA_Integer])) + ( dealt + ((String((L_Damage[LA_Integer])) + (to + (Name of (Picked unit))))))

Then you can see what is wrong.

(Set L_Damage[LA_Integer] = 30.00)
That must be L_MaxIndex instead of LA_Integer.
It is in your first trigger.

Because LA_Integer will be at the max (1) it will do the same.

 

[aple]

Alright, so my original problem was me being stupid. This is finished and I haven't found another bug yet.

This is the basic trigger, that can be used for spells:

(Let me know if you see any leaks or mistakes or redundant code!)

• Example Trigger
  • Events
    • Unit - A unit Starts the effect of an ability
  • Conditions
  • Actions
    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
      • If - Conditions
        • (Ability being cast) Equal to Attack (Lurker)
      • Then - Actions
        • Set L_MaxIndex = (L_MaxIndex + 1)
        • Set L_Attacker[L_MaxIndex] = (Triggering unit)
        • Set L_SpineDelay[L_MaxIndex] = 0.20
        • Set L_AttackPoint[L_MaxIndex] = (Position of (Target unit of ability being cast))
        • Set L_SpineCount[L_MaxIndex] = 9
        • Set L_SpineDistance[L_MaxIndex] = 70.00
        • Set L_AoEOfSpine[L_MaxIndex] = 80.00
        • Set L_Damage[L_MaxIndex] = 30.00
        • Set L_FriendlyFire[L_MaxIndex] = False
        • Set L_TargetUnit[L_MaxIndex] = (Target unit of ability being cast)
        • Set LA_AttackTimer[L_MaxIndex] = 0.00
        • Trigger - Turn on Line Attack Clock <gen>
      • Else - Actions

• Line Attack Clock
  • Events
    • Time - Every 0.01 seconds of game time
  • Conditions
  • Actions
    • For each (Integer LA_Integer) from 1 to L_MaxIndex, do (Actions)
      • Loop - Actions
        • Set LA_AttackTimer[LA_Integer] = (LA_AttackTimer[LA_Integer] + 0.01)
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • LA_AttackTimer[LA_Integer] Equal to L_SpineDelay[LA_Integer]
          • Then - Actions
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • LA_SpineCounter[LA_Integer] Less than L_SpineCount[LA_Integer]
              • Then - Actions
                • Set LA_AttackTimer[LA_Integer] = 0.00
                • Set LA_SpineCounter[LA_Integer] = (LA_SpineCounter[LA_Integer] + 1)
                • Set LA_SpineDistance[LA_Integer] = (LA_SpineDistance[LA_Integer] + L_SpineDistance[LA_Integer])
                • Set L_SpineTempPoint[LA_Integer] = ((Position of L_Attacker[LA_Integer]) offset by LA_SpineDistance[LA_Integer] towards (Angle from (Position of L_Attacker[LA_Integer]) to L_AttackPoint[LA_Integer]) degrees)
                • Unit Group - Pick every unit in (Units within L_AoEOfSpine[LA_Integer] of L_SpineTempPoint[LA_Integer]) and do (Actions)
                  • Loop - Actions
                    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                      • If - Conditions
                        • L_FriendlyFire[LA_Integer] Equal to True
                      • Then - Actions
                        • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                      • Else - Actions
                        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                          • If - Conditions
                            • L_FriendlyFire[LA_Integer] Equal to False
                          • Then - Actions
                            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                              • If - Conditions
                                • Or - Any (Conditions) are true
                                  • Conditions
                                    • ((Picked unit) belongs to an enemy of (Owner of L_Attacker[LA_Integer])) Equal to True
                                    • (Picked unit) Equal to L_TargetUnit[LA_Integer]
                              • Then - Actions
                                • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                              • Else - Actions
                          • Else - Actions
                • Unit - Create 1 Lurker Attack Spine for (Owner of L_Attacker[LA_Integer]) at L_SpineTempPoint[LA_Integer] facing (Angle from L_AttackPoint[LA_Integer] to (Position of L_Attacker[LA_Integer])) degrees
                • Unit - Add a 3.00 second Generic expiration timer to (Last created unit)
                • Custom script: call RemoveLocation (udg_L_SpineTempPoint[udg_LA_Integer])
                • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                  • If - Conditions
                    • LA_SpineCounter[LA_Integer] Equal to L_SpineCount[LA_Integer]
                  • Then - Actions
                    • -------- LOCALS --------
                    • Set LA_SpineCounter[LA_Integer] = 0
                    • Set LA_SpineDistance[LA_Integer] = 0.00
                    • -------- GLOBALS --------
                    • Set L_Attacker[LA_Integer] = L_Attacker[L_MaxIndex]
                    • Set L_Attacker[L_MaxIndex] = No unit
                    • Set L_TargetUnit[LA_Integer] = L_Attacker[L_MaxIndex]
                    • Set L_TargetUnit[L_MaxIndex] = No unit
                    • Set L_SpineDelay[LA_Integer] = L_SpineDelay[L_MaxIndex]
                    • Set L_SpineDelay[L_MaxIndex] = 0.00
                    • Set L_AoEOfSpine[LA_Integer] = L_AoEOfSpine[L_MaxIndex]
                    • Set L_AoEOfSpine[L_MaxIndex] = 0.00
                    • Custom script: call RemoveLocation (udg_L_AttackPoint[udg_LA_Integer])
                    • Set L_SpineCount[LA_Integer] = L_SpineCount[L_MaxIndex]
                    • Set L_SpineCount[L_MaxIndex] = 0
                    • Set L_SpineDistance[LA_Integer] = L_SpineDistance[L_MaxIndex]
                    • Set L_SpineDistance[L_MaxIndex] = 0.00
                    • Set L_Damage[LA_Integer] = L_Damage[L_MaxIndex]
                    • Set L_Damage[L_MaxIndex] = 0.00
                    • Set L_FriendlyFire[LA_Integer] = L_FriendlyFire[L_MaxIndex]
                    • Set L_FriendlyFire[L_MaxIndex] = False
                    • Set L_MaxIndex = (L_MaxIndex - 1)
                  • Else - Actions
              • Else - Actions
          • Else - Actions

NOW. If you want this to be used for a normal unit's ATTACK, here is one more trigger that you'll need per unit to do this:

• Scan Range
  • Events
    • Time - Every 0.03 seconds of game time
  • Conditions
  • Actions
    • For each (Integer Lurk_AutoInteger) from 1 to LurkerGroupMaxIndex, do (Actions)
      • Loop - Actions
        • Set Lurk_Target[Lurk_AutoInteger] = (Random unit from (Units within 600.00 of (Position of LurkerGroup[Lurk_AutoInteger]) matching (((Matching unit) belongs to an enemy of (Owner of LurkerGroup[Lurk_AutoInteger])) Equal to True)))
        • Game - Display to (All players) the text: (Name of Lurk_Target[Lurk_AutoInteger])
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • HoldFireLurker[Lurk_AutoInteger] Equal to False
          • Then - Actions
            • Unit - Order LurkerGroup[Lurk_AutoInteger] to Attack Lurk_Target[Lurk_AutoInteger]
            • Set Lurk_Target[Lurk_AutoInteger] = No unit
          • Else - Actions

You will also need separate triggers for indexing the units.

Things to keep in mind:

My Dummy Unit that I'm spawning is a Flying unit that has the Locust ability so it's collision is disabled.
The base of this system will only work 100% bug-free with spells. If you try to use it with an attack, it will be very wonky.

You have MANY adjustable variables. The first trigger is an example on how to use the system.

You can adjust:

1. Delay between Spines spawning.
2. The number of Spines that spawn.
3. The distance between each Spine that spawns.
4. The AoE Range of each Spine that spawns.
5. The damage of each Spine.
6. And whether Spines will do friendly fire or not.

All you need to do is put the proper variables into any trigger and then run the Clock and it'll do the rest.

I might try submitting this today, if it's not broken and has no problems.

 

[Wietlol]

(Let me know if you see any leaks or mistakes or redundant code!)

Please get rid of the 0.01 and use 0.03 instead.
That is the first that people see... that destroys their expectations.

Also setting the values to null/0 when you remove one spell of the array is not required as you set them to new values anyway.

You have to make a clean spell when you create one anyway to remove any bugs/gitches.

Also there are many group and location leaks.
You should fix those fast.

I might try submitting this today, if it's not broken and has no problems.

I don't really know what this trigger does... because I am too lazy to make the trigger myself or even read what it does.
But I guess that you create a beam (kind of) that damages units in an arced rectangle.
It also spawns a unit that will automatically attack the target.

Is that right?

 

[aple]

Please get rid of the 0.01 and use 0.03 instead.
That is the first that people see... that destroys their expectations.

Also setting the values to null/0 when you remove one spell of the array is not required as you set them to new values anyway.

You have to make a clean spell when you create one anyway to remove any bugs/gitches.

Also there are many group and location leaks.
You should fix those fast.



I don't really know what this trigger does... because I am too lazy to make the trigger myself or even read what it does.
But I guess that you create a beam (kind of) that damages units in an arced rectangle.
It also spawns a unit that will automatically attack the target.

Is that right?

It recreates line damage from StarCraft or StarCraft II.

Example: https://www.youtube.com/watch?v=PZNdaEM9SfI

The spikes that shoot up do damage in those areas and in those areas only.

Also, it appears that sometimes the angle is off and sends the spikes/damage in a complete opposite direction.

 

[Wietlol]

Ah I see.

If the complete opposite direction is towards the center of the map then you have already destroyed the target location. Which will then refer to 0,0 aka center of map. (Could be somewhere else if the map is not centered itself.)

About the spell, yea you cannot do that with a missile system easily.
If you polish it a bit it might get approved.

(My Effect Over Time System 1.3 which is not released yet can do that too.
However I am a bit too busy atm to polish and upload it so it will take some time until that system will get approved.

However... there are massive possibilities with the version that I have (1.2b))

 

[aple]

I was able to fix the angle problem. It wasn't that I was destroying the point before it was being used, I was just putting the information in wrong.

Anyway, this should be the final triggers with everything functional. And as many leaks as I could find fixed:

• Line Attack Clock
  • Events
    • Time - Every 0.03 seconds of game time
  • Conditions
  • Actions
    • For each (Integer LA_Integer) from 1 to L_MaxIndex, do (Actions)
      • Loop - Actions
        • Set LA_AttackTimer[LA_Integer] = (LA_AttackTimer[LA_Integer] + 0.01)
        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
          • If - Conditions
            • LA_AttackTimer[LA_Integer] Equal to L_SpineDelay[LA_Integer]
          • Then - Actions
            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
              • If - Conditions
                • LA_SpineCounter[LA_Integer] Less than L_SpineCount[LA_Integer]
              • Then - Actions
                • Set LA_AttackTimer[LA_Integer] = 0.00
                • Set LA_SpineCounter[LA_Integer] = (LA_SpineCounter[LA_Integer] + 1)
                • Set LA_SpineDistance[LA_Integer] = (LA_SpineDistance[LA_Integer] + L_SpineDistance[LA_Integer])
                • Set L_SpineTempPoint[LA_Integer] = ((Position of L_Attacker[LA_Integer]) offset by LA_SpineDistance[LA_Integer] towards L_Angle[LA_Integer] degrees)
                • Custom script: set bj_wantDestroyGroup = true
                • Unit Group - Pick every unit in (Units within L_AoEOfSpine[LA_Integer] of L_SpineTempPoint[LA_Integer]) and do (Actions)
                  • Loop - Actions
                    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                      • If - Conditions
                        • L_FriendlyFire[LA_Integer] Equal to True
                      • Then - Actions
                        • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                      • Else - Actions
                        • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                          • If - Conditions
                            • L_FriendlyFire[LA_Integer] Equal to False
                          • Then - Actions
                            • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                              • If - Conditions
                                • Or - Any (Conditions) are true
                                  • Conditions
                                    • ((Picked unit) belongs to an enemy of (Owner of L_Attacker[LA_Integer])) Equal to True
                                    • (Picked unit) Equal to L_TargetUnit[LA_Integer]
                              • Then - Actions
                                • Unit - Cause L_Attacker[LA_Integer] to damage (Picked unit), dealing L_Damage[LA_Integer] damage of attack type Normal and damage type Normal
                              • Else - Actions
                          • Else - Actions
                • Unit - Create 1 Lurker Attack Spine for (Owner of L_Attacker[LA_Integer]) at L_SpineTempPoint[LA_Integer] facing L_Angle[LA_Integer] degrees
                • Unit - Add a 3.00 second Generic expiration timer to (Last created unit)
                • Custom script: call RemoveLocation (udg_L_SpineTempPoint[udg_LA_Integer])
                • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                  • If - Conditions
                    • LA_SpineCounter[LA_Integer] Equal to L_SpineCount[LA_Integer]
                  • Then - Actions
                    • -------- LOCALS --------
                    • Set LA_SpineCounter[LA_Integer] = 0
                    • Set LA_SpineDistance[LA_Integer] = 0.00
                    • -------- GLOBALS --------
                    • Set L_Attacker[LA_Integer] = L_Attacker[L_MaxIndex]
                    • Set L_Attacker[L_MaxIndex] = No unit
                    • Set L_TargetUnit[LA_Integer] = L_TargetUnit[L_MaxIndex]
                    • Set L_TargetUnit[L_MaxIndex] = No unit
                    • Set L_SpineDelay[LA_Integer] = L_SpineDelay[L_MaxIndex]
                    • Set L_SpineDelay[L_MaxIndex] = 0.00
                    • Set L_Angle[LA_Integer] = L_Angle[L_MaxIndex]
                    • Set L_Angle[L_MaxIndex] = 0.00
                    • Set L_AoEOfSpine[LA_Integer] = L_AoEOfSpine[L_MaxIndex]
                    • Set L_AoEOfSpine[L_MaxIndex] = 0.00
                    • Custom script: call RemoveLocation (udg_L_AttackPoint[udg_LA_Integer])
                    • Custom script: call RemoveLocation (udg_L_PositionOfAttacker[udg_LA_Integer])
                    • Set L_SpineCount[LA_Integer] = L_SpineCount[L_MaxIndex]
                    • Set L_SpineCount[L_MaxIndex] = 0
                    • Set L_SpineDistance[LA_Integer] = L_SpineDistance[L_MaxIndex]
                    • Set L_SpineDistance[L_MaxIndex] = 0.00
                    • Set L_Damage[LA_Integer] = L_Damage[L_MaxIndex]
                    • Set L_Damage[L_MaxIndex] = 0.00
                    • Set L_FriendlyFire[LA_Integer] = L_FriendlyFire[L_MaxIndex]
                    • Set L_FriendlyFire[L_MaxIndex] = False
                    • Set L_MaxIndex = (L_MaxIndex - 1)
                  • Else - Actions
              • Else - Actions
          • Else - Actions

And a better example trigger that is cleaner and easier to follow:

• Lurker Attack
  • Events
    • Unit - A unit Is attacked
  • Conditions
  • Actions
    • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
      • If - Conditions
        • (Unit-type of (Attacking unit)) Equal to Lurker (Burrowed)
      • Then - Actions
        • -------- Copy/Paste these. These are needed for system functionality. --------
        • Set L_MaxIndex = (L_MaxIndex + 1)
        • Set L_TargetUnit[L_MaxIndex] = (Attacked unit)
        • Set L_Attacker[L_MaxIndex] = (Attacking unit)
        • Set L_AttackPoint[L_MaxIndex] = (Position of L_TargetUnit[L_MaxIndex])
        • Set L_PositionOfAttacker[L_MaxIndex] = (Position of L_Attacker[L_MaxIndex])
        • Set LA_AttackTimer[L_MaxIndex] = 0.00
        • Set L_Angle[L_MaxIndex] = (Angle from L_PositionOfAttacker[L_MaxIndex] to L_AttackPoint[L_MaxIndex])
        • -------- These are adjustables. You can change these, but not the ones above. --------
        • Set L_Damage[L_MaxIndex] = 30.00
        • Set L_SpineDelay[L_MaxIndex] = 0.08
        • Set L_SpineCount[L_MaxIndex] = 9
        • Set L_SpineDistance[L_MaxIndex] = 70.00
        • Set L_AoEOfSpine[L_MaxIndex] = 80.00
        • Set L_FriendlyFire[L_MaxIndex] = False
        • -------- Run system once all adjustables are finished. --------
        • Trigger - Turn on Line Attack Clock <gen>
      • Else - Actions