public Face Init(Transform parent, PlanetSettings settings, Directions direction, ShapeGenerator shapeGenerator) { planetSettings = settings; Direction = direction; this.shapeGenerator = shapeGenerator; if (parent != null) { transform.parent = parent; } if (meshFilter == null) { meshFilter = gameObject.AddComponent <MeshFilter>(); meshFilter.mesh = Mesh = new Mesh { name = "Procedural Face" }; } if (meshRenderer == null) { meshRenderer = gameObject.AddComponent <MeshRenderer>(); } meshGenerator = null; gameObject.name = direction.ToString(); return(this); }
public PlanetMaker(Vector3 solarSysCenter, float orbit) { //INIT this.planetSettings = GameObject.Find("SpaceMaker").GetComponent <CommonSettings>().planetSettings; Vector3 seedPosition = solarSysCenter * orbit * CommonSettings.smallNoiseScale; seed = ((int)(seedPosition.x)) | (((int)(seedPosition.y)) << 8) | (((int)(seedPosition.z)) << 16); //Debug.Log(seed); noise = new NoiseFilter(seed); Vector3 position = solarSysCenter + Vector3.left * orbit; this.radius = planetSettings.minRadius + noise.newValueFromCoords(position) * planetSettings.radiusMultiplier; this.orbit = orbit; this.speed = noise.newValueFromCoords(position) * planetSettings.speedMultiplier; //MAKING GameObject planet = new GameObject("Planet"); initialize(planet); generateMesh(); planet.transform.position = solarSysCenter + Vector3.left * this.orbit; planet.transform.localScale = Vector3.one * radius; planet.AddComponent(typeof(PlanetBehavior)); planet.GetComponent <PlanetBehavior>().center = solarSysCenter; planet.GetComponent <PlanetBehavior>().radius = this.orbit; planet.GetComponent <PlanetBehavior>().speed = speed; }
public void Fill(PlanetSettings settings, UnityAction clickAction) { name = settings.name; _textPlanetName.text = settings.Name; _buttonPlanetLoad.onClick.AddListener(clickAction); }
public void Create(System.Random GameRNG, Zenith.Database database, PlanetSettings planetSettings) { this.GameRNG = GameRNG; PlanetSettings = planetSettings; Database = database; StartCoroutine(GenWorldOnSecondThread(GameRNG)); }
public void AssignLevelSettings(PlanetSettings settings) { planetTileCount = settings.planetTileCount; minTilesBetweenDeployPoint = settings.minTilesBetweenDeployPoint; planetHeatDistance = settings.planetHeatDistance; _currentSettings = settings; }
public TerrainFace(Mesh mesh, Vector3 up, PlanetSettings settings) { this.mesh = mesh; this.settings = settings; this.TerrainMinMax = new MinMax(); this.elevationCalculator = new ElevationCalculator(settings.LayerSettings); this.localYAxis = up; }
void OnEnable() { if (instance != null) { Destroy(gameObject); return; } instance = this; }
public void SpawnMeteor() { _PlanetTagToSpawn = _Player.GetComponent <Gravity>()._PlanetTag; PlanetSettings PlanetToSpawnSettings = GameObject.FindGameObjectWithTag(_PlanetTagToSpawn).GetComponent <PlanetSettings>(); GameObject newMeteor = Instantiate(_MeteorPrefab, PlanetToSpawnSettings._PlanetPosition, Quaternion.identity); newMeteor.transform.rotation = Quaternion.Euler(new Vector3(UnityEngine.Random.Range(0, 360), UnityEngine.Random.Range(0, 360), UnityEngine.Random.Range(0, 360))); newMeteor.transform.position = PlanetToSpawnSettings._PlanetPosition + newMeteor.transform.up * (PlanetToSpawnSettings._PlanetSize * 200); }
private Button InitNewPlanetButton(PlanetSettings planetSettings) { Button newPlanetButton = Instantiate(planetsButtonsPrefab, planetsButtonsParent); newPlanetButton.gameObject.name = planetSettings.PlanetName; newPlanetButton.image.color = planetSettings.SkyColor; newPlanetButton.gameObject.GetComponentInChildren <Text>().text = planetSettings.PlanetName; return(newPlanetButton); }
private void Start() { _CurPlanetSettings = gameObject.GetComponent <PlanetSettings>(); int ammoutToSpawn = (int)(200 * Mathf.Pow(_CurPlanetSettings._PlanetSize, 2f)); for (int i = 0; i < ammoutToSpawn; i++) { SpawnPref(); } }
public Planet(Zenith.Database database, PlanetSettings planetSettings, Random GameRNG) { Database = database; PlanetSettings = planetSettings; caves = Mathf.Max(planetSettings.worldSize.x, planetSettings.worldSize.y) / 16; caveLengthBoost = planetSettings.caveLengthBoost; stonePockets = Mathf.Max(planetSettings.worldSize.x, planetSettings.worldSize.y) / 32; blocks = new Tile[planetSettings.worldSize.x, planetSettings.worldSize.y]; blocksBG = new Tile[planetSettings.worldSize.x, planetSettings.worldSize.y]; GenHeight = new int[planetSettings.worldSize.x]; random = GameRNG; }
public void SetPlanet(string planetName) { PlanetSettings newPlanetSettings = mainSettings.FindPlanetSettings(planetName); if (newPlanetSettings == null) { throw new ArgumentException($"Unknown planet {planetName}"); } Physics2D.gravity = Vector2.down * newPlanetSettings.Gravity; camera.backgroundColor = newPlanetSettings.SkyColor; }
public void StartGame(PlanetSettings planet) { Debug.Log("Start game, Planet " + planet.id); Physics2D.gravity = Vector2.down * planet.gravity; this.CurrentPlanet = planet; this.IsValidGame = true; sceneManager.SwitchScene(Scenes.GAME); this.signalBus.Fire(new OnGameStart()); }
public GasGiant(PlanetSettings settings, GasGiantData data, Orbit orbit) : base(settings, data, orbit) { GasGiantData = data; GravityWavesDepth = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.WaveDepthMultiplier, (mass, depth) => settings.WaveDepth.Evaluate(mass) * depth)); GravityWavesRadius = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.WaveRadiusMultiplier, (mass, radius) => settings.WaveRadius.Evaluate(mass) * radius)); GravityWavesSpeed = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.WaveSpeedMultiplier, (mass, speed) => settings.WaveSpeed.Evaluate(mass) * speed)); }
public Planet(PlanetSettings settings, BodyData data, Orbit orbit) { Orbit = orbit; BodyData = data; BodyRadius = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.BodyRadiusMultiplier, (mass, radius) => settings.BodyRadius.Evaluate(mass) * radius)); GravityWellRadius = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.GravityRadiusMultiplier, (mass, radius) => settings.GravityRadius.Evaluate(mass) * radius)); GravityWellDepth = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.GravityDepthMultiplier, (mass, depth) => settings.GravityDepth.Evaluate(mass) * depth)); }
void SetPlanetSettings() { PlanetSettings ps1 = new PlanetSettings(); ps1.minimumLevelTime = 120f; ps1.maximumLevelTime = 180f; ps1.maximumLevelID = 8; ps1.planetID = 1; planetSettings.Add(1, ps1); PlanetSettings ps2 = new PlanetSettings(); ps2.minimumLevelTime = 120f; ps2.maximumLevelTime = 180f; ps2.maximumLevelID = 10; ps2.planetID = 2; planetSettings.Add(2, ps2); PlanetSettings ps3 = new PlanetSettings(); ps3.minimumLevelTime = 210f; ps3.maximumLevelTime = 270f; ps3.maximumLevelID = 12; ps3.planetID = 3; planetSettings.Add(3, ps3); PlanetSettings ps4 = new PlanetSettings(); ps4.minimumLevelTime = 210f; ps4.maximumLevelTime = 270f; ps4.maximumLevelID = 8; ps4.planetID = 4; planetSettings.Add(4, ps4); PlanetSettings ps5 = new PlanetSettings(); ps5.minimumLevelTime = 270f; ps5.maximumLevelTime = 350f; ps5.maximumLevelID = 10; ps5.planetID = 5; planetSettings.Add(5, ps5); PlanetSettings ps6 = new PlanetSettings(); ps6.minimumLevelTime = 270f; ps6.maximumLevelTime = 350f; ps6.maximumLevelID = 12; ps6.planetID = 6; planetSettings.Add(6, ps6); }
public PlanetSettings GeneratePlanet() { WorldSize worldSize = Database.WorldDatabase.World.sizes[Utils.RandomInt(random, 0, Database.WorldDatabase.World.sizes.Length)]; int oreSamples = Database.WorldDatabase.World.oreSamples[Utils.RandomInt(random, 0, Database.WorldDatabase.World.oreSamples.Length)]; double heightBoost = Database.WorldDatabase.World.heightBoost[Utils.RandomInt(random, 0, Database.WorldDatabase.World.heightBoost.Length)]; List <string> ores = new List <string>(); for (int i = 0; i < oreSamples; i++) { ores.Add(Database.WorldDatabase.World.ores[Utils.RandomInt(random, 0, Database.WorldDatabase.World.ores.Length)]); } float oreLengthBoost = Database.WorldDatabase.World.oreLengthBoost[Utils.RandomInt(random, 0, Database.WorldDatabase.World.oreLengthBoost.Length)]; float caveLengthBoost = Database.WorldDatabase.World.caveLengthBoost[Utils.RandomInt(random, 0, Database.WorldDatabase.World.caveLengthBoost.Length)]; string biome = Database.WorldDatabase.World.biomes[Utils.RandomInt(random, 0, Database.WorldDatabase.World.biomes.Length)]; string surfaceTile = Database.BiomeDatabase.BiomeDictionary[biome].surfaceTile; string middleTile = Database.BiomeDatabase.BiomeDictionary[biome].middleTile; string undergroundTile = Database.BiomeDatabase.BiomeDictionary[biome].undergroundTile; string[] features = Database.BiomeDatabase.BiomeDictionary[biome].features; PlanetSettings settings = new PlanetSettings { worldSize = worldSize, heightBoost = heightBoost, ores = ores.ToArray(), oreLengthBoost = oreLengthBoost, caveLengthBoost = caveLengthBoost, biome = biome, surfaceTile = surfaceTile, middleTile = middleTile, undergroundTile = undergroundTile, features = features }; Debug.Log("GENERALMANAGER:GENERATEPLANET():PLANETSETTINGS:"); settings.DebugPrint(); return(settings); }
public override void OnInspectorGUI() { _planetSettings = (PlanetSettings)target; SerializedObject planetSettings = new SerializedObject(target); CustomEditorHelpers.DrawHeader("Planet settings"); _planetSettings.Resolution = (int)EditorGUILayout.Slider("Resolution", _planetSettings.Resolution, 2, 128); _planetSettings.Radius = (int)EditorGUILayout.Slider("Radius", _planetSettings.Radius, 2, 128); EditorGUILayout.PropertyField(planetSettings.FindProperty("NoiseSettings")); CustomEditorHelpers.DrawHeader("Color settings"); _planetSettings.ColorSettings.Gradient = EditorGUILayout.GradientField("Gradient", _planetSettings.ColorSettings.Gradient); planetSettings.ApplyModifiedProperties(); }
public static void ApplyFileDefaults() { if (FlightGlobals.fetch == null || FlightGlobals.Bodies == null) { Extensions.Log("Could not apply planet defaults: FlightGlobals.Bodies was null"); return; } _haveAppliedDefaults = true; foreach (var body in FlightGlobals.Bodies) { new PlanetSettings(body); // trigger default settings check var filepath = IoExt.GetPath(body.bodyName + ".cfg"); if (System.IO.File.Exists(filepath) == false) { continue; } var cfg = ConfigNode.Load(filepath); Extensions.Log("Applying saved config for " + body.bodyName); PlanetSettings.ApplyConfig(cfg, body); } }
public void GenerateCube(PlanetSettings planetSettings, PlanetNoiseSettings noiseSettings, Planet planet, int chunkX, int chunkZ, int chunkY) { _meshFilter = GetComponent <MeshFilter>(); _meshCollider = GetComponent <MeshCollider>(); _planetSettings = planetSettings; _noiseSettings = noiseSettings; _chunkX = chunkX; _chunkZ = chunkZ; _chunkY = chunkY; _data = new float[_planetSettings.chunkResolution, _planetSettings.worldHeight, _planetSettings.chunkResolution]; float size = (float)_planetSettings.chunkSize / _planetSettings.chunkResolution; for (int x = 0; x < _planetSettings.chunkResolution; x++) { for (int z = 0; z < _planetSettings.chunkResolution; z++) { float posX = x * size; float posZ = z * size; float posY = 0; Vector3 sphereCoordinates = new Vector3(posX, posZ, posY) + transform.localPosition; sphereCoordinates.Normalize(); Vector3 pos = sphereCoordinates * planetSettings.radius; float height = Noise.Value(pos.x, pos.y, pos.z, noiseSettings); height *= _planetSettings.worldHeight; for (int h = 0; h < (int)height; h++) { _data[x, h, z] = 1; } } } GenerateMesh(_planetSettings.surfaceCrossValue, planet, _planetSettings.chunkResolution); }
public static void SavePlanet(CelestialBody body) { PlanetSettings.GetConfig(body).Save(); }
private void SelectPlanet(PlanetSettings s) { Debug.Log($"You have selected {s.name} planet! Prepare to landing..."); _persistent.SetPlanet(s); SceneManager.LoadScene(_gameScene); }
public void UpdateSettings(PlanetSettings settings) { this.settings = settings; this.elevationCalculator.Update(settings.LayerSettings); this.UpdateMesh(); }
public Orbit(PlanetSettings settings, OrbitData data) { Data = data; Period = new ReadOnlyReactiveProperty <float>(data.Distance.Select(f => settings.OrbitPeriod.Evaluate(f))); }
public void UpdateSettings(PlanetSettings settings) { this.settings = settings; this.UpdateMesh(); }
private void OnPlanetSelected(PlanetSettings settings) { Session.Current.SetPlanetSettings(settings); SceneManager.LoadScene(_sceneIndex, LoadSceneMode.Single); }
public void RevealStartingPlanets(PlanetSettings settings) { int totalPlanetsRevealed = 0; int planetCount = _allPlanetTiles.Count; //int totalDistance = 0; //int averageDistance = 0; //foreach (var planet in _allPlanetTiles) //{ // totalDistance += planet.DistanceRating; //} //averageDistance = totalDistance / planetCount; //Debug.Log("Average distance : " + averageDistance); List <GridTile_Planet> allCandidatePlanets = new List <GridTile_Planet>(_allPlanetTiles); List <GridTile_Planet> closePlanets = new List <GridTile_Planet>(); List <GridTile_Planet> farPlanets = new List <GridTile_Planet>(); //foreach (var planet in _allPlanetTiles) //{ // if (planet.DistanceRating >= averageDistance) // farPlanets.Add(planet); // else // closePlanets.Add(planet); //} int closeCount = closePlanets.Count; int farCount = farPlanets.Count; for (int i = 0; i < settings.planetsRevealedCloseToDeploy; i++) { if (i < closeCount) { int randomIndex = UnityEngine.Random.Range(0, closeCount); closePlanets[randomIndex].RevealPlanet(true); //Debug.Log("Close planet chosen : " + closePlanets[randomIndex].DistanceRating); allCandidatePlanets.Remove(closePlanets[randomIndex]); closePlanets.RemoveAt(randomIndex); closeCount--; totalPlanetsRevealed++; } else { break; } } for (int i = 0; i < settings.planetsRevealedFarFromDeploy; i++) { if (i < farCount) { int randomIndex = UnityEngine.Random.Range(0, farCount); farPlanets[randomIndex].RevealPlanet(true); //Debug.Log("Far planet chosen : " + farPlanets[randomIndex].DistanceRating); allCandidatePlanets.Remove(farPlanets[randomIndex]); farPlanets.RemoveAt(randomIndex); farCount--; totalPlanetsRevealed++; } else { break; } } while (totalPlanetsRevealed < settings.planetsRevealedOnStart) { int allCandidatesCount = allCandidatePlanets.Count; if (allCandidatesCount == 0) { break; } int randomIndex = UnityEngine.Random.Range(0, allCandidatesCount); allCandidatePlanets[randomIndex].RevealPlanet(true); allCandidatePlanets.RemoveAt(randomIndex); totalPlanetsRevealed++; } }
public Sun(PlanetSettings settings, SunData data, Orbit orbit) : base(settings, data, orbit) { LightRadius = new ReadOnlyReactiveProperty <float>( data.Mass.CombineLatest(data.LightRadiusMultiplier, (mass, radius) => settings.LightRadius.Evaluate(mass) * radius)); }
public ShapeGenerator(int seed, PlanetSettings settings) { this.seed = seed; this.settings = settings; }
public WaterFace(Mesh mesh, Vector3 up, PlanetSettings settings) { this.mesh = mesh; this.localYAxis = up; this.settings = settings; }