1215 lines
36 KiB
C#
1215 lines
36 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using Gaia.FullSerializer;
|
|
using GaiaCommon1;
|
|
using UnityEngine;
|
|
|
|
namespace Gaia
|
|
{
|
|
[ExecuteInEditMode]
|
|
public class GaiaSessionManager : MonoBehaviour
|
|
{
|
|
public IEnumerator m_updateSessionCoroutine;
|
|
|
|
public IEnumerator m_updateOperationCoroutine;
|
|
|
|
private bool m_cancelPlayback;
|
|
|
|
public GaiaSession m_session;
|
|
|
|
public bool m_focusSceneView = true;
|
|
|
|
public bool m_genShowRandomGenerator;
|
|
|
|
public bool m_genShowTerrainHelper;
|
|
|
|
public GaiaConstants.GeneratorBorderStyle m_genBorderStyle = GaiaConstants.GeneratorBorderStyle.Water;
|
|
|
|
public int m_genGridSize = 3;
|
|
|
|
public int m_genNumStampsToGenerate = 10;
|
|
|
|
public float m_genScaleWidth = 10f;
|
|
|
|
public float m_genScaleHeight = 4f;
|
|
|
|
public float m_genChanceOfHills = 0.7f;
|
|
|
|
public float m_genChanceOfIslands;
|
|
|
|
public float m_genChanceOfLakes;
|
|
|
|
public float m_genChanceOfMesas = 0.1f;
|
|
|
|
public float m_genChanceOfMountains = 0.1f;
|
|
|
|
public float m_genChanceOfPlains;
|
|
|
|
public float m_genChanceOfRivers = 0.1f;
|
|
|
|
public float m_genChanceOfValleys;
|
|
|
|
public float m_genChanceOfVillages;
|
|
|
|
public float m_genChanceOfWaterfalls;
|
|
|
|
[fsIgnore]
|
|
public Stamper m_currentStamper;
|
|
|
|
[fsIgnore]
|
|
public Spawner m_currentSpawner;
|
|
|
|
[fsIgnore]
|
|
public DateTime m_lastUpdateDateTime = DateTime.Now;
|
|
|
|
[fsIgnore]
|
|
public ulong m_progress;
|
|
|
|
private List<string> m_genHillStamps = new List<string>();
|
|
|
|
private List<string> m_genIslandStamps = new List<string>();
|
|
|
|
private List<string> m_genLakeStamps = new List<string>();
|
|
|
|
private List<string> m_genMesaStamps = new List<string>();
|
|
|
|
private List<string> m_genMountainStamps = new List<string>();
|
|
|
|
private List<string> m_genPlainsStamps = new List<string>();
|
|
|
|
private List<string> m_genRiverStamps = new List<string>();
|
|
|
|
private List<string> m_genValleyStamps = new List<string>();
|
|
|
|
private List<string> m_genVillageStamps = new List<string>();
|
|
|
|
private List<string> m_genWaterfallStamps = new List<string>();
|
|
|
|
public static GaiaSessionManager GetSessionManager(bool pickupExistingTerrain = false)
|
|
{
|
|
GameObject gameObject = GameObject.Find("Gaia");
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = new GameObject("Gaia");
|
|
}
|
|
GaiaSessionManager gaiaSessionManager = null;
|
|
GameObject gameObject2 = GameObject.Find("Session Manager");
|
|
if (gameObject2 == null)
|
|
{
|
|
gameObject2 = new GameObject("Session Manager");
|
|
gaiaSessionManager = gameObject2.AddComponent<GaiaSessionManager>();
|
|
gaiaSessionManager.CreateSession(pickupExistingTerrain);
|
|
gameObject2.transform.parent = gameObject.transform;
|
|
gameObject2.transform.position = TerrainHelper.GetActiveTerrainCenter();
|
|
}
|
|
else
|
|
{
|
|
gaiaSessionManager = gameObject2.GetComponent<GaiaSessionManager>();
|
|
}
|
|
return gaiaSessionManager;
|
|
}
|
|
|
|
public bool IsLocked()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
CreateSession();
|
|
}
|
|
return m_session.m_isLocked;
|
|
}
|
|
|
|
public bool LockSession()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
CreateSession();
|
|
}
|
|
bool isLocked = m_session.m_isLocked;
|
|
m_session.m_isLocked = true;
|
|
if (!isLocked)
|
|
{
|
|
SaveSession();
|
|
}
|
|
return isLocked;
|
|
}
|
|
|
|
public bool UnLockSession()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
CreateSession();
|
|
}
|
|
bool isLocked = m_session.m_isLocked;
|
|
m_session.m_isLocked = false;
|
|
if (isLocked)
|
|
{
|
|
SaveSession();
|
|
}
|
|
return isLocked;
|
|
}
|
|
|
|
public void AddOperation(GaiaOperation operation)
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant add operation on locked session");
|
|
return;
|
|
}
|
|
m_session.m_operations.Add(operation);
|
|
SaveSession();
|
|
}
|
|
|
|
public GaiaOperation GetOperation(int operationIdx)
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
CreateSession();
|
|
}
|
|
if (operationIdx < 0 || operationIdx >= m_session.m_operations.Count)
|
|
{
|
|
return null;
|
|
}
|
|
return m_session.m_operations[operationIdx];
|
|
}
|
|
|
|
public void RemoveOperation(int operationIdx)
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant remove operation on locked session");
|
|
}
|
|
else if (operationIdx >= 0 && operationIdx < m_session.m_operations.Count)
|
|
{
|
|
m_session.m_operations.RemoveAt(operationIdx);
|
|
SaveSession();
|
|
}
|
|
}
|
|
|
|
public void AddResource(GaiaResource resource)
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant add resource on locked session");
|
|
}
|
|
else if (resource != null)
|
|
{
|
|
m_session.m_resources.ContainsKey(resource.m_resourcesID + resource.name);
|
|
}
|
|
}
|
|
|
|
public void AddDefaults(GaiaDefaults defaults)
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant add defaults on locked session");
|
|
}
|
|
else
|
|
{
|
|
_ = defaults != null;
|
|
}
|
|
}
|
|
|
|
public void AddPreviewImage(Texture2D image)
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant add preview on locked session");
|
|
return;
|
|
}
|
|
m_session.m_previewImageWidth = image.width;
|
|
m_session.m_previewImageHeight = image.height;
|
|
m_session.m_previewImageBytes = image.GetRawTextureData();
|
|
SaveSession();
|
|
}
|
|
|
|
public bool HasPreviewImage()
|
|
{
|
|
if (m_session.m_previewImageWidth > 0 && m_session.m_previewImageHeight > 0 && m_session.m_previewImageBytes.GetLength(0) > 0)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void RemovePreviewImage()
|
|
{
|
|
if (IsLocked())
|
|
{
|
|
Debug.Log("Cant remove preview on locked session");
|
|
return;
|
|
}
|
|
m_session.m_previewImageWidth = 0;
|
|
m_session.m_previewImageHeight = 0;
|
|
m_session.m_previewImageBytes = new byte[0];
|
|
SaveSession();
|
|
}
|
|
|
|
public Texture2D GetPreviewImage()
|
|
{
|
|
if (m_session.m_previewImageBytes.GetLength(0) == 0)
|
|
{
|
|
return null;
|
|
}
|
|
Texture2D texture2D = new Texture2D(m_session.m_previewImageWidth, m_session.m_previewImageHeight, TextureFormat.ARGB32, mipChain: false);
|
|
texture2D.LoadRawTextureData(m_session.m_previewImageBytes);
|
|
texture2D.Apply();
|
|
texture2D.name = m_session.m_name;
|
|
return texture2D;
|
|
}
|
|
|
|
public void SaveSession()
|
|
{
|
|
}
|
|
|
|
public void StartEditorUpdates()
|
|
{
|
|
}
|
|
|
|
public void StopEditorUpdates()
|
|
{
|
|
m_currentSpawner = null;
|
|
m_currentStamper = null;
|
|
m_updateOperationCoroutine = null;
|
|
m_updateSessionCoroutine = null;
|
|
}
|
|
|
|
private void EditorUpdate()
|
|
{
|
|
if (m_cancelPlayback)
|
|
{
|
|
if (m_currentSpawner != null)
|
|
{
|
|
m_currentSpawner.CancelSpawn();
|
|
}
|
|
if (m_currentStamper != null)
|
|
{
|
|
m_currentStamper.CancelStamp();
|
|
}
|
|
StopEditorUpdates();
|
|
}
|
|
else if (m_updateSessionCoroutine == null && m_updateOperationCoroutine == null)
|
|
{
|
|
StopEditorUpdates();
|
|
}
|
|
else if (m_updateOperationCoroutine != null)
|
|
{
|
|
m_updateOperationCoroutine.MoveNext();
|
|
}
|
|
else
|
|
{
|
|
m_updateSessionCoroutine.MoveNext();
|
|
}
|
|
}
|
|
|
|
public GaiaSession CreateSession(bool pickupExistingTerrain = false)
|
|
{
|
|
m_session = ScriptableObject.CreateInstance<GaiaSession>();
|
|
m_session.m_description = "Rocking out at Creativity Central! If you like Gaia please consider rating it :)";
|
|
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
|
|
if (gaiaSettings != null && gaiaSettings.m_currentDefaults != null)
|
|
{
|
|
m_session.m_seaLevel = gaiaSettings.m_currentDefaults.m_seaLevel;
|
|
}
|
|
Terrain activeTerrain = TerrainHelper.GetActiveTerrain();
|
|
if (activeTerrain != null)
|
|
{
|
|
m_session.m_terrainWidth = (int)activeTerrain.terrainData.size.x;
|
|
m_session.m_terrainDepth = (int)activeTerrain.terrainData.size.z;
|
|
m_session.m_terrainHeight = (int)activeTerrain.terrainData.size.y;
|
|
if (pickupExistingTerrain)
|
|
{
|
|
GaiaDefaults gaiaDefaults = ScriptableObject.CreateInstance<GaiaDefaults>();
|
|
gaiaDefaults.UpdateFromTerrain();
|
|
GaiaResource gaiaResource = ScriptableObject.CreateInstance<GaiaResource>();
|
|
gaiaResource.UpdatePrototypesFromTerrain();
|
|
gaiaResource.ChangeSeaLevel(m_session.m_seaLevel);
|
|
AddDefaults(gaiaDefaults);
|
|
AddResource(gaiaResource);
|
|
AddOperation(gaiaDefaults.GetTerrainCreationOperation(gaiaResource));
|
|
}
|
|
}
|
|
else if (gaiaSettings != null && gaiaSettings.m_currentDefaults != null)
|
|
{
|
|
m_session.m_terrainWidth = gaiaSettings.m_currentDefaults.m_terrainSize;
|
|
m_session.m_terrainDepth = gaiaSettings.m_currentDefaults.m_terrainHeight;
|
|
m_session.m_terrainHeight = gaiaSettings.m_currentDefaults.m_terrainSize;
|
|
}
|
|
float num = 0.0048828125f;
|
|
float num2 = 0.001953125f;
|
|
float num3 = 0.024414062f;
|
|
float num4 = m_session.m_terrainWidth;
|
|
float num5 = m_session.m_terrainHeight;
|
|
m_genScaleWidth = Mathf.Clamp(num4 * num, 0.1f, 40f);
|
|
m_genScaleHeight = Mathf.Clamp(num5 * num2, 0.1f, 16f);
|
|
m_session.m_seaLevel = Mathf.Clamp(num5 * num3, 0f, 150f);
|
|
return m_session;
|
|
}
|
|
|
|
public void SetSeaLevel(float seaLevel)
|
|
{
|
|
m_session.m_seaLevel = seaLevel;
|
|
}
|
|
|
|
public float GetSeaLevel()
|
|
{
|
|
if (m_session != null)
|
|
{
|
|
return m_session.m_seaLevel;
|
|
}
|
|
GaiaSettings gaiaSettings = GaiaUtils.GetGaiaSettings();
|
|
if (gaiaSettings != null)
|
|
{
|
|
return gaiaSettings.m_currentDefaults.m_seaLevel;
|
|
}
|
|
return 50f;
|
|
}
|
|
|
|
public void ResetSession()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
Debug.LogError("Can not erase the session as there is no existing session!");
|
|
}
|
|
else if (m_session.m_isLocked)
|
|
{
|
|
Debug.LogError("Can not erase the session as it is locked!");
|
|
}
|
|
else if (m_session.m_operations.Count > 1)
|
|
{
|
|
GaiaOperation gaiaOperation = m_session.m_operations[0];
|
|
m_session.m_operations.Clear();
|
|
if (gaiaOperation.m_operationType == GaiaOperation.OperationType.CreateTerrain)
|
|
{
|
|
AddOperation(gaiaOperation);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RandomiseStamps()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
Debug.LogError("Can not randomise stamps as there is no existing session!");
|
|
return;
|
|
}
|
|
if (m_session.m_isLocked)
|
|
{
|
|
Debug.LogError("Can not randomise stamps as the existing session is locked!");
|
|
return;
|
|
}
|
|
Terrain activeTerrain = TerrainHelper.GetActiveTerrain();
|
|
if (activeTerrain == null)
|
|
{
|
|
GaiaSettings gaiaSettings = (GaiaSettings)GaiaUtils.GetAssetScriptableObject("GaiaSettings");
|
|
if (gaiaSettings == null)
|
|
{
|
|
Debug.LogError("Can not randomise stamps as we are missing the terrain and settings!");
|
|
return;
|
|
}
|
|
GaiaDefaults currentDefaults = gaiaSettings.m_currentDefaults;
|
|
GaiaResource currentResources = gaiaSettings.m_currentResources;
|
|
if (currentDefaults == null || currentResources == null)
|
|
{
|
|
Debug.LogError("Can not randomise stamps as we are missing the terrain defaults or resources!");
|
|
return;
|
|
}
|
|
currentDefaults.CreateTerrain(currentResources);
|
|
activeTerrain = TerrainHelper.GetActiveTerrain();
|
|
}
|
|
Bounds bounds = default(Bounds);
|
|
TerrainHelper.GetTerrainBounds(activeTerrain, ref bounds);
|
|
GameObject gameObject = GameObject.Find("Gaia");
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = new GameObject("Gaia");
|
|
}
|
|
Stamper stamper = null;
|
|
GameObject gameObject2 = GameObject.Find("Stamper");
|
|
if (gameObject2 == null)
|
|
{
|
|
gameObject2 = new GameObject("Stamper");
|
|
gameObject2.transform.parent = gameObject.transform;
|
|
stamper = gameObject2.AddComponent<Stamper>();
|
|
}
|
|
else
|
|
{
|
|
stamper = gameObject2.GetComponent<Stamper>();
|
|
}
|
|
float num = 1f;
|
|
if (m_genNumStampsToGenerate > 1)
|
|
{
|
|
num = Mathf.Sqrt((float)m_genNumStampsToGenerate - 1f);
|
|
if (!GaiaUtils.Math_ApproximatelyEqual(0f, num % 1f))
|
|
{
|
|
m_genNumStampsToGenerate = Mathf.CeilToInt(num);
|
|
m_genNumStampsToGenerate = m_genNumStampsToGenerate * m_genNumStampsToGenerate + 1;
|
|
}
|
|
num = Mathf.Sqrt((float)m_genNumStampsToGenerate - 1f);
|
|
}
|
|
for (int i = 0; i < m_genNumStampsToGenerate; i++)
|
|
{
|
|
string imagePreviewPath = "";
|
|
GaiaConstants.FeatureType featureType = GaiaConstants.FeatureType.Hills;
|
|
stamper.LoadStamp(imagePreviewPath);
|
|
stamper.FitToTerrain();
|
|
stamper.HidePreview();
|
|
if (m_session.m_operations.Count <= 1)
|
|
{
|
|
float width = stamper.m_width;
|
|
PositionStamp(bounds, stamper, featureType);
|
|
stamper.m_rotation = 0f;
|
|
stamper.m_x = 0f;
|
|
stamper.m_z = 0f;
|
|
stamper.m_width = width;
|
|
if (m_genBorderStyle == GaiaConstants.GeneratorBorderStyle.Mountains)
|
|
{
|
|
stamper.m_distanceMask = new AnimationCurve(new Keyframe(1f, 1f), new Keyframe(1f, 1f));
|
|
stamper.m_areaMaskMode = GaiaConstants.ImageFitnessFilterMode.ImageGreyScale;
|
|
stamper.m_imageMask = GaiaUtils.GetAsset("Island Mask 1.jpg", typeof(Texture2D)) as Texture2D;
|
|
stamper.m_imageMaskNormalise = true;
|
|
stamper.m_imageMaskInvert = true;
|
|
}
|
|
else
|
|
{
|
|
stamper.m_distanceMask = new AnimationCurve(new Keyframe(1f, 1f), new Keyframe(1f, 1f));
|
|
stamper.m_areaMaskMode = GaiaConstants.ImageFitnessFilterMode.ImageGreyScale;
|
|
stamper.m_imageMask = GaiaUtils.GetAsset("Island Mask 1.jpg", typeof(Texture2D)) as Texture2D;
|
|
stamper.m_imageMaskNormalise = true;
|
|
stamper.m_imageMaskInvert = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num2 = (i - 1) % (int)num;
|
|
int num3 = (i - 1) / (int)num;
|
|
float num4 = 1f / num;
|
|
float num5 = num4 / 2f;
|
|
float suggestZ = num5 + num4 * (float)num2;
|
|
float suggestX = num5 + num4 * (float)num3;
|
|
PositionStampV2(bounds, stamper, featureType, suggestX, suggestZ, num5);
|
|
float num6 = UnityEngine.Random.Range(0f, 1f);
|
|
if (num6 < 0.1f)
|
|
{
|
|
stamper.m_stampOperation = GaiaConstants.FeatureOperation.LowerHeight;
|
|
stamper.m_invertStamp = true;
|
|
}
|
|
else if (num6 < 0.35f)
|
|
{
|
|
stamper.m_stampOperation = GaiaConstants.FeatureOperation.StencilHeight;
|
|
stamper.m_normaliseStamp = true;
|
|
if (featureType == GaiaConstants.FeatureType.Rivers || featureType == GaiaConstants.FeatureType.Lakes)
|
|
{
|
|
stamper.m_invertStamp = true;
|
|
stamper.m_stencilHeight = UnityEngine.Random.Range(-80f, -5f);
|
|
}
|
|
else if (UnityEngine.Random.Range(0f, 1f) < 0.5f)
|
|
{
|
|
stamper.m_invertStamp = true;
|
|
stamper.m_stencilHeight = UnityEngine.Random.Range(-80f, -5f);
|
|
}
|
|
else
|
|
{
|
|
stamper.m_invertStamp = false;
|
|
stamper.m_stencilHeight = UnityEngine.Random.Range(5f, 80f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stamper.m_stampOperation = GaiaConstants.FeatureOperation.RaiseHeight;
|
|
stamper.m_invertStamp = false;
|
|
}
|
|
}
|
|
stamper.UpdateStamp();
|
|
stamper.AddToSession(GaiaOperation.OperationType.Stamp, "Stamping " + stamper.m_stampPreviewImage.name);
|
|
}
|
|
}
|
|
|
|
private void PositionStamp(Bounds bounds, Stamper stamper, GaiaConstants.FeatureType stampType)
|
|
{
|
|
float baseLevel = 0f;
|
|
float minHeight = 0f;
|
|
float maxHeight = 0f;
|
|
float num = stamper.m_height * 4f;
|
|
float num2 = 0f;
|
|
if ((float)m_session.m_terrainHeight > 0f)
|
|
{
|
|
num2 = m_session.m_seaLevel / (float)m_session.m_terrainHeight;
|
|
}
|
|
if (stamper.GetHeightRange(ref baseLevel, ref minHeight, ref maxHeight))
|
|
{
|
|
stamper.m_stampOperation = GaiaConstants.FeatureOperation.RaiseHeight;
|
|
stamper.m_invertStamp = false;
|
|
stamper.m_normaliseStamp = false;
|
|
stamper.m_rotation = UnityEngine.Random.Range(-179f, 179f);
|
|
stamper.m_width = UnityEngine.Random.Range(0.7f, 1.3f) * m_genScaleWidth;
|
|
stamper.m_height = UnityEngine.Random.Range(0.7f, 1.3f) * m_genScaleHeight;
|
|
float num3 = stamper.m_height / num * (float)m_session.m_terrainHeight;
|
|
float num4 = num3 / 2f;
|
|
float num5 = num2 * (float)m_session.m_terrainHeight;
|
|
stamper.m_stickBaseToGround = false;
|
|
stamper.m_y = num4 + num5 - baseLevel * num3;
|
|
float num6 = 1f;
|
|
if (m_genBorderStyle == GaiaConstants.GeneratorBorderStyle.None)
|
|
{
|
|
stamper.m_x = UnityEngine.Random.Range(0f - bounds.extents.x, bounds.extents.x);
|
|
stamper.m_z = UnityEngine.Random.Range(0f - bounds.extents.z, bounds.extents.z);
|
|
}
|
|
else if (m_genBorderStyle == GaiaConstants.GeneratorBorderStyle.Mountains)
|
|
{
|
|
num6 = 0.85f;
|
|
stamper.m_x = UnityEngine.Random.Range(0f - bounds.extents.x * num6, bounds.extents.x * num6);
|
|
stamper.m_z = UnityEngine.Random.Range(0f - bounds.extents.z * num6, bounds.extents.z * num6);
|
|
}
|
|
else
|
|
{
|
|
num6 = 0.75f;
|
|
stamper.m_x = UnityEngine.Random.Range(0f - bounds.extents.x * num6, bounds.extents.x * num6);
|
|
stamper.m_z = UnityEngine.Random.Range(0f - bounds.extents.z * num6, bounds.extents.z * num6);
|
|
}
|
|
stamper.m_distanceMask = new AnimationCurve(new Keyframe(0f, 1f), new Keyframe(1f, 0f));
|
|
stamper.m_areaMaskMode = GaiaConstants.ImageFitnessFilterMode.None;
|
|
stamper.m_imageMask = null;
|
|
}
|
|
}
|
|
|
|
private void PositionStampV2(Bounds bounds, Stamper stamper, GaiaConstants.FeatureType stampType, float suggestX, float suggestZ, float suggestJitter)
|
|
{
|
|
float baseLevel = 0f;
|
|
float minHeight = 0f;
|
|
float maxHeight = 0f;
|
|
float num = stamper.m_height * 4f;
|
|
float num2 = 0f;
|
|
if ((float)m_session.m_terrainHeight > 0f)
|
|
{
|
|
num2 = m_session.m_seaLevel / (float)m_session.m_terrainHeight;
|
|
}
|
|
if (stamper.GetHeightRange(ref baseLevel, ref minHeight, ref maxHeight))
|
|
{
|
|
stamper.m_stampOperation = GaiaConstants.FeatureOperation.RaiseHeight;
|
|
stamper.m_invertStamp = false;
|
|
stamper.m_normaliseStamp = false;
|
|
stamper.m_rotation = UnityEngine.Random.Range(-179f, 179f);
|
|
stamper.m_width = UnityEngine.Random.Range(0.7f, 1.3f) * m_genScaleWidth;
|
|
stamper.m_height = UnityEngine.Random.Range(0.7f, 1.3f) * m_genScaleHeight;
|
|
float num3 = stamper.m_height / num * (float)m_session.m_terrainHeight;
|
|
float num4 = num3 / 2f;
|
|
float num5 = num2 * (float)m_session.m_terrainHeight;
|
|
stamper.m_stickBaseToGround = false;
|
|
stamper.m_y = num4 + num5 - baseLevel * num3;
|
|
if (m_genBorderStyle == GaiaConstants.GeneratorBorderStyle.Water)
|
|
{
|
|
Vector2 a = new Vector2(suggestX, suggestZ);
|
|
Vector2 b = new Vector2(0.5f, 0.5f);
|
|
float num6 = Vector2.Distance(a, b) * 2f;
|
|
Vector2 vector = Vector2.Lerp(a, b, num6 / 2f);
|
|
suggestX = vector.x;
|
|
suggestZ = vector.y;
|
|
}
|
|
float x = bounds.size.x;
|
|
float z = bounds.size.z;
|
|
float num7 = x * suggestJitter;
|
|
float num8 = z * suggestJitter;
|
|
stamper.m_x = bounds.min.x + suggestX * x + UnityEngine.Random.Range(0f - num7, num7);
|
|
stamper.m_z = bounds.min.z + suggestZ * z + UnityEngine.Random.Range(0f - num8, num8);
|
|
stamper.m_distanceMask = new AnimationCurve(new Keyframe(0f, 1f), new Keyframe(1f, 0f));
|
|
stamper.m_areaMaskMode = GaiaConstants.ImageFitnessFilterMode.None;
|
|
stamper.m_imageMask = null;
|
|
}
|
|
}
|
|
|
|
private GaiaConstants.FeatureType GetWeightedRandomFeatureType()
|
|
{
|
|
float num = UnityEngine.Random.Range(0f, 1f);
|
|
float num2 = m_genChanceOfHills + m_genChanceOfIslands + m_genChanceOfLakes + m_genChanceOfMesas + m_genChanceOfMountains + m_genChanceOfPlains + m_genChanceOfRivers + m_genChanceOfValleys + m_genChanceOfVillages + m_genChanceOfWaterfalls;
|
|
if (num2 == 0f)
|
|
{
|
|
num2 = 1f;
|
|
}
|
|
float num3 = 0f;
|
|
float num4 = 0f;
|
|
num4 = num3 + m_genChanceOfHills / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Hills;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfIslands / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Islands;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfLakes / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Lakes;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfMesas / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Mesas;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfMountains / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Mountains;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfPlains / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Plains;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfRivers / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Rivers;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfValleys / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Valleys;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfVillages / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Villages;
|
|
}
|
|
num3 = num4;
|
|
num4 = num3 + m_genChanceOfWaterfalls / num2;
|
|
if (num >= num3 && num < num4)
|
|
{
|
|
return GaiaConstants.FeatureType.Waterfalls;
|
|
}
|
|
return (GaiaConstants.FeatureType)UnityEngine.Random.Range(2, 7);
|
|
}
|
|
|
|
public string GetRandomStampPath(GaiaConstants.FeatureType featureType)
|
|
{
|
|
switch (featureType)
|
|
{
|
|
case GaiaConstants.FeatureType.Adhoc:
|
|
return "";
|
|
case GaiaConstants.FeatureType.Bases:
|
|
return "";
|
|
case GaiaConstants.FeatureType.Hills:
|
|
if (m_genHillStamps.Count == 0)
|
|
{
|
|
m_genHillStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Hills);
|
|
}
|
|
if (m_genHillStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genHillStamps[UnityEngine.Random.Range(0, m_genHillStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Islands:
|
|
if (m_genIslandStamps.Count == 0)
|
|
{
|
|
m_genIslandStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Islands);
|
|
}
|
|
if (m_genIslandStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genIslandStamps[UnityEngine.Random.Range(0, m_genIslandStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Lakes:
|
|
if (m_genLakeStamps.Count == 0)
|
|
{
|
|
m_genLakeStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Lakes);
|
|
}
|
|
if (m_genLakeStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genLakeStamps[UnityEngine.Random.Range(0, m_genLakeStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Mesas:
|
|
if (m_genMesaStamps.Count == 0)
|
|
{
|
|
m_genMesaStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Mesas);
|
|
}
|
|
if (m_genMesaStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genMesaStamps[UnityEngine.Random.Range(0, m_genMesaStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Mountains:
|
|
if (m_genMountainStamps.Count == 0)
|
|
{
|
|
m_genMountainStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Mountains);
|
|
}
|
|
if (m_genMountainStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genMountainStamps[UnityEngine.Random.Range(0, m_genMountainStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Plains:
|
|
if (m_genPlainsStamps.Count == 0)
|
|
{
|
|
m_genPlainsStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Plains);
|
|
}
|
|
if (m_genPlainsStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genPlainsStamps[UnityEngine.Random.Range(0, m_genPlainsStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Rivers:
|
|
if (m_genRiverStamps.Count == 0)
|
|
{
|
|
m_genRiverStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Rivers);
|
|
}
|
|
if (m_genRiverStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genRiverStamps[UnityEngine.Random.Range(0, m_genRiverStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Rocks:
|
|
return "";
|
|
case GaiaConstants.FeatureType.Valleys:
|
|
if (m_genValleyStamps.Count == 0)
|
|
{
|
|
m_genValleyStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Valleys);
|
|
}
|
|
if (m_genValleyStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genValleyStamps[UnityEngine.Random.Range(0, m_genValleyStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Villages:
|
|
if (m_genVillageStamps.Count == 0)
|
|
{
|
|
m_genVillageStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Villages);
|
|
}
|
|
if (m_genVillageStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genVillageStamps[UnityEngine.Random.Range(0, m_genVillageStamps.Count - 1)];
|
|
case GaiaConstants.FeatureType.Waterfalls:
|
|
if (m_genWaterfallStamps.Count == 0)
|
|
{
|
|
m_genWaterfallStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Waterfalls);
|
|
}
|
|
if (m_genWaterfallStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
return m_genWaterfallStamps[UnityEngine.Random.Range(0, m_genWaterfallStamps.Count - 1)];
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public string GetRandomMountainFieldPath()
|
|
{
|
|
if (m_genMountainStamps.Count == 0)
|
|
{
|
|
m_genMountainStamps = GaiaUtils.GetGaiaStampsList(GaiaConstants.FeatureType.Mountains);
|
|
}
|
|
if (m_genMountainStamps.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
for (num = 0; num < m_genMountainStamps.Count; num++)
|
|
{
|
|
string text = m_genMountainStamps[num];
|
|
if (text.Contains("Field"))
|
|
{
|
|
num2++;
|
|
}
|
|
}
|
|
int num3 = 0;
|
|
int num4 = UnityEngine.Random.Range(0, num2 - 1);
|
|
for (num = 0; num < m_genMountainStamps.Count; num++)
|
|
{
|
|
string text = m_genMountainStamps[num];
|
|
if (text.Contains("Field"))
|
|
{
|
|
if (num3 == num4)
|
|
{
|
|
return text;
|
|
}
|
|
num3++;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public GameObject Apply(int operationIdx)
|
|
{
|
|
if (operationIdx < 0 || operationIdx >= m_session.m_operations.Count)
|
|
{
|
|
Debug.LogWarning($"Can not Apply operation because the index {operationIdx} is out of bounds.");
|
|
return null;
|
|
}
|
|
GaiaOperation gaiaOperation = m_session.m_operations[operationIdx];
|
|
GameObject gameObject = FindOrCreateObject(gaiaOperation);
|
|
if (gameObject == null)
|
|
{
|
|
return gameObject;
|
|
}
|
|
Stamper component = gameObject.GetComponent<Stamper>();
|
|
if (component != null && gaiaOperation.m_operationType == GaiaOperation.OperationType.Stamp)
|
|
{
|
|
component.DeSerialiseJson(gaiaOperation.m_operationDataJson[0]);
|
|
component.m_resources = GaiaUtils.GetAsset(ScriptableObjectWrapper.GetSessionedFileName(m_session.GetSessionFileName(), component.m_resourcesPath), typeof(GaiaResource)) as GaiaResource;
|
|
if (component.m_resources == null)
|
|
{
|
|
ExportSessionResource(component.m_resourcesPath);
|
|
component.m_resources = GaiaUtils.GetAsset(ScriptableObjectWrapper.GetSessionedFileName(m_session.GetSessionFileName(), component.m_resourcesPath), typeof(GaiaResource)) as GaiaResource;
|
|
}
|
|
component.m_seaLevel = m_session.m_seaLevel;
|
|
}
|
|
Spawner component2 = gameObject.GetComponent<Spawner>();
|
|
if (component2 != null && gaiaOperation.m_operationType == GaiaOperation.OperationType.Spawn)
|
|
{
|
|
component2.DeSerialiseJson(gaiaOperation.m_operationDataJson[0]);
|
|
component2.m_resources = GaiaUtils.GetAsset(ScriptableObjectWrapper.GetSessionedFileName(m_session.GetSessionFileName(), component2.m_resourcesPath), typeof(GaiaResource)) as GaiaResource;
|
|
if (component2.m_resources == null)
|
|
{
|
|
ExportSessionResource(component2.m_resourcesPath);
|
|
component2.m_resources = GaiaUtils.GetAsset(ScriptableObjectWrapper.GetSessionedFileName(m_session.GetSessionFileName(), component2.m_resourcesPath), typeof(GaiaResource)) as GaiaResource;
|
|
}
|
|
if (component2.m_resources == null)
|
|
{
|
|
Debug.LogError("Unable to get resources file for " + component2.name);
|
|
}
|
|
else
|
|
{
|
|
component2.AssociateAssets();
|
|
int[] missingResources = component2.GetMissingResources();
|
|
if (missingResources.GetLength(0) > 0)
|
|
{
|
|
component2.AddResourcesToTerrain(missingResources);
|
|
}
|
|
component2.m_resources.ChangeSeaLevel(m_session.m_seaLevel);
|
|
}
|
|
}
|
|
return gameObject;
|
|
}
|
|
|
|
public void PlaySession()
|
|
{
|
|
m_cancelPlayback = false;
|
|
ExportSessionResources();
|
|
StartCoroutine(PlaySessionCoRoutine());
|
|
}
|
|
|
|
public IEnumerator PlaySessionCoRoutine()
|
|
{
|
|
m_progress = 0uL;
|
|
if (Application.isPlaying)
|
|
{
|
|
for (int idx = 0; idx < m_session.m_operations.Count; idx++)
|
|
{
|
|
if (!m_cancelPlayback && m_session.m_operations[idx].m_isActive)
|
|
{
|
|
yield return StartCoroutine(PlayOperationCoRoutine(idx));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int idx = 0; idx < m_session.m_operations.Count; idx++)
|
|
{
|
|
if (!m_cancelPlayback && m_session.m_operations[idx].m_isActive)
|
|
{
|
|
m_updateOperationCoroutine = PlayOperationCoRoutine(idx);
|
|
yield return new WaitForSeconds(0.2f);
|
|
}
|
|
}
|
|
}
|
|
Debug.Log("Finished playing session " + m_session.m_name);
|
|
m_updateSessionCoroutine = null;
|
|
}
|
|
|
|
public void PlayOperation(int opIdx)
|
|
{
|
|
m_cancelPlayback = false;
|
|
StartCoroutine(PlayOperationCoRoutine(opIdx));
|
|
}
|
|
|
|
public IEnumerator PlayOperationCoRoutine(int operationIdx)
|
|
{
|
|
if (operationIdx < 0 || operationIdx >= m_session.m_operations.Count)
|
|
{
|
|
Debug.LogWarning($"Operation index {operationIdx} is out of bounds.");
|
|
m_updateOperationCoroutine = null;
|
|
yield break;
|
|
}
|
|
if (!m_session.m_operations[operationIdx].m_isActive)
|
|
{
|
|
Debug.LogWarning($"Operation '{m_session.m_operations[operationIdx].m_description}' is not active. Ignoring.");
|
|
m_updateOperationCoroutine = null;
|
|
yield break;
|
|
}
|
|
bool lockState = m_session.m_isLocked;
|
|
m_session.m_isLocked = true;
|
|
GaiaOperation gaiaOperation = m_session.m_operations[operationIdx];
|
|
GameObject gameObject = Apply(operationIdx);
|
|
Stamper stamper = null;
|
|
Spawner spawner = null;
|
|
if (gameObject != null)
|
|
{
|
|
stamper = gameObject.GetComponent<Stamper>();
|
|
spawner = gameObject.GetComponent<Spawner>();
|
|
}
|
|
switch (gaiaOperation.m_operationType)
|
|
{
|
|
case GaiaOperation.OperationType.CreateTerrain:
|
|
if (TerrainHelper.GetActiveTerrainCount() == 0 && m_session.m_defaults != null && m_session.m_defaults.m_content.GetLength(0) <= 0)
|
|
{
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.FlattenTerrain:
|
|
if (stamper != null)
|
|
{
|
|
stamper.FlattenTerrain();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.SmoothTerrain:
|
|
if (stamper != null)
|
|
{
|
|
stamper.SmoothTerrain();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.ClearDetails:
|
|
if (stamper != null)
|
|
{
|
|
stamper.ClearDetails();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.ClearTrees:
|
|
if (stamper != null)
|
|
{
|
|
stamper.ClearTrees();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.Stamp:
|
|
if (!(stamper != null))
|
|
{
|
|
break;
|
|
}
|
|
m_currentStamper = stamper;
|
|
m_currentSpawner = null;
|
|
if (!Application.isPlaying)
|
|
{
|
|
stamper.HidePreview();
|
|
stamper.Stamp();
|
|
while (stamper.IsStamping())
|
|
{
|
|
if ((DateTime.Now - m_lastUpdateDateTime).Milliseconds > 250)
|
|
{
|
|
m_lastUpdateDateTime = DateTime.Now;
|
|
m_progress++;
|
|
}
|
|
yield return new WaitForSeconds(0.2f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
yield return StartCoroutine(stamper.ApplyStamp());
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.StampUndo:
|
|
if (stamper != null)
|
|
{
|
|
stamper.Undo();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.StampRedo:
|
|
if (stamper != null)
|
|
{
|
|
stamper.Redo();
|
|
}
|
|
break;
|
|
case GaiaOperation.OperationType.Spawn:
|
|
if (!(spawner != null))
|
|
{
|
|
break;
|
|
}
|
|
m_currentStamper = null;
|
|
m_currentSpawner = spawner;
|
|
if (Application.isPlaying)
|
|
{
|
|
break;
|
|
}
|
|
spawner.RunSpawnerIteration();
|
|
while (spawner.IsSpawning())
|
|
{
|
|
if ((DateTime.Now - m_lastUpdateDateTime).Milliseconds > 250)
|
|
{
|
|
m_lastUpdateDateTime = DateTime.Now;
|
|
m_progress++;
|
|
}
|
|
yield return new WaitForSeconds(0.2f);
|
|
}
|
|
break;
|
|
}
|
|
m_session.m_isLocked = lockState;
|
|
m_updateOperationCoroutine = null;
|
|
}
|
|
|
|
public void CancelPlayback()
|
|
{
|
|
m_cancelPlayback = true;
|
|
if (m_currentStamper != null)
|
|
{
|
|
m_currentStamper.CancelStamp();
|
|
}
|
|
if (m_currentSpawner != null)
|
|
{
|
|
m_currentSpawner.CancelSpawn();
|
|
}
|
|
}
|
|
|
|
public void ExportSessionResources()
|
|
{
|
|
string text = "Assets/GaiaSessions/";
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
text = Path.Combine(text, GaiaCommon1.Utils.FixFileName(m_session.m_name));
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
if (m_session != null && m_session.m_defaults != null && m_session.m_defaults.m_content != null && m_session.m_defaults.m_content.GetLength(0) > 0)
|
|
{
|
|
GaiaCommon1.Utils.WriteAllBytes(Path.Combine(text, ScriptableObjectWrapper.GetSessionedFileName(m_session.m_name, m_session.m_defaults.m_fileName)), m_session.m_defaults.m_content);
|
|
}
|
|
foreach (KeyValuePair<string, ScriptableObjectWrapper> resource in m_session.m_resources)
|
|
{
|
|
GaiaCommon1.Utils.WriteAllBytes(Path.Combine(text, ScriptableObjectWrapper.GetSessionedFileName(m_session.m_name, resource.Value.m_fileName)), resource.Value.m_content);
|
|
}
|
|
}
|
|
|
|
public void ExportSessionDefaults()
|
|
{
|
|
string text = "Assets/GaiaSessions/";
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
text = Path.Combine(text, GaiaCommon1.Utils.FixFileName(m_session.m_name));
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
if (m_session != null && m_session.m_defaults != null && m_session.m_defaults.m_content != null && m_session.m_defaults.m_content.GetLength(0) > 0)
|
|
{
|
|
GaiaCommon1.Utils.WriteAllBytes(Path.Combine(text, ScriptableObjectWrapper.GetSessionedFileName(m_session.m_name, m_session.m_defaults.m_fileName)), m_session.m_defaults.m_content);
|
|
}
|
|
}
|
|
|
|
public void ExportSessionResource(string resourcePath)
|
|
{
|
|
string text = "Assets/GaiaSessions/";
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
text = Path.Combine(text, GaiaCommon1.Utils.FixFileName(m_session.m_name));
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
foreach (KeyValuePair<string, ScriptableObjectWrapper> resource in m_session.m_resources)
|
|
{
|
|
if (Path.GetFileName(resourcePath).ToLower() == Path.GetFileName(resource.Value.m_fileName).ToLower())
|
|
{
|
|
GaiaCommon1.Utils.WriteAllBytes(Path.Combine(text, ScriptableObjectWrapper.GetSessionedFileName(m_session.m_name, resource.Value.m_fileName)), resource.Value.m_content);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
if (m_session != null)
|
|
{
|
|
Bounds bounds = default(Bounds);
|
|
if (TerrainHelper.GetTerrainBounds(base.transform.position, ref bounds))
|
|
{
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawWireCube(bounds.center, bounds.size);
|
|
bounds.center = new Vector3(bounds.center.x, m_session.m_seaLevel, bounds.center.z);
|
|
bounds.size = new Vector3(bounds.size.x, 0.05f, bounds.size.z);
|
|
Gizmos.color = new Color(Color.blue.r, Color.blue.g, Color.blue.b, Color.blue.a / 4f);
|
|
Gizmos.DrawCube(bounds.center, bounds.size);
|
|
}
|
|
}
|
|
}
|
|
|
|
private GameObject FindOrCreateObject(GaiaOperation operation)
|
|
{
|
|
if (operation.m_generatedByType == "Gaia.Stamper")
|
|
{
|
|
Stamper[] array = UnityEngine.Object.FindObjectsOfType<Stamper>();
|
|
for (int i = 0; i < array.GetLength(0); i++)
|
|
{
|
|
if (array[i].m_stampID == operation.m_generatedByID && array[i].name == operation.m_generatedByName)
|
|
{
|
|
return array[i].gameObject;
|
|
}
|
|
}
|
|
return ShowStamper(operation.m_generatedByName, operation.m_generatedByID);
|
|
}
|
|
if (operation.m_generatedByType == "Gaia.Spawner")
|
|
{
|
|
Spawner[] array2 = UnityEngine.Object.FindObjectsOfType<Spawner>();
|
|
for (int j = 0; j < array2.GetLength(0); j++)
|
|
{
|
|
if (array2[j].m_spawnerID == operation.m_generatedByID && array2[j].name == operation.m_generatedByName)
|
|
{
|
|
return array2[j].gameObject;
|
|
}
|
|
}
|
|
return CreateSpawner(operation.m_generatedByName, operation.m_generatedByID);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private GameObject ShowStamper(string name, string id)
|
|
{
|
|
GameObject gameObject = GameObject.Find("Gaia");
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = new GameObject("Gaia");
|
|
}
|
|
GameObject gameObject2 = GameObject.Find(name);
|
|
if (gameObject2 == null)
|
|
{
|
|
gameObject2 = new GameObject(name);
|
|
gameObject2.transform.parent = gameObject.transform;
|
|
Stamper stamper = gameObject2.AddComponent<Stamper>();
|
|
stamper.m_stampID = id;
|
|
stamper.HidePreview();
|
|
stamper.m_seaLevel = m_session.m_seaLevel;
|
|
}
|
|
return gameObject2;
|
|
}
|
|
|
|
private GameObject CreateSpawner(string name, string id)
|
|
{
|
|
GameObject gameObject = GameObject.Find("Gaia");
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = new GameObject("Gaia");
|
|
}
|
|
GameObject obj = new GameObject(name);
|
|
obj.transform.parent = gameObject.transform;
|
|
obj.AddComponent<Spawner>().m_spawnerID = id;
|
|
return obj;
|
|
}
|
|
}
|
|
}
|