-- $Id: //depot/Projects/StarWars_Expansion/Run/Data/Scripts/Library/PGCommands.lua#10 $
--/////////////////////////////////////////////////////////////////////////////////////////////////
--
-- (C) Petroglyph Games, Inc.
--
--
--  *****           **                          *                   *
--  *   **          *                           *                   *
--  *    *          *                           *                   *
--  *    *          *     *                 *   *          *        *
--  *   *     *** ******  * **  ****      ***   * *      * *****    * ***
--  *  **    *  *   *     **   *   **   **  *   *  *    * **   **   **   *
--  ***     *****   *     *   *     *  *    *   *  *   **  *    *   *    *
--  *       *       *     *   *     *  *    *   *   *  *   *    *   *    *
--  *       *       *     *   *     *  *    *   *   * **   *   *    *    *
--  *       **       *    *   **   *   **   *   *    **    *  *     *   *
-- **        ****     **  *    ****     *****   *    **    ***      *   *
--                                          *        *     *
--                                          *        *     *
--                                          *       *      *
--                                      *  *        *      *
--                                      ****       *       *
--
--/////////////////////////////////////////////////////////////////////////////////////////////////
-- C O N F I D E N T I A L   S O U R C E   C O D E -- D O   N O T   D I S T R I B U T E
--/////////////////////////////////////////////////////////////////////////////////////////////////
--
--              $File: //depot/Projects/StarWars_Expansion/Run/Data/Scripts/Library/PGCommands.lua $
--
--    Original Author: Brian Hayes
--
--            $Author: James_Yarrow $
--
--            $Change: 53991 $
--
--          $DateTime: 2006/09/08 11:01:51 $
--
--          $Revision: #10 $
--
--/////////////////////////////////////////////////////////////////////////////////////////////////

require("PGBaseDefinitions")

-- Deprecated...
--
-- function ProduceForce(taskforce)
--    tfIndex = 0
--
--    DebugMessage("Beginning production on %s at %s.", tostring(taskforce),
--          tostring(taskforce.Production_Facility()))
--
--    -- loop through all the unit types and produce each one.
--    UnitType = taskforce.Get_Type_Of_Unit(tfIndex)
--    while UnitType do
--
--       -- Build the object at the production facility.
--       tfObj = WaitProduceObject(UnitType, taskforce.Production_Facility())
--       DebugMessage("Object %s produced.", tostring(tfObj))
--
--       -- Add the object to the task force.
--       taskforce.Add_Force(tfObj)
--
--        -- Remove our reference to the object, since a merge will destroy it.
--       tfObj.Release()
--
--       -- Merge the new fleets together.
--       BlockOnCommand(taskforce.Form_Units())
--
--       -- Look for another unit type.
--       tfIndex = tfIndex + 1
--       UnitType = taskforce.Get_Type_Of_Unit(tfIndex)
--    end
-- end
--
-- function ProduceObject(player, objecttype, where)
--    return _ProduceObject(player, objecttype, where)
-- end
--
-- function WaitProduceObject(objecttype, where)
--    return BlockOnCommand(ProduceObject(PlayerObject, objecttype, where))
-- end

function WaitForever()
	DebugMessage("%s -- Waiting forever...", tostring(Script))
	while true do
		PumpEvents()
	end
--	BlockOnCommand(BlockForever())
	DebugMessage("%s -- Something interrupted the wait!.", tostring(Script))
end

--	TimerTable[func] = {timeout = timeout, start_time = GetCurrentTime(), param = param }
--function Debug_Timer_Table()
--	OutputDebug("%s -- TimerTable Dump.\n", tostring(Script))
--	for func,tabtab in pairs(TimerTable) do
--		for idx,tab in pairs(tabtab) do
--			OutputDebug("%s, %f, %f, %s\n", tostring(func), tab.timeout, tab.start_time, tostring(tab.param))
--		end
--	end
--end

function Register_Timer(func, timeout, param)
	if TimerTable[func] == nil then
		TimerTable[func] = {}
	end
	
	table.insert(TimerTable[func], {timeout = timeout, start_time = GetCurrentTime(), param = param})
end

function Process_Timers()
	for func,tabtab in pairs(TimerTable) do
		found_entry = false
		for idx,tab in pairs(tabtab) do
			found_entry = true
			if tab.timeout + tab.start_time < GetCurrentTime() then
				tabtab[idx] = nil
				func(tab.param)
				Process_Timers()
				return
			end
		end
		if found_entry == false then
			TimerTable[func] = nil
			Process_Timers()
			return
		end
	end
end

