Hello all ! I Have questions ! You got answers !

library ListModule
//===========================================================================
// Information:
//==============
//
//    This library provides the List module, which allows you to easily create
// a linked list of all of the allocated instances of a struct-type. Iterating
// through a linked list is about 12% faster than iteratating through an array
// in JASS. There is no faster method to iterate through a list of structs than
// the method used by this module. Aside from the marginal speed gain, the best
// use of this library is to hide some ugly low-level code from your structs.
// Rather than manually building and maintaining a list of struct instances,
// just implement the List module, and your code will become much prettier.
//
//===========================================================================
// How to use the List module:
//=============================
//
//    Using the List module is pretty simple. First, implement it in your
// struct (preferably at the top to avoid unnecessary TriggerEvaluate calls).
// In the struct's create method, you must call listAdd(). In the onDestroy
// method, you must also call listRemove(). An example is shown below:
/*
    struct Example
        implement List
       
        static method create takes nothing returns Example
            local Example this = allocate()
                call listAdd() //This method adds the instance to the list.
            return this
        endmethod
       
        method onDestroy takes nothing returns nothing
            call listRemove() //This method removes the instance from the list.
        endmethod
    endstruct
*/
//    The requirement to call listAdd() and listRemove() will be done away
// with once JassHelper supports module onDestroy and module onCreate, but
// for now, it is not too much of a burden.
//
//    Once this is done, your struct will gain all of the methods detailed
// in the API section. Below is an example of how to iterate through the list
// of allocated structs of the implementing struct-type:
/*
    function IterationExample takes nothing returns nothing
        local Example e = Example.first
            loop
                exitwhen e == 0
                //Do something with e here.
                set e = e.next
            endloop
        //Use .last and .prev instead to iterate backwards.
    endmethod
*/
//
//===========================================================================
// List module API:
//==================
//
// (readonly)(static) first -> thistype
//  This member contains the first instance of thistype in the list.
//
// (readonly)(static) last -> thistype
//  This member contains the last instance of thistype in the list.
//
// (readonly)(static) count -> integer
//  This member contains the number of allocated structs of thistype.
//
// (readonly) next -> thistype
//  This member contains the next instance of thistype in the list.
//
// (readonly) prev -> thistype
//  This member contains the previous instance of thistype in the list.
//
// listAdd()
//  This method adds this instance to the list of structs of thistype.
//  This should be called on each instance after it is allocated (within
//  the create method).
//
// listRemove()
//  This method removes this instance from the list of structs of thistype.
//  This should be called on each instance before it is destroyed (within
//  the onDestroy method).
//
// (static) listDestroy()
//  This method destroys all the structs of thistype within the list.
//
//===========================================================================

module List
    private static boolean destroying = false
    private boolean inlist = false
   
    readonly static integer count = 0
   
    readonly thistype next = 0
    readonly thistype prev = 0
   
    static method operator first takes nothing returns thistype
        return thistype(0).next
    endmethod
   
    static method operator last takes nothing returns thistype
        return thistype(0).prev
    endmethod
       
    method listRemove takes nothing returns nothing
        if not inlist then
            return
        endif
        set inlist = false
        set prev.next = next
        set next.prev = prev
        set count = count - 1
    endmethod

    method listAdd takes nothing returns nothing
        if inlist or destroying then
            return
        endif
        set inlist = true
        set last.next = this
        set prev = last
        set thistype(0).prev = this
        set count = count + 1
    endmethod
   
    static method listDestroy takes nothing returns nothing
        local thistype this = last
            set destroying = true
            loop
                exitwhen this == 0
                call destroy()
                set this = prev
            endloop
            set destroying = false
    endmethod
   
endmodule

endlibrary

