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;
}
