Revised client and database logic. Still work in progress.

Moose/Database.lua

@@ -68,25 +68,33 @@ Include.File( "Menu" )
 Include.File( "Group" )
 Include.File( "Unit" )
 Include.File( "Event" )
+Include.File( "Client" )
 
 --- DATABASE class
 -- @type DATABASE
 -- @extends Base#BASE
 DATABASE = {
   ClassName = "DATABASE",
-  Templates = {},
+  Templates = {
+    Units = {},
+    Groups = {},
+    ClientsByName = {},
+    ClientsByID = {},
+  },
   DCSUnits = {},
   DCSUnitsAlive = {},
-  Units = {},
-  Groups = {},
   DCSGroups = {},
   DCSGroupsAlive = {},
+  Units = {},
+  UnitsAlive = {},
+  Groups = {},
+  GroupsAlive = {},
   NavPoints = {},
   Statics = {},
   Players = {},
-  AlivePlayers = {},
-  ClientsByName = {},
-  ClientsByID = {},
+  PlayersAlive = {},
+  Clients = {},
+  ClientsAlive = {},
   Filter = {
     Coalitions = nil,
     Categories = nil,
@@ -142,6 +150,14 @@ function DATABASE:New()
   _EVENTDISPATCHER:OnDead( self._EventOnDeadOrCrash, self )
   _EVENTDISPATCHER:OnCrash( self._EventOnDeadOrCrash, self )
   
+  
+  -- Add database with registered clients and already alive players
+  
+  -- Follow alive players and clients
+  _EVENTDISPATCHER:OnPlayerEnterUnit( self._EventOnPlayerEnterUnit, self )
+  _EVENTDISPATCHER:OnPlayerLeaveUnit( self._EventOnPlayerLeaveUnit, self )
+  
+  
   return self
 end
 
@@ -262,16 +278,43 @@ function DATABASE:FilterStart()
     -- OK, we have a _DATABASE
     -- Now use the different filters to build the set.
     -- We first take ALL of the Units of the _DATABASE.
-    for UnitRegistrationID, UnitRegistration in pairs( _DATABASE.Templates.Units ) do
-      self:T( UnitRegistration )
-      local DCSUnit = Unit.getByName( UnitRegistration.UnitName )
+    
+    self:E( { "Adding Database Datapoints with filters" } )
+    for DCSUnitName, DCSUnit in pairs( _DATABASE.DCSUnits ) do
+
       if self:_IsIncludeDCSUnit( DCSUnit ) then
-        self.DCSUnits[DCSUnit:getName()] = DCSUnit
-      end
-      if self:_IsAliveDCSUnit( DCSUnit ) then
-        self.DCSUnitsAlive[DCSUnit:getName()] = DCSUnit
+
+        self:E( { "Adding Unit:", DCSUnitName } )
+        self.DCSUnits[DCSUnitName] = _DATABASE.DCSUnits[DCSUnitName]
+        self.Units[DCSUnitName] = _DATABASE.Units[DCSUnitName]
+        
+        if _DATABASE.DCSUnitsAlive[DCSUnitName] then
+          self.DCSUnitsAlive[DCSUnitName] = _DATABASE.DCSUnitsAlive[DCSUnitName]
+          self.UnitsAlive[DCSUnitName] = _DATABASE.UnitsAlive[DCSUnitName]
+        end
+        
       end
     end
+    
+    for DCSGroupName, DCSGroup in pairs( _DATABASE.DCSGroups ) do
+      
+      --if self:_IsIncludeDCSGroup( DCSGroup ) then
+      self:E( { "Adding Group:", DCSGroupName } )
+      self.DCSGroups[DCSGroupName] = _DATABASE.DCSGroups[DCSGroupName]
+      self.Groups[DCSGroupName] = _DATABASE.Groups[DCSGroupName]
+      --end
+      
+      if _DATABASE.DCSGroupsAlive[DCSGroupName] then
+        self.DCSGroupsAlive[DCSGroupName] = _DATABASE.DCSGroupsAlive[DCSGroupName]
+        self.GroupsAlive[DCSGroupName] = _DATABASE.GroupsAlive[DCSGroupName]
+      end
+    end
+
+    for DCSUnitName, Client in pairs( _DATABASE.Clients ) do
+      self:E( { "Adding Client for Unit:", DCSUnitName } )
+      self.Clients[DCSUnitName] = _DATABASE.Clients[DCSUnitName]
+    end
+    
   else
     self:E( "There is a structural error in MOOSE. No _DATABASE has been defined! Cannot build this custom DATABASE." )
   end
@@ -378,6 +421,77 @@ function DATABASE:_RegisterGroup( GroupTemplate )
   end
 end
 
+--- Private method that registers all alive players in the mission.
+-- @param #DATABASE self
+-- @return #DATABASE self
+function DATABASE:_RegisterPlayers()
+
+  local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ) }
+  for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
+    for UnitId, UnitData in pairs( CoalitionData ) do
+      self:T3( { "UnitData:", UnitData } )
+      if UnitData and UnitData:isExist() then
+        local UnitName = UnitData:getName()
+        if not self.PlayersAlive[UnitName] then
+          self:E( { "Add player for unit:", UnitName, UnitData:getPlayerName() } )
+          self.PlayersAlive[UnitName] = UnitData:getPlayerName()
+        end
+      end
+    end
+  end
+  
+  return self
+end
+
+--- Private method that registers all datapoints within in the mission.
+-- @param #DATABASE self
+-- @return #DATABASE self
+function DATABASE:_RegisterDatabase()
+
+  local CoalitionsData = { AlivePlayersRed = coalition.getGroups( coalition.side.RED ), AlivePlayersBlue = coalition.getGroups( coalition.side.BLUE ) }
+  for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
+    for DCSGroupId, DCSGroup in pairs( CoalitionData ) do
+
+      local DCSGroupName = DCSGroup:getName()
+
+      self:E( { "Register Group:", DCSGroup, DCSGroupName } )
+      self.DCSGroups[DCSGroupName] = DCSGroup
+      self.Groups[DCSGroupName] = GROUP:New( DCSGroup )
+
+      if self:_IsAliveDCSGroup(DCSGroup) then
+        self:E( { "Register Alive Group:", DCSGroup, DCSGroupName } )
+        self.DCSGroupsAlive[DCSGroupName] = DCSGroup
+        self.GroupsAlive[DCSGroupName] = self.Groups[DCSGroupName]  
+      end
+
+      for DCSUnitId, DCSUnit in pairs( DCSGroup:getUnits() ) do
+
+        local DCSUnitName = DCSUnit:getName()
+        self:E( { "Register Unit:", DCSUnit, DCSUnitName } )
+
+        self.DCSUnits[DCSUnitName] = DCSUnit
+        self.Units[DCSUnitName] = UNIT:New( DCSUnit )
+
+        if self:_IsAliveDCSUnit(DCSUnit) then
+          self:E( { "Register Alive Unit:", DCSUnit, DCSUnitName } )
+          self.DCSUnitsAlive[DCSUnitName] = DCSUnit
+          self.UnitsAlive[DCSUnitName] = self.Units[DCSUnitName]  
+        end
+
+        if self.Templates.ClientsByName[DCSUnitName] then
+          self.Clients[DCSUnitName] = CLIENT:New( DCSUnitName )
+        end
+        
+      end
+    end
+  end
+  
+  return self
+end
+
+
+--- Events
+
 --- Handles the OnBirth event for the alive units set.
 -- @param #DATABASE self
 -- @param Event#EVENTDATA Event
