public static List <ImprovedSpawnGroup> GetPlanetaryCargoShips(Vector3D playerCoords, List <string> eligibleNames, out Dictionary <string, List <string> > validFactions)
        {
            string specificGroup      = "";
            var    planetRestrictions = new List <string>(Settings.General.PlanetSpawnsDisableList.ToList());

            validFactions = new Dictionary <string, List <string> >();
            SpawnGroupSublists.Clear();
            EligibleSpawnsByModId.Clear();
            var environment = new EnvironmentEvaluation(playerCoords);

            if (environment.NearestPlanet != null && environment.IsOnPlanet)
            {
                if (planetRestrictions.Contains(environment.NearestPlanetName) == true)
                {
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            bool specificSpawnRequest = false;

            if (SpawnGroupManager.AdminSpawnGroup != "")
            {
                specificGroup = SpawnGroupManager.AdminSpawnGroup;
                SpawnGroupManager.AdminSpawnGroup = "";
                specificSpawnRequest = true;
            }

            if (!environment.IsOnPlanet)
            {
                return(new List <ImprovedSpawnGroup>());
            }

            if (environment.NearestPlanet == null)
            {
                return(new List <ImprovedSpawnGroup>());
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();

            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (eligibleNames != null)
                {
                    if (!eligibleNames.Contains(spawnGroup.SpawnGroupName))
                    {
                        continue;
                    }
                }
                else
                {
                    if (specificGroup != "" && spawnGroup.SpawnGroup.Id.SubtypeName != specificGroup)
                    {
                        continue;
                    }

                    if (specificGroup == "" && spawnGroup.AdminSpawnOnly == true)
                    {
                        continue;
                    }
                }



                if (spawnGroup.AtmosphericCargoShip == false)
                {
                    continue;
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, playerCoords, environment, specificSpawnRequest) == false)
                {
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, playerCoords);

                if (validFactionsList.Count == 0)
                {
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    string modID = spawnGroup.SpawnGroup.Context.ModId;

                    if (string.IsNullOrEmpty(modID) == true)
                    {
                        modID = "KeenSWH";
                    }

                    if (SpawnGroupSublists.ContainsKey(modID) == false)
                    {
                        SpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                    }

                    if (EligibleSpawnsByModId.ContainsKey(modID) == false)
                    {
                        EligibleSpawnsByModId.Add(modID, 1);
                    }
                    else
                    {
                        EligibleSpawnsByModId[modID] += 1;
                    }

                    if (Settings.PlanetaryCargoShips.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.PlanetaryCargoShips.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.PlanetaryCargoShips.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                        SpawnGroupSublists[modID].Add(spawnGroup);
                    }
                }
            }

            return(eligibleGroups);
        }
        public static List <ImprovedSpawnGroup> GetPlanetaryInstallations(Vector3D playerCoords, out List <ImprovedSpawnGroup> smallStations, out List <ImprovedSpawnGroup> mediumStations, out List <ImprovedSpawnGroup> largeStations, out Dictionary <string, List <string> > validFactions)
        {
            smallStations  = new List <ImprovedSpawnGroup>();
            mediumStations = new List <ImprovedSpawnGroup>();
            largeStations  = new List <ImprovedSpawnGroup>();
            validFactions  = new Dictionary <string, List <string> >();

            MyPlanet planet             = SpawnResources.GetNearestPlanet(playerCoords);
            string   specificGroup      = "";
            var      planetRestrictions = new List <string>(Settings.General.PlanetSpawnsDisableList.ToList());

            SpawnGroupSublists.Clear();
            SmallSpawnGroupSublists.Clear();
            MediumSpawnGroupSublists.Clear();
            LargeSpawnGroupSublists.Clear();
            EligibleSpawnsByModId.Clear();
            EligibleSmallSpawnsByModId.Clear();
            EligibleMediumSpawnsByModId.Clear();
            EligibleLargeSpawnsByModId.Clear();

            if (planet != null)
            {
                if (planetRestrictions.Contains(planet.Generator.Id.SubtypeName) == true)
                {
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            bool specificSpawnRequest = false;

            if (SpawnGroupManager.AdminSpawnGroup != "")
            {
                specificGroup = SpawnGroupManager.AdminSpawnGroup;
                SpawnGroupManager.AdminSpawnGroup = "";
                specificSpawnRequest = true;
            }

            if (SpawnResources.IsPositionInGravity(playerCoords, planet) == false)
            {
                return(new List <ImprovedSpawnGroup>());
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();


            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (specificGroup != "" && spawnGroup.SpawnGroup.Id.SubtypeName != specificGroup)
                {
                    continue;
                }

                if (specificGroup == "" && spawnGroup.AdminSpawnOnly == true)
                {
                    continue;
                }

                if (spawnGroup.PlanetaryInstallation == false)
                {
                    continue;
                }

                if (spawnGroup.PlanetaryInstallationType != "Small" && spawnGroup.PlanetaryInstallationType != "Medium" && spawnGroup.PlanetaryInstallationType != "Large")
                {
                    continue;
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, playerCoords, planet, specificSpawnRequest) == false)
                {
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, playerCoords);

                if (validFactionsList.Count == 0)
                {
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    string modID = spawnGroup.SpawnGroup.Context.ModId;

                    if (string.IsNullOrEmpty(modID) == true)
                    {
                        modID = "KeenSWH";
                    }

                    if (SpawnGroupSublists.ContainsKey(modID) == false)
                    {
                        SpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                    }

                    if (spawnGroup.PlanetaryInstallationType == "Small")
                    {
                        if (SmallSpawnGroupSublists.ContainsKey(modID) == false)
                        {
                            SmallSpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                        }

                        if (EligibleSmallSpawnsByModId.ContainsKey(modID) == false)
                        {
                            EligibleSmallSpawnsByModId.Add(modID, 1);
                        }
                        else
                        {
                            EligibleSmallSpawnsByModId[modID] += 1;
                        }
                    }

                    if (spawnGroup.PlanetaryInstallationType == "Medium")
                    {
                        if (MediumSpawnGroupSublists.ContainsKey(modID) == false)
                        {
                            MediumSpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                        }

                        if (EligibleMediumSpawnsByModId.ContainsKey(modID) == false)
                        {
                            EligibleMediumSpawnsByModId.Add(modID, 1);
                        }
                        else
                        {
                            EligibleMediumSpawnsByModId[modID] += 1;
                        }
                    }

                    if (spawnGroup.PlanetaryInstallationType == "Large")
                    {
                        if (LargeSpawnGroupSublists.ContainsKey(modID) == false)
                        {
                            LargeSpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                        }

                        if (EligibleLargeSpawnsByModId.ContainsKey(modID) == false)
                        {
                            EligibleLargeSpawnsByModId.Add(modID, 1);
                        }
                        else
                        {
                            EligibleLargeSpawnsByModId[modID] += 1;
                        }
                    }

                    if (Settings.PlanetaryInstallations.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.PlanetaryInstallations.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.PlanetaryInstallations.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                        SpawnGroupSublists[modID].Add(spawnGroup);

                        if (spawnGroup.PlanetaryInstallationType == "Small")
                        {
                            smallStations.Add(spawnGroup);
                            SmallSpawnGroupSublists[modID].Add(spawnGroup);
                        }

                        if (spawnGroup.PlanetaryInstallationType == "Medium")
                        {
                            mediumStations.Add(spawnGroup);
                            MediumSpawnGroupSublists[modID].Add(spawnGroup);
                        }

                        if (spawnGroup.PlanetaryInstallationType == "Large")
                        {
                            largeStations.Add(spawnGroup);
                            LargeSpawnGroupSublists[modID].Add(spawnGroup);
                        }
                    }
                }
            }

            return(eligibleGroups);
        }
Example #3
0
        public static List <ImprovedSpawnGroup> GetSpawnGroups(List <string> spawnGroups, Vector3D coords, string factionOverride, out Dictionary <string, List <string> > validFactions)
        {
            var planetRestrictions = new List <string>(Settings.General.PlanetSpawnsDisableList.ToList());

            validFactions = new Dictionary <string, List <string> >();
            var environment = new EnvironmentEvaluation(coords);

            if (environment.NearestPlanet != null)
            {
                if (planetRestrictions.Contains(environment.NearestPlanetName) && environment.IsOnPlanet)
                {
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();

            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (!spawnGroups.Contains(spawnGroup.SpawnGroupName))
                {
                    continue;
                }

                if (spawnGroup.RivalAiAnySpawn == false && spawnGroup.RivalAiSpawn == false)
                {
                    if (environment.GravityAtPosition > 0 && spawnGroup.RivalAiSpaceSpawn)
                    {
                        continue;
                    }

                    if (environment.NearestPlanet != null)
                    {
                        if (spawnGroup.RivalAiAtmosphericSpawn == false || environment.NearestPlanet.HasAtmosphere == false || environment.AtmosphereAtPosition < 0.4f)
                        {
                            continue;
                        }
                    }
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, coords, environment, false) == false)
                {
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, coords, factionOverride);

                if (validFactionsList.Count == 0)
                {
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    if (Settings.SpaceCargoShips.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                    }
                }
            }

            return(eligibleGroups);
        }
Example #4
0
        public static List <ImprovedSpawnGroup> GetRandomEncounters(Vector3D playerCoords, out Dictionary <string, List <string> > validFactions)
        {
            MyPlanet planet        = SpawnResources.GetNearestPlanet(playerCoords);
            string   specificGroup = "";

            validFactions = new Dictionary <string, List <string> >();
            SpawnGroupSublists.Clear();
            EligibleSpawnsByModId.Clear();

            bool specificSpawnRequest = false;

            if (SpawnGroupManager.AdminSpawnGroup != "")
            {
                specificGroup = SpawnGroupManager.AdminSpawnGroup;
                SpawnGroupManager.AdminSpawnGroup = "";
                specificSpawnRequest = true;
            }

            if (SpawnResources.IsPositionInGravity(playerCoords, planet) == true)
            {
                return(new List <ImprovedSpawnGroup>());
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();

            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (specificGroup != "" && spawnGroup.SpawnGroup.Id.SubtypeName != specificGroup)
                {
                    continue;
                }

                if (specificGroup == "" && spawnGroup.AdminSpawnOnly == true)
                {
                    continue;
                }

                if (spawnGroup.SpaceRandomEncounter == false)
                {
                    continue;
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, playerCoords, planet, specificSpawnRequest) == false)
                {
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, playerCoords);

                if (validFactionsList.Count == 0)
                {
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    string modID = spawnGroup.SpawnGroup.Context.ModId;

                    if (string.IsNullOrEmpty(modID) == true)
                    {
                        modID = "KeenSWH";
                    }

                    if (SpawnGroupSublists.ContainsKey(modID) == false)
                    {
                        SpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                    }

                    if (EligibleSpawnsByModId.ContainsKey(modID) == false)
                    {
                        EligibleSpawnsByModId.Add(modID, 1);
                    }
                    else
                    {
                        EligibleSpawnsByModId[modID] += 1;
                    }

                    if (Settings.RandomEncounters.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.RandomEncounters.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.RandomEncounters.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                        SpawnGroupSublists[modID].Add(spawnGroup);
                    }
                }
            }

            return(eligibleGroups);
        }
        public static List <ImprovedSpawnGroup> GetSpawnGroups(List <string> spawnGroups, Vector3D coords, out Dictionary <string, List <string> > validFactions)
        {
            MyPlanet planet             = SpawnResources.GetNearestPlanet(coords);
            var      planetRestrictions = new List <string>(Settings.General.PlanetSpawnsDisableList.ToList());

            validFactions = new Dictionary <string, List <string> >();

            if (planet != null)
            {
                if (planetRestrictions.Contains(planet.Generator.Id.SubtypeName) == true)
                {
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            string planetName = "";

            if (planet != null)
            {
                planetName = planet.Generator.Id.SubtypeId.ToString();
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();

            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (!spawnGroups.Contains(spawnGroup.SpawnGroupName))
                {
                    continue;
                }

                if (spawnGroup.RivalAiAnySpawn == false)
                {
                    if (planet == null && spawnGroup.RivalAiSpaceSpawn == false)
                    {
                        continue;
                    }

                    if (planet != null)
                    {
                        var airDensity = planet.GetAirDensity(coords);

                        if (spawnGroup.RivalAiAtmosphericSpawn == false || planet.HasAtmosphere == false || airDensity < 0.4f)
                        {
                            continue;
                        }
                    }
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, coords, planet, false) == false)
                {
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, coords);

                if (validFactionsList.Count == 0)
                {
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    if (Settings.SpaceCargoShips.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                    }
                }
            }

            return(eligibleGroups);
        }
Example #6
0
        public static List <ImprovedSpawnGroup> GetSpaceCargoShips(Vector3D playerCoords, List <string> eligibleNames, out Dictionary <string, List <string> > validFactions)
        {
            bool   allowLunar         = false;
            string specificGroup      = "";
            var    planetRestrictions = new List <string>(Settings.General.PlanetSpawnsDisableList.ToList());

            validFactions = new Dictionary <string, List <string> >();
            SpawnGroupSublists.Clear();
            EligibleSpawnsByModId.Clear();
            var environment = new EnvironmentEvaluation(playerCoords);

            if (environment.NearestPlanet != null)
            {
                if (planetRestrictions.Contains(environment.NearestPlanetName) && environment.IsOnPlanet)
                {
                    Logger.SpawnGroupDebug(Logger.DebugSpawnGroup, "Restricted Planet, No Spawns Allowed");
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            bool specificSpawnRequest = false;

            if (SpawnGroupManager.AdminSpawnGroup != "")
            {
                specificGroup = SpawnGroupManager.AdminSpawnGroup;
                SpawnGroupManager.AdminSpawnGroup = "";
                specificSpawnRequest = true;
            }

            if (environment.IsOnPlanet)
            {
                if (SpawnResources.LunarSpawnEligible(playerCoords) == true)
                {
                    allowLunar = true;
                }
                else
                {
                    Logger.SpawnGroupDebug("[No Spawn Group]", "On Planet and Cannot Spawn As Lunar, No Spawns Allowed");
                    return(new List <ImprovedSpawnGroup>());
                }
            }

            var eligibleGroups = new List <ImprovedSpawnGroup>();

            //Filter Eligible Groups To List
            foreach (var spawnGroup in SpawnGroupManager.SpawnGroups)
            {
                if (eligibleNames != null)
                {
                    if (!eligibleNames.Contains(spawnGroup.SpawnGroupName))
                    {
                        Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Was not included in Groups From API Request");
                        continue;
                    }
                }
                else
                {
                    if (specificGroup != "" && spawnGroup.SpawnGroup.Id.SubtypeName != specificGroup)
                    {
                        Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Doesn't Match Admin Spawn");
                        continue;
                    }

                    if (specificGroup == "" && spawnGroup.AdminSpawnOnly == true)
                    {
                        Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Only Admin Spawn Allowed");
                        continue;
                    }
                }

                if (spawnGroup.SpaceCargoShip == false)
                {
                    if (allowLunar == true)
                    {
                        if (spawnGroup.LunarCargoShip == false)
                        {
                            Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Is Not Space Cargo Ship Or Lunar");
                            continue;
                        }
                    }
                    else
                    {
                        Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Is Not Space Cargo Ship");
                        continue;
                    }
                }

                if (SpawnResources.CheckCommonConditions(spawnGroup, playerCoords, environment, specificSpawnRequest) == false)
                {
                    Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "Common Conditions Failed");
                    continue;
                }

                var validFactionsList = SpawnResources.ValidNpcFactions(spawnGroup, playerCoords);

                if (validFactionsList.Count == 0)
                {
                    Logger.SpawnGroupDebug(spawnGroup.SpawnGroup.Id.SubtypeName, "No Valid Faction");
                    continue;
                }

                if (validFactions.ContainsKey(spawnGroup.SpawnGroupName) == false)
                {
                    validFactions.Add(spawnGroup.SpawnGroupName, validFactionsList);
                }

                if (spawnGroup.Frequency > 0)
                {
                    string modID = spawnGroup.SpawnGroup.Context.ModId;

                    if (string.IsNullOrEmpty(modID) == true)
                    {
                        modID = "KeenSWH";
                    }

                    if (SpawnGroupSublists.ContainsKey(modID) == false)
                    {
                        SpawnGroupSublists.Add(modID, new List <ImprovedSpawnGroup>());
                    }

                    if (EligibleSpawnsByModId.ContainsKey(modID) == false)
                    {
                        EligibleSpawnsByModId.Add(modID, 1);
                    }
                    else
                    {
                        EligibleSpawnsByModId[modID] += 1;
                    }

                    if (Settings.SpaceCargoShips.UseMaxSpawnGroupFrequency == true && spawnGroup.Frequency > Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10)
                    {
                        spawnGroup.Frequency = (int)Math.Round((double)Settings.SpaceCargoShips.MaxSpawnGroupFrequency * 10);
                    }

                    for (int i = 0; i < spawnGroup.Frequency; i++)
                    {
                        eligibleGroups.Add(spawnGroup);
                        SpawnGroupSublists[modID].Add(spawnGroup);
                    }
                }
            }

            return(eligibleGroups);
        }