Close ×

AI.AI_A2A

AI -- (R2.2) - Models the process of air operations for airplanes.
AI.AI_A2A_Cap

AI -- (R2.2) - Models the process of Combat Air Patrol (CAP) for airplanes.
AI.AI_A2A_Dispatcher

AI - (R2.2) - Manages the process of an automatic A2A defense system based on an EWR network targets and coordinating CAP and GCI.
AI.AI_A2A_GCI

AI -- (R2.2) - Models the process of Ground Controlled Interception (GCI) for airplanes.
AI.AI_A2A_Patrol

AI -- (R2.2) - Models the process of air patrol of airplanes.
AI.AI_Bai

AI -- Peform Battlefield Area Interdiction (BAI) within an engagement zone.
AI.AI_Balancer

AI -- Balance player slots with AI to create an engaging simulation environment, independent of the amount of players.
AI.AI_Cap

AI -- Perform Combat Air Patrolling (CAP) for airplanes.
AI.AI_Cargo

AI -- (R2.4) - Models the intelligent transportation of infantry and other cargo.
AI.AI_Cargo_APC

AI -- (R2.4) - Models the intelligent transportation of infantry and other cargo.
AI.AI_Cargo_Airplane

AI -- (R2.4) - Models the intelligent transportation of infantry (cargo).
AI.AI_Cargo_Dispatcher

AI -- (R2.4) - Models the intelligent transportation of infantry and other cargo.
AI.AI_Cargo_Dispatcher_APC

AI -- (2.4) - Models the intelligent transportation of infantry and other cargo using APCs.
AI.AI_Cargo_Dispatcher_Airplane

AI -- (R2.4) - Models the intelligent transportation of infantry and other cargo using Planes.
AI.AI_Cargo_Dispatcher_Helicopter

AI -- (2.4) - Models the intelligent transportation of infantry and other cargo using Helicopters.
AI.AI_Cargo_Helicopter

AI -- (R2.4) - Models the intelligent transportation of infantry (cargo).
AI.AI_Cas

AI -- Perform Close Air Support (CAS) near friendlies.
AI.AI_Formation

AI -- Build large airborne formations of aircraft.
AI.AI_Patrol

AI -- Perform Air Patrolling for airplanes.
Actions.Account

Actions - ACT_ACCOUNT_ classes account for (detect, count & report) various DCS events occuring on Wrapper.Units.
Actions.Assign

(SP) (MP) (FSM) Accept or reject process for player (task) assignments.
Actions.Assist

(SP) (MP) (FSM) Route AI or players through waypoints or to zones.
Actions.Route

(SP) (MP) (FSM) Route AI or players through waypoints or to zones.
Cargo.Cargo

Core -- Management of CARGO logistics, that can be transported from and to transportation carriers.
Cargo.CargoCrate

Cargo -- Management of single cargo crates, which are based on a Static object.
Cargo.CargoGroup

Cargo -- Management of grouped cargo logistics, which are based on a Wrapper.Group object.
Cargo.CargoSlingload

Cargo -- Management of single cargo crates, which are based on a Static object.
Cargo.CargoUnit

Cargo -- Management of single cargo logistics, which are based on a Wrapper.Unit object.
Core.Base

Core - The base class within the framework.
Core.Database

Core - Manages several databases containing templates, mission objects, and mission information.
Core.Event

Core - Models DCS event dispatching using a publish-subscribe model.
Core.Fsm

Core - FSM (Finite State Machine) are objects that model and control long lasting business processes and workflow.
Core.Goal

Core - Models the process to achieve goal(s).
Core.Menu

Core - Manage hierarchical menu structures and commands for players within a mission.
Core.Message

Core - Informs the players using messages during a simulation.
Core.Point

Core - Defines an extensive API to manage 3D points in the DCS World 3D simulation space.
Core.Radio

Core - Is responsible for everything that is related to radio transmission and you can hear in DCS, be it TACAN beacons, Radio transmissions.
Core.Report