-- Cancels all occurences of this timer function
function Cancel_Timer(func)
	if func ~= nil then
		TimerTable[func] = nil
	else
		MessageBox("%s -- cancelling nonexistant function, got:%s; aborting.", tostring(Script), type(func))
	end
end


-- Setup a callback for the death or deletion of a given object.
function Register_Death_Event(obj, func)
	if not TestValid(obj) then
		MessageBox("%s -- Error, object doesn't exist or has already died.", tostring(Script))
		return
	end

	if DeathTable[obj] ~= nil then
		MessageBox("%s -- Error, object already registered for death event", tostring(Script))
		return
	end
	
	DeathTable[obj] = func
end

function Process_Death_Events()
	for obj, func in pairs(DeathTable) do
		if not TestValid(obj) then
			DeathTable[obj] = nil
			func()
			Process_Death_Events()
			return
		end
	end
end

-- Setup a callback for a given object falling under attack.
function Register_Attacked_Event(obj, func)
	if not TestValid(obj) then
		MessageBox("%s -- Error, object doesn't exist or has died.", tostring(Script))
		return
	end

	if AttackedTable[obj] ~= nil then
		MessageBox("%s -- Error, object already registered for attacked event", tostring(Script))
		return
	end
	
	-- Storing the callback and if the object currently has a "deadly enemy"
	AttackedTable[obj] = {func, false}
end


-- Executes the callback with (true, object) if first going under attack.
-- Executes the callback with (false) if no longer under attack.
function Process_Attacked_Events()
	for obj, table in pairs(AttackedTable) do
		if not TestValid(obj) then
			AttackedTable[obj] = nil
		else
			most_deadly_enemy = FindDeadlyEnemy(obj)
			if most_deadly_enemy then
		
				-- If we have a deadly enemy and this just became true, run the callback.
				if not table[2] then
					table[2] = true
					table[1](true, most_deadly_enemy, obj)
					Process_Attacked_Events()
					return
				end
			
			-- Update that we don't have a deadly enemy any longer.
			--else
			elseif table[2] then
				--MessageBox("obj:%s now has no deadly enemy", tostring(obj))
				table[2] = false
				table[1](false, nil, obj)
			end
		end
	end
end

function Cancel_Attacked_Event(obj)
	if obj ~= nil then
		AttackedTable[obj] = nil
	else
		MessageBox("received nil object")
	end
end



-- Set up proximity triggers on arbitrary objects and have them serviced.
function Register_Prox(obj, func, range, player_filter)

	-- prevent this from doing anything in galactic mode
	if Get_Game_Mode() == "Galactic" then
		DebugMessage("%s -- Warning, proximity register disallowed in galactic mode; aborting.", tostring(Script))
		return
	end

	if not TestValid(obj) then
		MessageBox("%s -- Error, prox object doesn't exist; aborting", tostring(Script))
		ScriptError("%s -- Error, prox object doesn't exist; aborting", tostring(Script))
		return
	end
	
	-- Note the player_filter is optional.  The user of this function must check
	-- for player validity at the source.	
	if player_filter == nil then
		DebugMessage("%s -- Warning, passed a nil player, not filtering prox by player", tostring(Script))
	end

	obj.Event_Object_In_Range(func, range, player_filter)
	ProxTable[obj] = 1
end

function Process_Proximities()
	for obj, count in pairs(ProxTable) do
		if TestValid(obj) then
			obj.Service_Wrapper()
		else
			ProxTable[obj] = nil
		end
	end
end

function Pump_Service()
	Process_Timers()
	Process_Death_Events()
	Process_Proximities()
	Process_Attacked_Events()
	
	-- Don't test if this is a function, so that we can catch accidental redefinitions when it's used as a function.
	if Process_Reinforcements then
		Process_Reinforcements()
	end
	
	-- This is for behavior that we need evaluated every service without regard to story event state.
	if Story_Mode_Service then
		Story_Mode_Service()
	end
end


-- Try an ability if the AI difficulty will allow a chance
function Try_Ability(thing, ability_name, target)

	owner = PlayerObject
	if not Is_A_Taskforce(thing) then
		owner = thing.Get_Owner()
	end
	if owner == nil then
		MessageBox("%s -- no owner for thing:%s", tostring(Script), tostring(thing))
	end

	-- At a given difficulty, there is a chance that the ability use will be allowed.
	if not Chance(GetAbilityChanceSeed(), GetChanceAllowed(owner.Get_Difficulty())) then
		return false
	end

	return Use_Ability_If_Able(thing, ability_name, target)
end


