# Original Fleet Order by Defiant <mail@defiant.homedns.org>
# This Neutral Fleet Order by Chris Jones <cjones2@stoc.info>


# Imports
import App
import MissionLib
import Bridge.BridgeUtils
import Lib.Ambiguity
import QuickBattle.QuickBattle
import Lib.LibEngineering

STAY = Lib.LibEngineering.GetEngineeringNextEventType()
ATTACK = Lib.LibEngineering.GetEngineeringNextEventType()
ATTACKFRIENDLY = Lib.LibEngineering.GetEngineeringNextEventType()
FOLLOW_THROUGH_WARP = Lib.LibEngineering.GetEngineeringNextEventType()
STAYFLEET = Lib.LibEngineering.GetEngineeringNextEventType()
ATTACKFLEET = Lib.LibEngineering.GetEngineeringNextEventType()
ATTACKMYFLEET = Lib.LibEngineering.GetEngineeringNextEventType()
FOLLOW_THROUGH_WARP_FLEET = Lib.LibEngineering.GetEngineeringNextEventType()

def init():
        # Vars
        pBridge = App.g_kSetManager.GetSet('bridge')
        BridgeType = App.BridgeSet_Cast(pBridge).GetConfig()
        g_pKiska = App.CharacterClass_GetObject(pBridge, 'Helm')
        pKiskaMenu = Bridge.BridgeUtils.GetBridgeMenu('Helm')

	pButtonOrder = App.STMenu_CreateW(App.TGString("Neutral Ships"))
	pKiskaMenu.PrependChild(pButtonOrder)
	
	pButtonOrderShip = App.STMenu_CreateW(App.TGString("NeutralShip"))
	pButtonOrder.PrependChild(pButtonOrderShip)
	
	pButtonOrderFleet = App.STMenu_CreateW(App.TGString("NeutralFleet"))
	pButtonOrder.PrependChild(pButtonOrderFleet)
	
	event = Lib.Ambiguity.getEvent(STAY)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".Stay")
	pButtonStay = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("Stop"), event, 0, g_pKiska)
	pButtonOrderShip.PrependChild(pButtonStay)
	
	event = Lib.Ambiguity.getEvent(ATTACK)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".Attack")
	pButtonAttack = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("AttackEnemy"), event, 0, g_pKiska)
	pButtonOrderShip.PrependChild(pButtonAttack)
	
	event = Lib.Ambiguity.getEvent(ATTACKFRIENDLY)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".AttackFriendly")
	pButtonAttack = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("AttackMyFleet"), event, 0, g_pKiska)
	pButtonOrderShip.PrependChild(pButtonAttack)	
	
	event = Lib.Ambiguity.getEvent(FOLLOW_THROUGH_WARP)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".FollowThroughWarp")
	pButtonFollow = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("Follow"), event, 0, g_pKiska)
	pButtonOrderShip.PrependChild(pButtonFollow)

	event = Lib.Ambiguity.getEvent(STAYFLEET)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".StayFleet")
	pButtonStay = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("Stop"), event, 0, g_pKiska)
	pButtonOrderFleet.PrependChild(pButtonStay)
	
	event = Lib.Ambiguity.getEvent(ATTACKFLEET)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".AttackFleet")
	pButtonAttack = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("AttackEnemy"), event, 0, g_pKiska)
	pButtonOrderFleet.PrependChild(pButtonAttack)
	
	event = Lib.Ambiguity.getEvent(ATTACKMYFLEET)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".AttackMyFleet")
	pButtonAttack = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("AttackMyFleet"), event, 0, g_pKiska)
	pButtonOrderFleet.PrependChild(pButtonAttack)	
	
	event = Lib.Ambiguity.getEvent(FOLLOW_THROUGH_WARP_FLEET)
	g_pKiska.AddPythonFuncHandlerForInstance(event, __name__ + ".FollowThroughWarpFleet")
	pButtonFollow = QuickBattle.QuickBattle.CreateBridgeMenuButton(App.TGString("Follow"), event, 0, g_pKiska)
	pButtonOrderFleet.PrependChild(pButtonFollow)


