Merge remote-tracking branch 'refs/remotes/origin/master' into MissileTrainer

# Conflicts: # Moose/MissileTrainer.lua
2025-10-29 16:58:06 +00:00 · 2016-05-17 07:05:27 +02:00
parent 15b189d747 ff689b05be
commit 1fef4793ca
51 changed files with 4111 additions and 1418 deletions
--- a/Moose/Client.lua
+++ b/Moose/Client.lua
@@ -1,6 +1,18 @@
 --- The CLIENT models client units in multi player missions.
-- Clients are those groups defined within the Mission Editor that have the skillset defined as "Client" or "Player".
-- Note that clients are NOT the same as groups, they are NOT necessarily alive. 
+-- 
+-- @{#CLIENT} class
+-- ================
+-- Clients are those **Units** defined within the Mission Editor that have the skillset defined as __Client__ or __Player__.
+-- Note that clients are NOT the same as Units, they are NOT necessarily alive.
+-- 
+-- Clients are being used by the @{MISSION} class to follow players and register their successes.
+-- 
+-- CLIENT construction methods:
+-- ============================ 
+-- Create a new CLIENT object with the @{#CLIENT.New} method:
+-- 
+--   * @{#CLIENT.New}: Creates a new CLIENT object taking the name of the **DCSUnit** that is a client as defined within the mission editor.
+--  
 -- @module Client
 -- @author FlightControl

@@ -33,9 +45,9 @@ CLIENT = {
 }


--- Use this method to register new Clients within the MOF.
+--- Use this method to register new Clients within a mission.
 -- @param #CLIENT self
-- @param #string ClientName Name of the Group as defined within the Mission Editor. The Group must have a Unit with the type Client.
+-- @param #string ClientName Name of the DCS **Unit** as defined within the Mission Editor.
 -- @param #string ClientBriefing Text that describes the briefing of the mission when a Player logs into the Client.
 -- @return #CLIENT
 -- @usage
@@ -51,7 +63,7 @@ function CLIENT:New( ClientName, ClientBriefing )
 	local self = BASE:Inherit( self, BASE:New() )
 	self:F( ClientName, ClientBriefing )

-	self.ClientName = ClientName
+  self.ClientName = ClientName
 	self:AddBriefing( ClientBriefing )
 	self.MessageSwitch = true
 	
@@ -132,9 +144,9 @@ end
 function CLIENT:IsAlive()
  self:F( self.ClientName )
  
-  local ClientDCSGroup = self:GetDCSGroup()
+  local ClientUnit = Unit.getByName( self.ClientName )
  
-  if ClientDCSGroup then
+  if ClientUnit and ClientUnit:isExist() then
    self:T("true")
    return true
  end
@@ -176,6 +188,8 @@ function CLIENT:GetDCSGroup()
 --		return nil
 --	end

+  local ClientUnit = Unit.getByName( self.ClientName )
+
 	local CoalitionsData = { AlivePlayersRed = coalition.getPlayers( coalition.side.RED ), AlivePlayersBlue = coalition.getPlayers( coalition.side.BLUE ) }
 	for CoalitionId, CoalitionData in pairs( CoalitionsData ) do
 		self:T3( { "CoalitionData:", CoalitionData } )
@@ -183,49 +197,49 @@ function CLIENT:GetDCSGroup()
 			self:T3( { "UnitData:", UnitData } )
 			if UnitData and UnitData:isExist() then

-				local ClientGroup = Group.getByName( self.ClientName )
-				if ClientGroup then
-					self:T3( "ClientGroup = " .. self.ClientName )
-					if ClientGroup:isExist() then 
-						if ClientGroup:getID() == UnitData:getGroup():getID() then
-							self:T3( "Normal logic" )
-							self:T3( self.ClientName .. " : group found!" )
-							return ClientGroup
-						end
-					else
-						-- Now we need to resolve the bugs in DCS 1.5 ...
-						-- Consult the database for the units of the Client Group. (ClientGroup:getUnits() returns nil)
-						self:T3( "Bug 1.5 logic" )
-						local ClientUnits = _DATABASE.Groups[self.ClientName].Units
-						self:T3( { ClientUnits[1].name, env.getValueDictByKey(ClientUnits[1].name) } )
-						for ClientUnitID, ClientUnitData in pairs( ClientUnits ) do
-							self:T3( { tonumber(UnitData:getID()), ClientUnitData.unitId } )
-							if tonumber(UnitData:getID()) == ClientUnitData.unitId then
-								local ClientGroupTemplate = _DATABASE.Groups[self.ClientName].Template
-								self.ClientID = ClientGroupTemplate.groupId
-								self.ClientGroupUnit = UnitData
-								self:T3( self.ClientName .. " : group found in bug 1.5 resolvement logic!" )
-								return ClientGroup
-							end
-						end
-					end
--				else
--					error( "Client " .. self.ClientName .. " not found!" )
-				end
+        --self:E(self.ClientName)
+        if ClientUnit then
+  				local ClientGroup = ClientUnit:getGroup()
+  				if ClientGroup then
+  					self:T3( "ClientGroup = " .. self.ClientName )
+  					if ClientGroup:isExist() and UnitData:getGroup():isExist() then 
+  						if ClientGroup:getID() == UnitData:getGroup():getID() then
+  							self:T3( "Normal logic" )
+  							self:T3( self.ClientName .. " : group found!" )
+                self.ClientGroupID = ClientGroup:getID()
+  							self.ClientGroupName = ClientGroup:getName()
+  							return ClientGroup
+  						end
+  					else
+  						-- Now we need to resolve the bugs in DCS 1.5 ...
+  						-- Consult the database for the units of the Client Group. (ClientGroup:getUnits() returns nil)
+  						self:T3( "Bug 1.5 logic" )
+  						local ClientGroupTemplate = _DATABASE.Templates.Units[self.ClientName].GroupTemplate
+  						self.ClientGroupID = ClientGroupTemplate.groupId
+  						self.ClientGroupName = _DATABASE.Templates.Units[self.ClientName].GroupName
+  						self:T3( self.ClientName .. " : group found in bug 1.5 resolvement logic!" )
+  						return ClientGroup
+  					end
+  --				else
+  --					error( "Client " .. self.ClientName .. " not found!" )
+  				end
+  		  end
 			end
 		end
 	end

 	-- For non player clients
-	local ClientGroup = Group.getByName( self.ClientName )
-	if ClientGroup then
-		self:T3( "ClientGroup = " .. self.ClientName )
-		if ClientGroup:isExist() then 
-			self:T3( "Normal logic" )
-			self:T3( self.ClientName .. " : group found!" )
-			return ClientGroup
-		end
-	end
+	if ClientUnit then
+  	local ClientGroup = ClientUnit:getGroup()
+  	if ClientGroup then
+  		self:T3( "ClientGroup = " .. self.ClientName )
+  		if ClientGroup:isExist() then 
+  			self:T3( "Normal logic" )
+  			self:T3( self.ClientName .. " : group found!" )
+  			return ClientGroup
+  		end
+  	end
+  end
 	
 	self.ClientGroupID = nil
 	self.ClientGroupUnit = nil
@@ -240,16 +254,9 @@ end
 -- @return DCSTypes#Group.ID
 function CLIENT:GetClientGroupID()

-  if not self.ClientGroupID then
-    local ClientGroup = self:GetDCSGroup()
-    if ClientGroup and ClientGroup:isExist() then
-      self.ClientGroupID = ClientGroup:getID()
-    else
-      self.ClientGroupID = self.ClientID
-    end
-  end
+  local ClientGroup = self:GetDCSGroup()

-  self:T( self.ClientGroupID )
+  --self:E( self.ClientGroupID ) -- Determined in GetDCSGroup()
 	return self.ClientGroupID
 end

@@ -259,16 +266,9 @@ end
 -- @return #string
 function CLIENT:GetClientGroupName()

-  if not self.ClientGroupName then
-    local ClientGroup = self:GetDCSGroup()
-    if ClientGroup and ClientGroup:isExist() then
-      self.ClientGroupName = ClientGroup:getName()
-    else
-      self.ClientGroupName = self.ClientName
-    end
-  end
+  local ClientGroup = self:GetDCSGroup()

-  self:T( self.ClientGroupName )
+  self:T( self.ClientGroupName ) -- Determined in GetDCSGroup()
 	return self.ClientGroupName
 end

@@ -276,14 +276,15 @@ end
 -- @param #CLIENT self
 -- @return Unit#UNIT
 function CLIENT:GetClientGroupUnit()
-	self:F()
+	self:F2()

-	local ClientGroup = self:GetDCSGroup()
-	
-	if ClientGroup and ClientGroup:isExist() then
-		return UNIT:New( ClientGroup:getUnit(1) )
-	else
-		return UNIT:New( self.ClientGroupUnit )
+	local ClientDCSUnit = Unit.getByName( self.ClientName )
+
+  self:T( self.ClientDCSUnit )
+	if ClientDCSUnit and ClientDCSUnit:isExist() then
+		local ClientUnit = _DATABASE.Units[ self.ClientName ]
+		self:T2( ClientUnit )
+		return ClientUnit
 	end
 end

@@ -293,12 +294,11 @@ end
 function CLIENT:GetClientGroupDCSUnit()
 	self:F2()

-  local ClientGroup = self:GetDCSGroup()
+  local ClientDCSUnit = Unit.getByName( self.ClientName )
  
-  if ClientGroup and ClientGroup:isExist() then
-    return ClientGroup:getUnit(1)
-  else
-    return self.ClientGroupUnit
+  if ClientDCSUnit and ClientDCSUnit:isExist() then
+    self:T2( ClientDCSUnit )
+    return ClientDCSUnit
  end
 end

@@ -315,7 +315,7 @@ end
 function CLIENT:GetPointVec2()
 	self:F()

-  ClientGroupUnit = self:GetClientGroupDCSUnit()
+  local ClientGroupUnit = self:GetClientGroupDCSUnit()
  
  if ClientGroupUnit then
    if ClientGroupUnit:isExist() then
@@ -331,6 +331,44 @@ function CLIENT:GetPointVec2()
  return nil
 end 

+function CLIENT:GetPositionVec3()
+  self:F( self.ClientName )
+  
+  local DCSUnit = Unit.getByName( self.ClientName )
+  local UnitPos = DCSUnit:getPosition().p
+
+  self:T( UnitPos )
+  return UnitPos
+end
+
+function CLIENT:GetID()
+  self:F( self.ClientName )
+
+  local DCSUnit = Unit.getByName( self.ClientName )
+  local UnitID = DCSUnit:getID()
+  
+  self:T( UnitID )
+  return UnitID
+end
+
+function CLIENT:GetName()
+  self:F( self.ClientName )
+  
+  self:T( self.ClientName )
+  return self.ClientName
+end
+
+function CLIENT:GetTypeName()
+  self:F( self.ClientName )
+
+  local DCSUnit = Unit.getByName( self.ClientName )
+  local TypeName = DCSUnit:getTypeName()
+  
+  self:T( TypeName )
+  return TypeName
+end
+
+

 --- Returns the position of the CLIENT in @{DCSTypes#Vec3} format.
 -- @param #CLIENT self
@@ -338,7 +376,7 @@ end
 function CLIENT:ClientPosition()
 	self:F()

-	ClientGroupUnit = self:GetClientGroupDCSUnit()
+	local ClientGroupUnit = self:GetClientGroupDCSUnit()
 	
 	if ClientGroupUnit then
 		if ClientGroupUnit:isExist() then
@@ -355,7 +393,7 @@ end
 function CLIENT:GetAltitude()
 	self:F()

-  ClientGroupUnit = self:GetClientGroupDCSUnit()
+  local ClientGroupUnit = self:GetClientGroupDCSUnit()
  
  if ClientGroupUnit then
    if ClientGroupUnit:isExist() then
--- a/Moose/Database.lua
+++ b/Moose/Database.lua
@@ -66,25 +66,35 @@ Include.File( "Routines" )
 Include.File( "Base" )
 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 = {
+    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,
@@ -140,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

@@ -260,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.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
@@ -318,7 +363,7 @@ end
 function DATABASE:SetStatusGroup( GroupName, Status )
  self:F( Status )

-  self.Groups[GroupName].Status = Status
+  self.Templates.Groups[GroupName].Status = Status
 end


@@ -326,8 +371,8 @@ end
 function DATABASE:GetStatusGroup( GroupName )
  self:F( Status )

-  if self.Groups[GroupName] then
-    return self.Groups[GroupName].Status
+  if self.Templates.Groups[GroupName] then
+    return self.Templates.Groups[GroupName].Status
  else
    return ""
  end
@@ -341,9 +386,9 @@ function DATABASE:_RegisterGroup( GroupTemplate )

  local GroupTemplateName = env.getValueDictByKey(GroupTemplate.name)

-  if not self.Groups[GroupTemplateName] then
-    self.Groups[GroupTemplateName] = {}
-    self.Groups[GroupTemplateName].Status = nil
+  if not self.Templates.Groups[GroupTemplateName] then
+    self.Templates.Groups[GroupTemplateName] = {}
+    self.Templates.Groups[GroupTemplateName].Status = nil
  end
  
  -- Delete the spans from the route, it is not needed and takes memory.
@@ -351,31 +396,102 @@ function DATABASE:_RegisterGroup( GroupTemplate )
    GroupTemplate.route.spans = nil
  end
  
-  self.Groups[GroupTemplateName].GroupName = GroupTemplateName
-  self.Groups[GroupTemplateName].Template = GroupTemplate
-  self.Groups[GroupTemplateName].groupId = GroupTemplate.groupId
-  self.Groups[GroupTemplateName].UnitCount = #GroupTemplate.units
-  self.Groups[GroupTemplateName].Units = GroupTemplate.units
+  self.Templates.Groups[GroupTemplateName].GroupName = GroupTemplateName
+  self.Templates.Groups[GroupTemplateName].Template = GroupTemplate
+  self.Templates.Groups[GroupTemplateName].groupId = GroupTemplate.groupId
+  self.Templates.Groups[GroupTemplateName].UnitCount = #GroupTemplate.units
+  self.Templates.Groups[GroupTemplateName].Units = GroupTemplate.units

-  self:T( { "Group", self.Groups[GroupTemplateName].GroupName, self.Groups[GroupTemplateName].UnitCount } )
+  self:T( { "Group", self.Templates.Groups[GroupTemplateName].GroupName, self.Templates.Groups[GroupTemplateName].UnitCount } )

-  for unit_num, UnitTemplate in pairs(GroupTemplate.units) do
+  for unit_num, UnitTemplate in pairs( GroupTemplate.units ) do

    local UnitTemplateName = env.getValueDictByKey(UnitTemplate.name)
-    self.Units[UnitTemplateName] = {}
-    self.Units[UnitTemplateName].UnitName = UnitTemplateName
-    self.Units[UnitTemplateName].Template = UnitTemplate
-    self.Units[UnitTemplateName].GroupName = GroupTemplateName
-    self.Units[UnitTemplateName].GroupTemplate = GroupTemplate
-    self.Units[UnitTemplateName].GroupId = GroupTemplate.groupId
+    self.Templates.Units[UnitTemplateName] = {}
+    self.Templates.Units[UnitTemplateName].UnitName = UnitTemplateName
+    self.Templates.Units[UnitTemplateName].Template = UnitTemplate
+    self.Templates.Units[UnitTemplateName].GroupName = GroupTemplateName
+    self.Templates.Units[UnitTemplateName].GroupTemplate = GroupTemplate
+    self.Templates.Units[UnitTemplateName].GroupId = GroupTemplate.groupId
+    self:E( {"skill",UnitTemplate.skill})
    if UnitTemplate.skill and (UnitTemplate.skill == "Client" or UnitTemplate.skill == "Player") then
-      self.ClientsByName[UnitTemplateName] = UnitTemplate
-      self.ClientsByID[UnitTemplate.unitId] = UnitTemplate
+      self.Templates.ClientsByName[UnitTemplateName] = UnitTemplate
+      self.Templates.ClientsByID[UnitTemplate.unitId] = UnitTemplate
    end
-    self:E( { "Unit", self.Units[UnitTemplateName].UnitName } )
+    self:E( { "Unit", self.Templates.Units[UnitTemplateName].UnitName } )
  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
+      end
+      
+      for ClientName, ClientTemplate in pairs( self.Templates.ClientsByName ) do
+        self.Clients[ClientName] = CLIENT:New( ClientName )
+      end
+    end
+  end
+  
+  return self
+end
+
+
+--- Events
+
 --- Handles the OnBirth event for the alive units set.
 -- @param #DATABASE self
 -- @param Event#EVENTDATA Event
@@ -385,7 +501,15 @@ function DATABASE:_EventOnBirth( Event )
  if Event.IniDCSUnit then
    if self:_IsIncludeDCSUnit( Event.IniDCSUnit ) then
      self.DCSUnits[Event.IniDCSUnitName] = Event.IniDCSUnit 
-      self.DCSUnitsAlive[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
+      self:_EventOnPlayerEnterUnit( Event )
    end
  end
 end
@@ -404,18 +528,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 )
@@ -435,15 +595,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() + 1 )
+  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()

@@ -507,6 +708,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

@@ -594,6 +798,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
--- a/Moose/Event.lua
+++ b/Moose/Event.lua
@@ -437,6 +437,32 @@ function EVENT:OnHitForUnit( EventDCSUnitName, EventFunction, EventSelf )
  return self
 end

+--- Set a new listener for an S_EVENT_PLAYER_ENTER_UNIT event.
+-- @param #EVENT self
+-- @param #function EventFunction The function to be called when the event occurs for the unit.
+-- @param Base#BASE EventSelf The self instance of the class for which the event is.
+-- @return #EVENT
+function EVENT:OnPlayerEnterUnit( EventFunction, EventSelf )
+  self:F()
+
+  self:OnEventGeneric( EventFunction, EventSelf, world.event.S_EVENT_PLAYER_ENTER_UNIT )
+  
+  return self
+end
+
+--- Set a new listener for an S_EVENT_PLAYER_LEAVE_UNIT event.
+-- @param #EVENT self
+-- @param #function EventFunction The function to be called when the event occurs for the unit.
+-- @param Base#BASE EventSelf The self instance of the class for which the event is.
+-- @return #EVENT
+function EVENT:OnPlayerLeaveUnit( EventFunction, EventSelf )
+  self:F()
+
+  self:OnEventGeneric( EventFunction, EventSelf, world.event.S_EVENT_PLAYER_LEAVE_UNIT )
+  
+  return self
+end
+


 function EVENT:onEvent( Event )
@@ -468,6 +494,7 @@ function EVENT:onEvent( Event )
      Event.WeaponName = Event.Weapon:getTypeName()
      --Event.WeaponTgtDCSUnit = Event.Weapon:getTarget()
    end
+    self:E( { _EVENTCODES[Event.id], Event } )
    for ClassName, EventData in pairs( self.Events[Event.id] ) do
      if Event.IniDCSUnitName and EventData.IniUnit and EventData.IniUnit[Event.IniDCSUnitName] then 
        self:T2( { "Calling event function for class ", ClassName, " unit ", Event.IniDCSUnitName } )
--- a/Moose/Group.lua
+++ b/Moose/Group.lua
@@ -1084,7 +1084,7 @@ end
 function GROUP:GetTaskMission()
  self:F( self.GroupName )

-  return routines.utils.deepCopy( _DATABASE.Groups[self.GroupName].Template )
+  return routines.utils.deepCopy( _DATABASE.Templates.Groups[self.GroupName].Template )
 end

 --- Return the mission route of the group.
@@ -1093,7 +1093,7 @@ end
 function GROUP:GetTaskRoute()
  self:F( self.GroupName )

-  return routines.utils.deepCopy( _DATABASE.Groups[self.GroupName].Template.route.points )
+  return routines.utils.deepCopy( _DATABASE.Templates.Groups[self.GroupName].Template.route.points )
 end

 --- Return the route of a group by using the @{Database#DATABASE} class.
@@ -1117,7 +1117,7 @@ function GROUP:CopyRoute( Begin, End, Randomize, Radius )
 	
 	self:T( { GroupName } )
 	
-	local Template = _DATABASE.Groups[GroupName].Template
+	local Template = _DATABASE.Templates.Groups[GroupName].Template
 	
 	if Template then
 		if not Begin then
--- a/Moose/Routines.lua
+++ b/Moose/Routines.lua
@@ -1737,7 +1737,7 @@ function routines.getGroupRoute(groupIdent, task)   -- same as getGroupPoints bu
 		-- refactor to search by groupId and allow groupId and groupName as inputs
 	local gpId = groupIdent
 	if type(groupIdent) == 'string' and not tonumber(groupIdent) then
-		gpId = _DATABASE.Groups[groupIdent].groupId
+		gpId = _DATABASE.Templates.Groups[groupIdent].groupId
 	end
 	
 	for coa_name, coa_data in pairs(env.mission.coalition) do
--- a/Moose/Sead.lua
+++ b/Moose/Sead.lua
@@ -67,7 +67,7 @@ function SEAD:EventShot( Event )
 		local _targetMimgroup = Unit.getGroup(Weapon.getTarget(SEADWeapon))
 		local _targetMimgroupName = _targetMimgroup:getName()
 		local _targetMimcont= _targetMimgroup:getController()
-		local _targetskill =  _DATABASE.Units[_targetMimname].Template.skill
+		local _targetskill =  _DATABASE.Templates.Units[_targetMimname].Template.skill
 		self:T( self.SEADGroupPrefixes )
 		self:T( _targetMimgroupName )
 		local SEADGroupFound = false
--- a/Moose/Spawn.lua
+++ b/Moose/Spawn.lua
@@ -954,7 +954,7 @@ function SPAWN:_GetTemplate( SpawnTemplatePrefix )

 	local SpawnTemplate = nil

-	SpawnTemplate = routines.utils.deepCopy( _DATABASE.Groups[SpawnTemplatePrefix].Template )
+	SpawnTemplate = routines.utils.deepCopy( _DATABASE.Templates.Groups[SpawnTemplatePrefix].Template )
 	
 	if SpawnTemplate == nil then
 		error( 'No Template returned for SpawnTemplatePrefix = ' .. SpawnTemplatePrefix )
--- a/Moose/Unit.lua
+++ b/Moose/Unit.lua
@@ -56,11 +56,13 @@ UNIT = {
 -- @return Unit#UNIT
 function UNIT:New( DCSUnit )
 	local self = BASE:Inherit( self, BASE:New() )
-	self:F( DCSUnit:getName() )
+	self:F( DCSUnit )

 	self.DCSUnit = DCSUnit
-	self.UnitName = DCSUnit:getName()
-	self.UnitID = DCSUnit:getID()
+	if DCSUnit then
+  	self.UnitName = DCSUnit:getName()
+  	self.UnitID = DCSUnit:getID()
+  end

 	return self
 end
@@ -91,6 +93,18 @@ function UNIT:GetName()
 	return self.UnitName
 end

+function UNIT:GetPlayerName()
+  self:F( self.UnitName )
+  
+  local DCSUnit = Unit.getByName( self.UnitName )
+  
+  local PlayerName = DCSUnit:getPlayerName()
+  if PlayerName == nil then
+    PlayerName = ""
+  end
+  
+  return PlayerName
+end
 function UNIT:GetTypeName()
 	self:F( self.UnitName )