2D Simple Shape System (2D3S) Line Shape opinion

//===========================================================================
//Description:
// - A system that allows the user to create many shapes in a very simple and 
//customizable way. This is simply the core of the system. To draw more shapes
//you will have to import libraries.
//
//Author:
// - Flame_Phoenix
//
//Credits:
// - ThredNThrash, for the main idea and math formulas
// - BubleTech, for efficiency advices
// - Pyro and Anitarf for suggestions on how to improve
// - Veev, for fixing grammar
//
//@version 1.1.3
//===========================================================================
library SimpleShapes requires LinkedList
    
    struct Point 
        private real pointx
        private real pointy
        private real pointTang
        
        static method create takes real newX, real newY returns Point
            local Point this = Point.allocate()
            
            //setting members
            set .pointx = newX
            set .pointy = newY
            
            return this
        endmethod
        
        //Getters
        method operator x takes nothing returns real
            return .pointx
        endmethod
        
        method operator y takes nothing returns real
            return .pointy
        endmethod
        
        method operator tang takes nothing returns real
            return .pointTang
        endmethod
        
        //Setters
        method operator x= takes real newX returns nothing
            set .pointx = newX
        endmethod
        
        method operator y= takes real newY returns nothing
            set .pointy = newY
        endmethod
        
        method operator tang= takes real newTang returns nothing
            set .pointTang = newTang
        endmethod
    endstruct
    
    struct Shape
        List points
        
        static method create takes nothing returns Shape
            local Shape this = Shape.allocate()
            
            //create our list
            set .points = List.create()
            
            return this
        endmethod
        
        method onDestroy takes nothing returns nothing
            call .points.destroy()
        endmethod
    endstruct
    
endlibrary

//===========================================================================
//Description:
// - This library allows you to have an object called Line. It has two optional
//modules you can import to have extra features: xefxLineModule and 
//lightningLineModule.
//
//Requires:
// - SimpleShapes
//
//Methods you can use:
//  static method createLine takes real sX, real sY, real eX, real eY, real interval 
//returns Line
// - sX and sY and startX and startY where the Line begins. eX and eY stand for endX
//and endY respectively. The interval is the space between points.
//
//Members you can use:
//  real ANGLE - imagine that you want to move an object accross a line. This is the angle
//the object needs to have and it is in radians. To get the inverse of an angle just do
//ANGLE + bj_PI.
//
//Author:
// - Flame_Phoenix
//
//Credits:
// - Chobibo, for reporting major problems
//
//@version 1.2.1
//===========================================================================
library LineShape requires SimpleShapes

    struct Line extends Shape
        private real LINE_ANGLE // the tangent line in rads, useful to move projectiles
        
        implement optional XefxLineModule
        implement optional LightningLineModule
        
        static method createLine takes real sX, real sY, real eX, real eY, real interval returns Line
            local Line this = Line.allocate()
            
            //the distance of the line
            local real dx = sX - eX
            local real dy = sY - eY
            local real dist = SquareRoot(dx*dx + dy*dy) 
            
            //temporary variables that will allow us to create many points
            local integer i = 0
            
            //this is to make code easier to read in the loop
            local real x    
            local real y
            
            //this variables are for efficiency reasons
            local real xAng   
            local real yAng   
            local integer size = R2I(dist / (interval ) )
            
            //setting our members
            set .LINE_ANGLE = Atan2(eY - sY, eX - sX)
            
            set xAng = Cos(.LINE_ANGLE) 
            set yAng = Sin(.LINE_ANGLE)
            
            loop
                exitwhen(i == size)
                
                //polar projection stuff
                set x = sX + ((i * dist) / size) * xAng
                set y = sY + ((i * dist) / size) * yAng
                
                call Link.createLast(.points, Point.create(x, y))
                
                set i = i + 1
            endloop
            
            return this
        endmethod
        
        //getter
        method operator ANGLE takes nothing returns real
            return .LINE_ANGLE
        endmethod
    endstruct
endlibrary

//===========================================================================
//Description:
// - This optional module allows you to draw lines using xefx. 
//
//Requires:
// - LineShape
// - xefx
//
//
//Methods:
// - To use this just have a look on the example trigger.
//
// method drawXefxLine takes string path, real interval returns nothing
// - draws the line using the model path suggested and by creatin 1 effect every 
//interval seconds. To create an instant line just set the interval lenght to zero.
//
//method ereaseXefxLine takes nothing returns nothing
// - erases the line created by drawXefxLine, by killing all xefx object. If a 
//line is not completed yet then it will still be immediatly deleted and it will
//not reach the final stage of the draw.
//
//method destroyXefxLine takes boolean eraseLine returns nothing
// - if eraseLine == true, then destroy method will erase the Line object
//created by drawXefxLine. If eraseLine == false, 
//then it simply destroys the line object but it lets the drawing live.
//
//Author:
// - Flame_Phoenix
//
//Credits:
// - Vexorian, for xefx
// - Veev, for fixing grammar
// - Chobibo, for reporting major problems
//
//@version 2.0.0
//===========================================================================
library XefxLineModule requires LineShape, xefx, LinkedList
//===========================================================================
//==========================SETUP START======================================
//===========================================================================
    globals
        public real PERIOD = .025   //the period of the timer
    endglobals
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================
    globals
    //for the stack !
        private timer xefxTimer = null
        private integer instancesCount = 0
        private Line array lines
    endglobals
    
    module XefxLineModule
        private List effects
        private real overTimeCount
        private Link overTimeL
        private string overTimePath
        private boolean drawDone     //when we want to erase a line, we must be sure it is completed. This flag tells us that!
        private real interval
        
        private method updateTimeCounter takes nothing returns nothing
            local xefx object
            set .overTimeCount = .overTimeCount + PERIOD
            
            if .overTimeCount >= .interval then
                //draw picture
                
                set .overTimeL = .overTimeL.next
                //we create the xefx object
                set object = xefx.create(Point(.overTimeL.data).x, Point(.overTimeL.data).y, 0)
                set object.fxpath = .overTimePath
                call Link.createLast(.effects, object)
            
                //if we are done we get rid of the timer
                if .overTimeL == .points.last then
                    set .drawDone = true
                endif
                                    
                set .overTimeCount = 0
            endif
        endmethod
        
        private static method periodic takes nothing returns nothing
            local integer currentIndex = 0
            local Line currentLine
            
            loop
                set currentLine = lines[currentIndex]
                call currentLine.updateTimeCounter()
                
                //if our instance is done, we decrement the number of total instances
                //and then we check if there are any more instances being run
                if currentLine.drawDone then
                    set instancesCount = instancesCount - 1
                    
                    //if there are more instances running, then we update our instance to the next of the array
                    //and we correct the index
                    if (instancesCount > 0) then
                        set lines[currentIndex] = lines[instancesCount]
                        set currentIndex = currentIndex - 1
                    //else we just release the timer
                    else
                        call PauseTimer(xefxTimer)
                    endif
                endif
                
                set currentIndex = currentIndex + 1
                exitwhen currentIndex >= instancesCount
            endloop
        endmethod
        
        method drawXefxLine takes string path, real interval returns nothing
            local xefx object 
            set .interval = interval
            set .overTimePath = path
            set .overTimeCount = 0
            set .drawDone = false
            
            set .overTimeL = .points.first
            set .effects = List.create()
            
            set object = xefx.create(Point(.overTimeL.data).x, Point(.overTimeL.data).y, 0)
            set object.fxpath = .overTimePath
            call Link.createLast(.effects, object)
            
            if instancesCount == 0 then
                //if the number of instances is 0 and xefxTimer == null then we 
                //need to create it because it isthe first time we are using the spell
                if xefxTimer == null then
                    set xefxTimer = CreateTimer()
                endif
                
                //if instances == 0 but xefxTimer != null means the timer is paused and
                //we need to start it again!
                call TimerStart(xefxTimer, PERIOD, true, function Line.periodic)
            endif
        
            set lines[instancesCount] = this
            set instancesCount = instancesCount + 1
        endmethod
        
        method eraseXefxLine takes nothing returns nothing
            local Link link = .effects.first 

            //if we didn't finished the picture yet, we finish it now
            if not(.drawDone) then
                set .drawDone = true
            endif
            
            //we need to wait to make the variable true make it's work
            call TriggerSleepAction(0.)
            
            call xefx(link.data).destroy()  
            
            //we destroy all xefx effects done
            loop
                set link = link.next
                call xefx(link.data).destroy()               
                exitwhen(link == .effects.last)
            endloop
   
            call .effects.destroy()
        endmethod
        
        method destroyXefxLine takes boolean ereaseLine returns nothing
            if ereaseLine then
                
                if .effects == null then
                    debug call BJDebugMsg("destroyXefxLine: There is no drawing to be erased")
                else
                    call .eraseXefxLine()
                endif
            
            endif
        
            call .destroy()
        endmethod
    endmodule
endlibrary

 local integer size = R2I(dist / (interval ) )