Core - Provides a handy means to create messages and reports.
Core.ScheduleDispatcher

Core -- SCHEDULEDISPATCHER dispatches the different schedules.
Core.Scheduler

Core - Prepares and handles the execution of functions over scheduled time (intervals).
Core.Set

Core - Define collections of objects to perform bulk actions and logically group objects.
Core.Settings

Core - Manages various settings for running missions, consumed by moose classes and provides a menu system for players to tweak settings in running missions.
Core.Spawn

Core - Spawn dynamically new groups of units in running missions.
Core.SpawnStatic

Core - Spawn new statics in your running missions.
Core.Spot

Core - Management of spotting logistics, that can be activated and deactivated upon command.
Core.UserFlag

Core - Manage user flags to interact with the mission editor trigger system and server side scripts.
Core.UserSound

Core - Manage user sound.
Core.Velocity

Core - Models a velocity or speed, which can be expressed in various formats according the settings.
Core.Zone

Core - Define zones within your mission of various forms, with various capabilities.
DCS

DCS API prototypes
See https://wiki.hoggitworld.com/view/Simulator_Scripting_Engine_Documentation 
for further explanation and examples.
Functional.ATC_Ground

Functional -- Monitor airbase traffic and regulate speed while taxiing.
Functional.Arty

Functional - Control artillery units.
Functional.CleanUp

Functional -- Keep airbases clean of crashing or colliding airplanes, and kill missiles when being fired at airbases.
Functional.Designate

Functional -- Management of target Designation.
Functional.Detection

Functional -- Models the detection of enemy units by FACs or RECCEs and group them according various methods.
Functional.Escort

Functional -- Taking the lead of AI escorting your flight.
Functional.MissileTrainer

Functional -- Train missile defence and deflection.
Functional.Movement

Functional -- Limit the movement of simulaneous moving ground vehicles.
Functional.PseudoATC

Functional - Rudimentary ATC.
Functional.Range

Functional - Range Practice.
Functional.Rat

Functional - Create random airtraffic in your missions.
Functional.Scoring

Functional - Administer the scoring of player achievements, and create a CSV file logging the scoring events for use at team or squadron websites.
Functional.Sead

Functional -- Make SAM sites execute evasive and defensive behaviour when being fired upon.
Functional.Suppression

Functional - Suppress fire of ground units when they get hit.
Functional.Warehouse

Functional - Simulation of logistic operations.
Functional.ZoneCaptureCoalition

Functional -- Models the process to zone guarding and capturing.
Functional.ZoneGoal

Functional (WIP) -- Base class that models processes to achieve goals involving a Zone.
Functional.ZoneGoalCargo

Functional (WIP) -- Base class that models processes to achieve goals involving a Zone and Cargo.
Functional.ZoneGoalCoalition

Functional (WIP) -- Base class that models processes to achieve goals involving a Zone for a Coalition.
Tasking.CommandCenter

Tasking -- A command center governs multiple missions, and takes care of the reporting and communications.
Tasking.DetectionManager

Tasking - This module contains the DETECTION_MANAGER class and derived classes.
Tasking.Mission

Tasking -- A mission models a goal to be achieved through the execution and completion of tasks by human players.
Tasking.Task

Tasking -- A task object governs the main engine to administer human taskings.
Tasking.TaskInfo

Tasking -- Controls the information of a Task.
Tasking.TaskZoneCapture

Tasking - The TASK_Protect models tasks for players to protect or capture specific zones.
Tasking.Task_A2A

Tasking - The TASK_A2A models tasks for players in Air to Air engagements.
Tasking.Task_A2A_Dispatcher

Tasking - Dynamically allocates A2A tasks to human players, based on detected airborne targets through an EWR network.
Tasking.Task_A2G

Tasking - The TASK_A2G models tasks for players in Air to Ground engagements.
Tasking.Task_A2G_Dispatcher

