void CommandAG(BDModulePilotAI wingman, int index, object ag)
{
//Debug.Log("object to string: "+ag.ToString());
KSPActionGroup actionGroup = (KSPActionGroup)ag;
//Debug.Log("ag to string: " + actionGroup.ToString());
wingman.CommandAG(actionGroup);
}
void SelectAll(BDModulePilotAI wingman, int index, object data)
{
for (int i = 0; i < wingmen.Count; i++)
{
if (!focusIndexes.Contains(i))
{
focusIndexes.Add(i);
}
}
}
IEnumerator CommandPositionGUIRoutine(BDModulePilotAI wingman, GPSTargetInfo tInfo)
{
//RemoveCommandPos(tInfo);
commandedPositions.Add(tInfo);
yield return(new WaitForSeconds(0.25f));
while (Vector3d.Distance(wingman.commandGPS, tInfo.gpsCoordinates) < 0.01f &&
(wingman.currentCommand == BDModulePilotAI.PilotCommands.Attack ||
wingman.currentCommand == BDModulePilotAI.PilotCommands.FlyTo))
{
yield return(null);
}
RemoveCommandPos(tInfo);
}
IEnumerator CommandPosition(BDModulePilotAI wingman, BDModulePilotAI.PilotCommands command)
{
if (focusIndexes.Count == 0 && !commandSelf)
{
yield break;
}
DisplayScreenMessage("Select target coordinates.\nRight-click to cancel.");
if (command == BDModulePilotAI.PilotCommands.FlyTo)
{
waitingForFlytoPos = true;
}
else if (command == BDModulePilotAI.PilotCommands.Attack)
{
waitingForAttackPos = true;
}
yield return(null);
bool waitingForPos = true;
drawMouseDiamond = true;
while (waitingForPos)
{
if (Input.GetMouseButtonDown(1))
{
break;
}
if (Input.GetMouseButtonDown(0))
{
Vector3 mousePos = new Vector3(Input.mousePosition.x / Screen.width,
Input.mousePosition.y / Screen.height, 0);
Plane surfPlane = new Plane(vessel.upAxis,
vessel.transform.position - (vessel.altitude * vessel.upAxis));
Ray ray = FlightCamera.fetch.mainCamera.ViewportPointToRay(mousePos);
float dist;
if (surfPlane.Raycast(ray, out dist))
{
Vector3 worldPoint = ray.GetPoint(dist);
Vector3d gps = VectorUtils.WorldPositionToGeoCoords(worldPoint, vessel.mainBody);
if (command == BDModulePilotAI.PilotCommands.FlyTo)
{
wingman.CommandFlyTo(gps);
}
else if (command == BDModulePilotAI.PilotCommands.Attack)
{
wingman.CommandAttack(gps);
}
StartCoroutine(CommandPositionGUIRoutine(wingman, new GPSTargetInfo(gps, command.ToString())));
}
break;
}
yield return(null);
}
waitingForAttackPos = false;
waitingForFlytoPos = false;
drawMouseDiamond = false;
ScreenMessages.RemoveMessage(screenMessage);
}
void CommandAttack(BDModulePilotAI wingman, int index, object data)
{
StartCoroutine(CommandPosition(wingman, BDModulePilotAI.PilotCommands.Attack));
}
void CommandFlyTo(BDModulePilotAI wingman, int index, object data)
{
StartCoroutine(CommandPosition(wingman, BDModulePilotAI.PilotCommands.FlyTo));
}
void OpenAGWindow(BDModulePilotAI wingman, int index, object data)
{
showAGWindow = !showAGWindow;
}
void CommandTakeOff(BDModulePilotAI wingman, int index, object data)
{
wingman.ActivatePilot();
wingman.standbyMode = false;
}
void CommandFollow(BDModulePilotAI wingman, int index, object data)
{
wingman.CommandFollow(this, index);
}
void CommandRelease(BDModulePilotAI wingman, int index, object data)
{
wingman.ReleaseCommand();
}
void RefreshFriendlies()
{
if (!weaponManager)
{
return;
}
friendlies = new List <BDModulePilotAI>();
List <Vessel> .Enumerator vs = BDATargetManager.LoadedVessels.GetEnumerator();
while (vs.MoveNext())
{
if (vs.Current == null)
{
continue;
}
if (!vs.Current.loaded || vs.Current == vessel)
{
continue;
}
BDModulePilotAI pilot = null;
MissileFire wm = null;
List <BDModulePilotAI> .Enumerator ps = vs.Current.FindPartModulesImplementing <BDModulePilotAI>().GetEnumerator();
while (ps.MoveNext())
{
if (ps.Current == null)
{
continue;
}
pilot = ps.Current;
break;
}
ps.Dispose();
if (!pilot)
{
continue;
}
List <MissileFire> .Enumerator ws = vs.Current.FindPartModulesImplementing <MissileFire>().GetEnumerator();
while (ws.MoveNext())
{
// TODO: JDK: note that this assigns the last module found. Is that what we want?
wm = ws.Current;
}
ws.Dispose();
if (!wm || wm.team != weaponManager.team)
{
continue;
}
friendlies.Add(pilot);
}
vs.Dispose();
//TEMPORARY
wingmen = new List <BDModulePilotAI>();
List <BDModulePilotAI> .Enumerator fs = friendlies.GetEnumerator();
while (fs.MoveNext())
{
if (fs.Current == null)
{
continue;
}
wingmen.Add(fs.Current);
}
fs.Dispose();
}
IEnumerator DogfightCompetitionModeRoutine(float distance)
{
competitionStarting = true;
competitionStatus = "Competition: Pilots are taking off.";
Dictionary <BDArmorySettings.BDATeams, List <BDModulePilotAI> > pilots =
new Dictionary <BDArmorySettings.BDATeams, List <BDModulePilotAI> >();
pilots.Add(BDArmorySettings.BDATeams.A, new List <BDModulePilotAI>());
pilots.Add(BDArmorySettings.BDATeams.B, new List <BDModulePilotAI>());
List <Vessel> .Enumerator loadedVessels = BDATargetManager.LoadedVessels.GetEnumerator();
while (loadedVessels.MoveNext())
{
if (loadedVessels.Current == null)
{
continue;
}
if (!loadedVessels.Current.loaded)
{
continue;
}
BDModulePilotAI pilot = null;
IEnumerator <BDModulePilotAI> ePilots = loadedVessels.Current.FindPartModulesImplementing <BDModulePilotAI>().AsEnumerable().GetEnumerator();
while (ePilots.MoveNext())
{
pilot = ePilots.Current;
break;
}
ePilots.Dispose();
if (!pilot || !pilot.weaponManager)
{
continue;
}
pilots[BDATargetManager.BoolToTeam(pilot.weaponManager.team)].Add(pilot);
pilot.ActivatePilot();
pilot.standbyMode = false;
if (pilot.weaponManager.guardMode)
{
pilot.weaponManager.ToggleGuardMode();
}
}
loadedVessels.Dispose();
//clear target database so pilots don't attack yet
BDATargetManager.ClearDatabase();
if (pilots[BDArmorySettings.BDATeams.A].Count == 0 || pilots[BDArmorySettings.BDATeams.B].Count == 0)
{
Debug.Log("[BDArmory]: Unable to start competition mode - one or more teams is empty");
competitionStatus = "Competition: Failed! One or more teams is empty.";
yield return(new WaitForSeconds(2));
competitionStarting = false;
yield break;
}
BDModulePilotAI aLeader = pilots[BDArmorySettings.BDATeams.A][0];
BDModulePilotAI bLeader = pilots[BDArmorySettings.BDATeams.B][0];
aLeader.weaponManager.wingCommander.CommandAllFollow();
bLeader.weaponManager.wingCommander.CommandAllFollow();
//wait till the leaders are airborne
while (aLeader && bLeader && (aLeader.vessel.LandedOrSplashed || bLeader.vessel.LandedOrSplashed))
{
yield return(null);
}
if (!aLeader || !bLeader)
{
StopCompetition();
}
competitionStatus = "Competition: Sending pilots to start position.";
Vector3 aDirection =
Vector3.ProjectOnPlane(aLeader.vessel.CoM - bLeader.vessel.CoM, aLeader.vessel.upAxis).normalized;
Vector3 bDirection =
Vector3.ProjectOnPlane(bLeader.vessel.CoM - aLeader.vessel.CoM, bLeader.vessel.upAxis).normalized;
Vector3 center = (aLeader.vessel.CoM + bLeader.vessel.CoM) / 2f;
Vector3 aDestination = center + (aDirection * (distance + 1250f));
Vector3 bDestination = center + (bDirection * (distance + 1250f));
aDestination = VectorUtils.WorldPositionToGeoCoords(aDestination, FlightGlobals.currentMainBody);
bDestination = VectorUtils.WorldPositionToGeoCoords(bDestination, FlightGlobals.currentMainBody);
aLeader.CommandFlyTo(aDestination);
bLeader.CommandFlyTo(bDestination);
Vector3 centerGPS = VectorUtils.WorldPositionToGeoCoords(center, FlightGlobals.currentMainBody);
//wait till everyone is in position
bool waiting = true;
while (waiting)
{
waiting = false;
if (!aLeader || !bLeader)
{
StopCompetition();
}
if (Vector3.Distance(aLeader.transform.position, bLeader.transform.position) < distance * 1.95f)
{
waiting = true;
}
else
{
Dictionary <BDArmorySettings.BDATeams, List <BDModulePilotAI> > .KeyCollection.Enumerator keys = pilots.Keys.GetEnumerator();
while (keys.MoveNext())
{
List <BDModulePilotAI> .Enumerator ePilots = pilots[keys.Current].GetEnumerator();
while (ePilots.MoveNext())
{
if (ePilots.Current == null)
{
continue;
}
if (ePilots.Current.currentCommand != BDModulePilotAI.PilotCommands.Follow ||
!((ePilots.Current.vessel.CoM - ePilots.Current.commandLeader.vessel.CoM).sqrMagnitude > 1000f * 1000f))
{
continue;
}
competitionStatus = "Competition: Waiting for teams to get in position.";
waiting = true;
}
ePilots.Dispose();
}
keys.Dispose();
}
yield return(null);
}
//start the match
Dictionary <BDArmorySettings.BDATeams, List <BDModulePilotAI> > .KeyCollection.Enumerator pKeys = pilots.Keys.GetEnumerator();
while (pKeys.MoveNext())
{
List <BDModulePilotAI> .Enumerator pPilots = pilots[pKeys.Current].GetEnumerator();
while (pPilots.MoveNext())
{
if (pPilots.Current == null)
{
continue;
}
//enable guard mode
if (!pPilots.Current.weaponManager.guardMode)
{
pPilots.Current.weaponManager.ToggleGuardMode();
}
//report all vessels
if (BDATargetManager.BoolToTeam(pPilots.Current.weaponManager.team) == BDArmorySettings.BDATeams.B)
{
BDATargetManager.ReportVessel(pPilots.Current.vessel, aLeader.weaponManager);
}
else
{
BDATargetManager.ReportVessel(pPilots.Current.vessel, bLeader.weaponManager);
}
//release command
pPilots.Current.ReleaseCommand();
pPilots.Current.defaultOrbitCoords = centerGPS;
}
}
pKeys.Dispose();
competitionStatus = "Competition starting! Good luck!";
yield return(new WaitForSeconds(2));
competitionStarting = false;
}
