public static bool CalculateAtmoTravelPath(ImprovedSpawnGroup spawnGroup, Vector3D startCoords, MyPlanet planet, out Vector3D startPathCoords, out Vector3D endPathCoords, out MatrixD startMatrix)
{
startPathCoords = Vector3D.Zero;
endPathCoords = Vector3D.Zero;
startMatrix = MatrixD.CreateWorld(Vector3D.Zero, Vector3D.Forward, Vector3D.Up);
SpawnResources.RefreshEntityLists();
if (planet == null)
{
return(false);
}
var planetEntity = planet as IMyEntity;
for (int i = 0; i < Settings.PlanetaryCargoShips.MaxSpawnAttempts; i++)
{
//Get Starting Point
var randDirFromPlayer = SpawnResources.GetRandomCompassDirection(startCoords, planet);
var pathDist = SpawnResources.GetRandomPathDist(Settings.PlanetaryCargoShips.MinPathDistanceFromPlayer, Settings.PlanetaryCargoShips.MaxPathDistanceFromPlayer);
var midPointSurface = SpawnResources.GetNearestSurfacePoint(randDirFromPlayer * pathDist + startCoords, planet);
var upDir = Vector3D.Normalize(midPointSurface - planetEntity.GetPosition());
var altitudeFromMid = SpawnResources.GetRandomPathDist(Settings.PlanetaryCargoShips.MinSpawningAltitude, Settings.PlanetaryCargoShips.MaxSpawningAltitude);
var tempStartPath = upDir * altitudeFromMid + midPointSurface;
if (spawnGroup.PlanetRequiresAtmo == true && planet.GetAirDensity(tempStartPath) < Settings.PlanetaryCargoShips.MinAirDensity)
{
tempStartPath = upDir * Settings.PlanetaryCargoShips.MinSpawningAltitude + midPointSurface;
if (spawnGroup.PlanetRequiresAtmo == true && planet.GetAirDensity(tempStartPath) < Settings.PlanetaryCargoShips.MinAirDensity)
{
continue;
}
}
if (SpawnResources.IsPositionNearEntities(tempStartPath, Settings.PlanetaryCargoShips.MinSpawnFromGrids) == true)
{
continue;
}
var startCoordsDistFromCenter = Vector3D.Distance(planetEntity.GetPosition(), tempStartPath);
//Get Ending Point
var randPathDir = SpawnResources.GetRandomCompassDirection(tempStartPath, planet);
var randPathDist = SpawnResources.GetRandomPathDist(Settings.PlanetaryCargoShips.MinPathDistance, Settings.PlanetaryCargoShips.MaxPathDistance);
var endPathA = randPathDir * randPathDist + tempStartPath;
var endPathB = -randPathDir * randPathDist + tempStartPath;
var tempEndPath = Vector3D.Zero;
if (Vector3D.Distance(endPathA, startCoords) < Vector3D.Distance(endPathB, startCoords))
{
tempEndPath = endPathA;
}
else
{
tempEndPath = endPathB;
randPathDir *= -1;
}
//TODO: Set At Same Height From Sealevel As Start
var endUpDir = Vector3D.Normalize(tempEndPath - planetEntity.GetPosition());
tempEndPath = endUpDir * startCoordsDistFromCenter + planetEntity.GetPosition();
//Check Path
var tempMatrix = MatrixD.CreateWorld(tempStartPath, randPathDir, upDir);
var truePathDir = Vector3D.Normalize(tempEndPath - tempStartPath);
bool badPath = false;
foreach (var prefab in spawnGroup.SpawnGroup.Prefabs)
{
var modifiedStart = Vector3D.Transform((Vector3D)prefab.Position, tempMatrix);
double totalSteps = 0;
while (totalSteps < randPathDist)
{
var testPath = totalSteps * truePathDir + modifiedStart;
if (SpawnResources.IsPositionInSafeZone(testPath) == true)
{
badPath = true;
break;
}
if (SpawnResources.GetDistanceFromSurface(testPath, planet) < Settings.PlanetaryCargoShips.MinPathAltitude)
{
badPath = true;
break;
}
totalSteps += Settings.PlanetaryCargoShips.PathStepCheckDistance;
}
if (badPath == true)
{
break;
}
}
if (badPath == true)
{
continue;
}
startPathCoords = tempStartPath;
endPathCoords = tempEndPath;
startMatrix = tempMatrix;
return(true);
}
return(false);
}
public static bool GetInitialSpawnCoords(Vector3D startCoords, out Vector3D spawnCoords)
{
spawnCoords = Vector3D.Zero;
MyPlanet planet = SpawnResources.GetNearestPlanet(startCoords);
var inGravity = SpawnResources.IsPositionInGravity(startCoords, planet);
for (int i = 0; i < Settings.BossEncounters.PathCalculationAttempts; i++)
{
var testCoords = Vector3D.Zero;
if (inGravity == false)
{
var randDir = Vector3D.Normalize(MyUtils.GetRandomVector3D());
var randDist = (double)SpawnResources.rnd.Next((int)Settings.BossEncounters.MinCoordsDistanceSpace, (int)Settings.BossEncounters.MaxCoordsDistanceSpace);
spawnCoords = randDir * randDist + startCoords;
if (SpawnResources.IsPositionInGravity(spawnCoords, planet) == true)
{
randDir *= -1;
spawnCoords = randDir * randDist + startCoords;
if (SpawnResources.IsPositionInGravity(spawnCoords, planet) == true)
{
continue;
}
}
}
else
{
var planetEntity = planet as IMyEntity;
var upDir = Vector3D.Normalize(startCoords - planetEntity.GetPosition());
var randDir = SpawnResources.GetRandomCompassDirection(startCoords, planet);
var randDist = (double)SpawnResources.rnd.Next((int)Settings.BossEncounters.MinCoordsDistancePlanet, (int)Settings.BossEncounters.MaxCoordsDistancePlanet);
var roughCoords = randDir * randDist + startCoords;
var surfaceCoords = SpawnResources.GetNearestSurfacePoint(roughCoords, planet);
spawnCoords = upDir * Settings.BossEncounters.MinPlanetAltitude + surfaceCoords;
if (planet.GetAirDensity(spawnCoords) < Settings.BossEncounters.MinAirDensity)
{
spawnCoords = Vector3D.Zero;
continue;
}
}
if (spawnCoords == Vector3D.Zero)
{
continue;
}
bool badCoords = false;
foreach (var entity in SpawnResources.EntityList)
{
if (Vector3D.Distance(spawnCoords, entity.GetPosition()) < Settings.BossEncounters.MinSignalDistFromOtherEntities)
{
badCoords = true;
break;
}
}
if (badCoords == false)
{
if (SpawnResources.IsPositionInSafeZone(spawnCoords) == true)
{
badCoords = true;
}
}
if (badCoords == false)
{
return(true);
}
}
spawnCoords = Vector3D.Zero;
return(false);
}
public static bool CalculateLunarTravelPath(MySpawnGroupDefinition spawnGroup, Vector3D startCoords, out Vector3D startPathCoords, out Vector3D endPathCoords)
{
startPathCoords = Vector3D.Zero;
endPathCoords = Vector3D.Zero;
SpawnResources.RefreshEntityLists();
MyPlanet planet = SpawnResources.GetNearestPlanet(startCoords);
if (planet == null)
{
return(false);
}
var planetEntity = planet as IMyEntity;
for (int i = 0; i < Settings.SpaceCargoShips.MaxSpawnAttempts; i++)
{
var spawnAltitude = (double)SpawnResources.rnd.Next((int)Settings.SpaceCargoShips.MinLunarSpawnHeight, (int)Settings.SpaceCargoShips.MaxLunarSpawnHeight);
var abovePlayer = SpawnResources.CreateDirectionAndTarget(planetEntity.GetPosition(), startCoords, startCoords, spawnAltitude);
var midpointDist = (double)SpawnResources.rnd.Next((int)Settings.SpaceCargoShips.MinPathDistanceFromPlayer, (int)Settings.SpaceCargoShips.MaxPathDistanceFromPlayer);
var pathMidpoint = SpawnResources.GetRandomCompassDirection(abovePlayer, planet) * midpointDist + abovePlayer;
var pathDist = (double)SpawnResources.rnd.Next((int)Settings.SpaceCargoShips.MinPathDistance, (int)Settings.SpaceCargoShips.MaxPathDistance);
var pathDir = SpawnResources.GetRandomCompassDirection(abovePlayer, planet);
var pathHalfDist = pathDist / 2;
var tempPathStart = pathDir * pathHalfDist + pathMidpoint;
pathDir = pathDir * -1;
var tempPathEnd = pathDir * pathHalfDist + pathMidpoint;
bool badPath = false;
IHitInfo hitInfo = null;
if (MyAPIGateway.Physics.CastLongRay(tempPathStart, tempPathEnd, out hitInfo, true) == true)
{
continue;
}
foreach (var entity in SpawnResources.EntityList)
{
if (Vector3D.Distance(tempPathStart, entity.GetPosition()) < Settings.SpaceCargoShips.MinSpawnDistFromEntities)
{
badPath = true;
break;
}
}
if (badPath == true)
{
continue;
}
var upDir = Vector3D.CalculatePerpendicularVector(pathDir);
var pathMatrix = MatrixD.CreateWorld(tempPathStart, pathDir, upDir);
foreach (var prefab in spawnGroup.Prefabs)
{
double stepDistance = 0;
var tempPrefabStart = Vector3D.Transform((Vector3D)prefab.Position, pathMatrix);
while (stepDistance < pathDist)
{
stepDistance += Settings.SpaceCargoShips.PathCheckStep;
var pathCheckCoords = pathDir * stepDistance + tempPrefabStart;
if (SpawnResources.IsPositionInSafeZone(pathCheckCoords) == true || SpawnResources.IsPositionInGravity(pathCheckCoords, planet) == true)
{
badPath = true;
break;
}
}
if (badPath == true)
{
break;
}
}
if (badPath == true)
{
continue;
}
startPathCoords = tempPathStart;
endPathCoords = tempPathEnd;
return(true);
}
return(false);
}
public static bool SpawnBossEncounter(BossEncounter encounter)
{
MyPlanet planet = SpawnResources.GetNearestPlanet(encounter.Position);
var inGravity = SpawnResources.IsPositionInGravity(encounter.Position, planet);
for (int i = 0; i < Settings.BossEncounters.PathCalculationAttempts; i++)
{
bool gotMatrix = false;
var tempMatrix = MatrixD.CreateWorld(Vector3D.Zero, Vector3D.Forward, Vector3D.Up);
if (inGravity == false)
{
var randDir = Vector3D.Normalize(MyUtils.GetRandomVector3D());
var randDist = (double)SpawnResources.rnd.Next((int)Settings.BossEncounters.MinSpawnDistFromCoords, (int)Settings.BossEncounters.MaxSpawnDistFromCoords);
var spawnCoords = randDir * randDist + encounter.Position;
if (SpawnResources.IsPositionInGravity(spawnCoords, planet) == true)
{
randDir *= -1;
spawnCoords = randDir * randDist + encounter.Position;
if (SpawnResources.IsPositionInGravity(spawnCoords, planet) == true)
{
continue;
}
}
var forwardDir = Vector3D.Normalize(encounter.Position - spawnCoords);
var upDir = Vector3D.CalculatePerpendicularVector(forwardDir);
tempMatrix = MatrixD.CreateWorld(spawnCoords, forwardDir, upDir);
gotMatrix = true;
}
else
{
var planetEntity = planet as IMyEntity;
var upDir = Vector3D.Normalize(encounter.Position - planetEntity.GetPosition());
var randDir = SpawnResources.GetRandomCompassDirection(encounter.Position, planet);
var randDist = (double)SpawnResources.rnd.Next((int)Settings.BossEncounters.MinSpawnDistFromCoords, (int)Settings.BossEncounters.MaxSpawnDistFromCoords);
var roughCoords = randDir * randDist + encounter.Position;
var surfaceCoords = SpawnResources.GetNearestSurfacePoint(roughCoords, planet);
var spawnCoords = upDir * Settings.BossEncounters.MinPlanetAltitude + surfaceCoords;
tempMatrix = MatrixD.CreateWorld(spawnCoords, randDir * -1, upDir);
gotMatrix = true;
}
if (gotMatrix == false)
{
continue;
}
bool badCoords = false;
foreach (var prefab in encounter.SpawnGroup.SpawnGroup.Prefabs)
{
var offsetCoords = Vector3D.Transform((Vector3D)prefab.Position, tempMatrix);
foreach (var entity in SpawnResources.EntityList)
{
if (Vector3D.Distance(offsetCoords, entity.GetPosition()) < Settings.BossEncounters.MinSignalDistFromOtherEntities)
{
badCoords = true;
break;
}
}
if (badCoords == false)
{
if (SpawnResources.IsPositionInSafeZone(offsetCoords) == true)
{
badCoords = true;
break;
}
}
if (SpawnResources.IsPositionInGravity(offsetCoords, planet) == true)
{
if (SpawnResources.GetDistanceFromSurface(offsetCoords, planet) < Settings.BossEncounters.MinPlanetAltitude / 4)
{
badCoords = true;
break;
}
}
}
if (badCoords == true)
{
continue;
}
//Spawn the things!
Logger.SkipNextMessage = false;
Logger.AddMsg("Boss Encounter SpawnGroup " + encounter.SpawnGroup.SpawnGroup.Id.SubtypeName + " Now Spawning.");
foreach (var prefab in encounter.SpawnGroup.SpawnGroup.Prefabs)
{
var options = SpawnGroupManager.CreateSpawningOptions(encounter.SpawnGroup, prefab);
var spawnPosition = Vector3D.Transform((Vector3D)prefab.Position, tempMatrix);
var speedL = prefab.Speed * (Vector3)tempMatrix.Forward;
var speedA = Vector3.Zero;
var gridList = new List <IMyCubeGrid>();
long gridOwner = 0;
//Speed Management
if (Settings.SpaceCargoShips.UseMinimumSpeed == true && prefab.Speed < Settings.SpaceCargoShips.MinimumSpeed)
{
speedL = Settings.SpaceCargoShips.MinimumSpeed * (Vector3)tempMatrix.Forward;
}
if (Settings.SpaceCargoShips.UseSpeedOverride == true)
{
speedL = Settings.SpaceCargoShips.SpeedOverride * (Vector3)tempMatrix.Forward;
}
if (NPCWatcher.NPCFactionTagToFounder.ContainsKey(encounter.SpawnGroup.FactionOwner) == true)
{
gridOwner = NPCWatcher.NPCFactionTagToFounder[encounter.SpawnGroup.FactionOwner];
}
else
{
Logger.AddMsg("Could Not Find Faction Founder For: " + encounter.SpawnGroup.FactionOwner);
}
//Grid Manipulation
GridBuilderManipulation.ProcessPrefabForManipulation(prefab.SubtypeId, encounter.SpawnGroup, "BossEncounter", prefab.Behaviour);
try{
MyAPIGateway.PrefabManager.SpawnPrefab(gridList, prefab.SubtypeId, spawnPosition, tempMatrix.Forward, tempMatrix.Up, speedL, speedA, prefab.BeaconText, options, gridOwner);
}catch (Exception exc) {
}
var pendingNPC = new ActiveNPC();
pendingNPC.SpawnGroup = encounter.SpawnGroup;
pendingNPC.SpawnGroupName = encounter.SpawnGroup.SpawnGroupName;
pendingNPC.InitialFaction = encounter.SpawnGroup.FactionOwner;
pendingNPC.faction = MyAPIGateway.Session.Factions.TryGetFactionByTag(pendingNPC.InitialFaction);
pendingNPC.Name = prefab.SubtypeId;
pendingNPC.GridName = MyDefinitionManager.Static.GetPrefabDefinition(prefab.SubtypeId).CubeGrids[0].DisplayName;
pendingNPC.StartCoords = spawnPosition;
pendingNPC.CurrentCoords = spawnPosition;
pendingNPC.EndCoords = spawnPosition;
pendingNPC.SpawnType = "BossEncounter";
pendingNPC.CleanupIgnore = encounter.SpawnGroup.IgnoreCleanupRules;
pendingNPC.ForceStaticGrid = encounter.SpawnGroup.ForceStaticGrid;
pendingNPC.KeenAiName = prefab.Behaviour;
pendingNPC.KeenAiTriggerDistance = prefab.BehaviourActivationDistance;
if (encounter.SpawnGroup.RandomizeWeapons == true)
{
pendingNPC.ReplenishedSystems = false;
pendingNPC.ReplacedWeapons = true;
}
else if ((MES_SessionCore.NPCWeaponUpgradesModDetected == true || Settings.General.EnableGlobalNPCWeaponRandomizer == true) && encounter.SpawnGroup.IgnoreWeaponRandomizerMod == false)
{
pendingNPC.ReplenishedSystems = false;
pendingNPC.ReplacedWeapons = true;
}
else if (encounter.SpawnGroup.ReplenishSystems == true)
{
pendingNPC.ReplenishedSystems = false;
}
if (inGravity == true)
{
pendingNPC.Planet = planet;
}
NPCWatcher.PendingNPCs.Add(pendingNPC);
}
return(true);
}
Logger.AddMsg("Could Not Find Safe Area To Spawn Boss Encounter");
return(false);
}