Tasking -- Dynamically allocates A2G tasks to human players, based on detected ground targets through reconnaissance.
Tasking.Task_Cargo

Tasking -- Base class to model tasks for players to transport cargo.
Tasking.Task_Cargo_CSAR

Tasking -- Orchestrates the task for players to execute CSAR for downed pilots.
Tasking.Task_Cargo_Dispatcher

Tasking - Creates and manages player TASK_CARGO tasks.
Tasking.Task_Cargo_Transport

Tasking -- Models tasks for players to transport cargo.
Tasking.Task_Manager

This module contains the TASK_MANAGER class and derived classes.
Utils

This module contains derived utilities taken from the MIST framework, 
which are excellent tools to be reused in an OO environment!.
Wrapper.Airbase

Wrapper -- AIRBASE is a wrapper class to handle the DCS Airbase objects.
Wrapper.Client

Wrapper -- CLIENT wraps DCS Unit objects acting as a Client or Player within a mission.
Wrapper.Controllable

Wrapper -- CONTROLLABLE is an intermediate class wrapping Group and Unit classes "controllers".
Wrapper.Group

Wrapper -- GROUP wraps the DCS Class Group objects.
Wrapper.Identifiable

Wrapper -- IDENTIFIABLE is an intermediate class wrapping DCS Object class derived Objects.
Wrapper.Object

Wrapper -- OBJECT wraps the DCS Object derived objects.
Wrapper.Positionable

Wrapper -- POSITIONABLE wraps DCS classes that are "positionable".
Wrapper.Scenery

Wrapper -- SCENERY models scenery within the DCS simulator.
Wrapper.Static

Wrapper -- STATIC wraps the DCS StaticObject class.
Wrapper.Unit

Wrapper - UNIT is a wrapper class for the DCS Class Unit.
routines

Various routines

Module Core.Scheduler

Core - Prepares and handles the execution of functions over scheduled time (intervals).

Features:

Schedule functions over time,
optionally in an optional specified time interval,
optionally repeating with a specified time repeat interval,
optionally randomizing with a specified time interval randomization factor,
optionally stop the repeating after a specified time interval.

Demo Missions

SCHEDULER Demo Missions source code

SCHEDULER Demo Missions, only for beta testers

ALL Demo Missions pack of the last release

YouTube Channel

SCHEDULER YouTube Channel (none)

Contributions:

FlightControl : Concept & Testing

Authors:

FlightControl : Design & Programming

Global(s)

Global SCHEDULER

Creates and handles schedules over time, which allow to execute code at specific time intervals with randomization.

#SCHEDULER SCHEDULER

Creates and handles schedules over time, which allow to execute code at specific time intervals with randomization.

A SCHEDULER can manage multiple (repeating) schedules. Each planned or executing schedule has a unique ScheduleID. The ScheduleID is returned when the method SCHEDULER.Schedule() is called. It is recommended to store the ScheduleID in a variable, as it is used in the methods SCHEDULER.Start() and SCHEDULER.Stop(), which can start and stop specific repeating schedules respectively within a SCHEDULER object.

SCHEDULER constructor

The SCHEDULER class is quite easy to use, but note that the New constructor has variable parameters:

The SCHEDULER.New() method returns 2 variables:

The SCHEDULER object reference.
The first schedule planned in the SCHEDULER object.

To clarify the different appliances, lets have a look at the following examples:

Construct a SCHEDULER object without a persistent schedule.

SCHEDULER.New( nil ): Setup a new SCHEDULER object, which is persistently executed after garbage collection.

SchedulerObject = SCHEDULER:New() SchedulerID = SchedulerObject:Schedule( nil, ScheduleFunction, {} )

The above example creates a new SchedulerObject, but does not schedule anything. A separate schedule is created by using the SchedulerObject using the method :Schedule..., which returns a ScheduleID

