public override void UpdateAfterSimulation()
{
if (Tick % 5 == 0)
{
if (Camera == null)
{
return;
}
rainImpactEntities.Clear();
MyGamePruningStructure.GetTopMostEntitiesInBox(ref frustumBBox, rainImpactEntities);
//MyAPIGateway.Parallel.Start(CalculateLines);
CalculateLines();
}
if (Tick % 60 == 0 && closestPlanet != null)
{
cameraDistanceFromSurface = closestPlanet.GetClosestSurfacePointGlobal(Camera.Position);
cameraAltitude = (Camera.Position - cameraDistanceFromSurface).Length();
}
if (Tick % 301 == 0)
{
closestPlanet = MyGamePruningStructure.GetClosestPlanet(Camera.Position);
if (closestPlanet != null)
{
planetCentre = closestPlanet.PositionComp.WorldAABB.Center;
}
}
lines.Clear();
}
public static MatrixD GetPlanetRandomSpawnMatrix(Vector3D coords, double minDist, double maxDist, double minAltitude, double maxAltitude, bool inheritAltitude = false)
{
MatrixD result = MatrixD.Identity;
var planet = MyGamePruningStructure.GetClosestPlanet(coords);
var upDir = GetPlanetUpDirection(coords);
if (planet == null)
{
return(result);
}
double inheritedAltitude = 0;
if (inheritAltitude)
{
var npcSurface = GetPlanetSurfaceCoordsAtPosition(coords, planet);
inheritedAltitude = Vector3D.Distance(npcSurface, coords);
}
var perpDir = RandomPerpendicular(upDir);
var roughArea = perpDir * RandomDistance(minDist, maxDist) + coords;
var surfaceCoords = GetPlanetSurfaceCoordsAtPosition(roughArea, planet);
var upAtSurface = Vector3D.Normalize(surfaceCoords - planet.PositionComp.WorldAABB.Center);
var spawnCoords = upAtSurface * (RandomDistance(minAltitude, maxAltitude) + inheritedAltitude) + surfaceCoords;
var perpSurfaceDir = RandomPerpendicular(upAtSurface);
result = MatrixD.CreateWorld(spawnCoords, perpSurfaceDir, upAtSurface);
return(result);
}
public static bool IsInSpace(Vector3D pos)
{
var closestPlanet = MyGamePruningStructure.GetClosestPlanet(pos);
return(closestPlanet == null || !closestPlanet.HasAtmosphere ||
closestPlanet.GetAirDensity(pos) <= 0.5);
}
/// <summary>
/// Returns the planet closest to the given position
/// </summary>
/// <param name="position">3D Point from where the search is started</param>
/// <returns>The closest planet</returns>
private MyPlanet GetPlanet(Vector3D position)
{
int voxelDistance = 200;
BoundingBoxD box = new BoundingBoxD(position - voxelDistance * 0.5f, position + voxelDistance * 0.5f);
return(MyGamePruningStructure.GetClosestPlanet(ref box));
}
//alter position based on altitude
private void HoverMechanic(ref Vector3D pos)
{
m_hoverMin = 5;
m_hoverMax = 25;
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (gravity.LengthSquared() > 0f)
{
MyPlanet planet = MyGamePruningStructure.GetClosestPlanet(pos);
if (planet != null)
{
Vector3D closestPoint = planet.GetClosestSurfacePointGlobal(ref pos);
float altitude = (float)Vector3D.Distance(closestPoint, pos);
if (Vector3D.DistanceSquared(planet.PositionComp.GetPosition(), closestPoint) > Vector3D.DistanceSquared(planet.PositionComp.GetPosition(), pos))
{
altitude *= -1;
}
if (altitude < m_hoverMin)
{
pos = closestPoint - Vector3D.Normalize(gravity) * m_hoverMin;
}
else if (altitude > m_hoverMax)
{
pos = closestPoint - Vector3D.Normalize(gravity) * m_hoverMax;
}
}
}
}
public static void ScorePlanetFlatness(Vector3D startPos, double radius, out double score, out Vector3D groundPos)
{
var planet = MyGamePruningStructure.GetClosestPlanet(startPos);
groundPos = planet.GetClosestSurfacePointGlobal(ref startPos);
var center = planet.PositionComp.WorldVolume.Center;
var normal = groundPos - center;
normal.Normalize();
// Sample two points _radius_ away perp. to normal
var otherDir = Vector3D.CalculatePerpendicularVector(normal);
otherDir.Normalize();
var otherWorld = groundPos + otherDir * radius;
var other1Surf = planet.GetClosestSurfacePointGlobal(ref otherWorld);
Vector3D.Cross(ref normal, ref otherDir, out otherDir);
otherDir.Normalize();
otherWorld = groundPos + otherDir * radius;
var other2Surf = planet.GetClosestSurfacePointGlobal(ref otherWorld);
var surfNorm = Vector3D.Cross(other2Surf - groundPos, other1Surf - groundPos);
surfNorm.Normalize();
score = Math.Abs(Vector3D.Dot(surfNorm, normal));
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
m_waitForUpdate--;
if (m_waitForUpdate > 0)
{
return;
}
m_waitForUpdate = UPDATE_DELAY;
Vector3D position = MySector.MainCamera.Position;
MyPlanet planet = MyGamePruningStructure.GetClosestPlanet(position);
if (planet != null)
{
var distanceFromPlanet = Vector3D.Distance(planet.PositionComp.GetPosition(), position);
if (distanceFromPlanet > planet.MaximumRadius + Math.Max(100, planet.MaximumRadius))
{
;
}
planet = null; //too far planet
}
if (m_closestPlanet != planet)
{
m_closestPlanet = planet;
if (m_closestPlanet != null)
{
MyStringId category = MyStringId.GetOrCompute(m_closestPlanet.Generator.Id.SubtypeId.ToString());
MyStringId transition = MyStringId.GetOrCompute(m_closestPlanet.Generator.Id.SubtypeId.ToString());
if (!MyAudio.Static.IsValidTransitionCategory(transition, category))
{
category = MyStringId.GetOrCompute("OtherPlanet");
transition = MyStringId.GetOrCompute("OtherPlanet");
}
MyMusicTrack mt = new MyMusicTrack()
{
MusicCategory = category,
TransitionCategory = transition
};
MyAudio.Static.PlayMusic(mt);
}
else
{
//random
MyMusicTrack mt = new MyMusicTrack()
{
};
MyAudio.Static.PlayMusic(mt, 1);
}
}
}
public static Vector3D GetRandomDespawnCoords(Vector3D coords, double distance = 8000, double altitude = 1500)
{
Vector3D result = Vector3D.Zero;
var planet = MyGamePruningStructure.GetClosestPlanet(coords);
var planetEntity = planet as IMyEntity;
var gravityProvider = planetEntity?.Components?.Get <MyGravityProviderComponent>();
if (gravityProvider != null && gravityProvider.IsPositionInRange(coords))
{
var up = Vector3D.Normalize(coords - planetEntity.GetPosition());
Vector3D randDirection = MyUtils.GetRandomPerpendicularVector(up);
var surfaceCoords = planet.GetClosestSurfacePointGlobal(randDirection * distance + coords);
result = Vector3D.Normalize(surfaceCoords - planetEntity.GetPosition()) * altitude + surfaceCoords;
}
else if (planet != null)
{
var up = Vector3D.Normalize(coords - planetEntity.GetPosition());
Vector3D randDirection = MyUtils.GetRandomPerpendicularVector(up);
result = randDirection * distance + coords;
}
else
{
Vector3D randDirection = Vector3D.Normalize(MyUtils.GetRandomVector3D());
return(randDirection * distance + coords);
}
return(result);
}
private MyPlanet GetPlanet(Vector3D position)
{
int num = 100;
BoundingBoxD box = new BoundingBoxD(position - (num * 0.5f), position + (num * 0.5f));
return(MyGamePruningStructure.GetClosestPlanet(ref box));
}
public void UpdateAtmosphereStatus()
{
if (m_character != null && (m_localPlayer == false || (MySession.Static != null && m_character == MySession.Static.LocalCharacter)))
{
AtmosphereStatus original = m_atmosphereStatus;
Vector3D pos = m_character.PositionComp.GetPosition();
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (gravity.LengthSquared() > 0f)
{
MyPlanet planet = MyGamePruningStructure.GetClosestPlanet(pos);
if (planet != null && planet.HasAtmosphere && planet.GetAirDensity(pos) > 0.5f)
{
m_atmosphereStatus = AtmosphereStatus.Atmosphere;//in atmosphere
}
else
{
m_atmosphereStatus = AtmosphereStatus.Space;
}
}
else
{
m_atmosphereStatus = AtmosphereStatus.Space;
}
if (m_atmosphereStatus == AtmosphereStatus.Space)
{
float oxygen = 0f;
if (m_character.OxygenComponent != null)
{
if (m_localPlayer)
{
if (MySession.Static.ControlledEntity is MyCharacter)
{
//in suit
oxygen = m_character.OxygenComponent.EnvironmentOxygenLevel;
}
else
{
//in cockpit
oxygen = m_character.OxygenComponent.OxygenLevelAtCharacterLocation;
}
}
else
{
oxygen = m_character.OxygenComponent.EnvironmentOxygenLevel;
}
}
if (oxygen > 0.1f)
{
m_atmosphereStatus = AtmosphereStatus.ShipOrStation;//in pressurized environment
}
}
if (MyFakes.ENABLE_REALISTIC_LIMITER && MyFakes.ENABLE_NEW_SOUNDS && original != m_atmosphereStatus && MySession.Static != null && MySession.Static.Settings.RealisticSound)
{
MyAudio.Static.EnableMasterLimiter(!(InAtmosphere || InShipOrStation));
}
}
}
public SpawnInfo(MyObjectBuilder_SpaceFaunaComponent.SpawnInfo info, int currentTime)
{
SpawnTime = currentTime + info.SpawnTime;
AbandonTime = currentTime + info.SpawnTime;
Position = new Vector3D(info.X, info.Y, info.Z);
Planet = MyGamePruningStructure.GetClosestPlanet(Position);
SpawnDone = false;
}
/// <summary>
/// Returns the planet closest to the given position
/// </summary>
/// <param name="position">3D Point from where the search is centered</param>
/// <returns>The closest planet</returns>
private MyPlanet GetPlanet(Vector3D position)
{
//TODO: what value to put here??? Warning - Also defined in other places
int voxelDistance = 500;
BoundingBoxD box = new BoundingBoxD(position - voxelDistance * 0.5f, position + voxelDistance * 0.5f);
return(MyGamePruningStructure.GetClosestPlanet(ref box));
}
private void FinalizeTargetDb()
{
MyPlanetTmp = MyGamePruningStructure.GetClosestPlanet(ScanVolume.Center);
ObstructionsTmp.Clear();
StaticsInRangeTmp.Clear();
for (int i = 0; i < NearByEntitiesTmp; i++)
{
var ent = _possibleTargets[i];
if (Session.ShieldApiLoaded && ent.DefinitionId?.SubtypeId == Session.ShieldHash && ent.Render.Visible)
{
var shieldblock = Session.SApi.MatchEntToShieldFast(ent, false);
if (shieldblock != null)
{
NearByShieldsTmp.Add(new Shields {
Id = ent.Hierarchy.ChildId, ShieldEnt = ent, ShieldBlock = (MyCubeBlock)shieldblock
});
}
}
var voxel = ent as MyVoxelBase;
var grid = ent as MyCubeGrid;
var safeZone = ent as MySafeZone;
var blockingThings = safeZone != null || ent.Physics != null && grid != null || voxel != null && voxel == voxel.RootVoxel;
if (!blockingThings || voxel != null && (voxel.RootVoxel is MyPlanet || voxel.PositionComp.LocalVolume.Radius < 15))
{
continue;
}
if (voxel != null || safeZone != null || ent.Physics.IsStatic)
{
StaticsInRangeTmp.Add(ent);
}
GridMap map;
if (grid != null && (PrevSubGrids.Contains(grid) || ValidGrids.Contains(ent) || grid.PositionComp.LocalVolume.Radius < 10 || Session.GridToInfoMap.TryGetValue(grid, out map) && map.Trash || grid.BigOwners.Count == 0))
{
continue;
}
ObstructionsTmp.Add(ent);
}
foreach (var pair in NoTargetLos)
{
if (Session.Tick - pair.Value > 120)
{
uint lastLosTick;
NoTargetLos.TryRemove(pair.Key, out lastLosTick);
}
}
ValidGrids.Clear();
_possibleTargets.Clear();
}
public static Vector3D GetPlanetSurfaceCoordsAtPosition(Vector3D coords)
{
var planet = MyGamePruningStructure.GetClosestPlanet(coords);
if (planet == null)
{
return(Vector3D.Zero);
}
return(GetPlanetSurfaceCoordsAtPosition(coords, planet));
}
private static MyPlanet FindNearestPlanet(Vector3D worldPosition)
{
BoundingBoxD bb = new BoundingBoxD(worldPosition, worldPosition);
MyPlanet foundPlanet = MyGamePruningStructure.GetClosestPlanet(ref bb);
if (foundPlanet != null && foundPlanet.AtmosphereAltitude > Vector3D.Distance(worldPosition, foundPlanet.PositionComp.GetPosition()))
{
foundPlanet = null;
}
return(foundPlanet);
}
/// <summary>
/// Computes the temperature at a given point in space.
/// </summary>
/// <param name="pos">Position</param>
/// <returns>Background temperature (K)</returns>
public static float TemperatureAtPoint(Vector3D pos)
{
var planet = MyGamePruningStructure.GetClosestPlanet(pos);
if (planet != null)
{
var density = planet.GetAirDensity(pos);
return(MathHelper.Lerp(TemperatureSpace, TemperatureSurface, MathHelper.Clamp(density * density, 0, 1)));
}
return(TemperatureSpace);
}
public SpawnTimeoutInfo(MyObjectBuilder_SpaceFaunaComponent.TimeoutInfo info, int currentTime)
{
TimeoutTime = currentTime + info.Timeout;
Position = new Vector3D(info.X, info.Y, info.Z);
var planet = MyGamePruningStructure.GetClosestPlanet(Position);
AnimalSpawnInfo = MySpaceBotFactory.GetDayOrNightAnimalSpawnInfo(planet, Position);
if (AnimalSpawnInfo == null)
{
TimeoutTime = currentTime;
}
}
/// <summary>
/// Returns a position that should be safe to spawn at given the radius and position.
/// </summary>
/// <param name="collisionRadius">The radius of the object that is trying to spawn.</param>
/// <param name="position">The position the object would like to spawn at.</param>
/// <param name="forward">(Out) The forward vector the object should spawn with.</param>
/// <param name="up">(Out) The up vector the object should spawn with.</param>
/// <param name="planetSpawnHeightRatio">The ratio within the planet's max radius and atmosphere radius you are positioned in.</param>
/// <param name="randomRangeMin">The minimum randomized distance that is added.</param>
/// <param name="randomRangeMax">The minimum randomized distance that is added.</param>
public static void GetSpawnPosition(float collisionRadius, ref Vector3D position, out Vector3D forward, out Vector3D up, float planetSpawnHeightRatio = 0.3f, float randomRangeMin = 500, float randomRangeMax = 650)
{
// Are we spawning near a planet?
MyPlanet planet = MyGamePruningStructure.GetClosestPlanet(position);
if (planet != null)
{
GetSpawnPositionNearPlanet(planet, collisionRadius, ref position, out forward, out up, planetSpawnHeightRatio, randomRangeMin, randomRangeMax);
return;
}
// Old logic, testing for asteroids and other objects
double distance = 0;
foreach (var entity in MyEntities.GetEntities())
{
MyVoxelMap voxelMap = entity as MyVoxelMap;
// Only test against voxels
if (entity == null)
{
continue;
}
distance = MathHelper.Max(distance, entity.PositionComp.WorldVolume.Center.Length() + entity.PositionComp.WorldVolume.Radius);
}
// Random range from last voxel
distance += MyUtils.GetRandomFloat(randomRangeMin, randomRangeMax);
if (MyEntities.IsWorldLimited())
{
distance = Math.Min(distance, MyEntities.WorldSafeHalfExtent());
}
else
{
distance = Math.Min(distance, 20000); // limited spawn area in infinite worlds
}
// Compute random position
forward = MyUtils.GetRandomVector3Normalized();
up = Vector3D.CalculatePerpendicularVector(forward);
Vector3D randomizedPosition = position + (forward * distance);
// Test if we can spawn here
Vector3D?searchPosition = MyEntities.FindFreePlace(randomizedPosition, collisionRadius);
if (searchPosition.HasValue)
{
randomizedPosition = searchPosition.Value;
}
position = randomizedPosition;
}
public static bool IsNight(Vector3D coords)
{
//Get Planet
MyPlanet myPlanet = MyGamePruningStructure.GetClosestPlanet(coords);
if (myPlanet == null)
{
return(false);
}
//Sun Rotation Axis
var BaseSunDirectionNormalized = new Vector3(0.339467347f, 0.709795356f, -0.617213368f);
var checkpoint = MyAPIGateway.Session.GetCheckpoint("null");
foreach (var component in checkpoint.SessionComponents)
{
var weather = component as MyObjectBuilder_SectorWeatherComponent;
if (weather != null)
{
BaseSunDirectionNormalized.X = weather.BaseSunDirection.X;
BaseSunDirectionNormalized.Y = weather.BaseSunDirection.Y;
BaseSunDirectionNormalized.Z = weather.BaseSunDirection.Z;
break;
}
}
Vector3 axis = (!(Math.Abs(Vector3.Dot(BaseSunDirectionNormalized, Vector3.Up)) > 0.95f)) ? Vector3.Cross(Vector3.Cross(BaseSunDirectionNormalized, Vector3.Up), BaseSunDirectionNormalized) : Vector3.Cross(Vector3.Cross(BaseSunDirectionNormalized, Vector3.Left), BaseSunDirectionNormalized);
axis.Normalize();
//Sun Direction
var speed = 60f * MyAPIGateway.Session.SessionSettings.SunRotationIntervalMinutes;
var gameTime = MyAPIGateway.Session.GameDateTime - new DateTime(2081, 1, 1, 0, 0, 0, DateTimeKind.Utc);
float angle = 6.283186f * (float)(gameTime.TotalSeconds / (double)speed);
Vector3 sunDirection = Vector3.Transform(BaseSunDirectionNormalized, Matrix.CreateFromAxisAngle(axis, angle));
sunDirection.Normalize();
Vector3D result = coords - myPlanet.PositionComp.GetPosition();
if ((float)result.Length() > myPlanet.MaximumRadius * 1.1f)
{
return(false);
}
Vector3 vector = Vector3.Normalize(result);
return(Vector3.Dot(sunDirection, vector) < -0.1f);
}
public SpawnTimeoutInfo(Vector3D position, int currentTime)
{
TimeoutTime = currentTime;
Position = position;
var planet = MyGamePruningStructure.GetClosestPlanet(Position);
Debug.Assert(planet != null);
AnimalSpawnInfo = MySpaceBotFactory.GetDayOrNightAnimalSpawnInfo(planet, Position);
if (AnimalSpawnInfo == null)
{
TimeoutTime = currentTime;
}
}
private float PlanetaryInfluence()
{
BoundingBoxD box = _thisEntity.PositionComp.WorldAABB;
MyPlanet closestPlanet = MyGamePruningStructure.GetClosestPlanet(ref box);
if (closestPlanet == null)
{
return(0);
}
MyGravityProviderComponent myGravityProviderComponent = closestPlanet.Components.Get <MyGravityProviderComponent>();
return(closestPlanet.GetAirDensity(box.Center) * myGravityProviderComponent.GetGravityMultiplier(box.Center));
}
private bool ElevationThreshold(Vector3D location)
{
var planet = MyGamePruningStructure.GetClosestPlanet(location);
if (planet == null)
{
return(false);
}
Vector3D surfaceLocation = planet.GetClosestSurfacePointGlobal(location);
return(Vector3D.Distance(surfaceLocation, location) <= MaxHeight);
}
public static double GetAltitudeAtPosition(Vector3D coords, MyPlanet planet = null)
{
if (planet == null)
{
planet = MyGamePruningStructure.GetClosestPlanet(coords);
if (planet == null)
{
return(0);
}
}
return(Vector3D.Distance(coords, GetPlanetSurfaceCoordsAtPosition(coords, planet)));
}
public static float CalculateRequiredLift(MyCubeBlock block)
{
BoundingBoxD box = block.PositionComp.WorldAABB;
MyPlanet closestPlanet = MyGamePruningStructure.GetClosestPlanet(ref box);
if (closestPlanet == null)
{
return(0);
}
MyGravityProviderComponent myGravityProviderComponent = closestPlanet.Components.Get <MyGravityProviderComponent>();
MatrixD worldMatrixRef = block.PositionComp.WorldMatrixRef;
return(block.CubeGrid.Mass * myGravityProviderComponent.GetGravityMultiplier(worldMatrixRef.Translation) * GravityConstant);
}
//GetDirectionAwayFromTarget
public static Vector3D GetDirectionAwayFromTarget(Vector3D myPosition, Vector3D targetPosition)
{
var planet = MyGamePruningStructure.GetClosestPlanet(myPosition);
if (planet == null)
{
return(Vector3D.Normalize(myPosition - targetPosition));
}
else
{
var mySealevel = GetPlanetSealevelAtPosition(myPosition, planet);
var targetSealevel = GetPlanetSealevelAtPosition(targetPosition, planet);
return(Vector3D.Normalize(mySealevel - targetSealevel));
}
}
public static float PlanetaryInfluence(IMyEntity block)
{
BoundingBoxD box = block.PositionComp.WorldAABB;
MyPlanet closestPlanet = MyGamePruningStructure.GetClosestPlanet(ref box);
if (closestPlanet == null)
{
return(0);
}
MyGravityProviderComponent myGravityProviderComponent = closestPlanet.Components.Get <MyGravityProviderComponent>();
return(closestPlanet.GetAirDensity(box.Center) * myGravityProviderComponent.GetGravityMultiplier(box.Center));
//MySimpleObjectDraw
//billboa
}
public void DrawLineFromPlayerToPlanetCentre()
{
var player = MyAPIGateway.Session.Player;
var playerPosition = player.Character.PositionComp.GetPosition();
var lineColor = Color.White.ToVector4();
var closestPlanet = MyGamePruningStructure.GetClosestPlanet(playerPosition);
if (closestPlanet != null)
{
var planetCentre = closestPlanet.PositionComp.GetPosition();
var lineStartPoint = playerPosition;
var lineEndPoint = planetCentre;
var lineCheck = new LineD(lineStartPoint, lineEndPoint);
DrawLine(lineColor, lineStartPoint, lineEndPoint);
}
}
public override void Draw()
{
if (DebugDrawEnvironmentProviders)
{
foreach (var provider in m_environmentProviders)
{
provider.DebugDraw();
}
}
var closest = MyGamePruningStructure.GetClosestPlanet(MySector.MainCamera.Position);
if (DebugDrawSectors && closest != null)
{
ActiveSector = closest.Components.Get <MyPlanetEnvironmentComponent>().GetSectorForPosition(MySector.MainCamera.Position);
}
}
public float GetAirDensity(IMyCubeGrid grid)
{
Vector3D pos = grid.PositionComp.GetPosition();
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (gravity.LengthSquared() > 0f)
{
var planet = MyGamePruningStructure.GetClosestPlanet(pos);
if (planet != null && planet.HasAtmosphere)
{
return(-(planet.GetAirDensity(pos)));
}
}
// Probably in space.
return(0);
}
public static MyPlanetNamesData GetPlanetNames(Vector3D position)
{
MyPlanetNamesData returnData = new MyPlanetNamesData();
var planet = MyGamePruningStructure.GetClosestPlanet(position);
if (planet != null)
{
returnData.planetName = planet.StorageName;
returnData.planetType = planet.Generator.FolderName;
}
else
{
returnData.planetName = "";
returnData.planetType = "";
}
return(returnData);
}