@@ -388,6 +502,13 @@ function DATABASE:_EventOnBirth( Event )
     if self:_IsIncludeDCSUnit( Event.IniDCSUnit ) then
       self.DCSUnits[Event.IniDCSUnitName] = Event.IniDCSUnit 
       self.DCSUnitsAlive[Event.IniDCSUnitName] = Event.IniDCSUnit
+      self.Units[Event.IniDCSUnitName] = UNIT:New( Event.IniDCSUnit )
+      
+      if not self.DCSGroups[Event.IniDCSGroupName] then
+        self.DCSGroups[Event.IniDCSGroupName] = Event.IniDCSGroupName
+        self.DCSGroupsAlive[Event.IniDCSGroupName] = Event.IniDCSGroupName
+        self.Groups[Event.IniDCSGroupName] = GROUP:New( Event.IniDCSGroup )
+      end
     end
   end
 end
@@ -406,18 +527,54 @@ function DATABASE:_EventOnDeadOrCrash( Event )
   end
 end
 
---- Interate the DATABASE and call an interator function for each **alive** unit, providing the Unit and optional parameters.
+--- Handles the OnPlayerEnterUnit event to fill the active players table (with the unit filter applied).
 -- @param #DATABASE self
--- @param #function IteratorFunction The function that will be called when there is an alive unit in the database. The function needs to accept a UNIT parameter.
+-- @param Event#EVENTDATA Event
+function DATABASE:_EventOnPlayerEnterUnit( Event )
+  self:F( { Event } )
+
+  if Event.IniDCSUnit then
+    if self:_IsIncludeDCSUnit( Event.IniDCSUnit ) then
+      if not self.PlayersAlive[Event.IniDCSUnitName] then
+        self:E( { "Add player for unit:", Event.IniDCSUnitName, Event.IniDCSUnit:getPlayerName() } )
+        self.PlayersAlive[Event.IniDCSUnitName] = Event.IniDCSUnit:getPlayerName()
+        self.ClientsAlive[Event.IniDCSUnitName] = _DATABASE.Clients[ Event.IniDCSUnitName ]
+      end
+    end
+  end
+end
+
+--- Handles the OnPlayerLeaveUnit event to clean the active players table.
+-- @param #DATABASE self
+-- @param Event#EVENTDATA Event
+function DATABASE:_EventOnPlayerLeaveUnit( Event )
+  self:F( { Event } )
+
+  if Event.IniDCSUnit then
+    if self:_IsIncludeDCSUnit( Event.IniDCSUnit ) then
+      if self.PlayersAlive[Event.IniDCSUnitName] then
+        self:E( { "Cleaning player for unit:", Event.IniDCSUnitName, Event.IniDCSUnit:getPlayerName() } )
+        self.PlayersAlive[Event.IniDCSUnitName] = nil
+        self.ClientsAlive[Event.IniDCSUnitName] = nil
+      end
+    end
+  end
+end
+
+--- Iterators
+
+--- Interate the DATABASE and call an interator function for the given set, providing the Object for each element within the set and optional parameters.
+-- @param #DATABASE self
+-- @param #function IteratorFunction The function that will be called when there is an alive player in the database.
 -- @return #DATABASE self