Construct a SCHEDULER object without a volatile schedule, but volatile to the Object existence...

SCHEDULER.New( Object ): Setup a new SCHEDULER object, which is linked to the Object. When the Object is nillified or destroyed, the SCHEDULER object will also be destroyed and stopped after garbage collection.

ZoneObject = ZONE:New( "ZoneName" ) SchedulerObject = SCHEDULER:New( ZoneObject ) SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} ) ... ZoneObject = nil garbagecollect()

The above example creates a new SchedulerObject, but does not schedule anything, and is bound to the existence of ZoneObject, which is a ZONE. A separate schedule is created by using the SchedulerObject using the method :Schedule()..., which returns a ScheduleID Later in the logic, the ZoneObject is put to nil, and garbage is collected. As a result, the ScheduleObject will cancel any planned schedule.

Construct a SCHEDULER object with a persistent schedule.

SCHEDULER.New( nil, Function, FunctionArguments, Start, ... ): Setup a new persistent SCHEDULER object, and start a new schedule for the Function with the defined FunctionArguments according the Start and sequent parameters.

SchedulerObject, SchedulerID = SCHEDULER:New( nil, ScheduleFunction, {} )

The above example creates a new SchedulerObject, and does schedule the first schedule as part of the call. Note that 2 variables are returned here: SchedulerObject, ScheduleID...

Construct a SCHEDULER object without a schedule, but volatile to the Object existence...

SCHEDULER.New( Object, Function, FunctionArguments, Start, ... ): Setup a new SCHEDULER object, linked to Object, and start a new schedule for the Function with the defined FunctionArguments according the Start and sequent parameters.

ZoneObject = ZONE:New( "ZoneName" ) SchedulerObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} ) ... ZoneObject = nil garbagecollect()

The above example creates a new SchedulerObject, and schedules a method call (ScheduleFunction), and is bound to the existence of ZoneObject, which is a ZONE object (ZoneObject). Both a ScheduleObject and a SchedulerID variable are returned. Later in the logic, the ZoneObject is put to nil, and garbage is collected. As a result, the ScheduleObject will cancel the planned schedule.

SCHEDULER timer stopping and (re-)starting.

The SCHEDULER can be stopped and restarted with the following methods:

SCHEDULER.Start(): (Re-)Start the schedules within the SCHEDULER object. If a CallID is provided to :Start(), only the schedule referenced by CallID will be (re-)started.
SCHEDULER.Stop(): Stop the schedules within the SCHEDULER object. If a CallID is provided to :Stop(), then only the schedule referenced by CallID will be stopped.

ZoneObject = ZONE:New( "ZoneName" ) SchedulerObject, SchedulerID = SCHEDULER:New( ZoneObject, ScheduleFunction, {} ) SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 10 ) ... SchedulerObject:Stop( SchedulerID ) ... SchedulerObject:Start( SchedulerID )

The above example creates a new SchedulerObject, and does schedule the first schedule as part of the call. Note that 2 variables are returned here: SchedulerObject, ScheduleID...
Later in the logic, the repeating schedule with SchedulerID is stopped.
A bit later, the repeating schedule with SchedulerId is (re)-started.

Create a new schedule

With the method SCHEDULER.Schedule() a new time event can be scheduled. This method is used by the :New() constructor when a new schedule is planned.

Consider the following code fragment of the SCHEDULER object creation.

ZoneObject = ZONE:New( "ZoneName" )
SchedulerObject = SCHEDULER:New( ZoneObject )

Several parameters can be specified that influence the behaviour of a Schedule.

A single schedule, immediately executed

SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {} )

The above example schedules a new ScheduleFunction call to be executed asynchronously, within milleseconds ...

A single schedule, planned over time

SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10 )

The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds ...

A schedule with a repeating time interval, planned over time

SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60 )

The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, and repeating 60 every seconds ...

A schedule with a repeating time interval, planned over time, with time interval randomization

SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5 )