-- Activates the ability for a unit or a taskforce's units if able.
-- Optionally uses ability on a target.
-- Returns true if the ability was attempted
function Use_Ability_If_Able(thing, ability_name, target)

	-- Taskforces aren't able to check for the ability availablity or readiness, but check this for units
	if Is_A_Taskforce(thing) or (thing.Has_Ability(ability_name) and thing.Is_Ability_Ready(ability_name) and (not thing.Is_Ability_Active(ability_name))) then
	
		if target == nil then
			thing.Activate_Ability(ability_name, true)
		elseif TestValid(target) then
			thing.Activate_Ability(ability_name, target)
		end
		return true
	end
	return false
end


function Is_A_Taskforce(thing)
	return thing and thing.Get_Unit_Table
end


-- This will consider diverting the passed object in order to use an area of effect ability centered on the unit.
function ConsiderDivertAndAOE(object, ability_name, area_of_effect, recent_enemy_units, min_threat_to_use_ability)

	-- At a given difficulty, there is a chance that the divert for ability use will be allowed.
	if (not aoe_pos) and (not Chance(GetCurrentMinute(), GetChanceAllowed(object.Get_Owner().Get_Difficulty()))) then
		return
	end

	-- See if the ability is ready and there are enough enemies around to consider using it.
	if object.Is_Ability_Ready(ability_name) then

		DebugMessage("%s -- %s is ready and trigger number met", tostring(Script), ability_name)

		-- If we haven't found a good use for the ability
		if aoe_pos == nil then

			-- Find a good place to use the ability and divert or throw the result away.
			aoe_pos, aoe_victim_threat = Find_Best_Local_Threat_Center(recent_enemy_units, area_of_effect)
			if aoe_pos == nil then
				DebugMessage("%s -- couldn't get a valid threat center", tostring(Script))
				DebugPrintTable(recent_enemy_units)
				return
			end				

			DebugMessage("%s -- Found ability pos with threat %d", tostring(Script), aoe_victim_threat)
			if (aoe_victim_threat > min_threat_to_use_ability) then
			
				-- Check distance to prevent the unit from spinning in circles on repeated diversions
				if object.Get_Distance(aoe_pos) > 15 then
					DebugMessage("%s -- Met minimum threat; diverting.", tostring(Script))
					Use_Ability_If_Able(object, "SPRINT")
					object.Divert(aoe_pos)
				else
					DebugMessage("%s -- Met minimum threat; Already very close to ideal target so no divert necessary.", tostring(Script))
				end
			else
				DebugMessage("%s -- Resetting pos and threat.", tostring(Script))
				aoe_pos = nil
				aoe_victim_threat = nil
			end

		-- We have found a good use for the ability 
		else

			-- Are we done chasing down the position to use the ability?
			if object.Is_On_Diversion() then
			
				DebugMessage("%s -- In process of diverting to chase threat %d (no new orders issued)", tostring(Script), aoe_victim_threat)
			
			else
				
				-- We're done diverting.  Perform a sanity check to make sure at least one enemy is now in range.
				--if OneOrMoreInRange(object, recent_enemy_units, area_of_effect) then
				-- We're done diverting so check to see if we're at least in range of the best location (even if not centered on it)
				aoe_pos, aoe_victim_threat = Find_Best_Local_Threat_Center(recent_enemy_units, area_of_effect)
				if aoe_pos and (object.Get_Distance(aoe_pos) < area_of_effect) then

					-- Use the ability
					DebugMessage("%s -- Attempting %s.", tostring(Script), ability_name)
					Use_Ability_If_Able(object, ability_name)
				else
					DebugMessage("%s -- Nothing at diversion locaion; aborting.", tostring(Script))
				end
				
				-- Reset everything; this try is done.  If the victims moved too much, we'll need to start over.
				recent_enemy_units = {}
				aoe_pos = nil
				aoe_victim_threat = nil
			end
		end
	end
end

function OneOrMoreInRange(origin_unit, target_unit_list, range)
	for key, unit in pairs(target_unit_list) do
		if origin_unit.Get_Distance(unit) < range then
			return true
		end
	end
	return false
end

function PruneFriendlyObjects(obj_table)
	non_friendly_obj_table = {}
	for i, obj in pairs(obj_table) do
		if not (obj.Get_Owner() == PlayerObject) then
			 table.insert(non_friendly_obj_table, obj)
		end
	end
	
	return non_friendly_obj_table
end

