• 🏆 Texturing Contest #33 is OPEN! Contestants must re-texture a SD unit model found in-game (Warcraft 3 Classic), recreating the unit into a peaceful NPC version. 🔗Click here to enter!
  • It's time for the first HD Modeling Contest of 2024. Join the theme discussion for Hive's HD Modeling Contest #6! Click here to post your idea!

Line Damage System 1.1

This bundle is marked as useful / simple. Simplicity is bliss, low effort and/or may contain minor bugs.
V1.0
First Release.

V1.1
+Fixed multiple bugs.
+Added the option to allow units to get hit by multiple spines from the same Attacker.
+Tried my best to make it more clear and easy to understand.

This system creates a line attack similar to what you see in StarCraft and StarCraft 2. You have several adjustable variables to customize how it works.

How that work's is:

Basically, the attack sends "Spines" travel across the screen in a line. Anything that touches the "Spines" takes damage. But only if they touch the spine, that includes the initial target. You can adjust the delay between Spines spawning to make it impossible to dodge, as well if you prefer.

And here's how that looks:


You have several things you can customize per instance. Each also has a default value, in case you don't want to immediately change something or if you forget to change something. You can customize:
Damage.
Variables

Delay between each "Spine" Default = 10
The number of "Spines" spawned Default = 70
The distance between each "Spine" Default = 60
AoE of each "Spine" Default = False
And whether the Spines do Friendly Fire damage or not. Default = False
NEW: Whether the same unit cannot take damage more then once from the same attacker by being within multiple AoE's of the attacker. Default = True
COMING SOON: The spines end at the acquired/targeted unit. Default = False
COMING SOON: Whether the spines will bounce in a random direction when they hit a unit or not. Default = False
It's a /little/ bit off, but I think it turned out really good.

Credits for the Lurker model goes to Caveman.


  • Line Attack Clock
    • Events
      • Time - Every 0.05 seconds of game time
    • Conditions
    • Actions
      • For each (Integer LA_Integer) from 1 to L_MaxIndex, do (Actions)
        • Loop - Actions
          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
            • If - Conditions
              • LA_AngleSet[LA_Integer] Equal to False
            • Then - Actions
              • Set L_AttackPoint[LA_Integer] = (Position of L_TargetUnit[LA_Integer])
              • Set L_PositionOfAttacker[LA_Integer] = (Position of L_Attacker[LA_Integer])
              • Set L_Angle[LA_Integer] = (Angle from L_PositionOfAttacker[LA_Integer] to L_AttackPoint[LA_Integer])
              • Set LA_AngleSet[LA_Integer] = True
            • Else - 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_SpineCounter[LA_Integer] = (LA_SpineCounter[LA_Integer] + 1)
                  • Set LA_AttackTimer[LA_Integer] = 0.00
                  • Set LA_SpineDistance[LA_Integer] = (LA_SpineDistance[LA_Integer] + L_SpineDistance[LA_Integer])
                  • Set L_SpineTempPoint[LA_Integer] = (L_PositionOfAttacker[LA_Integer] offset by LA_SpineDistance[LA_Integer] towards L_Angle[LA_Integer] degrees)
                  • Custom script: set bj_wantDestroyGroup = true
                  • 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)
                  • 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
                          • (Picked unit) Not equal to L_Attacker[LA_Integer]
                          • (Unit-type of (Picked unit)) Not equal to Lurker Attack Spine
                        • Then - Actions
                          • -------- Add more conditions above if you happen to add more units that you want to be immune. An example is already there, the Spines. --------
                          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                            • If - Conditions
                              • L_FriendlyFire[LA_Integer] Equal to True
                            • Then - Actions
                              • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                                • If - Conditions
                                  • L_DmgOnlyOnce[LA_Integer] Equal to True
                                • Then - Actions
                                  • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                                    • If - Conditions
                                      • ((Picked unit) is in L_DamagedUnits[LA_Integer]) Equal to False
                                    • Then - Actions
                                      • Unit Group - Add (Picked unit) to L_DamagedUnits[LA_Integer]
                                      • 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 - 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
                                      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                                        • If - Conditions
                                          • L_DmgOnlyOnce[LA_Integer] Equal to True
                                        • Then - Actions
                                          • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                                            • If - Conditions
                                              • ((Picked unit) is in L_DamagedUnits[LA_Integer]) Equal to False
                                            • Then - Actions
                                              • Unit Group - Add (Picked unit) to L_DamagedUnits[LA_Integer]
                                              • 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 - 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
                        • Else - Actions
                  • 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] = LA_SpineCounter[L_MaxIndex]
                      • Set LA_SpineCounter[L_MaxIndex] = 0
                      • Set LA_SpineDistance[LA_Integer] = LA_SpineDistance[L_MaxIndex]
                      • Set LA_SpineDistance[L_MaxIndex] = 0.00
                      • Set L_DamagedUnits[LA_Integer] = L_DamagedUnits[L_MaxIndex]
                      • Unit Group - Remove all units from L_DamagedUnits[L_MaxIndex]
                      • Set LA_AngleSet[LA_Integer] = LA_AngleSet[L_MaxIndex]
                      • Set LA_AngleSet[L_MaxIndex] = False
                      • Set L_Angle[LA_Integer] = L_Angle[L_MaxIndex]
                      • Set L_Angle[L_MaxIndex] = 0.00
                      • Custom script: call RemoveLocation (udg_L_PositionOfAttacker[udg_LA_Integer])
                      • Custom script: call RemoveLocation (udg_L_AttackPoint[udg_LA_Integer])
                      • -------- 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_AoEOfSpine[LA_Integer] = L_AoEOfSpine[L_MaxIndex]
                      • Set L_AoEOfSpine[L_MaxIndex] = 0.00
                      • 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] = True
                      • Set L_DmgOnlyOnce[LA_Integer] = L_DmgOnlyOnce[L_MaxIndex]
                      • Set L_DmgOnlyOnce[L_MaxIndex] = True
                      • Set L_MaxIndex = (L_MaxIndex - 1)
                    • Else - Actions
                • Else - Actions
            • Else - Actions