The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, and repeating 60 seconds, with a 50% time interval randomization ... So the repeating time interval will be randomized using the 0.5,
and will calculate between 60 - ( 60 * 0.5 ) and 60 + ( 60 * 0.5 ) for each repeat, which is in this example between 30 and 90 seconds.

A schedule with a repeating time interval, planned over time, with time interval randomization, and stop after a time interval

SchedulerID = SchedulerObject:Schedule( ZoneObject, ScheduleFunction, {}, 10, 60, 0.5, 300 )

The above example schedules a new ScheduleFunction call to be executed asynchronously, within 10 seconds, The schedule will repeat every 60 seconds. So the repeating time interval will be randomized using the 0.5,
and will calculate between 60 - ( 60 * 0.5 ) and 60 + ( 60 * 0.5 ) for each repeat, which is in this example between 30 and 90 seconds. The schedule will stop after 300 seconds.

Type(s)

Type SCHEDULER

SCHEDULER , extends Core.Base#BASE

Fields and Methods inherited from SCHEDULER	Description
SCHEDULER:Clear()	Clears all pending schedules.
SCHEDULER.MasterObject
SCHEDULER:New(SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop)	SCHEDULER constructor.
SCHEDULER:Remove(ScheduleID)	Removes a specific schedule if a valid ScheduleID is provided.
SCHEDULER:Schedule(SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop)	Schedule a new time event.
SCHEDULER.ScheduleID	the ID of the scheduler.
SCHEDULER.SchedulerObject
SCHEDULER:Start(ScheduleID)	(Re-)Starts the schedules or a specific schedule if a valid ScheduleID is provided.
SCHEDULER:Stop(ScheduleID)	Stops the schedules or a specific schedule if a valid ScheduleID is provided.

