Mine

/*	Object: Drone Combat - Designed to handle use of drones in a defensive manner, including 
		Launching, Targeting, Attacking, and Recalling.
	I designed this for use with obj_Miner, so that we may use our barges to tank rats while
	our drones destroy them. This way, we really don't have to worry about our drones being
	popped nearly as much, if at all. Just make sure you have a good tank.
		--Stealthy										*/

objectdef obj_DroneCombat
{
	/* Variables used in pulse checking */
	variable time NextPulse
	variable int PulseIntervalInSeconds = 3

	/* Variables used by DroneCombat */
	variable bool HaveResetTargets = FALSE
	variable index:entity TargetList
	variable index:entity LockedTargets
	variable iterator TargetIterator
	variable iterator Target
	variable bool StartedAttack = FALSE
	variable int MaxTargets
	variable bool NeedDefense = FALSE
	variable string DefendState = "IDLE"

	/* DEBUG SWITCH */
	variable bool Debug = TRUE

	method Initialize()
	{
		BotModules:Insert["DroneCombat"]
		Event[OnFrame]:AttachAtom[This:Pulse]
		UI:UpdateConsole["obj_DroneCombat: Initialized"]
	}

	method Pulse()
	{
		if ${EVEBot.Paused}
		{
			return
		}
		if ${Time.Timestamp} > ${This.NextPulse.Timestamp}
		{
			This.NextPulse:Set[${Time.Timestamp}]
			This.NextPulse.Second:Inc[${This.PulseIntervalInSeconds}]
			This.NextPulse:Update
			/* Return if we're in station */
			if (${Me.InStation})
			{
				return
			}
			This:UpdateLists
			if ${Config.Combat.LaunchCombatDrones} && \
				(${Miner.CurrentState.Equal[MINE]} || ${Miner.CurrentState.Equal[UNKNOWN]} || \
				${Miner.CurrentState.Equal[IDLE]})
			{
				if ${Social.IsSafe} && !${This.NeedDefense} && ${This.RatsOnMe} && ${Me.Ship.ShieldPct} < 100
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneDefense: Detected threat, handling"]
					This.NeedDefense:Set[TRUE]
					return
				}
				elseif !${This.RatsOnMe} && ${This.NeedDefense}
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneDefense: No drone threat"]
					This.NeedDefense:Set[FALSE]
					This.StartedAttack:Set[FALSE]
					This.HaveResetTargets:Set[FALSE]
					return
				}
				elseif ${This.RatsOnMe} && ${This.NeedDefense}
				{
					if !${Social.IsSafe}
					{
						This.StartedAttack:Set[FALSE]
						This.HaveResetTargets:Set[FALSE]
						This.NeedDefense:Set[FALSE]
						UI:UpdateConsole["DroneDefense: Aborting drone routines due to hostiles"]
						return
					}
					This:Defend
					return
				}
				if ${Ship.Drones.DronesInSpace} > 0
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneCombat: Recalling drones"]
					EVE:DronesReturnToDroneBay[Ship.Drones.ActiveDroneIDList]
				}
			}
			else
			{
				echo "Mine State ${Miner.CurrentState}"
				echo "Ship Drones ${Ship.Drones.DronesInBay}"
			}
		}
	}

	/* Update the target lists and iterators, etc */
	method UpdateLists()
	{
		Me:DoGetTargetedBy[TargetList, CategoryID, 11]
		TargetList:GetIterator[TargetIterator]
		Me:DoGetTargets[LockedTargets]
		LockedTargets:GetIterator[Target]

		/* Figure out how many things we can really have targeted */
		if (${Me.Ship.MaxLockedTargets} >= ${Me.MaxLockedTargets})
		{
			MaxTargets:Set[${Me.MaxLockedTargets}]
		}
		else
		{
			MaxTargets:Set[${Me.Ship.MaxLockedTargets}]
		}
	}

	/* Do we currently have rats on us? */
	member:bool RatsOnMe()
	{
		if (${TargetIterator:First(exists)})
		{
			return TRUE
		}
		return FALSE
	}

	method Defend()
	{

		/* While it's safe for us to defend ourselves... */
		while (${Social.IsSafe} && ${This.RatsOnMe})
		{
			/* Return having done nothing if we're targeting something */
			if (${Me.GetTargeting} > 0)
			{
				if ${This.Debug}
					UI:UpdateConsole["DroneDefense: Waiting on a target"]
				return
			}
	
			/* Send out our drones! */
			if (${Ship.Drones.DronesInSpace} == 0)
			{
				if ${This.Debug}
					UI:UpdateConsole["DroneDefense: Launching drones"]
				Ship.Drones:LaunchAll[]
				return
			}
	
			/* If we're full of targets... */
			if (!${This.StartedAttack} && ${This.MaxTargets} == ${Me.GetTargets})
			{
				if (${Target:Last(exists)} && ${TargetIterator:First(exists)})
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneDefense: Unlocking a target because Ihave too many"]
					if (${Target.Value.ID} != ${TargetIterator.Value.ID})
					{
						if (${Target:First(exists)})
						{
							Target.Value:UnlockTarget
							return
						}
					}
				}
			}
			/* We're not full of targets now! */
			elseif (!${This.HaveResetTargets} && ${Me.GetTargets} < ${This.MaxTargets})
			{
				if (${TargetIterator:First(exists)})
				{
					if ${This.Debug}
						UI:UpdateConsole["Starting to lock a target"]
					/* Lock its ass */
					TargetIterator.Value:LockTarget
					This.HaveResetTargets:Set[TRUE]
					return
				}
			}
			
			/* Targeting has been taken care of, bust some fuckers */
			if (${This.HaveResetTargets} && !${This.StartedAttack})
			{
				if (${Me.ActiveTarget.ID} != ${TargetIterator.Value.ID})
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneDefense: Making ${TargetIterator.Value.ID} active target"]
					echo ${TargetIterator.Value.Name}
					TargetIterator.Value:MakeActiveTarget
					return
				}
				if ${This.Debug}
					UI:UpdateConsole["DroneDefense: Sending in the drones!"]
				Ship.Drones:SendDrones
				This.StartedAttack:Set[TRUE]
				return
			}
			
			/* Make sure we're 
			if (${This.StartedAttacks})
			{
				return
			}
				
	
			/* If our "target" is dead, we need to clean up */
			if (${Target.Value.StructurePct} == 0)
			{
				if ${This.Debug}
					UI:UpdateConsole["DroneDefense: Drone target is dead"]
				/* If there is no next target, recall drones */
				if !${Target:Next(exists)}
				{
					if ${This.Debug}
						UI:UpdateConsole["DroneDefense: No more targets, recalling drones"]
					This.StartedAttack:Set[FALSE]
					This.HaveResetTargets:Set[FALSE]
					return
				}

			}
			return
		}
		if ${This.Debug}
			UI:UpdateConsole["DroneDefense: Broke the while loop, cleaning up"]
		This.StartedAttack:Set[FALSE]
		This.HaveResetTargets:Set[FALSE]
		return
	}

	/* Helper methods */
}