library CameraLibrary requires ListModule
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                        Rotation Camera
//                    by Serenity09 @ USEAST
//                    ListModule by Grim001 (give credit to him)
//                          Clan TMMM
// Purpose:
// Creates a structure which rotates "randomly" around a given unit for a given player
//====================================================================================
// Configuration:
// Change the values of the global variables to be as you want, recommended values are given
// descriptions of what each variable does is given by the comment directly above the variable
//============================================================================================
// Importing:
// This library requires ListModule. Either import ListModule manually, or copy and paste the Libraries folder located in the test map
// All global variables must have a value. Some must be set in a separate trigger at map init (like CamUnit)
// If being used in a maze, you most likely have an array which contains all the mazers - if this is the case
// you should replace the CamUnit array with your own.
// Because this uses libraries and structs, this requires JASS newGen editor to compile.
//======================================================================================
// Expanded API: (functions available to this struct) + explanations
//
// .create(integer i, unit u) -> RotationCamera
// creates a camera for Player(i) centering around unit u
// if ROTATEONCREATE in the configurables section is set to true, then the camera will begin rotation immediately
//
// .destroy() -> nothing
// deallocates the RotationCamera object as well as:
// nulling member variables, resetting default camera for owning player, stopping camera rotation.
//
// .CamStart() -> nothing
// resumes rotation for a previously created camera. camera MUST exist already.
//
// .CamStop() -> nothing
// stops rotation for an existing camera. however this does not destroy the camera.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
globals
    //CONFIGURABLES
    //should this run in debug mode?
    //only for testing (debug messages leak)
    private constant boolean CAMDEBUG = false
    //the timer used for the periodic function
    private timer CamTimer = CreateTimer()
    //should the rotation direction alternate or be random?
    private constant boolean CAMALTERNATEDIR = true
    //should cameras start rotating as soon as they are created?
    private constant boolean ROTATEONCREATE = true
    //how often the periodic trigger is run, higher means less memory intensive but choppier movement
    private constant real HowOften = .05
    //bounds for cam rotation speed
    private constant real LeastCamSpeed = .5
    private constant real MostCamSpeed = 5
    //bounds for rotation duration
    private constant integer LeastCamTicks = 50
    private constant integer MostCamTicks = 200
   
    //dont touch below here unless you know what you're doing

endglobals

