public void UpdateBeforeSimulation100()
{
m_soundEmitters[(int)MySoundEmitterEnum.PrimaryState].Update();
if (windSystem)
{
float oxygen = MyOxygenProviderSystem.GetOxygenInPoint(m_character.PositionComp.GetPosition());
if (oxygen > 0f)
{
inAtmosphere = true;//in pressurized environment
}
else
{
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(m_character.PositionComp.GetPosition());
if (gravity.LengthSquared() > 0f)
{
MyPlanet planet = MyGravityProviderSystem.GetNearestPlanet(m_character.PositionComp.GetPosition());
if (planet != null && planet.AtmosphereSettings.FogIntensity > 0f)
{
inAtmosphere = true;//in atmosphere without oxygen
}
else
{
inAtmosphere = false;
}
}
else
{
inAtmosphere = false;
}
}
windEmitter.Update();
}
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
Vector3 vector = MyGravityProviderSystem.CalculateNaturalGravityInPoint(base.PositionComp.GetPosition());
if (this.Physics.RigidBody.GetShape().ShapeType != HkShapeType.Sphere)
{
this.Physics.RigidBody.Gravity = vector;
}
else
{
this.m_smoothGravity = (this.m_smoothGravity * 0.5f) + (vector * 0.5f);
this.m_smoothGravityDir = this.m_smoothGravity;
this.m_smoothGravityDir.Normalize();
bool flag = false;
foreach (Vector3 vector2 in this.m_supportNormals)
{
if (vector2.Dot(this.m_smoothGravityDir) > 0.8f)
{
flag = true;
break;
}
}
this.m_supportNormals.Clear();
if (!flag)
{
this.Physics.RigidBody.Gravity = this.m_smoothGravity;
}
else if (this.Physics.RigidBody.Gravity.Length() > 0.01f)
{
HkRigidBody rigidBody = this.Physics.RigidBody;
rigidBody.Gravity *= 0.99f;
}
}
}
private void InitializePath(MyEnvironmentalParticle particle)
{
var pathData = new PathData();
if (pathData.PathPoints == null)
{
pathData.PathPoints = new Vector3D[PathData.PathPointCount + 2];
}
var gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(particle.Position);
var gravityDirection = Vector3D.Normalize(gravity);
pathData.PathPoints[1] = particle.Position - gravityDirection * MyRandom.Instance.NextFloat() * 2.5f;
// TODO general direction of movement
for (int index = 2; index < PathData.PathPointCount + 1; ++index)
{
var pathLength = 5.0f;
Vector3D randomNormal = Vector3D.Normalize(new Vector3D(MyRandom.Instance.NextFloat(), MyRandom.Instance.NextFloat(), MyRandom.Instance.NextFloat()) * 2.0f - Vector3D.One - 0.25 * gravityDirection);
pathData.PathPoints[index] = pathData.PathPoints[index - 1] + randomNormal * (MyRandom.Instance.NextFloat() + 1.0f) * pathLength - gravityDirection / (float)index * pathLength;
}
pathData.PathPoints[0] = pathData.PathPoints[1] - gravityDirection;
pathData.PathPoints[PathData.PathPointCount + 1] = pathData.PathPoints[PathData.PathPointCount] + Vector3D.Normalize(pathData.PathPoints[PathData.PathPointCount] - pathData.PathPoints[PathData.PathPointCount - 1]);
particle.UserData = pathData;
}
public override bool GetBotSpawnPosition(string behaviorType, out VRageMath.Vector3D spawnPosition)
{
// CH: TODO: Do this more generically, so that modders would be able to define their own bot types and the way they spawn
if (behaviorType == "Spider")
{
MatrixD spawnMatrix;
bool success = GetSpiderSpawnPosition(out spawnMatrix, null);
spawnPosition = spawnMatrix.Translation;
return(success);
}
else if (MySession.Static.LocalCharacter != null)
{
var pos = MySession.Static.LocalCharacter.PositionComp.GetPosition();
Vector3 up;
Vector3D right, forward;
up = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (up.LengthSquared() < 0.0001f)
{
up = Vector3.Up;
}
else
{
up = Vector3D.Normalize(up);
}
forward = Vector3.CalculatePerpendicularVector(up);
right = Vector3.Cross(forward, up);
spawnPosition = MyUtils.GetRandomDiscPosition(ref pos, 5.0f, ref forward, ref right);
return(true);
}
spawnPosition = Vector3D.Zero;
return(false);
}
public virtual void Start(MatrixD position, Vector3D initialVelocity, float scale, bool randomRotation = true)
{
MyDebug.AssertDebug(!m_isStarted);
m_createdTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
Container.Entity.PositionComp.Scale = RandomScale * scale;
Container.Entity.WorldMatrix = position;
(Container.Entity.Physics as MyDebrisPhysics).ScalePhysicsShape(ref m_massProperties);
Container.Entity.Physics.Clear();
Container.Entity.Physics.LinearVelocity = initialVelocity;
//apply random rotation impulse
if (randomRotation)
{
Container.Entity.Physics.AngularVelocity = new Vector3(MyUtils.GetRandomRadian(),
MyUtils.GetRandomRadian(),
MyUtils.GetRandomRadian());
}
MyEntities.Add(m_entity);
Container.Entity.Physics.Enabled = true;
float simulationRatio = Sync.IsServer ? 1.0f : Sync.RelativeSimulationRatio * Sync.RelativeSimulationRatio;
Vector3D gravity = simulationRatio * MyGravityProviderSystem.CalculateNaturalGravityInPoint(position.Translation);
((MyPhysicsBody)Container.Entity.Physics).RigidBody.Gravity = gravity;
(Container.Entity.Physics as MyPhysicsBody).HavokWorld.ActiveRigidBodies.Add((Container.Entity.Physics as MyPhysicsBody).RigidBody);
m_isStarted = true;
}
private bool CheckGravity()
{
if (!Config.AllowInGravity)
{
if (!Vector3D.IsZero(MyGravityProviderSystem.CalculateNaturalGravityInPoint(PlayerPosition)))
{
Chat?.Respond("Saving & Loading in gravity has been disabled!");
return(false);
}
}
else
{
if (Config.MaxGravityAmount == 0)
{
return(true);
}
float Gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(PlayerPosition).Length() / 9.81f;
if (Gravity > Config.MaxGravityAmount)
{
//Log.Warn("Players gravity amount: " + Gravity);
Chat?.Respond("You are not permitted to Save/load in this gravity amount. Max amount: " + Config.MaxGravityAmount + "g");
return(false);
}
}
return(true);
}
public override bool GetBotSpawnPosition(string behaviorType, out VRageMath.Vector3D spawnPosition)
{
if (MySession.LocalCharacter != null)
{
var pos = MySession.LocalCharacter.PositionComp.GetPosition();
Vector3 up;
Vector3D right, forward;
up = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (up.LengthSquared() < 0.0001f)
{
up = Vector3.Up;
}
else
{
up = Vector3D.Normalize(up);
}
forward = Vector3.CalculatePerpendicularVector(up);
right = Vector3.Cross(forward, up);
spawnPosition = MyUtils.GetRandomDiscPosition(ref pos, 5.0f, ref forward, ref right);
return(true);
}
spawnPosition = Vector3D.Zero;
return(false);
}
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));
}
}
}
private void SpawnBot(SpawnInfo spawnInfo, MyPlanet planet, MyPlanetAnimalSpawnInfo animalSpawnInfo)
{
PlanetAIInfo planetInfo = null;
if (!m_planets.TryGetValue(planet.EntityId, out planetInfo))
{
Debug.Assert(false, "Could not get planet info!");
return;
}
if (planetInfo.BotNumber >= MAX_BOTS_PER_PLANET)
{
return;
}
Debug.Assert(animalSpawnInfo != null);
double spawnDistMin = animalSpawnInfo.SpawnDistMin;
double spawnDistMax = animalSpawnInfo.SpawnDistMax;
Vector3D center = spawnInfo.Position;
Vector3D planetGravityVec = MyGravityProviderSystem.CalculateNaturalGravityInPoint(center);
//GR: if gravity is zero provide a random Vector to normalize
if (planetGravityVec == Vector3D.Zero)
{
planetGravityVec = Vector3D.Up;
}
planetGravityVec.Normalize();
Vector3D planetTangent = Vector3D.CalculatePerpendicularVector(planetGravityVec);
Vector3D planetBitangent = Vector3D.Cross(planetGravityVec, planetTangent);
planetTangent.Normalize();
planetBitangent.Normalize();
Vector3D spawnPos = MyUtils.GetRandomDiscPosition(ref center, spawnDistMin, spawnDistMax, ref planetTangent, ref planetBitangent);
spawnPos = planet.GetClosestSurfacePointGlobal(ref spawnPos);
Vector3D?spawnPosCorrected = MyEntities.FindFreePlace(spawnPos, 2.0f);
if (spawnPosCorrected.HasValue)
{
spawnPos = spawnPosCorrected.Value;
}
planet.CorrectSpawnLocation(ref spawnPos, 2.0f);
MyAgentDefinition botBehavior = GetAnimalDefinition(animalSpawnInfo) as MyAgentDefinition;
if (botBehavior != null)
{
if (botBehavior.Id.SubtypeName == Wolf_SUBTYPE_ID && MySession.Static.EnableWolfs)
{
MyAIComponent.Static.SpawnNewBot(botBehavior, spawnPos);
}
else if (botBehavior.Id.SubtypeName != Wolf_SUBTYPE_ID && MySession.Static.EnableSpiders)
{
MyAIComponent.Static.SpawnNewBot(botBehavior, spawnPos);
}
}
}
private bool IsNearPlanet()
{
if (ControlledEntity == null)
{
return(false);
}
return(!Vector3.IsZero(MyGravityProviderSystem.CalculateNaturalGravityInPoint(ControlledEntity.PositionComp.GetPosition())));
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
// DA: Consider using havok fields (buoyancy demo) for gravity of planets.
//<ib.floating>
//Physics.RigidBody.Gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(PositionComp.GetPosition());
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(PositionComp.GetPosition());
if (Physics.RigidBody.GetShape().ShapeType == HkShapeType.Sphere)
{
const float w = 0.5f;
m_smoothGravity = m_smoothGravity * w + gravity * (1 - w);
m_smoothGravityDir = m_smoothGravity;
m_smoothGravityDir.Normalize();
bool anySupport = false;
foreach (var supportNormal in m_supportNormals)
{
float cosalpha = supportNormal.Dot(m_smoothGravityDir);
const float cosalphaLimit = 0.8f; // +/- 12 Degrees
if (cosalpha > cosalphaLimit)
{
anySupport = true;
break;
}
}
m_supportNormals.Clear();
if (anySupport)
{
//Physics.RigidBody.Gravity = Vector3.Zero;
const float limitGravity = 0.01f;
if ((Physics.RigidBody.Gravity.Length() > limitGravity))
{
Physics.RigidBody.Gravity *= 0.99f; // Decay gravity
}
}
else
{
Physics.RigidBody.Gravity = m_smoothGravity;
}
}
else
{
Physics.RigidBody.Gravity = gravity;
}
if (m_massChangeForCollisions < 1f)
{
if ((MySession.Static.ElapsedPlayTime.TotalMilliseconds - m_timeFromSpawn.TotalMilliseconds) >= 2000)
{
m_massChangeForCollisions = 1f;
}
}
}
public bool UpdatePhysicalMovement()
{
if (!Running)
{
return(false);
}
var characterPhysics = Character.Physics;
var characterProxy = characterPhysics.CharacterProxy;
if (characterProxy != null)
{
if (characterProxy.LinearVelocity.Length() < MyCharacter.MINIMAL_SPEED)
{
characterProxy.LinearVelocity = Vector3.Zero;
}
}
var rigidBody = characterPhysics.RigidBody;
if (rigidBody != null)
{
rigidBody.Gravity = Vector3.Zero;
if (MySession.Static.SurvivalMode || MyFakes.ENABLE_PLANETS_JETPACK_LIMIT_IN_CREATIVE)
{
Vector3 planetGravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(Character.PositionComp.WorldAABB.Center);
if (planetGravity != Vector3.Zero)
{
rigidBody.Gravity = planetGravity * MyPerGameSettings.CharacterGravityMultiplier;
}
}
return(true);
}
else if (characterProxy != null)
{
characterProxy.Gravity = Vector3.Zero;
if (MySession.Static.SurvivalMode || MyFakes.ENABLE_PLANETS_JETPACK_LIMIT_IN_CREATIVE)
{
Vector3 planetGravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(Character.PositionComp.WorldAABB.Center);
if (planetGravity != Vector3.Zero)
{
characterProxy.Gravity = planetGravity * MyPerGameSettings.CharacterGravityMultiplier;
}
}
return(true);
}
return(false);
}
public void UpdateAtmosphereStatus()
{
if (m_character != null && (m_localPlayer == false || (MySession.Static != null && m_character == MySession.Static.LocalCharacter)))
{
Vector3D pos = m_character.PositionComp.GetPosition();
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
if (gravity.LengthSquared() > 0f)
{
MyPlanet planet = MyGravityProviderSystem.GetNearestPlanet(pos);
float d = (float)Vector3D.DistanceSquared(planet.PositionComp.GetPosition(), pos);
if (planet != null && planet.HasAtmosphere && Vector3D.DistanceSquared(planet.PositionComp.GetPosition(), pos) < planet.AtmosphereRadius * planet.AtmosphereRadius)
{
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
}
}
}
}
public bool Contains(ref Vector3D point)
{
Vector3D vectord;
List <BoundingBox> .Enumerator enumerator;
Vector3D.Transform(ref point, ref this.m_worldInv, out vectord);
Vector3 vector = Vector3.TransformNormal(MyGravityProviderSystem.CalculateNaturalGravityInPoint(this.m_grid.PositionComp.WorldAABB.Center), this.m_worldInv);
if (!Vector3.IsZero(vector))
{
vector = Vector3.Normalize(vector);
Ray ray = new Ray((Vector3)vectord, -vector * 2f);
using (enumerator = this.m_segments.GetEnumerator())
{
bool flag;
while (true)
{
if (enumerator.MoveNext())
{
float?nullable = enumerator.Current.Intersects(ray);
if (nullable == null)
{
continue;
}
flag = true;
}
else
{
goto TR_0000;
}
break;
}
return(flag);
}
}
using (enumerator = this.m_segments.GetEnumerator())
{
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
BoundingBox current = enumerator.Current;
if (current.Contains(vectord) == ContainmentType.Contains)
{
return(true);
}
}
}
TR_0000:
return(false);
}
private void CalculateGridPosition(Vector3D Target)
{
List <MyObjectBuilder_CubeGrid> TotalGrids = new List <MyObjectBuilder_CubeGrid>();
List <MyObjectBuilder_Cockpit> cockpits = new List <MyObjectBuilder_Cockpit>();
Vector3D forwardVector = Vector3D.Zero;
Hangar.Debug("Total Grids to be pasted: " + _grids.Count());
//Attempt to get gravity/Artificial gravity to align the grids to
//Here you can adjust the offset from the surface and rotation.
//Unfortunatley we move the grid again after this to find a free space around the character. Perhaps later i can incorporate that into
//LordTylus's existing grid checkplament method
float gravityRotation = 0f;
Vector3 gravityDirectionalVector = MyGravityProviderSystem.CalculateNaturalGravityInPoint(Target);
if (gravityDirectionalVector == Vector3.Zero)
{
gravityDirectionalVector = MyGravityProviderSystem.CalculateArtificialGravityInPoint(Target);
}
Vector3D upDirectionalVector;
if (gravityDirectionalVector != Vector3.Zero)
{
Hangar.Debug("Attempting to correct grid orientation!");
gravityDirectionalVector.Normalize();
upDirectionalVector = -gravityDirectionalVector;
if (forwardVector == Vector3D.Zero)
{
forwardVector = Vector3D.CalculatePerpendicularVector(gravityDirectionalVector);
if (gravityRotation != 0f)
{
MatrixD matrixa = MatrixD.CreateFromAxisAngle(upDirectionalVector, gravityRotation);
forwardVector = Vector3D.Transform(forwardVector, matrixa);
}
}
}
else if (forwardVector == Vector3D.Zero)
{
forwardVector = Vector3D.Right;
upDirectionalVector = Vector3D.Up;
}
else
{
upDirectionalVector = Vector3D.CalculatePerpendicularVector(-forwardVector);
}
BeginAlignToGravity(_grids, Target, forwardVector, upDirectionalVector);
}
public static void GetSpawnPosition(float collisionRadius, out Vector3 direction, out Vector3D position)
{
float distance = 0;
foreach (var entity in MyEntities.GetEntities())
{
// Include only voxels
if (entity is MyVoxelMap)
{
distance = (float)MathHelper.Max(distance, entity.PositionComp.WorldVolume.Center.Length() + entity.PositionComp.WorldVolume.Radius);
}
}
// 500 - 650m from last voxel
distance += MyUtils.GetRandomFloat(500, 650);
if (MyEntities.IsWorldLimited())
{
distance = Math.Min(distance, MyEntities.WorldSafeHalfExtent());
}
else
{
distance = Math.Min(distance, 20000); // limited spawn area in infinite worlds
}
direction = MyUtils.GetRandomVector3Normalized();
var searchPosition = MyEntities.FindFreePlace((Vector3D)(direction * distance), collisionRadius);
if (!searchPosition.HasValue)
{
searchPosition = (Vector3D)(direction * distance); // Spawn in existing place (better than crash)
}
Vector3D globalPoint = (Vector3D)searchPosition;
position = globalPoint;
if (MyGravityProviderSystem.CalculateNaturalGravityInPoint(globalPoint) != null && MyGravityProviderSystem.CalculateNaturalGravityInPoint(globalPoint).Length() != 0)
{
MyPlanet planet = MyGravityProviderSystem.GetStrongestGravityWell(globalPoint);
double multiplier = planet.MaximumRadius / globalPoint.Length();
globalPoint *= multiplier;
Vector3D closestPoint = planet.GetClosestSurfacePointGlobal(ref globalPoint) * 1.25;
searchPosition = MyEntities.FindFreePlace(closestPoint, collisionRadius);
if (searchPosition.HasValue)
{
position = searchPosition.Value;
}
}
else
{
position = searchPosition.Value;
}
}
private Vector3D?FindPastePosition(Vector3D Target)
{
//Log.info($"BoundingSphereD: {SphereD.Center}, {SphereD.Radius}");
//Log.info($"MyOrientedBoundingBoxD: {BoxD.Center}, {BoxD.GetAABB()}");
MyGravityProviderSystem.CalculateNaturalGravityInPoint(Target, out float val);
if (val == 0)
{
//following method is what SEworldgen uses. We only really need to use this in space
return(FindSuitableJumpLocationSpace(Target));
}
return(MyEntities.FindFreePlaceCustom(Target, (float)SphereD.Radius, 90, 10, 1.5f, 10));
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
// DA: Consider using havok fields (buoyancy demo) for gravity of planets.
Physics.RigidBody.Gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(PositionComp.GetPosition());
if (m_massChangeForCollisions < 1f)
{
if ((MySession.Static.ElapsedPlayTime.TotalMilliseconds - m_timeFromSpawn.TotalMilliseconds) >= 2000)
{
m_massChangeForCollisions = 1f;
}
}
}
private static void StartWave()
{
if (!m_currentTarget.HasValue)
{
return;
}
var sunDir = GetCorrectedDirection(MySector.DirectionToSunNormalized);
SetupDirVectors(sunDir);
var waveMeteorCount = MyUtils.GetRandomFloat(Math.Min(2, m_meteorcount - 3), m_meteorcount + 3);
var randCircle = MyUtils.GetRandomVector3CircleNormalized();
var rand = MyUtils.GetRandomFloat(0, 1);
Vector3D randomCircleInPlain = randCircle.X * m_rightVector + randCircle.Z * m_downVector;
var hitPosition = m_currentTarget.Value.Center + Math.Pow(rand, 0.7f) * m_currentTarget.Value.Radius * randomCircleInPlain * METEOR_BLUR_KOEF;
//Cast Ray for sure
var antigravityDir = -Vector3D.Normalize(MyGravityProviderSystem.CalculateNaturalGravityInPoint(hitPosition));
if (antigravityDir != Vector3D.Zero)
{
var hi = MyPhysics.CastRay(hitPosition + antigravityDir * (3000), hitPosition, MyPhysics.CollisionLayers.DefaultCollisionLayer);
if (hi != null)
{
hitPosition = hi.Value.Position;
}
}
m_meteorHitPos = hitPosition;
for (int i = 0; i < waveMeteorCount; i++)
{
// hit
randCircle = MyUtils.GetRandomVector3CircleNormalized();
rand = MyUtils.GetRandomFloat(0, 1);
randomCircleInPlain = randCircle.X * m_rightVector + randCircle.Z * m_downVector;
hitPosition = hitPosition + Math.Pow(rand, 0.7f) * m_currentTarget.Value.Radius * randomCircleInPlain;
// start
var toSun = sunDir * (2000 + 100 * i);
randCircle = MyUtils.GetRandomVector3CircleNormalized();
randomCircleInPlain = randCircle.X * m_rightVector + randCircle.Z * m_downVector;
var realPosition = hitPosition + toSun + (float)Math.Tan(MyUtils.GetRandomFloat(0, (float)Math.PI / 18)) * randomCircleInPlain;
m_meteorList.Add(MyMeteor.SpawnRandom(realPosition, Vector3.Normalize(hitPosition - realPosition)));
}
m_rightVector = Vector3.Zero;
}
public virtual void Start(MatrixD position, Vector3D initialVelocity, bool randomRotation = true)
{
this.m_createdTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
base.Container.Entity.WorldMatrix = position;
base.Container.Entity.Physics.Clear();
base.Container.Entity.Physics.LinearVelocity = (Vector3)initialVelocity;
if (randomRotation)
{
base.Container.Entity.Physics.AngularVelocity = new Vector3(MyUtils.GetRandomRadian(), MyUtils.GetRandomRadian(), MyUtils.GetRandomRadian());
}
MyEntities.Add(base.m_entity, true);
base.Container.Entity.Physics.Enabled = true;
Vector3 vector = MyGravityProviderSystem.CalculateNaturalGravityInPoint(position.Translation);
((MyPhysicsBody)base.Container.Entity.Physics).RigidBody.Gravity = vector;
this.m_isStarted = true;
}
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 data = new MyPlanetNamesData();
MyPlanet closestPlanet = MyGamePruningStructure.GetClosestPlanet(position);
Vector3 vector = MyGravityProviderSystem.CalculateNaturalGravityInPoint(position);
if ((closestPlanet == null) || (vector.LengthSquared() <= 0f))
{
data.planetName = "";
data.planetType = "";
}
else
{
data.planetName = closestPlanet.StorageName;
data.planetType = closestPlanet.Generator.FolderName;
}
return(data);
}
public bool UpdatePhysicalMovement()
{
if (!this.Running)
{
return(false);
}
MyPhysicsBody physics = base.Character.Physics;
MyCharacterProxy characterProxy = physics.CharacterProxy;
if ((characterProxy != null) && (characterProxy.LinearVelocity.Length() < 0.001f))
{
characterProxy.LinearVelocity = Vector3.Zero;
}
float num = 1f;
HkRigidBody rigidBody = physics.RigidBody;
if (rigidBody != null)
{
rigidBody.Gravity = Vector3.Zero;
if (MySession.Static.SurvivalMode || MyFakes.ENABLE_PLANETS_JETPACK_LIMIT_IN_CREATIVE)
{
Vector3 vector2 = (Vector3)(num * MyGravityProviderSystem.CalculateNaturalGravityInPoint(base.Character.PositionComp.WorldAABB.Center));
if (vector2 != Vector3.Zero)
{
rigidBody.Gravity = vector2 * MyPerGameSettings.CharacterGravityMultiplier;
}
}
return(true);
}
if (characterProxy == null)
{
return(false);
}
characterProxy.Gravity = Vector3.Zero;
if (MySession.Static.SurvivalMode || MyFakes.ENABLE_PLANETS_JETPACK_LIMIT_IN_CREATIVE)
{
Vector3 vector3 = (Vector3)(num * MyGravityProviderSystem.CalculateNaturalGravityInPoint(base.Character.PositionComp.WorldAABB.Center));
if (vector3 != Vector3.Zero)
{
characterProxy.Gravity = vector3 * MyPerGameSettings.CharacterGravityMultiplier;
}
}
return(true);
}
/// <summary>
/// Calculate propper direction for meteorits. Everytime above horizon.
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
private static Vector3 GetCorrectedDirection(Vector3 direction)
{
var currDir = direction;
if (m_currentTarget == null)
{
return(currDir);
}
var tgtPos = m_currentTarget.Value.Center;
MyMeteorShower.m_tgtPos = tgtPos;
if (!MyGravityProviderSystem.IsPositionInNaturalGravity(tgtPos))
{
return(currDir);
}
var pltTgtDir = -Vector3D.Normalize(MyGravityProviderSystem.CalculateNaturalGravityInPoint(tgtPos));
var tmpVec = Vector3D.Normalize(Vector3D.Cross(pltTgtDir, currDir));
var mirror = Vector3D.Normalize(Vector3D.Cross(tmpVec, pltTgtDir));
MyMeteorShower.m_mirrorDir = mirror;
MyMeteorShower.m_pltTgtDir = pltTgtDir;
MyMeteorShower.m_normalSun = tmpVec;
double horizonRatio = pltTgtDir.Dot(currDir);
//below down horizon
if (horizonRatio < -HORIZON_ANGLE_FROM_ZENITH_RATIO)
{
return(Vector3D.Reflect(-currDir, mirror));
}
// between below and above horizon (prohi
if (horizonRatio < HORIZON_ANGLE_FROM_ZENITH_RATIO)
{
MatrixD tmpMat = MatrixD.CreateFromAxisAngle(tmpVec, -Math.Asin(HORIZON_ANGLE_FROM_ZENITH_RATIO));
return(Vector3D.Transform(mirror, tmpMat));
}
// above 20 Degree above horizon
return(currDir);
}
private void CutTree(int itemInstanceId, Vector3D hitWorldPosition, Vector3 hitNormal, float forceMultiplier = 1.0f)
{
HkStaticCompoundShape shape = (HkStaticCompoundShape)Physics.RigidBody.GetShape();
int physicsInstanceId;
if (m_localIdToPhysicsShapeInstanceId.TryGetValue(itemInstanceId, out physicsInstanceId))
{
//Remove static tree
MyEnvironmentItemData itemData = m_itemsData[itemInstanceId];
RemoveItem(itemInstanceId, physicsInstanceId, sync: true, immediateUpdate: true);
//Create fractured tree
MyDefinitionId id = new MyDefinitionId(Definition.ItemDefinitionType, itemData.SubtypeId);
var itemDefinition = MyDefinitionManager.Static.GetEnvironmentItemDefinition(id);
if (MyModels.GetModelOnlyData(itemDefinition.Model).HavokBreakableShapes != null)
{
CreateBreakableShape(itemDefinition, ref itemData, ref hitWorldPosition, hitNormal, forceMultiplier);
}
else
{
ProfilerShort.Begin("Spawning tree");
// This is for SE when you hit a tree, it will create a floating object with the same model. In case it affects ME, it may be changed. Contact DusanA for it.
Debug.Assert(MyPerGameSettings.Game == GameEnum.SE_GAME);
MyPhysicalInventoryItem Item = new MyPhysicalInventoryItem()
{
Amount = 1, Content = new MyObjectBuilder_TreeObject()
{
SubtypeName = itemData.SubtypeId.ToString()
}
};
Vector3D pos = itemData.Transform.Position;
Vector3D gravity = -MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos);
gravity.Normalize();
MyFloatingObjects.Spawn(Item, pos + gravity, MyUtils.GetRandomPerpendicularVector(ref gravity), gravity);
ProfilerShort.End();
}
}
}
public bool Contains(ref Vector3D point)
{
Vector3D localPoint;
Vector3D.Transform(ref point, ref m_worldInv, out localPoint);
// Testing a point against extrusion of the BB along gravity is the same as
// testing extrusion of the point (i.e. a ray going in the opposite direction) against the original BB.
Vector3D testPoint = m_grid.PositionComp.WorldAABB.Center;
Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(testPoint);
gravity = Vector3.TransformNormal(gravity, m_worldInv);
if (!Vector3.IsZero(gravity))
{
gravity = Vector3.Normalize(gravity);
Ray ray = new Ray(localPoint, -gravity * 2.0f); // 2.0f = height of the character
foreach (var segment in m_segments)
{
if (segment.Intersects(ray).HasValue)
{
return(true);
}
}
}
else
{
// CH: Use some kind of a tree or something better than a list here!
foreach (var segment in m_segments)
{
if (segment.Contains(localPoint) == ContainmentType.Contains)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Returns a position adjusted for planets 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="planetAtmosphereRatio">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>
private static void GetSpawnPositionNearPlanet(MyPlanet planet, float collisionRadius, ref Vector3D position, out Vector3D forward, out Vector3D up, float planetAtmosphereRatio = 0.3f, float randomRangeMin = 500, float randomRangeMax = 650)
{
// Position us at a desirable height on the planet
// Roughl halfway the planet's upper atmosphere and outer radius
float randomHeightAdjustment = MyUtils.GetRandomFloat(randomRangeMin, randomRangeMax);
float height = planet.MaximumRadius + planetAtmosphereRatio * (planet.AtmosphereRadius - planet.MaximumRadius) + randomHeightAdjustment;
// Compute random position
position = planet.PositionComp.WorldVolume.Center + MyUtils.GetRandomVector3Normalized() * height;
Vector3D?freePlace = MyEntities.FindFreePlace(position, collisionRadius);
int numAttempts = 1;
// While we have no valid spawn position, try again 3 more times
while (!freePlace.HasValue && numAttempts <= 3)
{
position = planet.PositionComp.WorldVolume.Center + MyUtils.GetRandomVector3Normalized() * height;
freePlace = MyEntities.FindFreePlace(position, collisionRadius);
numAttempts += 1;
}
// If we have a valid position, use it
if (freePlace.HasValue)
{
position = freePlace.Value;
}
// Return orientation perpendicular to planet surface
Vector3 gravityAtPosition = MyGravityProviderSystem.CalculateNaturalGravityInPoint(position);
if (Vector3.IsZero(gravityAtPosition)) // If we are somehow randomized outside of gravity range, make sure some orientation is used
{
gravityAtPosition = Vector3.Up;
}
Vector3D normalizedGravityVector = Vector3D.Normalize(gravityAtPosition);
forward = Vector3.CalculatePerpendicularVector(-normalizedGravityVector);
up = -normalizedGravityVector;
}
private EdgePlacerSystem.AnnotatedNode CreateVertex(Vector3D worldPos)
{
var node = Graph.GetNode(worldPos);
Vector3D up;
if (node != null)
{
up = node.Up;
worldPos = node.Position;
}
else
{
up = Vector3D.Normalize(-MyGravityProviderSystem.CalculateNaturalGravityInPoint(worldPos));
if (!up.IsValid() || up.LengthSquared() < 1e-3f)
{
up = Vector3D.Up;
}
}
return(new EdgePlacerSystem.AnnotatedNode {
Position = worldPos, Up = (Vector3)up, Existing = node, Tangent = node?.Tangent ?? Vector3.Zero
});
}
public Node GetOrCreateNode(Vector3D pos, Vector3D?up = null, bool desirePin = false)
{
var nearest = NearestNode(pos);
if (nearest != null && Vector3D.DistanceSquared(nearest.Position, pos) < RailConstants.NodeMergeDistanceSq)
{
if (!desirePin || Vector3D.DistanceSquared(nearest.Position, pos) < .05f * .05f)
{
return(nearest);
}
}
// ReSharper disable once InvertIf
if (!up.HasValue)
{
up = Vector3D.Normalize(-MyGravityProviderSystem.CalculateNaturalGravityInPoint(pos));
if (!up.Value.IsValid() || up.Value.LengthSquared() < 1e-3f)
{
up = Vector3D.Up;
}
}
return(new Node(this, pos, up.Value));
}
protected MyBehaviorTreeState RunAway([BTParam] float distance)
{
if (!runAwayPos.HasValue)
{
Vector3D currentPosition = Bot.Player.Character.PositionComp.GetPosition();
Vector3D planetGravityVec = MyGravityProviderSystem.CalculateNaturalGravityInPoint(currentPosition);
var planet = MyGravityProviderSystem.GetNearestPlanet(currentPosition);
if (planet == null)
{
return(MyBehaviorTreeState.FAILURE);
}
if (lastTargetedEntityPosition.HasValue)
{
Vector3D lastTargetedEntityPositionProjected = lastTargetedEntityPosition.Value;
lastTargetedEntityPositionProjected = planet.GetClosestSurfacePointGlobal(ref lastTargetedEntityPositionProjected);
Vector3D direction = currentPosition - lastTargetedEntityPositionProjected;
Vector3D runAwayPosCandidate = currentPosition + Vector3D.Normalize(direction) * distance;
runAwayPos = planet.GetClosestSurfacePointGlobal(ref runAwayPosCandidate);
}
else
{
planetGravityVec.Normalize();
Vector3D planetTangent = Vector3D.CalculatePerpendicularVector(planetGravityVec);
Vector3D planetBitangent = Vector3D.Cross(planetGravityVec, planetTangent);
planetTangent.Normalize();
planetBitangent.Normalize();
Vector3D runAwayPosCandidate = MyUtils.GetRandomDiscPosition(ref currentPosition, distance, distance, ref planetTangent, ref planetBitangent);
if (planet != null)
{
runAwayPos = planet.GetClosestSurfacePointGlobal(ref runAwayPosCandidate);
}
else
{
runAwayPos = runAwayPosCandidate;
}
}
AiTargetBase.SetTargetPosition(runAwayPos.Value);
AimWithMovement();
}
else
{
if (Bot.Navigation.Stuck)
{
return(MyBehaviorTreeState.FAILURE);
}
}
AiTargetBase.GotoTargetNoPath(1.0f, false);
if (Vector3D.DistanceSquared(runAwayPos.Value, Bot.Player.Character.PositionComp.GetPosition()) < 10.0f * 10.0f)
{
CyberhoundLogic.Remove();
return(MyBehaviorTreeState.SUCCESS);
}
else
{
return(MyBehaviorTreeState.RUNNING);
}
}