Fields and Methods inherited from BASE	Description
SCHEDULER.ClassID	The ID number of the class.
SCHEDULER.ClassName	The name of the class.
SCHEDULER.ClassNameAndID	The name of the class concatenated with the ID number of the class.
SCHEDULER:ClearState(Object, StateName)	Clear the state of an object.
SCHEDULER:CreateEventBirth(EventTime, Initiator, IniUnitName, place, subplace)	Creation of a Birth Event.
SCHEDULER:CreateEventCrash(EventTime, Initiator)	Creation of a Crash Event.
SCHEDULER:CreateEventDead(EventTime, Initiator)	Creation of a Dead Event.
SCHEDULER:CreateEventRemoveUnit(EventTime, Initiator)	Creation of a Remove Unit Event.
SCHEDULER:CreateEventTakeoff(EventTime, Initiator)	Creation of a Takeoff Event.
SCHEDULER:E(Arguments)	Log an exception which will be traced always.
SCHEDULER:EventDispatcher()	Returns the event dispatcher
SCHEDULER:EventRemoveAll()	Remove all subscribed events
SCHEDULER:F(Arguments)	Trace a function call.
SCHEDULER:F2(Arguments)	Trace a function call level 2.
SCHEDULER:F3(Arguments)	Trace a function call level 3.
SCHEDULER:GetClassID()	Get the ClassID of the class instance.
SCHEDULER:GetClassName()	Get the ClassName of the class instance.
SCHEDULER:GetClassNameAndID()	Get the ClassName + ClassID of the class instance.
SCHEDULER:GetEventPriority()	Get the Class Event processing Priority.
SCHEDULER:GetParent(Child, FromClass)	This is the worker method to retrieve the Parent class.
SCHEDULER:GetState(Object, Key)	Get a Value given a Key from the Object.
SCHEDULER:HandleEvent(Event, EventFunction)	Subscribe to a DCS Event.
SCHEDULER:I(Arguments)	Log an information which will be traced always.
SCHEDULER:Inherit(Child, Parent)	This is the worker method to inherit from a parent class.
SCHEDULER:IsInstanceOf(ClassName)	This is the worker method to check if an object is an (sub)instance of a class.
SCHEDULER:IsTrace()	Enquires if tracing is on (for the class).
SCHEDULER:New()	BASE constructor.
SCHEDULER:OnEvent(EventData)	Occurs when an object is completely destroyed.
SCHEDULER:OnEventBaseCaptured(EventData)	Occurs when a ground unit captures either an airbase or a farp.
SCHEDULER:OnEventBirth(EventData)	Occurs when any object is spawned into the mission.
SCHEDULER:OnEventCrash(EventData)	Occurs when any aircraft crashes into the ground and is completely destroyed.
SCHEDULER:OnEventDead(EventData)	Occurs when an object is dead.
SCHEDULER:OnEventEjection(EventData)	Occurs when a pilot ejects from an aircraft initiator : The unit that has ejected
SCHEDULER:OnEventEngineShutdown(EventData)	Occurs when any aircraft shuts down its engines.
SCHEDULER:OnEventEngineStartup(EventData)	Occurs when any aircraft starts its engines.
SCHEDULER:OnEventHit(EventData)	Occurs whenever an object is hit by a weapon.
SCHEDULER:OnEventHumanFailure(EventData)	Occurs when any system fails on a human controlled aircraft.
SCHEDULER:OnEventLand(EventData)	Occurs when an aircraft lands at an airbase, farp or ship initiator : The unit that has landed place: Object that the unit landed on.
SCHEDULER:OnEventMissionEnd(EventData)	Occurs when a mission ends
SCHEDULER:OnEventMissionStart(EventData)	Occurs when a mission starts
SCHEDULER:OnEventPilotDead(EventData)	Occurs when the pilot of an aircraft is killed.
SCHEDULER:OnEventPlayerEnterUnit(EventData)	Occurs when any player assumes direct control of a unit.
SCHEDULER:OnEventPlayerLeaveUnit(EventData)	Occurs when any player relieves control of a unit to the AI.
SCHEDULER:OnEventRefueling(EventData)	Occurs when an aircraft connects with a tanker and begins taking on fuel.
SCHEDULER:OnEventRefuelingStop(EventData)	Occurs when an aircraft is finished taking fuel.
SCHEDULER:OnEventShootingEnd(EventData)	Occurs when any unit stops firing its weapon.
SCHEDULER:OnEventShootingStart(EventData)	Occurs when any unit begins firing a weapon that has a high rate of fire.
SCHEDULER:OnEventShot(EventData)	Occurs whenever any unit in a mission fires a weapon.
SCHEDULER:OnEventTakeoff(EventData)	Occurs when an aircraft takes off from an airbase, farp, or ship.
SCHEDULER:ScheduleOnce(Start, SchedulerFunction, ...)	Schedule a new time event.
SCHEDULER:ScheduleRepeat(Start, Repeat, RandomizeFactor, Stop, SchedulerFunction, ...)	Schedule a new time event.
SCHEDULER:ScheduleStop(SchedulerFunction)	Stops the Schedule.
SCHEDULER.Scheduler
SCHEDULER:SetEventPriority(EventPriority)	Set the Class Event processing Priority.
SCHEDULER:SetState(Object, Key, Value)	Set a state or property of the Object given a Key and a Value.
SCHEDULER:T(Arguments)	Trace a function logic level 1.
SCHEDULER:T2(Arguments)	Trace a function logic level 2.
SCHEDULER:T3(Arguments)	Trace a function logic level 3.
SCHEDULER:TraceAll(TraceAll)	Trace all methods in MOOSE
SCHEDULER:TraceClass(Class)	Set tracing for a class
SCHEDULER:TraceClassMethod(Class, Method)	Set tracing for a specific method of class
SCHEDULER:TraceLevel(Level)	Set trace level
SCHEDULER:TraceOnOff(TraceOnOff)	Set trace on or off Note that when trace is off, no BASE.Debug statement is performed, increasing performance! When Moose is loaded statically, (as one file), tracing is switched off by default.
SCHEDULER:UnHandleEvent(Event)	UnSubscribe to a DCS event.
SCHEDULER._
SCHEDULER:_F(Arguments, DebugInfoCurrentParam, DebugInfoFromParam)	Trace a function call.
SCHEDULER:_T(Arguments, DebugInfoCurrentParam, DebugInfoFromParam)	Trace a function logic.
SCHEDULER.__
SCHEDULER:onEvent(event)