-function DATABASE:ForEachAliveUnit( IteratorFunction, ... )
+function DATABASE:ForEach( IteratorFunction, arg, Set )
   self:F( arg )
   
   local function CoRoutine()
     local Count = 0
-    for DCSUnitID, DCSUnit in pairs( self.DCSUnitsAlive ) do
-        self:T2( DCSUnit )
-        IteratorFunction( DCSUnit, unpack( arg ) )
+    for ObjectID, Object in pairs( Set ) do
+        self:T2( Object )
+        IteratorFunction( Object, unpack( arg ) )
         Count = Count + 1
         if Count % 10 == 0 then
           coroutine.yield( false )
@@ -437,15 +594,56 @@ function DATABASE:ForEachAliveUnit( IteratorFunction, ... )
       error( res )
     end
     if res == false then
-      timer.scheduleFunction( Schedule, {}, timer.getTime() + 0.001 )
+      return true -- resume next time the loop
     end
+    
+    return false
   end
 
-  timer.scheduleFunction( Schedule, {}, timer.getTime() + 0.001 )
+  local Scheduler = SCHEDULER:New( self, Schedule, {}, 0.001, 0.001, 0 )
   
   return self
 end
 
+
+--- Interate the DATABASE and call an interator function for each **alive** unit, providing the Unit and optional parameters.
+-- @param #DATABASE self
+-- @param #function IteratorFunction The function that will be called when there is an alive unit in the database. The function needs to accept a UNIT parameter.
+-- @return #DATABASE self
+function DATABASE:ForEachDCSUnitAlive( IteratorFunction, ... )
+  self:F( arg )
+  
+  self:ForEach( IteratorFunction, arg, self.DCSUnitsAlive )
+
+  return self
+end
+
+--- Interate the DATABASE and call an interator function for each **alive** player, providing the Unit of the player and optional parameters.
+-- @param #DATABASE self
+-- @param #function IteratorFunction The function that will be called when there is an alive player in the database. The function needs to accept a UNIT parameter.
+-- @return #DATABASE self
+function DATABASE:ForEachPlayer( IteratorFunction, ... )
+  self:F( arg )
+  
+  self:ForEach( IteratorFunction, arg, self.PlayersAlive )
+  
+  return self
+end
+
+
+--- Interate the DATABASE and call an interator function for each client, providing the Client to the function and optional parameters.
+-- @param #DATABASE self
+-- @param #function IteratorFunction The function that will be called when there is an alive player in the database. The function needs to accept a CLIENT parameter.
+-- @return #DATABASE self
+function DATABASE:ForEachClient( IteratorFunction, ... )
+  self:F( arg )
+  
+  self:ForEach( IteratorFunction, arg, self.Clients )
+
+  return self
+end
+
+
 function DATABASE:ScanEnvironment()
   self:F()
 
@@ -509,6 +707,9 @@ function DATABASE:ScanEnvironment()
     end --if coa_name == 'red' or coa_name == 'blue' and type(coa_data) == 'table' then
   end --for coa_name, coa_data in pairs(mission.coalition) do
 
+  self:_RegisterDatabase()
+  self:_RegisterPlayers()
+
   return self
 end
 
@@ -596,6 +797,22 @@ function DATABASE:_IsAliveDCSUnit( DCSUnit )
   return DCSUnitAlive
 end
 
+---
+-- @param #DATABASE self
+-- @param DCSGroup#Group DCSGroup
+-- @return #DATABASE self
+function DATABASE:_IsAliveDCSGroup( DCSGroup )
+  self:F( DCSGroup )
+  local DCSGroupAlive = false
+  if DCSGroup and DCSGroup:isExist() then
+    if self.DCSGroups[DCSGroup:getName()] then
+      DCSGroupAlive = true
+    end
+  end
+  self:T( DCSGroupAlive )
+  return DCSGroupAlive
+end
+
 
 --- Traces the current database contents in the log ... (for debug reasons).
 -- @param #DATABASE self