function Try_Garrison(tf, unit, offensive_only, range)

	lib_nearest_garrison = Find_Nearest(unit, "GarrisonCanFire", unit.Get_Owner(), true)
	
	if TestValid(lib_nearest_garrison) and unit.Can_Garrison(lib_nearest_garrison) then
		lib_dist_to_garrison = unit.Get_Distance(lib_nearest_garrison)
		
		if lib_dist_to_garrison < range then
			unit.Activate_Ability("SPREAD_OUT", false)
			unit.Garrison(lib_nearest_garrison)
			
			if TestValid(tf) then
				tf.Release_Unit(unit)
				unit.Lock_Current_Orders()
			end
			
			return true
		end
	end
	
	if not offensive_only then
		lib_nearest_garrison = Find_Nearest(unit, "CanContainGarrison", unit.Get_Owner(), true)
		
		if TestValid(lib_nearest_garrison) and unit.Can_Garrison(lib_nearest_garrison) then
			lib_dist_to_garrison = unit.Get_Distance(lib_nearest_garrison)
			
			if lib_dist_to_garrison < range then
				unit.Activate_Ability("SPREAD_OUT", false)
				unit.Garrison(lib_nearest_garrison)
				if TestValid(tf) then
					unit.Lock_Current_Orders()
					tf.Release_Unit(unit)
				end
				return true
			end
		end
	end
	
	return false
end

function Try_Deploy_Garrison(object, target, health_threshold)
	lib_any_deployed = false
	lib_garrison_table = object.Get_Garrisoned_Units()
	if table.getn(lib_garrison_table) > 0 then		
		for i,garrison in pairs(lib_garrison_table) do
			if garrison.Get_Hull() > health_threshold then
				if (not TestValid(target)) or garrison.Is_Good_Against(target) then
					garrison.Leave_Garrison()
					lib_any_deployed = true
				end
			end
		end
	end
	return lib_any_deployed
end

function Get_Special_Healer_Property_Flag(unit)

	if not TestValid(unit) then
		return nil
	end
	
	if not special_healer_table then
		special_healer_table = {}
		special_healer_table["BOBA_FETT"] = "HealsInfantry"
		special_healer_table["EMPEROR_PALPATINE"] = "HealsInfantry"
		special_healer_table["HAN_SOLO"] = "HealsInfantry"
		special_healer_table["CHEWBACCA"] = "HealsInfantry"
		special_healer_table["MARA_JADE"] = "HealsInfantry"
		special_healer_table["OBI_WAN_KENOBI"] = "HealsInfantry"
		special_healer_table["DARTH_VADER"] = "HealsInfantry"
		special_healer_table["KYLE_KATARN"] = "HealsInfantry"
		special_healer_table["TACTICAL_R2_3PO_TEAM"] = "HealsVehicles"
		special_healer_table["GARGANTUAN_BATTLE_PLATFORM"] = "HealsVehicles"
		special_healer_table["LUKE_SKYWALKER_JEDI"] = "HealsInfantry"
		special_healer_table["YODA"] = "HealsInfantry"
		special_healer_table["BOSSK"] = "HealsInfantry"
		special_healer_table["IG-88"] = "HealsVehicles"
		special_healer_table["SILRI"] = "HealsInfantry"
		special_healer_table["TYBER_ZANN"] = "HealsInfantry"
		special_healer_table["URAI_FEN"] = "HealsInfantry"
		special_healer_table["PESTELOUS_THE_HUTT"] = "HealsVehicles"
		special_healer_table["CUARSON"] = "HealsInfantry"
		special_healer_table["XIZOR"] = "HealsInfantry"
		special_healer_table["SYKARIIUS"] = "HealsInfantry"
		special_healer_table["MPTL_SPOTTER"] = "HealsVehicles"
		special_healer_table["SCOUT_TROOPER"] = "HealsVehicles"
		special_healer_table["B1_BATTLEDROID"] = "HealsVehicles"
		special_healer_table["B2_BATTLEDROID"] = "HealsVehicles"
		special_healer_table["B1_REPAIRDROID"] = "HealsVehicles"
		special_healer_table["MAGNAGUARD"] = "HealsVehicles"
	end
	
	return special_healer_table[unit.Get_Type().Get_Name()]

end

