Something

#define TARGET_BASE_PRIORITY 50

#define TARGET_NONE 0
#define TARGET_VALIDATE 1

/*
 * Events:
 *
 * TARGET_DIED [guid]
 * TARGET_ADDED [guid]
 */

objectdef oTarget
{
	variable objectref Data
	variable bool IsPlayer = FALSE
	variable int Priority

	method Initialize(string TargetGUID, int Priority)
	{
		Data:Set[${TargetGUID}]
		This.Priority:Set[${Priority}]
	}
}

objectdef oTargets inherits oBase
{
	variable int TotalTargets = 0
	variable int CurrentState = 0
	variable int PreviousState = 0

	variable index:oTarget Targets
	variable objectref CurrentTarget
	variable int LastValidation = 0

	member NeedValidation()
	{
		if ${TotalTargets} > 0 && ${Math.Calc[${LavishScript.RunningTime} - ${LastValidation}]} > 1000
		{
			return TRUE
		}

		return FALSE
	}

	member State()
	{
		if ${NeedValidation}
		{
			return TARGET_VALIDATE
		}

		return TARGET_NONE
	}

	method Pulse()
	{
		CurrentState:Set[${State}]
		if ${CurrentState} != ${PreviousState}
		{
			This:OnStateChange
			PreviousState:Set[${CurrentState}]
		}

		switch ${CurrentState}
		{
			case TARGET_VALIDATE
				This:Validate
				break
			case TARGET_NONE
				break
		}
	}

	method OnStateChange()
	{
	}

	/*
	 * Methods
	 */

	method Add(string TargetGUID, int Priority=TARGET_BASE_PRIORITY)
	{
		if !${Unit[${TargetGUID}](exists)}
		{
			return
		}

		Event["TARGET_ADDED"]:Execute[${TargetGUID}]
		Targets:Insert[${TargetGUID},${Priority}]
		TotalTargets:Inc
	}

	method Clear()
	{
		Targets:Collapse
		if ${Targets.Get[1](exists)}
		{
			do
			{
				Targets:Remove[1]
			}
			while ${Targets.Get[1](exists)}
		}
		This:ResetActiveTarget
	}

	method ResetActiveTarget()
	{
		CurrentTarget:Set[0]
	}

	member TargetIndex(string TargetGUID)
	{
		variable int Index = 1

		Targets:Collapse

		if ${Targets.Get[${Index}](exists)}
		{
			do
			{
				if ${Targets.Get[${Index}].Data.GUID.Equal[${TargetGUID}]}
				{
					return ${Index}
				}
			}
			while ${Targets.Get[${Index:Inc}](exists)}
		}

		return 0
	}

	method SetPriority(string TargetGUID, int Priority)
	{
		variable int Index = 0

		Index:Set[${TargetIndex[${TargetGUID}]}]

		if ${Index} > 0
		{
			Targets.Get[${Index}].Priority:Set[${Priority}]
		}
	}

	method Remove(string TargetGUID)
	{
		variable int Index = 0

		Index:Set[${TargetIndex[${TargetGUID}]}]

		if ${Index} > 0
		{
			Targets:Remove[${Index}]
			TotalTargets:Dec
		}
	}

	method Validate()
	{
		variable int Index = 1
		variable int Best = 0

		if ${TotalTargets} == 0
		{
			return
		}

		Targets:Collapse

		if ${Targets.Get[${Index}](exists)}
		{
			do
			{
				;FIXME! calculate priority using callbacks
				if ${Targets.Get[${Index}].Data.Dead}
				{
					Event["TARGET_DIED"]:Execute[${Targets.Get[${Index}].Data.GUID}]
					Targets:Remove[${Index}]
				}

				Best:Set[${Index}]			
			}
			while ${Targets.Get[${Index:Inc}](exists)}
			CurrentTarget:Set[${Targets.Get[${Best}].Data.GUID}]
		}
	}

	method Initialize()
	{
		LastValidation:Set[${LavishScript.RunningTime}]
		LavishScript:RegisterEvent["TARGET_DIED"]
		LavishScript:RegisterEvent["TARGET_ADDED"]
	}

	method Shutdown()
	{
		Event["TARGET_DIED"]:Unregister
		Event["TARGET_ADDED"]:Unregister
	}
}