2D Simple Shape System (2D3S) REBORN !

//===========================================================================
//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
        
        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
        
        //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
    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
// - TimerUtils
//
//
//Methods:
// - To use this just have a look on the example trigger.
//
// method drawXefxLine takes string path returns nothing
// - draws the line using the model path suggested. This line is created using 
//xefx objects and it is instant.
//
//method drawXefxLineOverTime takes string path, real interval returns nothing
// - same as drawXefxLine, however it takes a time interval that is the wait between
//creating points.
//
//method ereaseXefxLine takes nothing returns nothing
// - erases the line created by drawXefxLine or be drawXefxLineOverTime, by 
//killing all xefx object. If a line is not completed yet (because you are 
//using drawXefxLineOverTime) then it does NOT DELETE the objects but displays 
//an error message instead.
//
//method destroyXefxLine takes boolean eraseLine returns nothing
// - if eraseLine == true, then destroy method will erase the Line object
//created by drawXefxLine or drawXefxLineOverTiem. 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 1.0.0
//===========================================================================
library XefxLineModule requires LineShape, xefx, TimerUtils

    module XefxLineModule
        private xefx array effects[2000]
        private integer overTimeCounter
        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 static method drawOverTimeLoop takes nothing returns nothing
            //we get the structure from the timer
            local Line this = Line(GetTimerData(GetExpiredTimer())) 
                
            //we create the xefx object
            set .effects[.overTimeCounter] = xefx.create(Point(.overTimeL.data).x, Point(.overTimeL.data).y, 0)
            set .effects[.overTimeCounter].fxpath = .overTimePath
            
            set .overTimeL = .overTimeL.next
            set .overTimeCounter = .overTimeCounter + 1
            
            //if we are done we get rid of the timer
            if .overTimeCounter == .points.size then
                set .drawDone = true
                call ReleaseTimer(GetExpiredTimer())
            endif
        endmethod
        
        method drawXefxLineOverTime takes string path, real interval returns nothing
            local timer xefxTimer = NewTimer()
            
            set .drawDone = false
            set .overTimePath = path
            set .overTimeCounter = 0
            set .overTimeL = .points.first
            
            call SetTimerData(xefxTimer, integer(this))
            call TimerStart(xefxTimer, interval, true, function Line.drawOverTimeLoop)
        endmethod
        
        method drawXefxLine takes string path returns nothing
            //now we create 1 unit per each point
            local Link L = .points.first
            local Point point
            local integer i = 0
            
            loop
                exitwhen(i == .points.size)
                set point = L.data
                
                set .effects[i] = xefx.create(point.x, point.y, 0)
                set .effects[i].fxpath = path
                
                set L = L.next
                set i = i + 1
            endloop

            set .drawDone = true
        endmethod
        
        method eraseXefxLine takes nothing returns nothing
            local integer i

            if .drawDone then
                set i = 0
                loop
                    exitwhen(i == .points.size)
                    call .effects[i].destroy()                    
                    set i = i + 1
                endloop
            else
                debug call BJDebugMsg("eraseXefxLine: draw is not complete and so it can not be erased!")
            endif
        endmethod
        
        method destroyXefxLine takes boolean ereaseLine returns nothing
            if ereaseLine then
                
                if .effects[0] == null then
                    debug call BJDebugMsg("destroyXefxLine: There is no drawing to be erased")
                else
                    call .eraseXefxLine()
                endif
            
            endif
            
            call .destroy()
        endmethod

    endmodule

endlibrary

public constant integer MAX_SIZE = 1000

real array COORD_X[MAX_SIZE]
real array COORD_Y[MAX_SIZE]

( 360.00 / (radius / interval)) * bj_DEGTORAD

struct point // defines a point in the shape
    real x
    real y
    // add your methods for the points, like show effects
endstruct

struct connector // allows to connect 2 points 
    point start
    point end
    static method create takes point A, point B returns thistype
    
    endmethod
endstruct

struct line
    // the methods to gather several connectors and form a line
endstruct

struct circle
    // the methods to gather several connectors and form a circle
endstruct