function Set_Land_AI_Targeting_Priorities(tf)

	--First set up generic priorities
	tf.Set_Targeting_Priorities("Infantry_Attack_Move", "Infantry")
	tf.Set_Targeting_Priorities("Infantry_Attack_Move", "LandHero")
	tf.Set_Targeting_Priorities("Air_Attack_Move", "Air")
	tf.Set_Targeting_Priorities("Heavy_Vehicle_Attack_Move", "Vehicle")
	
	--Now for some more specific stuff
	tf.Set_Targeting_Priorities("Rocket_Infantry_Attack_Move", "Plex_Soldier_Team")
	tf.Set_Targeting_Priorities("Rocket_Infantry_Attack_Move", "Pirate_Plex_Soldier_Team")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "TIE_Crawler")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "AT_RT_Walker")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "AT_PT_Walker")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "AT_ST_Walker")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "T1C_Tank")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "T2B_Tank")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "Dark_Trooper_PhaseI")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "Hutt_Modified_Skiff")
	tf.Set_Targeting_Priorities("Light_Vehicle_Attack_Move", "Hutt_Modified_Swamp_Speeder")
	tf.Set_Targeting_Priorities("Artillery_Attack_Move", "MPTL")
	tf.Set_Targeting_Priorities("Artillery_Attack_Move", "SPMAT_Walker")
	tf.Set_Targeting_Priorities("Artillery_Attack_Move", "MAL_Rocket_Vehicle")
	tf.Set_Targeting_Priorities("Artillery_Attack_Move", "HAG")
end

function Try_Weapon_Switch(object, target)

	lib_switcher_type = object.Get_Type()

	if not lib_t4b_type then
		lib_t4b_type = Find_Object_Type("T4B_TANK")
		lib_t3b_type = Find_Object_Type("T3B_TANK")
--		lib_marauder_type = Find_Object_Type("Marauder_Missile_Cruiser")
--		lib_broadside_type = Find_Object_Type("Broadside_Class_Cruiser")
--		lib_atst_type = Find_Object_Type("AT_ST_Walker")
		lib_bossk_type = Find_Object_Type("BOSSK")
		lib_b2battledroid_type = Find_Object_Type("B2_Battledroid")
		lib_destroyer_droid_type = Find_Object_Type("DESTROYER_DROID")
		lib_mal_type = Find_Object_Type("MAL_ROCKET_VEHICLE")
--		lib_subjugator_type = Find_Object_Type("Malevolence")
		lib_vader_type = Find_Object_Type("TIE_Prototype")
		lib_vader_team_type = Find_Object_Type("Darth_Vader_TIE_Fighter_Container")
	end

	if lib_switcher_type == lib_t4b_type then
		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Structure") or target.Is_Category("Infantry"))
	elseif lib_switcher_type == lib_t3b_type then
		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Structure") or target.Is_Category("Infantry"))
--	elseif lib_switcher_type == lib_marauder_type then
--		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Structure") or target.Is_Category("Capital"))
--	elseif lib_switcher_type == lib_broadside_type then
--		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Structure") or target.Is_Category("Capital"))
--	elseif lib_switcher_type == lib_atst_type then
--		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Infantry") or target.Is_Category("Vehicle"))
	elseif lib_switcher_type == lib_bossk_type then
		object.Activate_Ability("SWAP_WEAPONS", target.Is_Category("Infantry") or target.Is_Category("Vehicle"))
	elseif lib_switcher_type == lib_b2battledroid_type then
		object.Activate_Ability("SWAP_WEAPONS", target.Is_Category("Infantry") or target.Is_Category("Vehicle"))
	elseif lib_switcher_type == lib_destroyer_droid_type then
		object.Activate_Ability("ROCKET_ATTACK", target.Get_Shield() > 0.0)
	elseif lib_switcher_type == lib_mal_type then
		object.Activate_Ability("SWAP_WEAPONS", (target.Is_Category("Infantry") or target.Is_Category("Vehicle")) and GameRandom.Get_Float() > 0.8)
--	elseif lib_switcher_type == lib_subjugator_type then
--		object.Activate_Ability("ROCKET_ATTACK", target.Is_Category("Structure") or target.Is_Category("Super") or target.Is_Category("Capital") and target.Get_Shield() > 0.0)
	elseif lib_switcher_type == lib_vader_type then
		object.Activate_Ability("SWAP_WEAPONS", target.Get_Shield() > 0.0)
	elseif lib_switcher_type == lib_vader_team_type then
		object.Activate_Ability("SWAP_WEAPONS", target.Get_Shield() > 0.0)
	elseif object.Should_Switch_Weapons(target) then
		object.Activate_Ability("SWAP_WEAPONS", not object.Is_Ability_Active("SWAP_WEAPONS"))
	end	

end

function Determine_Magic_Wait_Duration()

	lib_magic_wait_time = 2400 - GetCurrentTime()
	if lib_magic_wait_time < 60 then 
		lib_magic_wait_time = 60
	end
	
	return lib_magic_wait_time
end