Type Core.Scheduler

Type SCHEDULER

The SCHEDULER class

Field(s)

SCHEDULER.MasterObject

#number SCHEDULER.ScheduleID

the ID of the scheduler.

SCHEDULER.SchedulerObject

Function(s)

SCHEDULER:Clear()

Clears all pending schedules.

Defined in:

SCHEDULER

SCHEDULER:New(SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop)

SCHEDULER constructor.

Defined in:

SCHEDULER

Parameters:

#table SchedulerObject

Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference.

#function SchedulerFunction

The event function to be called when a timer event occurs. The event function needs to accept the parameters specified in SchedulerArguments.

#table SchedulerArguments

Optional arguments that can be given as part of scheduler. The arguments need to be given as a table { param1, param 2, ... }.

#number Start

Specifies the amount of seconds that will be waited before the scheduling is started, and the event function is called.

#number Repeat

Specifies the interval in seconds when the scheduler will call the event function.

#number RandomizeFactor

Specifies a randomization factor between 0 and 1 to randomize the Repeat.

#number Stop

Specifies the amount of seconds when the scheduler will be stopped.

Return values:

#SCHEDULER:

self.

#number:

The ScheduleID of the planned schedule.

SCHEDULER:Remove(ScheduleID)

Removes a specific schedule if a valid ScheduleID is provided.

Defined in:

SCHEDULER

Parameter:

#number ScheduleID

(optional) The ScheduleID of the planned (repeating) schedule.

SCHEDULER:Schedule(SchedulerObject, SchedulerFunction, SchedulerArguments, Start, Repeat, RandomizeFactor, Stop)

Schedule a new time event.

Note that the schedule will only take place if the scheduler is started. Even for a single schedule event, the scheduler needs to be started also.

Defined in:

SCHEDULER

Parameters:

#table SchedulerObject

Specified for which Moose object the timer is setup. If a value of nil is provided, a scheduler will be setup without an object reference.

#function SchedulerFunction

The event function to be called when a timer event occurs. The event function needs to accept the parameters specified in SchedulerArguments.

#table SchedulerArguments

Optional arguments that can be given as part of scheduler. The arguments need to be given as a table { param1, param 2, ... }.

#number Start

Specifies the amount of seconds that will be waited before the scheduling is started, and the event function is called.

#number Repeat

Specifies the interval in seconds when the scheduler will call the event function.

#number RandomizeFactor

Specifies a randomization factor between 0 and 1 to randomize the Repeat.

#number Stop

Specifies the amount of seconds when the scheduler will be stopped.

Return value:

#number:

The ScheduleID of the planned schedule.

SCHEDULER:Start(ScheduleID)

(Re-)Starts the schedules or a specific schedule if a valid ScheduleID is provided.

Defined in:

SCHEDULER

Parameter:

#number ScheduleID

(optional) The ScheduleID of the planned (repeating) schedule.

SCHEDULER:Stop(ScheduleID)

Stops the schedules or a specific schedule if a valid ScheduleID is provided.

Defined in:

SCHEDULER

Parameter:

#number ScheduleID

(optional) The ScheduleID of the planned (repeating) schedule.

Field(s)

SCHEDULER.MasterObject

#number SCHEDULER.ScheduleID

the ID of the scheduler.

SCHEDULER.SchedulerObject

Function(s)

SCHEDULER:ClearState(Object, StateName)

Clear the state of an object.