def Stay(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pNeutrals	= pMission.GetNeutralGroup()
	pPlayer	= MissionLib.GetPlayer()
	pTarget	= pPlayer.GetTarget()
	pTargetattr	= App.ShipClass_Cast(pTarget)

	if not pTarget:
		print("No Target")
		return
	
	if (pNeutrals.IsNameInGroup(pPlayer.GetTarget().GetName()) != 1):
		print("Target is not friendly - failed.")
		return

	import AI.Player.Stay
	pTargetattr.SetAI(AI.Player.Stay.CreateAI(pTargetattr))

	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()


def StayFleet(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pPlayer	= MissionLib.GetPlayer()
	pSet = pPlayer.GetContainingSet()
	pNeutralGroup = pMission.GetNeutralGroup()
	pNeutrals	= pMission.GetNeutralGroup()
	lpNeutrals = pNeutralGroup.GetActiveObjectTupleInSet(pSet)
	
	import AI.Player.Stay

	for pNeutral in lpNeutrals:
		pTargetattr	= App.ShipClass_Cast(pNeutral)
		if (str(pTargetattr) != str(App.ShipClass_Cast(pPlayer))):
			pTargetattr.SetAI(AI.Player.Stay.CreateAI(pTargetattr))
	
	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()
	

def Attack(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pFriendlies	= pMission.GetNeutralGroup()
	pPlayer	= MissionLib.GetPlayer()
	pTarget	= pPlayer.GetTarget()
	pTargetattr	= App.ShipClass_Cast(pTarget)

	if not pTarget:
		print("No Target")
		return
	
	if (pFriendlies.IsNameInGroup(pPlayer.GetTarget().GetName()) != 1):
		print("Target is not friendly - failed.")
		return
	
	import QuickBattle.QuickBattle
	import Custom.QuickBattleGame.QuickBattle

	# set AI
	# We need to know if we are playing normal QB or QBR:
	# QB
	if QuickBattle.QuickBattle.pFriendlies:
		if (pTargetattr.GetShipProperty().IsStationary() == 1):
			# its a Station
			import QuickBattle.StarbaseFriendlyAI
			pTargetattr.SetAI(QuickBattle.StarbaseFriendlyAI.CreateAI(pTargetattr))
		else:
			import QuickBattle.QuickBattleFriendlyAI
			pTargetattr.SetAI(QuickBattle.QuickBattleFriendlyAI.CreateAI(pTargetattr))
	# QBR
	elif Custom.QuickBattleGame.QuickBattle.pFriendlies:
		if (pTargetattr.GetShipProperty().IsStationary() == 1):
			# its a Station
			import Custom.QuickBattleGame.StarbaseFriendlyAI
			pTargetattr.SetAI(Custom.QuickBattleGame.StarbaseFriendlyAI.CreateAI(pTargetattr))
		else:
			import Custom.QuickBattleGame.QuickBattleFriendlyAI
			pTargetattr.SetAI(Custom.QuickBattleGame.QuickBattleFriendlyAI.CreateAI(pTargetattr))
	
	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()
	
def AttackFriendly(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pFriendlies	= pMission.GetNeutralGroup()
	pPlayer	= MissionLib.GetPlayer()
	pTarget	= pPlayer.GetTarget()
	pTargetattr	= App.ShipClass_Cast(pTarget)

	if not pTarget:
		print("No Target")
		return
	
	if (pFriendlies.IsNameInGroup(pPlayer.GetTarget().GetName()) != 1):
		print("Target is not friendly - failed.")
		return
	
	import QuickBattle.QuickBattle
	import Custom.QuickBattleGame.QuickBattle

	# set AI
	# We need to know if we are playing normal QB or QBR:
	# QB
	if QuickBattle.QuickBattle.pFriendlies:
		if (pTargetattr.GetShipProperty().IsStationary() == 1):
			# its a Station
			import QuickBattle.StarbaseAI
			pTargetattr.SetAI(QuickBattle.StarbaseAI.CreateAI(pTargetattr))
		else:
			import QuickBattle.QuickBattleAI
			pTargetattr.SetAI(QuickBattle.QuickBattleAI.CreateAI(pTargetattr))
	# QBR
	elif Custom.QuickBattleGame.QuickBattle.pFriendlies:
		if (pTargetattr.GetShipProperty().IsStationary() == 1):
			# its a Station
			import Custom.QuickBattleGame.StarbaseAI
			pTargetattr.SetAI(Custom.QuickBattleGame.StarbaseAI.CreateAI(pTargetattr))
		else:
			import Custom.QuickBattleGame.QuickBattleAI
			pTargetattr.SetAI(Custom.QuickBattleGame.QuickBattleAI.CreateAI(pTargetattr))
	
	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()	
	

def AttackFleet(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pPlayer	= MissionLib.GetPlayer()
	pSet = pPlayer.GetContainingSet()
	pFriendlyGroup = pMission.GetNeutralGroup()
	pFriendlies	= pMission.GetNeutralGroup()
	lpFriendlies = pFriendlyGroup.GetActiveObjectTupleInSet(pSet)
	
	import QuickBattle.QuickBattle
	import Custom.QuickBattleGame.QuickBattle
	
	for pFriendly in lpFriendlies:
		pTargetattr	= App.ShipClass_Cast(pFriendly)
		if (str(pTargetattr) != str(App.ShipClass_Cast(pPlayer))):
			# set AI
			# We need to know if we are playing normal QB or QBR:
			# QB
			if QuickBattle.QuickBattle.pFriendlies:
				if (pTargetattr.GetShipProperty().IsStationary() == 1):
					# its a Station
					import QuickBattle.StarbaseFriendlyAI
					pTargetattr.SetAI(QuickBattle.StarbaseFriendlyAI.CreateAI(pTargetattr))
				else:
					import QuickBattle.QuickBattleFriendlyAI
					pTargetattr.SetAI(QuickBattle.QuickBattleFriendlyAI.CreateAI(pTargetattr))
			# QBR
			elif Custom.QuickBattleGame.QuickBattle.pNeutrals:
				if (pTargetattr.GetShipProperty().IsStationary() == 1):
					# its a Station
					import Custom.QuickBattleGame.StarbaseFriendlyAI
					pTargetattr.SetAI(Custom.QuickBattleGame.StarbaseFriendlyAI.CreateAI(pTargetattr))
				else:
					import Custom.QuickBattleGame.QuickBattleFriendlyAI
					pTargetattr.SetAI(Custom.QuickBattleGame.QuickBattleFriendlyAI.CreateAI(pTargetattr))
					
def AttackMyFleet(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pPlayer	= MissionLib.GetPlayer()
	pSet = pPlayer.GetContainingSet()
	pFriendlyGroup = pMission.GetNeutralGroup()
	pFriendlies	= pMission.GetNeutralGroup()
	lpFriendlies = pFriendlyGroup.GetActiveObjectTupleInSet(pSet)
	
	import QuickBattle.QuickBattle
	import Custom.QuickBattleGame.QuickBattle
	
	for pFriendly in lpFriendlies:
		pTargetattr	= App.ShipClass_Cast(pFriendly)
		if (str(pTargetattr) != str(App.ShipClass_Cast(pPlayer))):
			# set AI
			# We need to know if we are playing normal QB or QBR:
			# QB
			if QuickBattle.QuickBattle.pFriendlies:
				if (pTargetattr.GetShipProperty().IsStationary() == 1):
					# its a Station
					import QuickBattle.StarbaseAI
					pTargetattr.SetAI(QuickBattle.StarbaseAI.CreateAI(pTargetattr))
				else:
					import QuickBattle.QuickBattleAI
					pTargetattr.SetAI(QuickBattle.QuickBattleAI.CreateAI(pTargetattr))
			# QBR
			elif Custom.QuickBattleGame.QuickBattle.pNeutrals:
				if (pTargetattr.GetShipProperty().IsStationary() == 1):
					# its a Station
					import Custom.QuickBattleGame.StarbaseAI
					pTargetattr.SetAI(Custom.QuickBattleGame.StarbaseAI.CreateAI(pTargetattr))
				else:
					import Custom.QuickBattleGame.QuickBattleAI
					pTargetattr.SetAI(Custom.QuickBattleGame.QuickBattleAI.CreateAI(pTargetattr))					
	
	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()
	
	
def FollowThroughWarp(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pNeutrals	= pMission.GetNeutralGroup()
	pPlayer	= MissionLib.GetPlayer()
	pTarget	= pPlayer.GetTarget()
	pTargetattr	= App.ShipClass_Cast(pTarget)

	if not pTarget:
		print("No Target")
		return
	
	if (pNeutrals.IsNameInGroup(pTarget.GetName()) != 1):
		print("Target is not friendly - failed.")
		return

	if ( pTargetattr.GetShipProperty().IsStationary() == 1 ):
		print("Target is a Station - can't follow.")
		return
		
	pTargetattr.SetAI(CreateAI(pTargetattr))

	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()


def FollowThroughWarpFleet(pObject, pEvent):		
	pGame	= App.Game_GetCurrentGame()
	pEpisode	= pGame.GetCurrentEpisode()
	pMission	= pEpisode.GetCurrentMission()
	pPlayer	= MissionLib.GetPlayer()
	pSet = pPlayer.GetContainingSet()
	pNeutralGroup = pMission.GetNeutralGroup()
	pNeutrals	= pMission.GetNeutralGroup()
	lpNeutrals = pNeutralGroup.GetActiveObjectTupleInSet(pSet)

	for pNeutral in lpNeutrals:
		pTargetattr	= App.ShipClass_Cast(pNeutral)
		if (str(pTargetattr) != str(App.ShipClass_Cast(pPlayer)) and pNeutral.GetShipProperty().IsStationary() == 0 ):
			pTargetattr.SetAI(CreateAI(pTargetattr))

	pSequence = App.TGSequence_Create()
	pSet = App.g_kSetManager.GetSet("bridge")
	if (pSet):
		pHelm = App.CharacterClass_GetObject(pSet, "Helm")
		if (pHelm):
			pSequence.AppendAction(App.CharacterAction_Create(pHelm, App.CharacterAction.AT_SAY_LINE, "SendingOrders" + str(App.g_kSystemWrapper.GetRandomNumber(2) + 1), "Captain", 1))
	pSequence.Play()


# From Maelstrom.Episode4.E4M4.FollowPlayerAI, only changed the string "Player" to pPlayer.GetName()
def CreateAI(pShip):
	pPlayer = MissionLib.GetPlayer()
	
	#########################################
	# Creating PlainAI Follow at (121, 148)
	pFollow = App.PlainAI_Create(pShip, "Follow")
	pFollow.SetScriptModule("FollowObject")
	pFollow.SetInterruptable(1)
	pScript = pFollow.GetScriptInstance()
	pScript.SetFollowObjectName(pPlayer.GetName())
	pScript.SetRoughDistances(100,150,200)
	# Done creating PlainAI Follow
	#########################################
	#########################################
	# Creating ConditionalAI PlayerInSameSet at (120, 102)
	## Conditions:
	#### Condition InSet
	pInSet = App.ConditionScript_Create("Conditions.ConditionAllInSameSet", "ConditionAllInSameSet", pShip.GetName(), pPlayer.GetName())
	## Evaluation function:
	def EvalFunc(bInSet):
		ACTIVE = App.ArtificialIntelligence.US_ACTIVE
		DORMANT = App.ArtificialIntelligence.US_DORMANT
		DONE = App.ArtificialIntelligence.US_DONE
		if bInSet:
			# Player is in the same set as we are.
			return ACTIVE
		return DORMANT
	## The ConditionalAI:
	pPlayerInSameSet = App.ConditionalAI_Create(pShip, "PlayerInSameSet")
	pPlayerInSameSet.SetInterruptable(1)
	pPlayerInSameSet.SetContainedAI(pFollow)
	pPlayerInSameSet.AddCondition(pInSet)
	pPlayerInSameSet.SetEvaluationFunction(EvalFunc)
	# Done creating ConditionalAI PlayerInSameSet
	#########################################
	#########################################
	# Creating CompoundAI FollowWarp at (209, 102)
	import AI.Compound.FollowThroughWarp
	pFollowWarp = AI.Compound.FollowThroughWarp.CreateAI(pShip, pPlayer.GetName())
	# Done creating CompoundAI FollowWarp
	#########################################
	#########################################
	# Creating PriorityListAI PriorityList at (120, 24)
	pPriorityList = App.PriorityListAI_Create(pShip, "PriorityList")
	pPriorityList.SetInterruptable(1)
	# SeqBlock is at (139, 65)
	pPriorityList.AddAI(pPlayerInSameSet, 1)
	pPriorityList.AddAI(pFollowWarp, 2)
	# Done creating PriorityListAI PriorityList
	#########################################
	#########################################
	# Creating PreprocessingAI AvoidObstacles at (28, 23)
	## Setup:
	import AI.Preprocessors
	pScript = AI.Preprocessors.AvoidObstacles()
	## The PreprocessingAI:
	pAvoidObstacles = App.PreprocessingAI_Create(pShip, "AvoidObstacles")
	pAvoidObstacles.SetInterruptable(1)
	pAvoidObstacles.SetPreprocessingMethod(pScript, "Update")
	pAvoidObstacles.SetContainedAI(pPriorityList)
	# Done creating PreprocessingAI AvoidObstacles
	#########################################
	return pAvoidObstacles