To use this system, make a trigger similar to this one. Replace "(Unit-type of (Attacking unit)) Equal to Lurker (Burrowed)" and the Event with your condition and event of choice. Finally, make sure you set "L_TargetUnit[L_MaxIndex]" and "L_Attacker[L_MaxIndex]" accordingly.

  • Example Trigger
    • 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)
          • -------- These are adjustables. You can change these, but not the ones above unless you know what your doing. --------
          • Set L_Damage[L_MaxIndex] = 30.00
          • Set L_SpineDelay[L_MaxIndex] = 0.04
          • Set L_SpineCount[L_MaxIndex] = 9
          • Set L_SpineDistance[L_MaxIndex] = 77.78
          • Set L_AoEOfSpine[L_MaxIndex] = 60.00
          • Set L_FriendlyFire[L_MaxIndex] = True
          • Set L_DmgOnlyOnce[L_MaxIndex] = False
          • -------- Run system once all adjustables are finished. --------
          • Trigger - Turn on Line Attack Clock <gen>
        • Else - Actions


EDIT: This could potentially be modified to recreate SC2's Effects system and I think I'll work on that next.

IMPORTANT NOTES:

1. Your unit that uses this system must have -1 damage and 1 for Number of Dice and 1 for Sides per Dice otherwise it will cause units to run away. To do the -1 Damage, Hold shift and press enter or click on the damage field. It will also still cause the "Your Unit is Under Attack" Alert, so if you want to create something like the Hold Fire for the Lurkers in here you must COMPLETELY DISABLE their attack. Which I have no idea how to do other then using Entangling Roots. So I have to script a custom morph ability to use this 100%

Keywords:
Starcraft, Star Craft, Lurker, Line, Splash
Contents

Line Attack System (Map)

Reviews
12th Dec 2015 IcemanBo: For long time as NeedsFix. Rejected. 12:00, 7th Apr 2015 IcemanBo: Read post in thread.

Moderator

M

Moderator

12th Dec 2015
IcemanBo: For long time as NeedsFix. Rejected.

12:00, 7th Apr 2015
IcemanBo: Read post in thread.
 
aple said:
IMPORTANT NOTES:

1. Your unit that uses this system must have -1 damage and 1 for Number of Dice and 1 for Sides per Dice otherwise it will cause units to run away. To do the -1 Damage, Hold shift and press enter or click on the damage field. It will also still cause the "Your Unit is Under Attack" Alert, so if you want to create something like the Hold Fire for the Lurkers in here you must COMPLETELY DISABLE their attack. Which I have no idea how to do other then using Entangling Roots. So I have to script a custom morph ability to use this 100%.

Just add cargo hold orc burrow to the units to disable it. Don't require a dummy ability.
 
Level 12
Joined
May 20, 2009
Messages
822
I see this more of a spell than a system. WHY? Heck it is not configurable. You can't even register things to it whatsoever.

1/5 voting for rejection UNTIL this finds the suitable type(system, spell, etc.)

You take this Trigger:
  • Example Trigger
    • 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)
          • -------- 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.05
          • 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

  • Example Trigger
    • 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.05
          • 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


And replace " (Unit-type of (Attacking unit)) Equal to Lurker (Burrowed)" With the unit of choice. It's as simple as that...

Or replace it with your own Conditions, like "Spell being cast = Stuff".

Maybe I'll make a few more example triggers.

Just add cargo hold orc burrow to the units to disable it. Don't require a dummy ability.

Wouldn't that disable all other abilities as well, though? Or does it just disable attack?...

EDIT: It doesn't seem to want to go on my unit for some reason.
 
Last edited:
Level 24
Joined
Aug 1, 2013
Messages
4,657
I suggest to create a "Create" function so you only have to set the last 6 (which would be modifyable) and then call the Create().
The other ones could simply be created inside the function.

Also do set the values to regular variables and let the create put them in the arrays...
more friendly.

btw... yes it is more like a spell because it only supports one kind of spell and that spell is created without specific data to tell the system that it is a spine spell.
The modifyable variables are necessary otherwise people won't use it.
 
Level 12
Joined
May 20, 2009
Messages
822
I second this. 14 lines to create an instance?

I can reduce it to 9, but that's about all I can go.

I'll change the type for now so people stop complaining...

EDIT: Okay, so before I post the first ACTUAL update to fix that bug, first I need to ask a question. I actually have no idea if this could be any smaller:


This is the actual damage being done, but my problem is this is obviously very unnecessary but I can't seem to figure out how to make it more efficient without breaking it.

  • 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
                  • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                    • If - Conditions
                      • L_DmgOnlyOnce[LA_Integer] Equal to True
                    • Then - Actions
                      • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                        • If - Conditions
                          • ((Picked unit) is in DamagedUnits[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
                          • Unit Group - Add (Picked unit) to DamagedUnits[LA_Integer]
                        • Else - Actions
                    • Else - 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
                      • Unit Group - Add (Picked unit) to DamagedUnits[LA_Integer]
                • Else - Actions
            • Else - Actions
              • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                • If - Conditions
                  • L_DmgOnlyOnce[LA_Integer] Equal to True
                • Then - Actions
                  • If (All Conditions are True) then do (Then Actions) else do (Else Actions)
                    • If - Conditions
                      • ((Picked unit) is in DamagedUnits[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
                      • Unit Group - Add (Picked unit) to DamagedUnits[LA_Integer]
                    • Else - Actions
                • Else - 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
                  • Unit Group - Add (Picked unit) to DamagedUnits[LA_Integer]
Friendly Fire and Damage Only Once should be known beforehand and they need to work in combination with each other to insure results are accurate.
 
Last edited:
Level 12
Joined
May 20, 2009
Messages
822
I don't see anything wrong with those 14 lines, it's in GUI anyway.

You never know. The difference between 9 lines and 14 lines could really throw people off and make them give up on using it. *Shrug*

Anyway, fixing that bug is a bit more complicated then I thought. Will take a bit longer then I expect, don't know if I'll even figure it out today.

(If you didn't read the OP, basically units take damage more then one time if they are ontop of more then 1 spine's AoE. That should not happen, or at least not by default.)

Also, the Spines/damage are STILL being spawned wrongly... Sometimes one of them shoots off in a completely random direction... ATM it seems to be caused by the angle being lost, I fixed that and it still happens but not as often.

EDIT: It was stupidity on my part. Fixed it now.

Updated to version 1.1.

Aple said:
V1.1
+Fixed multiple bugs.
+Added the option to allow units to get hit by multiple spines from the same Attacker.
+Tried my best to make it more clear and easy to understand.

EDIT2: Working on some more bugs. Currently if the Spine Count is beyond about 12, the rest will start spawning at the center of the map and continue as normally with the proper angle from the center of the map...
EDIT3: It appears that might have been a hiccup by WC3, because I didn't change anything and now it's not happening anymore.
 
Last edited:
Level 37
Joined
Mar 6, 2006
Messages
9,240
-You don't need to test if something is false if you have already tested if it is true
-The damage types should be configurable
-Adjusting time variable by 0.01 during every loop when the loop updates once per 0.05 seconds ins unintuitive
-The unit groups are not created in the code so the system most likely won't work for multiple units
-You should set the amgle stuff when you initialize the instance
 
Level 12
Joined
May 20, 2009
Messages
822
Maker said:
-You don't need to test if something is false if you have already tested if it is true

I do that because if I don't it never seems to work for me. Every time I check something like that, Else never works unless I check if the Variable is false for some reason.

Maker said:
-The damage types should be configurable

Will do! Dunno why I didn't think of that before.
Maker said:
-Adjusting time variable by 0.01 during every loop when the loop updates once per 0.05 seconds ins unintuitive

That was an oversight. I originally had the Periodic Timer at 0.01 for testing purposes because it felt laggy, but after some improvements to the code it stopped feeling laggy so I changed it to 0.05 to slow it down some. Will fix that at some point xD

Maker said:
-The unit groups are not created in the code so the system most likely won't work for multiple units

It most-certainly does work for multiple units, I wouldn't of uploaded it if it didn't. It only uses a Unit Group for the damaged units. Everything else is indexed.

Maker said:
-You should set the amgle stuff when you initialize the instance

What do you mean?
 
Level 12
Joined
May 20, 2009
Messages
822
There should be some descriptive comments for user.
This is not a real line damage system. This is a specification already.
I suggest you to overthink the basic concept in terms what you want to submit.

Edit: And there are some general suggestions by others in thread, too... that might be helpful.

What do you mean by it's not a real line damage system? What's different about this from say... Something you or someone else in this thread would make?

I'm really confused about the quality-standard here. This is 100% functional, you have tons of configurable options, it's useful as this makes a perfect replacement for WC3's existing line damage which is hugely restricted, there's no leaks as far as I can tell, and it seems plenty of people understand how to use it (40+ downloads)...

Don't get me wrong, I still want to learn what it is I need to do to this to make it acceptable. But I'm just really confused.
 
Level 12
Joined
May 20, 2009
Messages
822
A system should only do it's job. Rest should be optional or configurable.
For example in this submission you create lurkers all over it's way to look like this starctraft ability. (hardcoded, not chanegable)
So finaly this is more like a "line damage spell" as a "line demage system" for me, if you see what I mean. :)

I think I get it. It's looking like it's something meant to create the Lurker from BW and thus it makes it look like it's something not quite so useful.

So should I make a better example, that uses an ability instead?
 
Level 12
Joined
May 20, 2009
Messages
822
Basically, what IcemanBo means is that it's applicable in any form related to Line Damaging.
I recommend make more examples to proof that this is a system rather than a spell.

That's what I was getting but I wasn't too sure. I'm going to have to do that it seems. I'll have to stick it on a building and a couple different abilities that implement it in different ways.

One could be where the ability is cast and then the spines travel toward the target, and another would be it's cast on the target and travels in a random direction. Those are just a couple ideas off the top of my head.

BTW, I also realized if I were to stick an enemy-casting autocast ability (Such as Curse) on my "Lurker" here then I wouldn't have the bug where the weapon will chase off units before the spines even reach them... And that'd be a totally better solution then making the unit have -1 base damage which is fine because my original intention from that was to keep the UI visible but it says it does 1 - 1 damage or something like that anyway so it's not really functional...
 
Top