// Obtain day or night spawning info based on given planet and position. Position is in global space. public static MyPlanetAnimalSpawnInfo GetDayOrNightAnimalSpawnInfo(MyPlanet planet, Vector3D position) { if (planet == null) { return(null); } if (planet.Generator.NightAnimalSpawnInfo != null && planet.Generator.NightAnimalSpawnInfo.Animals != null && planet.Generator.NightAnimalSpawnInfo.Animals.Length > 0 && IsThereNight(planet, ref position)) { return(planet.Generator.NightAnimalSpawnInfo); } else if (planet.Generator.AnimalSpawnInfo != null && planet.Generator.AnimalSpawnInfo.Animals != null && planet.Generator.AnimalSpawnInfo.Animals.Length > 0) { return(planet.Generator.AnimalSpawnInfo); } else { return(null); } }
public static void RefreshLists() { entityList.Clear(); planetList.Clear(); planetNameList.Clear(); MyAPIGateway.Entities.GetEntities(entityList); if (entityList.Count != 0) { foreach (var entity in entityList) { planet = entity as MyPlanet; if (planet != null) { planetList.Add(planet); } } } planetNameList.Clear(); var planetDefList = MyDefinitionManager.Static.GetPlanetsGeneratorsDefinitions(); foreach (var planetDef in planetDefList) { planetNameList.Add(planetDef.Id.SubtypeName); } }
// Is there night on the given place on planet? Position is in global space. static bool IsThereNight(MyPlanet planet, ref Vector3D position) { // gravitation vector and vector to sun are facing same direction Vector3 grav = planet.GetWorldGravityNormalized(ref position); return(Vector3.Dot(MySector.DirectionToSunNormalized, grav) > 0); }
public void generatePlanet() { if (((sm.listeVisited[this.planetIndex - 1] == true && sm.listeVisited[this.planetIndex] == false) || (this.planetIndex == 1 && sm.listeVisited[this.planetIndex] == false)) && this.planetIndex != 9) { //Si la planète n'a pas déjà été générée on la génère if (this.myPlanet == null) { this.myPlanet = new MyPlanet(); this.changePlanetSkin(myPlanet.getPlanetType().getType()); this.getPlanetInfo(); this.infoTravel.text = "You are here\nClick on the planet to land"; } else { //================================================================ // Put here code to land on the planet GameObject.Find("SceneManager").GetComponent <CustomSceneManager>().TravelTo(this); //================================================================ Debug.Log("land"); // La planète a été visité sm.listeVisited[this.planetIndex] = true; } } else if (sm.listeVisited[this.planetIndex - 1] == true && this.planetIndex == 9) { //================================================================ // Put win or losing condition here when palyer arrive to homeland GameObject.Find("SceneManager").GetComponent <CustomSceneManager>().WinTheGame(); //================================================================ Debug.Log("game win"); } }
public PlanetEntity(IMyEntity entity) : base(entity) { Planet = entity as MyPlanet; HasGravity = entity.Components.TryGet <MyGravityProviderComponent>(out Gravity); HasAtmosphere = Planet.HasAtmosphere; HasOxygen = Planet.GetOxygenForPosition(GetPosition()) > 0 ? true : false; }
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 void AddPlanetPrefab(string prefabName, string name) { DictionaryValuesReader <MyDefinitionId, MyPlanetPrefabDefinition> planetDefinitions = MyDefinitionManager.Static.GetPlanetsPrefabsDefinitions(); foreach (var planetPrebabDefinition in planetDefinitions) { if (planetPrebabDefinition.Id.SubtypeName == prefabName) { var voxelMap = new MyPlanet(); var ob = planetPrebabDefinition.PlanetBuilder; string storageName = MyFileSystem.ContentPath + "\\VoxelMaps\\" + ob.StorageName + MyVoxelConstants.FILE_EXTENSION; voxelMap.EntityId = ob.EntityId; MyPlanetInitArguments planetInitArguments; planetInitArguments.StorageName = ob.StorageName; planetInitArguments.Storage = MyStorageBase.LoadFromFile(storageName); planetInitArguments.PositionMinCorner = ob.PositionAndOrientation.Value.Position; planetInitArguments.AveragePlanetRadius = ob.Radius; planetInitArguments.AtmosphereRadius = ob.AtmosphereRadius; planetInitArguments.MaximumHillRadius = ob.MaximumHillRadius; planetInitArguments.MinimumSurfaceRadius = ob.MinimumSurfaceRadius; planetInitArguments.HasAtmosphere = ob.HasAtmosphere; planetInitArguments.AtmosphereWavelengths = ob.AtmosphereWavelengths; planetInitArguments.MaxOxygen = ob.MaximumOxygen; planetInitArguments.GravityFalloff = ob.GravityFalloff; planetInitArguments.MarkAreaEmpty = true; voxelMap.Init(planetInitArguments); MyEntities.Add(voxelMap); } } }
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); } } }
void OnPickPlanet(MyGuiControlButton button) { var results = new List <MyLineSegmentOverlapResult <MyEntity> >(); var ray = new LineD(MySector.MainCamera.Position, MySector.MainCamera.ForwardVector); MyGamePruningStructure.GetAllEntitiesInRay(ref ray, results); float closestPlanetDistance = float.MaxValue; MyPlanet closestPlanet = null; foreach (var result in results) { var planet = result.Element as MyPlanet; if (planet != null && planet.EntityId != m_selectedPlanetEntityID) { if (result.Distance < closestPlanetDistance) { closestPlanet = planet; } } } if (closestPlanet != null) { m_selectedPlanetEntityID = closestPlanet.EntityId; m_atmosphereSettings = closestPlanet.AtmosphereSettings; m_originalAtmosphereSettings = m_atmosphereSettings; RecreateControls(false); } }
private void GenerateDebugDrawPolygonNavmesh(MyPlanet planet, List <MyRecastDetourPolygon> polygons, MyOrientedBoundingBoxD centerOBB, Vector2I coords) { if (polygons != null) { List <MyFormatPositionColor> list = new List <MyFormatPositionColor>(); int num = 10; int num2 = 0; int num3 = 0x5f; int num4 = 10; using (List <MyRecastDetourPolygon> .Enumerator enumerator = polygons.GetEnumerator()) { while (enumerator.MoveNext()) { foreach (Vector3 vector in enumerator.Current.Vertices) { MyFormatPositionColor item = new MyFormatPositionColor { Position = (Vector3)this.LocalNavmeshPositionToWorldPosition(centerOBB, vector, this.Center, Vector3D.Zero), Color = new Color(0, num + num2, 0) }; list.Add(item); } num2 = (num2 + num4) % num3; } } if (list.Count > 0) { this.m_newObbCoordsPolygons[coords] = list; } } }
/// <summary> /// Checks if a position on a planet is underground /// </summary> public static bool IsUnderGround(MyPlanet planet, Vector3D position, double altitudeOffset = 0) { if (planet == null) { return(false); } double altitude = (position - planet.WorldMatrix.Translation).Length() + altitudeOffset; if (altitude < planet.MinimumRadius) { return(true); } if (altitude > planet.MaximumRadius) { return(false); } if ((altitude - (planet.GetClosestSurfacePointGlobal(position) - planet.WorldMatrix.Translation).Length()) < 0) { return(true); } return(false); }
public override void OnAddedToScene() { base.OnAddedToScene(); if (this.m_mesher == null) { this.m_mesher = new MyVoxelMesherComponent(); MyPlanet rootVoxel = this.m_voxelMap.RootVoxel as MyPlanet; if (rootVoxel != null) { MyObjectBuilder_VoxelMesherComponentDefinition mesherPostprocessing = rootVoxel.Generator.MesherPostprocessing; if (mesherPostprocessing != null) { MyVoxelMesherComponentDefinition def = new MyVoxelMesherComponentDefinition(); def.Init(mesherPostprocessing, MyModContext.BaseGame); this.m_mesher.Init(def); } } this.m_mesher.SetContainer(base.Entity.Components); this.m_mesher.OnAddedToScene(); } if (!this.m_bodiesInitialized) { this.CreateRigidBodies(); } ActiveVoxelPhysicsBodies++; }
public override void OnAddedToContainer() { base.OnAddedToContainer(); this.m_planet = base.Entity as MyPlanet; this.m_oldNeedsDraw = this.NeedsDraw; this.NeedsDraw = true; }
public MyNavmeshOBBs(MyPlanet planet, Vector3D centerPoint, Vector3D forwardDirection, int obbsPerLine, int tileSize, int tileHeight) { m_planet = planet; // There will always be an odd number of obbs in a line OBBsPerLine = obbsPerLine; if (OBBsPerLine % 2 == 0) { OBBsPerLine += 1; } m_middleCoord = (OBBsPerLine - 1) / 2; m_tileHalfSize = tileSize * 0.5f; m_tileHalfHeight = tileHeight * 0.5f; m_obbs = new MyOrientedBoundingBoxD?[OBBsPerLine][]; for (int i = 0; i < OBBsPerLine; i++) { m_obbs[i] = new MyOrientedBoundingBoxD?[OBBsPerLine]; } Initialize(centerPoint, forwardDirection); BaseOBB = GetBaseOBB(); }
private void GenerateDebugDrawPolygonNavmesh(MyPlanet planet, List <MyRecastDetourPolygon> polygons, MyOrientedBoundingBoxD centerOBB, Vector2I coords /*List<Vertex> navmesh, int xCoord, int yCoord*/) { if (polygons == null) { return; } List <Vertex> navmesh = new List <Vertex>(); int greenBase = 10; int greenValue = 0; int maxExclusiveGreenValue = 95; int greenStep = 10; foreach (var polygon in polygons) { foreach (var vertice in polygon.Vertices) { var v = new Vertex() { pos = LocalNavmeshPositionToWorldPosition(centerOBB, vertice, Center, Vector3D.Zero), color = new Color(0, greenBase + greenValue, 0) }; navmesh.Add(v); } greenValue += greenStep; greenValue %= maxExclusiveGreenValue; } if (navmesh != null && navmesh.Count > 0) { m_newObbCoordsPolygons[coords] = navmesh; } }
private bool PlanetHasFauna(MyPlanet planet) { // compulsory: at least normal spawning info, planet can exist without night animals return(planet.Generator.AnimalSpawnInfo != null && planet.Generator.AnimalSpawnInfo.Animals != null && planet.Generator.AnimalSpawnInfo.Animals.Length > 0); }
/// <summary> /// Returns the planet that has the most influential gravity well in the given world point. /// The most influential gravity well is defined as the planet that has the highest gravity in the point and /// if no such planet is found, it returns the planet, whose gravity well is the closest to the given point. /// </summary> /// <param name="worldPosition">Position to test for the strongest gravity well</param> /// <returns>Planet that has the most influential gravity well in the given world point</returns> public static MyPlanet GetStrongestGravityWell(Vector3D worldPosition) { MyPlanet nearestPlanet = null; double maxMetricValue = double.MinValue; foreach (IMyGravityProvider gravityProvider in m_planetGenerators) { MyPlanet planet = gravityProvider as MyPlanet; if (planet == null) { continue; } double planetDistance = (planet.PositionComp.GetPosition() - worldPosition).Length(); double metricValue = double.MinValue; if (planetDistance <= planet.GravityLimit) { metricValue = (double)planet.GetGravityMultiplier(worldPosition); } else { // Outside of the gravity well, just invert the distance, so that we can use only one value // for comparison of planets which affect us and which don't metricValue = planet.GravityLimit - planetDistance; } if (metricValue > maxMetricValue) { nearestPlanet = planet; maxMetricValue = metricValue; } } return(nearestPlanet); }
/// <summary> /// This quickly checks if a given position is in any natural gravity. /// </summary> /// <param name="position">Position to check</param> /// <param name="sphereSize">Sphere size to test with.</param> /// <returns>True if there is natural gravity at this position, false otherwise.</returns> public static bool IsPositionInNaturalGravity(Vector3D position, double sphereSize = 0) { // Clamp sphere size to be at least 0. sphereSize = MathHelper.Max(sphereSize, 0); for (int i = 0; i < m_planetGenerators.Count; i++) { IMyGravityProvider provider = m_planetGenerators[i]; if (provider == null) { continue; } MyPlanet planet = provider as MyPlanet; if (planet == null) { continue; } //we don't really care which planet's gravity we're in, so return as soon as we find one if (planet.IsPositionInGravityWell(position)) { return(true); } } return(false); }
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 MyPlanet GetClosestContainingPlanet(Vector3D point) { m_voxels.Clear(); BoundingBoxD b = new BoundingBoxD(point, point); MyGamePruningStructure.GetAllVoxelMapsInBox(ref b, m_voxels); double dist = double.PositiveInfinity; MyPlanet p = null; foreach (var v in m_voxels) { if (v is MyPlanet) { var d = Vector3.Distance(v.WorldMatrix.Translation, point); if (d < dist) { dist = d; p = (MyPlanet)v; } } } return(p); }
//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 override void OnAddedToContainer() { base.OnAddedToContainer(); m_planet = Entity as MyPlanet; m_oldNeedsDraw = NeedsDraw; NeedsDraw = true; }
private void CreatePlanet(int seed, float size) { Vector3D pos = MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * size * 3 - new Vector3D(size); MyPlanetGeneratorDefinition planetDefinition = MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(m_selectedPlanetName)); MyPlanetStorageProvider provider = new MyPlanetStorageProvider(); provider.Init(seed, planetDefinition, size / 2f); IMyStorage storage = new MyOctreeStorage(provider, provider.StorageSize); float minHillSize = provider.Radius * planetDefinition.HillParams.Min; float maxHillSize = provider.Radius * planetDefinition.HillParams.Max; float averagePlanetRadius = provider.Radius; float outerRadius = averagePlanetRadius + maxHillSize; float innerRadius = averagePlanetRadius + minHillSize; float atmosphereRadius = planetDefinition.AtmosphereSettings.HasValue && planetDefinition.AtmosphereSettings.Value.Scale > 1f ? 1 + planetDefinition.AtmosphereSettings.Value.Scale : 1.75f; atmosphereRadius *= provider.Radius; var planet = new MyPlanet(); planet.EntityId = MyRandom.Instance.NextLong(); MyPlanetInitArguments planetInitArguments; planetInitArguments.StorageName = "test"; planetInitArguments.Storage = storage; planetInitArguments.PositionMinCorner = pos; planetInitArguments.Radius = provider.Radius; planetInitArguments.AtmosphereRadius = atmosphereRadius; planetInitArguments.MaxRadius = outerRadius; planetInitArguments.MinRadius = innerRadius; planetInitArguments.HasAtmosphere = planetDefinition.HasAtmosphere; planetInitArguments.AtmosphereWavelengths = Vector3.Zero; planetInitArguments.GravityFalloff = planetDefinition.GravityFalloffPower; planetInitArguments.MarkAreaEmpty = true; planetInitArguments.AtmosphereSettings = planetDefinition.AtmosphereSettings.HasValue ? planetDefinition.AtmosphereSettings.Value : MyAtmosphereSettings.Defaults(); planetInitArguments.SurfaceGravity = planetDefinition.SurfaceGravity; planetInitArguments.AddGps = false; planetInitArguments.SpherizeWithDistance = true; planetInitArguments.Generator = planetDefinition; planetInitArguments.UserCreated = true; planet.Init(planetInitArguments); m_lastAsteroidInfo = new SpawnAsteroidInfo() { Asteroid = null, RandomSeed = seed, Position = Vector3D.Zero, IsProcedural = true, ProceduralRadius = size, }; MyCubeBuilder.Static.ActivateVoxelClipboard(planet.GetObjectBuilder(), storage, MySector.MainCamera.ForwardVector, (storage.Size * 0.5f).Length()); }
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 MyRDPath(MyRDPathfinding pathfinding, Vector3D begin, IMyDestinationShape destination) { this.m_pathfinding = pathfinding; this.m_destination = destination; this.m_isValid = true; this.m_currentPointIndex = 0; this.m_planet = this.GetClosestPlanet(begin); }
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; }
public Vector3D?GetWind(MyPlanet Planet, Vector3D pos, IMyEntity ent) { if (WindGetter != null) { return(WindGetter(Planet, pos, ent)); } return(null); }
public static Vector3D GetClosestSurface(Vector3D coords, MyPlanet planet, Water water, ref bool isWater, bool ignoreWater = false) { double waterLevel = 0; var result = GetClosestSurface(coords, planet, water, ref waterLevel, ignoreWater); isWater = waterLevel < 0; return(result); }
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 = MyGravityProviderSystem.GetNearestPlanet(Position); SpawnDone = false; }
public static string GetWeather(MyPlanet planet) { float planetRadius = planet.MaximumRadius; Vector3D pos = planet.PositionLeftBottomCorner + new Vector3D(planetRadius, planetRadius, planetRadius); var currentWeather = GetWeather(pos); return(currentWeather); }
public static void UnRegister(MyPlanet myPlanet) { Get().m_planets.Remove(myPlanet); }
public static void Register(MyPlanet myPlanet) { Get().m_planets.Add(myPlanet); }