struct RotationCamera
    //an array that stores previous camera angles
    private real CurCamAngle
    //how many ticks are left going in this direction
    private integer CamNumTicks
    //true == clockwise, false == counterclockwise
    private boolean CamRotationDirection
    //the speed for the camera
    private real CamRotationSpeed
    //the current camera
    private camerasetup CurCam
    //who does this camera belong to
    private player CamOwner
    //which unit does the camera center on
    private unit CamUnit
   
    private method CamRandGenerate takes nothing returns nothing
        //generates a new random set of paramaters which replace the previous ones
        set CamNumTicks = GetRandomInt(LeastCamTicks, MostCamTicks)
        set CamRotationSpeed = GetRandomReal(LeastCamSpeed, MostCamSpeed)
        static if CAMALTERNATEDIR then
            set CamRotationDirection = not CamRotationDirection
        else
            set CamRotationDirection = (GetRandomInt(0, 1) == 0)
        endif
       
        //debug stuff
        static if CAMDEBUG then
            call DisplayTextToForce(bj_FORCE_PLAYER[GetPlayerId(GetOwningPlayer(CamUnit))], "New Parameters")
            call DisplayTextToForce(bj_FORCE_PLAYER[GetPlayerId(GetOwningPlayer(CamUnit))], "Num Ticks: " + I2S(CamNumTicks))
            call DisplayTextToForce(bj_FORCE_PLAYER[GetPlayerId(GetOwningPlayer(CamUnit))], "Rotation Speed: " + R2S(CamRotationSpeed))
            if CamRotationDirection then
                call DisplayTextToForce(bj_FORCE_PLAYER[GetPlayerId(GetOwningPlayer(CamUnit))], "Rotate Clockwise")
            else
                call DisplayTextToForce(bj_FORCE_PLAYER[GetPlayerId(GetOwningPlayer(CamUnit))], "Rotate Counter-Clockwise")
            endif
        endif

    endmethod
   
    private method CamRotate takes nothing returns nothing
        //if the camera has finished its rotation period then its time to generate a new set of parameters
        if CamNumTicks < 1 then
            call CamRandGenerate()
        //otherwise keep rotating the camera with the existing parameters
        else
            //clockwise or counterclockwise? might be easier for CamRotationDirection to just be -1 or 1.
            if CamRotationDirection then
                set CurCamAngle = CurCamAngle - CamRotationSpeed
            else
                set CurCamAngle = CurCamAngle + CamRotationSpeed
            endif
           
            //prevents super big reals
            if CurCamAngle > 360 then
                set CurCamAngle = CurCamAngle - 360
            elseif CurCamAngle < 0 then
                set CurCamAngle = CurCamAngle + 360
            endif
           
            //set the angle for the camera field
            call CameraSetupSetField(CurCam, CAMERA_FIELD_ROTATION, CurCamAngle, HowOften)
            call CameraSetupSetDestPosition(CurCam, GetUnitX(CamUnit), GetUnitY(CamUnit), HowOften)
           
            //apply the new angle/camera for the specified person
            if GetLocalPlayer() == CamOwner then
                call CameraSetupApply(CurCam, false, false)
                call PanCameraToTimed(GetUnitX(CamUnit), GetUnitY(CamUnit), HowOften)
            endif
           
            //decrement the number of ticks remaining for these parameters
            set CamNumTicks = CamNumTicks - 1
        endif
    endmethod
   
    implement List
   
    //iterates through the list of cameras calling the rotation function
    private static method periodic takes nothing returns nothing
        local RotationCamera e = .first
       
        loop
        exitwhen e == 0
            call e.CamRotate()
            set e = e.next
        endloop
    endmethod
       
    //start a camera given a previously stopped camera.
    //Cannot start a destroyed camera, if you destroy a camera you need to .create a new one to replace it
    public method CamStart takes nothing returns nothing
        call .listAdd()
    endmethod
   
    //stops a camera while leaving the RotationCamera object intact
    public method CamStop takes nothing returns nothing
        call .listRemove()
    endmethod
   
    //initializes all the data fields for the rotating camera object
    //no rotation is actually done here
    public static method create takes integer WhosCamId, unit whichCamUnit returns RotationCamera
        local RotationCamera new = RotationCamera.allocate()
       
        set new.CamOwner = Player(WhosCamId)
        set new.CamUnit = whichCamUnit
        set new.CurCamAngle = 0
        set new.CurCam = CreateCameraSetup()
       
        //generates and sets the parameters for the camera
        call new.CamRandGenerate()
       
        //if true, the camera will begin rotating immediately for the given player
        static if ROTATEONCREATE then
            call new.listAdd()
        endif
       
        call TimerStart(CamTimer, HowOften, true, function RotationCamera.periodic)
       
        return new
    endmethod
       
    private method onDestroy takes nothing returns nothing
        //remove this camera from the list
        call .listRemove()
        //if no camera is being rotated, then pause the timer
        if .count == 0 then
            call PauseTimer(CamTimer)
        endif
        //resets the game camera to default for given player
        if GetLocalPlayer() == CamOwner then
            call ResetToGameCamera(3.00)
        endif
        //null handle member variables
        set CamOwner = null
        set CurCam = null
    endmethod
   
endstruct

endlibrary

globals
    //how many people play (at most)
    constant integer NumberPlayers = 10
    //used to access the different cameras
    RotationCamera array RotCameras[NumberPlayers]
    //array for all the units which are "attached" to the camera
    unit array CamUnit[NumberPlayers]
endglobals


//===========================================================================
function InitTrig_CamTest takes nothing returns nothing
    local integer i = 0
   
    set CamUnit[0] = gg_unit_Hblm_0000
    set CamUnit[1] = gg_unit_Hblm_0003
    set gg_trg_CamTest = CreateTrigger(  )
   
    loop
    exitwhen i > NumberPlayers - 1
        if GetPlayerSlotState(Player(i)) == PLAYER_SLOT_STATE_PLAYING then
            set RotCameras[i] = RotationCamera.create(i, CamUnit[i])
        endif
        set i = i + 1
    endloop
endfunction