Results 1 to 3 of 3

Thread: Troubleshoot script problem?

  1. #1
    Supporting Member
    Join Date
    Sep 2019
    Location
    Yorkshire
    Posts
    138
    Post Thanks / Like
    Total Downloaded
    1.39 GB

    Troubleshoot script problem?

    Hi I'm tring to test this script by Kodiak:

    http://forum.1cpublishing.eu/showthr...=30979&page=12

    I can see the script is referenced (by forcing errors and checking in console), but the functionality doesn't seem to work. It should call out aircraft locations in the chat window.

    I read somewhere that there is a conf.ini setting that needs to be present to make scripts run, but having only recently read through all 22 pages of this section I have no idea where I saw it.

    Or maybe there is something in the code that doesn't work in the current version (4.56)?

    Would appreciate a pointer in the right direction!

    Thanks M

    Code:
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using maddox.game;
    using maddox.game.world;
    using maddox.GP;
    
    
    public class Mission : AMission
    {
    
        private static string userdocpath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
        private static string CLODO_FILE_PATH = userdocpath + @"\1C SoftClub\il-2 sturmovik cliffs of dover\";
        private static string FILE_PATH = @"missions\RadarTest\Radar.mis"; // adjust to your needs
        private static string MISSION_FILE = CLODO_FILE_PATH + FILE_PATH;
    
        //List<LocalHeadquarters> Headquarters = new List<LocalHeadquarters>{
        //    {new LocalHeadquarters("Luton (Ash)", "CallSign24", 50000.0, 242928.64, 251773.16, 
        //        new ObserverStation( "Static0","AN,16","AN,17","AN,18","AN,19","AO,16","AO,17","AO,18","AO,19","AP,16","AP,17","AP,18","AP,19","AQ,16","AQ,17","AQ,18","AQ,19"), //Dover
        //        new ObserverStation( "Static2","AL,20","AL,21","AL,22","AM,20","AM,21","AM,22","AN,20","AN,21","AN,22","AO,20","AO,21","AO,22"))}, // Dunkirk
        //    {new LocalHeadquarters("RadPoe (Woodchurch)", "CallSign32", 50000.0, 208162.91, 227726.61, 
        //        new ObserverStation( "Static1","AJ,15","AJ,16","AJ,17","AJ,18","AK,15","AK,16","AK,17","AK,18","AL,15","AL,16","AL,17","AL,18","AM,15","AM,16","AM,17","AM,18"), //Rye
        //        new ObserverStation( "Royal Observer Corps I","AK,19","AK,20","AK,21","AL,19","AL,20","AL,21","AM,19","AM,20","AM,21"))}, // fake simulation of Royal Observer Corps, none destructable
        //    //{new LocalHeadquarters("Forest (Woodchurch)", "CallSign15", 208162.91, 227726.61, new ObserverStation( "Static4","E,1","E,2","E,3"), new ObserverStation( "Static5","F,1","F,2","F,3"))}
        //};
    
    
        List<LocalHeadquarters> Headquarters = new List<LocalHeadquarters>{
            {new LocalHeadquarters("Luton(Eastbourne)", "CallSign24", 50000.0, 178852.52, 197246.94, 
                 new ObserverStation( "Static1","A,4","B,4","C,4","D,4","E,4","A,3","B,3","C,3","D,3","E,3","A,2","B,2","C,2","D,2","E,2","A,1","B,1","C,1","D,1","E,1"))}, //Dover
     		{new LocalHeadquarters("RadPoe (Rye)", "CallSign23", 50000.0, 206102.81, 212379.97, 
                new ObserverStation( "Static37","F,6","G,6","H,6","I,6","F,5","G,5","H,5","I,5","J,5","F,4","G,4","H,4","I,4","J,4","K,4","F,3","G,3","H,3","I,3","J,3","K,3","L,3","F,2","G,2","H,2","I,2","J,2","K,2","L,2","F,1","G,1","H,1","I,1","J,1","K,1","L,1"))}, //Rye
     		{new LocalHeadquarters("Dover (Ash)", "CallSign22", 50000.0, 246758.98, 235779.38, 
                new ObserverStation( "Static38","I,7","J,7","K,8","L,8","M,11","N,11","O,11","J,6","K,7","L,7","M,10","N,10","O,10","L,5","L,6","K,6","K,5","L,6","L,5","L,4","L,3","L,2","M,9","M,8","M,7","M,6","N,9","N,8","L,10","L,11","L,12","O,9","O,8"))}, //Dover
     		{new LocalHeadquarters("Dunkirk (Woodchurch)", "CallSign32", 50000.0, 220622.50, 252385.53, 
                new ObserverStation( "Static3","A,12","B,12","C,12","D,12","E,12","F,12","G,12","H,12","I,12","J,12","K,12","A,11","B,11","C,11","D,11","E,11","F,11","G,11","H,11","I,11","J,11","A,10","B,10","C,10","D,10","E,10","F,10","G,10","H,10","I,10","J,10","A,9","B,9","C,9","D,9","E,9","F,9","G,9","H,9","I,9","J,9","A,8","B,8","C,8","D,8","E,8","F,8","G,8","A,7","B,7","C,7","D,7","E,7","F,7","G,7","A,6","B,6","C,6","D,6","E,6","B,5","C,5"))}, //Rye
        };
    
    
    
    
    
        LandMarkHandling LandMarks = new LandMarkHandling(
            new LandMark("Dover", 245577.51, 234521.20),
            new LandMark("Folkestone", 235333.17, 229568.64),
            new LandMark("St.Magarets's at Cliffe", 250423.81, 238001.64),
            new LandMark("Deal", 250985.14, 244801.80),
            new LandMark("Dymchurch", 223734.62, 222437.79),
            new LandMark("New Romney", 220005.71, 218110.40),
            new LandMark("Rye", 205758.66, 213525.22),
            new LandMark("Hastings", 195366.28, 203132.83),
            new LandMark("Eastbourne", 174755.54, 191963.14),
            new LandMark("Brighton", 144909.86, 197927.40),
            new LandMark("Calais", 284654.87, 215707.54)
            );
    
    
        Random random = new Random();
    
    
        internal class LandMark
        {
            public string LandMarkName { get; set; }
            public Point2d LandMarkPosition { get; set; }
    
            public LandMark(string landMarkName, double x, double y)
            {
                this.LandMarkName = landMarkName;
                this.LandMarkPosition = new Point2d(x, y);
            }
        }
    
    
        internal class LandMarkHandling
        {
            List<LandMark> LandMarkList = new List<LandMark>();
    
            public LandMarkHandling(params LandMark[] mark)
            {
                if (mark != null)
                    LandMarkList.AddRange(mark);
            }
    
    
            public LandMark getNearestLandMarkTo(Point3d position)
            {
    
                if (!(LandMarkList.Count > 0))
                    return null;
    
                LandMark NearestLandMark = null;
                Point2d currentPosition = new Point2d(position.x, position.y);
    
                LandMarkList.ForEach(item =>
                {
                    if (NearestLandMark != null)
                    {
                        if (NearestLandMark.LandMarkPosition.distance(ref currentPosition) > item.LandMarkPosition.distance(ref currentPosition))
                            NearestLandMark = item;
                    }
                    else NearestLandMark = item;
                });
    
                return NearestLandMark;
            }
        }
    
    
        private List<string> getRadarCreationStrings(string filename)
        {
            List<string> list = new List<string>();
            
            if (!File.Exists(filename))
                GamePlay.gpLogServer(new Player[] { GamePlay.gpPlayer() }, "Missionfile {0} not found! Please check settings", new object[] { FILE_PATH });
    
            using (StreamReader reader = new StreamReader(filename))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.Contains("Stationary.Radar"))
                    {
                        list.Add(line);
                    }
                }
            }
            return list;
        }
    
        
        private ISectionFile createRadarTriggers()
        {
            ISectionFile trigger = GamePlay.gpCreateSectionFile();
    
            List<string> Radarstations = getRadarCreationStrings(MISSION_FILE);
    
            if (Radarstations.Count > 0)
            {
                int i = 0;
                Radarstations.ForEach(item =>
                    {
                        item = item.TrimStart(' ');
                        string[] splittet = item.Split(' ');
                        string keyTr, valueTr;
    
                        keyTr = "Radar" + string.Format("{0:00}", i) +"Destroyed";
                        valueTr = " TGroundDestroyed 50 " + splittet[3] + " " + splittet[4] + " 100"; //TGroundDestroyedTrigger 50% destroyed in radius 100m
                        trigger.add("Trigger", keyTr, valueTr);
    
                        Headquarters.ForEach(hq => hq.AddTriggerToObserver(splittet[0], keyTr));
                        i++;
                    });
            }
            return trigger;
        }
    
    
        #region Calculations
    
        private int ToAngels(double altitude)
        {
            double altAngels = (altitude / 0.3048) / 1000;
    
            if (altAngels > 1)
                altAngels = Math.Round(altAngels, MidpointRounding.AwayFromZero);
            else
                altAngels = 1;
    
            return (int)altAngels;
        }
    
    
        private int ToMiles(double distance)
        {
            double distanceMiles = 0;
            distanceMiles = Math.Round(((distance / 1609.3426)), 0, MidpointRounding.AwayFromZero);   // distance in Miles
    
            return (int)distanceMiles;
        }
    
    
        private string degreesToWindRose(double degrees)
        {
            String[] directions = { "North", "North East", "East", "South East", "South", "South West", "West", "North West", "North" };
            return directions[(int)Math.Round((((double)degrees % 360) / 45))];
        }
    
        // to get the correct bearing its nessesary to make a litte enter the matrix operation.
        // the Vector2d.direction() (same as atan2) has 0° at the x-axis and goes counter clockwise, but we need 0° at the y-axis
        // and clockwise direction
        // so to convert it we need 
        // |0 1| |x|   |0*x + 1*y|    |y|
        // |   | | | = |         | =  | |   // ok not very surprising ;)
        // |1 0| |y|   |1*x + 0*y|    |x|
    
        private double calculateBearingDegree(Vector3d vector)
        {
            Vector2d matVector = new Vector2d(vector.y, vector.x);
            // the value of direction is in rad so we need *180/Pi to get the value in degrees
            return matVector.direction() * 180.0 / Math.PI;
        }
    
    
        private double calculateBearingDegree(Vector2d vector)
        {
            Vector2d newVector = new Vector2d(vector.y, vector.x);
    
            return newVector.direction() * 180.0 / Math.PI;
        }
    
    
        private double calculateBearingFromOrigin(Point2d targetLocation, Point2d originLocation)
        {
    
            double deltaX = targetLocation.x - originLocation.x;
            double deltaY = targetLocation.y - originLocation.y;
    
            double bearing = Math.Atan2(deltaX, deltaY);
            bearing = bearing * (180.0 / Math.PI); 
    
            return (bearing > 0.0 ? bearing : (360.0 + bearing));
        }
    
    
        private double calculateBearingFromOrigin(Point3d targetLocation, Point3d originLocation)
        {
    
            double deltaX = targetLocation.x - originLocation.x;
            double deltaY = targetLocation.y - originLocation.y;
    
    
            double bearing = Math.Atan2(deltaX, deltaY); 
            bearing = bearing * (180.0 / Math.PI); 
    
            return (bearing > 0.0 ? bearing : (360.0 + bearing));
        }
    
    
        private int getDegreesIn10Step(double degrees)
        {
            degrees = Math.Round((degrees / 10), MidpointRounding.AwayFromZero) * 10;
    
            if ((int)degrees == 360)
                degrees = 0.0;
    
            return (int) degrees;
        }
    
        private int noOfAircraft(int number)
        {
            int firstDecimal = 0;
            int higherDecimal = 0;
    
            higherDecimal = Math.DivRem(number, 10, out firstDecimal);
    
            if (firstDecimal > 3 && firstDecimal <= 8)
                firstDecimal = 5;
            else if (firstDecimal > 8)
                higherDecimal += 1;
    
            if (higherDecimal > 0)
                return (int)higherDecimal * 10;
            else
                return (int)firstDecimal;
        }
        
        #endregion
    
    
        internal class LocalHeadquarters
        {
            public string Name { get; set; }
            public Point2d LocationCoords { get; set; }
            public string Callsign { get; set; }
    
            public double MaxRange { get; set; }
    
            private List<ObserverStation> AttachedObservers = new List<ObserverStation>();
    
            public LocalHeadquarters(string name, string callsign, double maxRange, double x, double y, params ObserverStation[] observerStations)
            {
                this.Name = name;
                this.Callsign = callsign;
                this.LocationCoords = new Point2d(x, y);
                this.MaxRange = maxRange;
    
                if (observerStations != null)
                    AttachedObservers.AddRange(observerStations);
            }
    
    
            public bool CheckInRange(Player player)
            {
                if (player.Place() == null) return false;
                
                bool inRange = false;
                Point2d currentPos = new Point2d(player.Place().Pos().x, player.Place().Pos().y);
    
                if (LocationCoords.distance(ref currentPos) < MaxRange)
                    return true;
    
                return false;
            }
    
    
            public bool ObserveSector(string sectorName)
            {
    
                List<string> AttachedSectors = new List<string>();
    
                if (AttachedObservers.Count > 0)
                {
                    AttachedObservers.ForEach(item =>
                    {
                        if (item.IsActive)
                            AttachedSectors.AddRange(item.observedSectors);
                    });
                }
    
                if (AttachedSectors.Exists(item => item.Equals(sectorName)))
                    return true;
                else
                    return false;
            }
    
    
            public List<ObserverStation> GetObservers()
            {
                return AttachedObservers;
            }
    
    
            public List<string> GetObservedSectors()
            {
                List<string> sectorList = new List<string>();
    
                AttachedObservers.ForEach(item =>
                    {
                        if (item.IsActive)
                        {
                            item.observedSectors.ForEach(sector =>
                                {
                                    if (!sectorList.Exists(newsector => sector == newsector))
                                        sectorList.Add(sector);
                                });
                        };
                    });
                return sectorList;
            }
    
    
            public List<string> GetLostObservedSectors()
            {
                List<string> sectorList = new List<string>();
    
                AttachedObservers.ForEach(item =>
                {
                    if (!item.IsActive)
                    {
                        item.observedSectors.ForEach(sector =>
                        {
                            if (!sectorList.Exists(newsector => sector == newsector))
                                sectorList.Add(sector);
                        });
                    };
                });
    
                if (sectorList.Count > 0)
                {
                    List<string> CurrentObservedSectors = GetObservedSectors();
    
                    if (CurrentObservedSectors.Count > 0)
                    {
                        CurrentObservedSectors.ForEach(item =>
                            {
                                if (sectorList.Exists(sector => sector == item))
                                {
                                    sectorList.RemoveAll(sector => sector == item);
                                }
                            });
    
                    }
    
                }
                return sectorList;
            }
    
            public void SetObserverInactive(string triggerName)
            {
    
                if (AttachedObservers.Exists(item => item.TriggerName == triggerName))
                {
                    AttachedObservers[AttachedObservers.FindIndex(item => item.TriggerName == triggerName)].IsActive = false;
                }
            }
    
    
            public void AddTriggerToObserver(string staticName, string triggerName)
            {
                if (AttachedObservers.Exists(item => item.StaticName == staticName))
                {
                    AttachedObservers[AttachedObservers.FindIndex(item => item.StaticName == staticName)].TriggerName = triggerName;
                }
            }
    
    
            public double GetDistance(Player player)
            {
                Point2d playerLocation = new Point2d(player.Place().Pos().x, player.Place().Pos().y);
    
                double distance = LocationCoords.distance(ref playerLocation);
    
                return distance;
            }
    
        }
    
        internal class ObserverStation
        {
            public bool IsActive { get; set; }
            public string StaticName { get; set; }
            public string TriggerName { get; set; }
    
            public List<string> observedSectors = new List<string>();
    
            public ObserverStation(string staticName, params string[] sectorNames)
            {
                this.StaticName = staticName;
                this.IsActive = true;
    
                if (sectorNames != null)
                    observedSectors.AddRange(sectorNames);
            }
    
    
            public ObserverStation(string staticName, string triggerName, params string[] sectorNames)
            {
                this.StaticName = staticName;
                this.TriggerName = triggerName;
                this.IsActive = true;
    
                if (sectorNames != null)
                    observedSectors.AddRange(sectorNames);
            }
    
    
            public void SetTriggerName(string triggerName)
            {
                this.TriggerName = triggerName;
            }
    
        }
    
    
        internal class Pilot
        {
            public Player player { get; set; }
            public LocalHeadquarters ConnectedHeadquarter;
            public DateTime TimeStamp { get; set; }
            public bool RadarUsed { get; set; }
    
            public Pilot(Player player)
            {
                this.player = player;
                this.RadarUsed = false;
            }
        }
    
    
        internal List<Pilot> PilotsInGame = new List<Pilot>();
    
    
        public void checkSectors(Player player)
        {
    
            double timeDelay = 0.0;
            
            if (PilotsInGame.Exists(item => item.player == player))
            {
                int i = PilotsInGame.FindIndex(item => item.player == player);
    
                if (PilotsInGame[i].RadarUsed) return;
                
     
                if (PilotsInGame[i].ConnectedHeadquarter != null && PilotsInGame[i].ConnectedHeadquarter.CheckInRange(player))
                {
                    PilotsInGame[i].RadarUsed = true;
    
                    if (Headquarters.Exists(hq => hq == PilotsInGame[i].ConnectedHeadquarter))
                    {
                        LocalHeadquarters localHQ = PilotsInGame[i].ConnectedHeadquarter;
    
                        Timeout(timeDelay += 2.0, () => 
                            {
                                GamePlay.gpLogServer(new[]{player},"From {0} to {1}:", new object[]{localHQ.Name, player.Name()});
                                GamePlay.gpLogServer(new[] { player }, "Collecting available informations - stay patient", null);
                            });
    
                        Dictionary<AiAirGroup, int> planePulks = getPulks(GamePlay.gpAirGroups((player.Army() == 1) ? 2 : 1), 1600.0); //all Airgroups in 1600m radius count as one
    
                        Dictionary<string, string> Messages = new Dictionary<string, string>();
    
                        
                        if (planePulks != null) //&& planePulks.Count > 0)
                        {
                            bool foundEnemy = false;
    
                            foreach (var kvp in planePulks)
                            {
                                string sectorName = GamePlay.gpSectorName(kvp.Key.Pos().x, kvp.Key.Pos().y);
    
                                if (localHQ.ObserveSector(sectorName) && kvp.Key.Pos().z > 600.00)
                                {
                                    string tmpKey = "";
                                    string message = "";
                                    Point3d destinationPoint = kvp.Key.Pos();
                                    LandMark nearestLandMark = LandMarks.getNearestLandMarkTo(kvp.Key.Pos());
                                    Point2d airgroupPos = new Point2d(kvp.Key.Pos().x, kvp.Key.Pos().y);
                                    Vector2d airgroupVector = new Vector2d(kvp.Key.Vwld().x, kvp.Key.Vwld().y);
    
                                    if (kvp.Value > 3) // only if more than 3 planes in a pulk generate a message
                                    {
                                        foundEnemy = true;
                                        if (nearestLandMark != null)
                                        {
                                            tmpKey = string.Format("Enemy {0} miles {1} from {2} at Angels {3}, Heading {4}", ToMiles(nearestLandMark.LandMarkPosition.distance(ref airgroupPos)), degreesToWindRose(calculateBearingFromOrigin(airgroupPos, nearestLandMark.LandMarkPosition)), nearestLandMark.LandMarkName, ToAngels(kvp.Key.Pos().z), getDegreesIn10Step(calculateBearingDegree(airgroupVector)));
                                            message = string.Format("{0}+ Enemy {1} miles {2} from {3} at Angels {4}, Heading {5}", noOfAircraft(kvp.Value), ToMiles(nearestLandMark.LandMarkPosition.distance(ref airgroupPos)), degreesToWindRose(calculateBearingFromOrigin(airgroupPos, nearestLandMark.LandMarkPosition)), nearestLandMark.LandMarkName, ToAngels(kvp.Key.Pos().z), getDegreesIn10Step(calculateBearingDegree(airgroupVector)));
                                        }
                                        else
                                        {
                                            tmpKey = string.Format("Enemy in Sector: {0} heading {1}", noOfAircraft(kvp.Value), sectorName, getDegreesIn10Step(calculateBearingDegree(airgroupVector)));
                                            message = string.Format("{0}+ Enemy in Sector: {1} heading {2}", noOfAircraft(kvp.Value), sectorName, getDegreesIn10Step(calculateBearingDegree(airgroupVector)));
                                        }
                                        if (!Messages.ContainsKey(tmpKey))
                                        {
                                            Messages.Add(tmpKey, message);
                                        }
                                    }
                                    
                                }
                            }
    
                            Timeout(timeDelay += 28, () =>
                            {
                                GamePlay.gpLogServer(new[] { player }, "From {0}:", new object[]{localHQ.Name });
                                
                                if (Messages.Count > 0)
                                    foreach(var kvp in Messages)
                                    {
                                            GamePlay.gpLogServer(new[] { player }, kvp.Value, null);
                                    };
    
                                if (localHQ.GetLostObservedSectors().Count > 0)
                                {
                                    string lostSectors = "";
    
                                    localHQ.GetLostObservedSectors().ForEach(item =>
                                    {
                                        lostSectors += item + " ";
                                    });
    
                                    lostSectors = lostSectors.TrimEnd(' ');
                                    GamePlay.gpLogServer(null, "Radar blind for Sectors {0}!", new[] { lostSectors });
                                    
                                    if (!foundEnemy)
                                        GamePlay.gpLogServer(new[] { player }, "No Enemy in other available Sectors spottet", null);
                                }
                                else if (!foundEnemy)
                                    GamePlay.gpLogServer(new[] { player }, "No Enemy in Range", null);
                            });
                        }
                    }
                }
                else
                {
                    GamePlay.gpLogServer(new[] { player }, "Connection to HQ lost (out of Range)", null);
                }
    
    
    
    
                Timeout(timeDelay += 10.0, doTimeout: () => // delay for next use
                    {
                        PilotsInGame[i].RadarUsed = false;
                    });
            }
        }
    
    
        private Dictionary<AiAirGroup, int> getPulks(AiAirGroup[] airgroups, double maxdistance)
        {
            Dictionary<AiAirGroup, List<AiAirGroup>> Pulks = new Dictionary<AiAirGroup, List<AiAirGroup>>(); 
    
            if (airgroups != null && airgroups.Length > 1)
            {
                Pulks.Add(airgroups[0], new List<AiAirGroup>());  //leaderGroup //'attached' groups (in radius maxdistance)
    
                for (int i = 1; i < airgroups.Length; i++)
                {
                    bool airgroupAdded = false;
                    foreach (var kvp in Pulks)
                    {
                        Point3d airgroupPos = kvp.Key.Pos();
    
                        if (airgroups[i].Pos().distance(ref airgroupPos) < maxdistance)
                        {
                            kvp.Value.Add(airgroups[i]);
                            airgroupAdded = true;
                        }
                    }
                    if (!airgroupAdded)
                        Pulks.Add(airgroups[i], new List<AiAirGroup>());
                }
            }
    
            Dictionary<AiAirGroup, int> planePulks = new Dictionary<AiAirGroup, int>();
    
            foreach (var kvp in Pulks)
            {
                int numberOfPlanes = 0;
    
                numberOfPlanes += kvp.Key.NOfAirc;
    
                if (kvp.Value.Count > 0)
                    kvp.Value.ForEach(item =>
                        {
                            numberOfPlanes += item.NOfAirc;
                        });
    
                planePulks.Add(kvp.Key, numberOfPlanes);
            }
    
            return planePulks;
        }
    
    
        private void connectToHeadquarterSpeech(AiAircraft aircraft, LocalHeadquarters localHQ)
        {
            double initTime = 0.0;
            
            aircraft.SayToGroup(aircraft.AirGroup(), "Hello_guys");
    
            Timeout(initTime += 2, () =>
                {
                    aircraft.SayToGroup(aircraft.AirGroup(), "This_is");
                });
    
            Timeout(initTime += 2, () =>
            {
                aircraft.SayToGroup(aircraft.AirGroup(), localHQ.Callsign);
            });
    
            Timeout(initTime += 2, () =>
            {
                aircraft.SayToGroup(aircraft.AirGroup(), "n2"); // to is missing as ogg
            });
    
            Timeout(initTime += 2, () =>
            {
                aircraft.SayToGroup(aircraft.AirGroup(), aircraft.CallSign());
            });
    
            Timeout(initTime += 2, () =>
            {
                aircraft.SayToGroup(aircraft.AirGroup(), "leader__");
            });
        }
    
    
        #region mission menus
    
        #region class Menu
    
        internal class Menu
        {
            internal class MenuEntry
            {
                internal string MenuName { get; set; }
                internal bool active { get; set; }
            }
    
            internal List<MenuEntry> menuEntries = new List<MenuEntry>();
    
            public void AddMenuEntry(string description, bool active)
            {
                MenuEntry NewMenuEntry = new MenuEntry();
    
                NewMenuEntry.MenuName = description;
                NewMenuEntry.active = active;
    
                menuEntries.Add(NewMenuEntry);
            }
    
            public string[] GetMenuDescriptions()
            {
                List<string> Descriptions = new List<string>();
    
                menuEntries.ForEach(item =>
                {
                    Descriptions.Add(item.MenuName);
                });
    
                return Descriptions.ToArray();
            }
    
            public bool[] GetActives()
            {
                List<bool> Actives = new List<bool>();
    
                menuEntries.ForEach(item =>
                {
                    Actives.Add(item.active);
                });
    
                return Actives.ToArray();
            }
    
            public bool IsValid()
            {
                if (menuEntries == null || menuEntries.Count < 1)
                    return false;
                else
                    return true;
    
            }
    
        }
    
        #endregion
    
        
        public void SetMainMenu(Player player)
        {
            if (player.Army() == 1) // red Side
                GamePlay.gpSetOrderMissionMenu(player, false, 0, new string[] { "Fighter Command HQs" }, new bool[] { true });
            //else // blue Side
            //    GamePlay.gpSetOrderMissionMenu(player, false, 0, new string[] { "Nothing Available" }, new bool[] { true });
        }
    
    
        public void SetRadarMenu(Player player)
        {
            if (player.Army() != 1) return;
            
            string headQuarter = "Select Headquarter";
            string connectedTo = "";
    
            if (PilotsInGame.Exists(item => item.player == player))
            {
                int i = PilotsInGame.FindIndex(item => item.player == player);
    
                if (PilotsInGame[i].ConnectedHeadquarter != null)
                    connectedTo = string.Format(" (connected: {0})", PilotsInGame[i].ConnectedHeadquarter.Name);
            }
            headQuarter += connectedTo;
    
            if(PilotsInGame.Exists(item=> item.player == player))
            {
                int i = PilotsInGame.FindIndex(item=> item.player == player);
                if (PilotsInGame[i].ConnectedHeadquarter == null)
                    GamePlay.gpSetOrderMissionMenu(player, true, 100, new string[] { headQuarter, "Get Radar Information" }, new bool[] { true, false });
                else if (PilotsInGame[i].RadarUsed)
                    GamePlay.gpSetOrderMissionMenu(player, true, 100, new string[] { headQuarter, "Get Radar Information" }, new bool[] { false, false });
                else
                    GamePlay.gpSetOrderMissionMenu(player, true, 100, new string[] { headQuarter, "Get Radar Information" }, new bool[] { true, true });
            }
        }
    
    
        public void SetConnectToHeadquarterMenu(Player player)
        {
    
            Menu NewMenu = new Menu();
            LocalHeadquarters headQuarter = null;
            int i = -1;
    
            if (PilotsInGame.Exists(item => item.player == player))
            {
                i = PilotsInGame.FindIndex(item => item.player == player);
                headQuarter = PilotsInGame[i].ConnectedHeadquarter;
            }
    
            if (i < 0 && PilotsInGame[i].RadarUsed == true) return;
    
    
            Headquarters.ForEach(item =>
            {
                if (headQuarter != null && item == headQuarter && headQuarter.CheckInRange(player))
                {
                    NewMenu.AddMenuEntry(item.Name + " *", true);
                }
                else if (item.CheckInRange(player))
                    NewMenu.AddMenuEntry(item.Name, true);
            });
    
            if (NewMenu.IsValid())
                GamePlay.gpSetOrderMissionMenu(player, true, 101, NewMenu.GetMenuDescriptions() , NewMenu.GetActives());
            else
                GamePlay.gpSetOrderMissionMenu(player, true, 101, new string[]{ "None available" }, new bool[]{false});
        }
    
    
        public void SetHeadQuarter(Player player, int menuItemIndex)
        {
            
    
            List<LocalHeadquarters> AvailableHQs = new List<LocalHeadquarters>();
    
            Headquarters.ForEach(item =>
            {
               if (item.CheckInRange(player))
                   AvailableHQs.Add(item);
            });
    
            if (menuItemIndex == 0 || AvailableHQs.Count == 0) return;
            
            if (PilotsInGame.Exists(item => item.player == player))
            {
                int i = PilotsInGame.FindIndex(item => item.player == player);
    
                if (AvailableHQs[menuItemIndex - 1].CheckInRange(player) && !PilotsInGame[i].RadarUsed)
                {
                    PilotsInGame[i].ConnectedHeadquarter = AvailableHQs[menuItemIndex - 1];
                    if (player.Place() != null)
                    {
                       // connectToHeadquarterSpeech((player.Place() as AiAircraft), PilotsInGame[i].ConnectedHeadquarter);
                        Timeout(2.0, () => 
                            {
                                GamePlay.gpLogServer(new[] { player }, "From {0} to {1}:", new object[] { PilotsInGame[i].ConnectedHeadquarter.Name, player.Name() });
                                GamePlay.gpLogServer(new[] { player }, "You are welcome!", null);
                            });
                    }
                }
                PilotsInGame[i].RadarUsed = false;
            }
    
        }
    
    
    
    
        public void MenuPartRadarOperations(Player player, int id, int menuItemIndex)
        {
            if (id == 100)
            {
                if (PilotsInGame.Exists(item => item.player == player))
                {
                    if (!PilotsInGame[PilotsInGame.FindIndex(item => item.player == player)].RadarUsed)
                    {
                        //Radar Menu
                        if (menuItemIndex == 1)
                        {
                            SetMainMenu(player);
                        }
                        if (menuItemIndex == 1)
                        {
                            SetConnectToHeadquarterMenu(player);
                        }
    
                        if (menuItemIndex == 2)
                        {
    
                            checkSectors(player);
                            SetMainMenu(player);
                        }
                    }
                    else
                    {
                        SetMainMenu(player);
                    }
                }
            }
    
            if (id == 101)
            {
                //Radar Menu
                if (menuItemIndex == 0)
                    SetRadarMenu(player);
                else
                {
                    SetHeadQuarter(player, menuItemIndex);
                    SetRadarMenu(player);
                }
            }
        }
            
        
    
    
    
    
    
    
        public override void OnOrderMissionMenuSelected(Player player, int ID, int menuItemIndex)
        {
            base.OnOrderMissionMenuSelected(player, ID, menuItemIndex);
    
            
            if (ID == 0)
            { // main menu
                if (menuItemIndex == 1)
                {
                    SetRadarMenu(player);
                }
            }
    
    
            MenuPartRadarOperations(player, ID, menuItemIndex);
    
        }
    
        #endregion
    
    
        public override void OnBattleStarted()
        {
            base.OnBattleStarted();
            MissionNumberListener = -1;
            GamePlay.gpPostMissionLoad(createRadarTriggers());
        }
    
    
        public override void OnPlaceEnter(Player player, AiActor actor, int placeIndex)
        {
            base.OnPlaceEnter(player, actor, placeIndex);
    
    
            if (!PilotsInGame.Exists(item => item.player == player))
            {
                PilotsInGame.Add(new Pilot(player));
            }
    
            SetMainMenu(player);
        }
    
    
        public override void OnTrigger(int missionNumber, string shortName, bool active)
        {
            base.OnTrigger(missionNumber, shortName, active);
            
            if (shortName.StartsWith("Radar") && shortName.EndsWith("Destroyed"))
            {
                GamePlay.gpLogServer(null, "Radar destroyed", null); //testing only
    
                Headquarters.ForEach(item =>
                    {
                        item.SetObserverInactive(shortName);
                    });
            }
    
            AiAction action = GamePlay.gpGetAction(shortName);
            if (action != null)
                action.Do();
        }
    
    }

  2. #2
    Ace No.401_Wolverine's Avatar
    Join Date
    Jan 2012
    Posts
    767
    Post Thanks / Like
    Total Downloaded
    974.2 KB

    Re: Troubleshoot script problem?

    Are you initiating the radar requests by selecting a radar station and asking for reports via TAB-4 mission menu? This script does not automatically report aircraft locations.

    Also, this code requires that you have the 'Server' messages visible in your chat window. You may need to edit that information window to include them.

  3. Likes ♣_Spiritus_♣, Marcost liked this post
  4. #3
    Supporting Member
    Join Date
    Sep 2019
    Location
    Yorkshire
    Posts
    138
    Post Thanks / Like
    Total Downloaded
    1.39 GB

    Re: Troubleshoot script problem?

    A-ha! Thank you Wolverine, I had the server window open but did not appreciate that this function had to be initiated through the comms menu. Works now, thank you!

    Regards,

    M

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •