Example #1
0
        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);
        }
Example #2
0
 void SelectAll(BDModulePilotAI wingman, int index, object data)
 {
     for (int i = 0; i < wingmen.Count; i++)
     {
         if (!focusIndexes.Contains(i))
         {
             focusIndexes.Add(i);
         }
     }
 }
Example #3
0
        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);
        }
Example #4
0
        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);
        }
Example #5
0
 void CommandAttack(BDModulePilotAI wingman, int index, object data)
 {
     StartCoroutine(CommandPosition(wingman, BDModulePilotAI.PilotCommands.Attack));
 }
Example #6
0
 void CommandFlyTo(BDModulePilotAI wingman, int index, object data)
 {
     StartCoroutine(CommandPosition(wingman, BDModulePilotAI.PilotCommands.FlyTo));
 }
Example #7
0
 void OpenAGWindow(BDModulePilotAI wingman, int index, object data)
 {
     showAGWindow = !showAGWindow;
 }
Example #8
0
 void CommandTakeOff(BDModulePilotAI wingman, int index, object data)
 {
     wingman.ActivatePilot();
     wingman.standbyMode = false;
 }
Example #9
0
 void CommandFollow(BDModulePilotAI wingman, int index, object data)
 {
     wingman.CommandFollow(this, index);
 }
Example #10
0
 void CommandRelease(BDModulePilotAI wingman, int index, object data)
 {
     wingman.ReleaseCommand();
 }
Example #11
0
        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();
        }
Example #12
0
        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;
        }