void Awake()
{
GameManager.worldEvent += EventManager;
GameManager.nextTurn += NextTurn;
WorldManager.onHexClick += OnHexClick;
worldManager = GameObject.FindObjectOfType<WorldManager>();
}
/// <summary>
/// Sets up the resource manager.
/// Caches all needed values.
/// </summary>
internal void SetUp()
{
//insert default "None" resource into the resource array
resources.Insert(0, new Resource("None", 0, 0, null, null, false, null));
//set internal array
internalResources = resources.ToArray();
//cache managers
tileManager = GetComponent<TileManager>();
worldManager = GetComponent<WorldManager>();
//instatiate the improvement name array
if (resourceNames == null)
{
UpdateResourceNames();
}
}
/// <summary>
/// Sets up the cameras to position themselves correctly depending on the user settings.
/// Spawns the second follow camera if wrapping is enabled.
/// Caches transforms for the cameras for speed.
/// </summary>
/// <remarks>
/// The WorldManager script must be within the scene for this method to execute.
/// </remarks>
public void SetupCameras()
{
//cache the lead camera and world manager
cam1 = gameObject.GetComponent<Camera>();
worldManager = GameObject.FindObjectOfType<WorldManager>();
//set the lead camera to the origin
cam1.transform.position = new Vector3(0, 0, 0);
//setup wrapping camera if needed
if (enableWrapping == true)
{
//spawn the follow camera and setup it's camera setting to match the lead camera
cam2 = new GameObject("Cam2").gameObject.AddComponent<Camera>();
cam2.gameObject.AddComponent<GUILayer>();
cam2.fieldOfView = cam1.fieldOfView;
cam2.clearFlags = CameraClearFlags.Depth;
cam2.depth = cam1.depth + 1;
//calculate the offset between the two cameras to make a wrapping world
camOffset = new Vector2((this.worldManager.mapSize.x * this.worldManager.hexSize.x), 0);
}
//cache the transform on the lead camera and assign its position and rotation
cam1T = cam1.transform;
cam1T.localEulerAngles = new Vector3(cameraAngle, cam1T.localEulerAngles.y, cam1T.localEulerAngles.z);
cam1T.position = new Vector3(camOffset.x * .5f, cameraHeight, (worldManager.hexExt.y * worldManager.mapSize.y) * .5f);
//set the follow camera to the lead cameras values until they are correctly calculated in the update methods
if (enableWrapping == true)
{
cam2T = cam2.transform;
cam2T.position = cam1T.position;
cam2T.rotation = cam1T.rotation;
}
}
void Awake()
{
worldManager = (WorldManager)target;
}
public override void OnInspectorGUI()
{
if (done == false)
{
Awake();
done = true;
}
if (improvementManager == null) { improvementManager = (ImprovementManager)target; }
if (worldManager == null) { worldManager = improvementManager.GetComponent<WorldManager>(); }
if (tileManager == null) { tileManager = improvementManager.GetComponent<TileManager>(); }
if (improvementManager.improvements != null && (foldoutOpen == null || foldoutOpen.Length != improvementManager.improvements.Count)) { foldoutOpen = new bool[improvementManager.improvements.Count]; }
if (improvementManager.improvements != null && (extraInfoFoldout == null || extraInfoFoldout.Length != improvementManager.improvements.Count)) { extraInfoFoldout = new bool[improvementManager.improvements.Count]; }
if (GUILayout.Button("Add New Improvement"))
{
ImprovementEditorWindow window = EditorWindow.CreateInstance<ImprovementEditorWindow>();
EditorWindow.GetWindow<ImprovementEditorWindow>();
window.editMode = false;
window.improvementIndexToEdit = 0;
}
if (improvementManager.improvements != null && improvementManager.improvements.Count > 0)
{
for (int i = 0; i < improvementManager.improvements.Count; i++)
{
Improvement improvement = improvementManager.improvements[i];
EditorGUILayout.BeginHorizontal();
foldoutOpen[i] = EditorGUILayout.Foldout(foldoutOpen[i], improvement.name);
if (GUILayout.Button("Edit"))
{
ImprovementEditorWindow window = EditorWindow.CreateInstance<ImprovementEditorWindow>();
EditorWindow.GetWindow<ImprovementEditorWindow>();
window.editMode = true;
window.improvementIndexToEdit = i;
}
if (GUILayout.Button("Remove"))
{
improvementManager.DeleteImprovement(improvement);
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel++;
if (foldoutOpen[i])
{
improvement.name = EditorGUILayout.TextField("Improvement Name:", improvement.name);
improvement.replaceGroundTexture = EditorGUILayout.Toggle("Replace Ground Texture:", improvement.replaceGroundTexture);
extraInfoFoldout[i] = EditorGUILayout.Foldout(extraInfoFoldout[i], "Rules:");
if (extraInfoFoldout[i])
{
EditorGUILayout.SelectableLabel("Possible Tiles:", EditorStyles.boldLabel, GUILayout.ExpandHeight(false), GUILayout.MaxHeight(15));
EditorGUI.indentLevel++;
if(improvement.rule.possibleTiles.Length == 0)
{
EditorGUILayout.SelectableLabel("No Possible Tiles");
}
else
{
foreach (int t in improvement.rule.possibleTiles)
{
EditorGUI.indentLevel++;
EditorGUILayout.SelectableLabel(tileManager.tiles[t].name, GUILayout.ExpandHeight(false), GUILayout.MaxHeight(18));
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
EditorGUILayout.SelectableLabel("Possible Features:", EditorStyles.boldLabel, GUILayout.ExpandHeight(false), GUILayout.MaxHeight(15));
EditorGUI.indentLevel++;
if(improvement.rule.possibleFeatures.Length == 0)
{
EditorGUILayout.SelectableLabel("No Possible Features");
}
else
{
foreach (Feature f in improvement.rule.possibleFeatures)
{
EditorGUI.indentLevel++;
EditorGUILayout.SelectableLabel(f.ToString(), GUILayout.ExpandHeight(false), GUILayout.MaxHeight(18));
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
improvement.meshToSpawn = (Mesh)EditorGUILayout.ObjectField("Improvement Mesh", (Object)improvement.meshToSpawn, typeof(Mesh), false);
improvement.meshTexture = (Texture2D)EditorGUILayout.ObjectField("Improvement Mesh Texture:", (Object)improvement.meshTexture, typeof(Texture2D), false, GUILayout.ExpandHeight(false), GUILayout.ExpandWidth(true));
}
EditorGUI.indentLevel--;
}
}
else
{
GUILayout.Label("No Improvements Created; Please Add Some");
}
if (GUILayout.Button("Finalize"))
{
improvementManager.UpdateImprovementNames();
}
}
/// <summary>
/// Loads a terrain into the scene from a file.
/// <see cref="WorldManager.LoadAndGenerateMap"/> should be used unless additional custom modification will be used.
/// This method only loads the data into memory and does not generate the world from the data.
/// </summary>
/// <param name="location">File to load</param>
/// <remarks>
/// <see cref="WorldManager.LoadAndGenerateMap"/> should be used instead of this method unless advanced custom work needs to be implimented.
/// </remarks>
public static void LoadTerrain(string location)
{
WorldManager worldManager = GameObject.FindObjectOfType <WorldManager>();
if (worldManager == null)
{
Debug.LogError("WorldManager not found while attempting to load the game. \n Game load failed. ");
return;
}
bool startedGen = false;
using (XmlReader reader = XmlReader.Create(location + ".xml"))
{
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "WorldManager":
worldManager.useCivGridCamera = XmlConvert.ToBoolean(reader["useCivGridCamera"]);
worldManager.useWorldTypeValues = XmlConvert.ToBoolean(reader["usePresetWorldValue"]);
worldManager.worldType = (WorldType)XmlConvert.ToInt32(reader["worldType"]);
worldManager.mapSize = new Vector2(XmlConvert.ToInt32(reader["mapSizeX"]), XmlConvert.ToInt32(reader["mapSizeY"]));
worldManager.chunkSize = XmlConvert.ToInt32(reader["chunkSize"]);
worldManager.hexRadiusSize = (float)XmlConvert.ToDouble(reader["hexRadiusSize"]);
worldManager.mountainHeightMap = FileUtility.LoadTexture("Base_Mountain_Map");
break;
case "CivGridCamera":
worldManager.civGridCamera.enableWrapping = XmlConvert.ToBoolean(reader["enableWrapping"]);
worldManager.civGridCamera.cameraHeight = (float)XmlConvert.ToDouble(reader["cameraHeight"]);
worldManager.civGridCamera.cameraAngle = (float)XmlConvert.ToDouble(reader["cameraAngle"]);
worldManager.civGridCamera.cameraSpeed = (float)XmlConvert.ToDouble(reader["cameraSpeed"]);
break;
case "Chunk":
if (startedGen == false)
{
worldManager.GenerateNewMap(false);
startedGen = true;
}
break;
case "Hexagon":
Hex hex = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])].hexArray[XmlConvert.ToInt32(reader["xHexLoc"]), XmlConvert.ToInt32(reader["yHexLoc"])];
hex.terrainType = worldManager.tileManager.TryGetTile(reader["type"]);
hex.terrainFeature = (Feature)XmlConvert.ToInt32(reader["feature"]);
hex.parentChunk = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])];
//rectLocation
hex.currentRectLocation = new Rect((float)XmlConvert.ToDouble(reader["rLeft"]), (float)XmlConvert.ToDouble(reader["rTop"]), (float)XmlConvert.ToDouble(reader["rWidth"]), (float)XmlConvert.ToDouble(reader["rHeight"]));
hex.currentResource = worldManager.resourceManager.TryGetResource(reader["resource"]);
hex.currentImprovement = worldManager.improvementManager.TryGetImprovement(reader["improvement"]);
break;
#region VoidedManagers
/*
#region TileManager
* case "TileManager":
* Debug.Log("opening tile manager");
* break;
* case "Tiles":
* Debug.Log("finding tiles");
* break;
* case "NewTile":
* Debug.Log("adding Tile: " + reader["name"]);
* tileManager.AddTile(new Tile(reader["name"], XmlConvert.ToBoolean(reader["isShore"]), XmlConvert.ToBoolean(reader["isOcean"]), XmlConvert.ToBoolean(reader["isMountain"]), (float)XmlConvert.ToDouble(reader["bottomLongitude"]), (float)XmlConvert.ToDouble(reader["topLongitude"])));
* break;
#endregion
#region ResourceManager
* case "ResourceManager":
* Debug.Log("opening resource manager");
* break;
* case "Resources":
* Debug.Log("opening resources");
* break;
* case "NewResource":
* string loc1 = reader["meshToSpawn"];
* string loc2 = reader["meshTexture"];
*
* List<int> possibleTiles = new List<int>();
* List<Feature> possibleFeatures = new List<Feature>();
*
* for(int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleTiles"]); i++)
* {
* possibleTiles.Add(XmlConvert.ToInt32(reader["possibleTile" + i]));
* }
*
* for (int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleFeatures"]); i++)
* {
* possibleFeatures.Add((Feature)System.Enum.Parse(typeof(Feature), reader["possibleFeature" + i]));
* }
*
* resourceManager.resources.Add(new Resource(
* reader["name"],
* ((float)XmlConvert.ToDouble(reader["rarity"])),
* XmlConvert.ToInt32(reader["spawnAmount"]),
* ((Mesh)AssetDatabase.LoadAssetAtPath(loc1, typeof(Mesh))),
* ((Texture2D)AssetDatabase.LoadAssetAtPath(loc2, typeof(Texture2D))),
* XmlConvert.ToBoolean(reader["replaceGroundTexture"]), new ResourceRule(possibleTiles.ToArray(), possibleFeatures.ToArray())));
* break;
#endregion
*/
#endregion
default:
//Debug.Log("unhandled exception: " + reader.Name);
break;
}
}
}
}
foreach (Chunk chunk in worldManager.hexChunks)
{
chunk.StartHexGeneration();
foreach (Hex hex in chunk.hexArray)
{
if (hex.currentResource.name != "None")
{
worldManager.resourceManager.SpawnResource(hex, hex.currentResource, true);
}
if (hex.currentImprovement.name != "None")
{
worldManager.improvementManager.AddImprovement(hex.currentImprovement);
}
}
}
}
/// <summary>
/// Saves the current terrain to a file. <see cref="WorldManager.SaveMap"/> is a wrapper for this method, both are congruent.
/// </summary>
/// <param name="name">Name of the file</param>
/// <example>
/// The following code saves the terrain to a file called <b>terrainSave</b>.
/// <code>
/// class SaveTerrain : MonoBehaviour
/// {
/// void Start()
/// {
/// CivGridFileUtility.SaveTerrain("terrainSave");
/// }
/// }
/// </code>
/// <remarks>
/// <see cref="WorldManager"/> must be in the scene and currently have a world in memory. Method will return errors if a WorldManager
/// is not currently in the scene or if it doesn't have a world currently loaded into memory.
/// </remarks>
/// </example>
public static void SaveTerrain(string name)
{
WorldManager worldManager = GameObject.FindObjectOfType <WorldManager>();
if (worldManager == null)
{
Debug.LogError("WorldManager not found while attempting to save the game. \n Game save failed. ");
return;
}
System.Text.StringBuilder assetPrefix = new System.Text.StringBuilder(Application.dataPath);
assetPrefix.Remove((assetPrefix.Length - 6), 6);
using (XmlWriter writer = XmlWriter.Create(name + ".xml"))
{
writer.WriteStartDocument();
writer.WriteStartElement("Root");
#region WorldManager
writer.WriteStartElement("WorldManager");
writer.WriteAttributeString("useCivGridCamera", XmlConvert.ToString(worldManager.useCivGridCamera));
writer.WriteAttributeString("usePresetWorldValue", XmlConvert.ToString(worldManager.useWorldTypeValues));
writer.WriteAttributeString("worldType", ((int)worldManager.worldType).ToString());
writer.WriteAttributeString("mapSizeX", worldManager.mapSize.x.ToString());
writer.WriteAttributeString("mapSizeY", worldManager.mapSize.y.ToString());
writer.WriteAttributeString("chunkSize", worldManager.chunkSize.ToString());
writer.WriteAttributeString("hexRadiusSize", worldManager.hexRadiusSize.ToString());
FileUtility.SaveTexture(worldManager.mountainHeightMap, "Base_Mountain_Map", false);
writer.WriteEndElement();
#endregion
#region VoidedManagers
/*
#region TileManager
*
* TileManager tileManager = worldManager.tileManager;
*
* writer.WriteStartElement("TileManager");
*
* writer.WriteStartElement("Tiles");
* for (int i = 0; i < tileManager.tiles.Count; i++)
* {
* writer.WriteStartElement("NewTile");
*
* writer.WriteAttributeString("name", tileManager.tiles[i].name);
* writer.WriteAttributeString("bottomLongitude", XmlConvert.ToString(tileManager.tiles[i].bottomLongitude));
* writer.WriteAttributeString("topLongitude", XmlConvert.ToString(tileManager.tiles[i].topLongitude));
* writer.WriteAttributeString("isShore", XmlConvert.ToString(tileManager.tiles[i].isShore));
* writer.WriteAttributeString("isOcean", XmlConvert.ToString(tileManager.tiles[i].isOcean));
* writer.WriteAttributeString("isMountain", XmlConvert.ToString(tileManager.tiles[i].isMountain));
*
* writer.WriteEndElement();
* }
* writer.WriteEndElement();
*
* writer.WriteEndElement();
*
#endregion
*
#region ResourceManager
*
* ResourceManager resourceManager = worldManager.resourceManager;
*
* writer.WriteStartElement("ResourceManager");
*
* writer.WriteStartElement("Resources");
* for (int i = 1; i < resourceManager.resources.Count; i++)
* {
* writer.WriteStartElement("NewResource");
*
* writer.WriteAttributeString("name", resourceManager.resources[i].name);
* writer.WriteAttributeString("rarity", resourceManager.resources[i].rarity.ToString());
* writer.WriteAttributeString("spawnAmount", resourceManager.resources[i].spawnAmount.ToString());
* writer.WriteAttributeString("meshToSpawn", (AssetDatabase.GetAssetPath(resourceManager.resources[i].meshToSpawn)));
* writer.WriteAttributeString("meshTexture", (AssetDatabase.GetAssetPath(resourceManager.resources[i].meshTexture)));
* writer.WriteAttributeString("replaceGroundTexture", XmlConvert.ToString(resourceManager.resources[i].replaceGroundTexture));
*
* writer.WriteAttributeString("numOfPossibleTiles", resourceManager.resources[i].rule.possibleTiles.Length.ToString());
*
* for (int y = 0; y < resourceManager.resources[i].rule.possibleTiles.Length; y++)
* {
* writer.WriteAttributeString("possibleTile" + y, resourceManager.resources[i].rule.possibleTiles[y].ToString());
* }
*
* writer.WriteAttributeString("numOfPossibleFeatures", resourceManager.resources[i].rule.possibleFeatures.Length.ToString());
*
* for (int y = 0; y < resourceManager.resources[i].rule.possibleFeatures.Length; y++)
* {
* writer.WriteAttributeString("possibleFeature" + y, resourceManager.resources[i].rule.possibleFeatures[y].ToString());
* }
*
* writer.WriteEndElement();
* }
* writer.WriteEndElement();
*
* writer.WriteEndElement();
*
#endregion
*
#region ImprovementManager
*
* ImprovementManager improvementManager = worldManager.improvementManager;
*
* writer.WriteStartElement("ImprovementManager");
*
* writer.WriteElementString("improvementCount", improvementManager.searalizableImprovements.Count.ToString());
*
* writer.WriteStartElement("Improvements");
* for (int i = 1; i < improvementManager.searalizableImprovements.Count; i++)
* {
* writer.WriteStartElement("Improvement");
*
* writer.WriteElementString("name", improvementManager.searalizableImprovements[i].name);
* writer.WriteElementString("meshToSpawn", (assetPrefix.ToString() + AssetDatabase.GetAssetPath(improvementManager.searalizableImprovements[i].meshToSpawn)));
* writer.WriteElementString("meshTexture", (assetPrefix.ToString() + AssetDatabase.GetAssetPath(improvementManager.searalizableImprovements[i].meshTexture)));
* writer.WriteElementString("replaceGroundTexture", improvementManager.searalizableImprovements[i].replaceGroundTexture.ToString());
*
* writer.WriteStartElement("ImprovementRule");
*
* writer.WriteStartElement("PossibleTiles");
* for (int y = 0; y < improvementManager.searalizableImprovements[i].rule.possibleTiles.Length; y++)
* {
* writer.WriteStartElement("Tile");
* writer.WriteElementString("tile", improvementManager.searalizableImprovements[i].rule.possibleTiles[i].ToString());
* writer.WriteEndElement();
* }
* writer.WriteEndElement();
*
* writer.WriteStartElement("PossibleFeatures");
* for (int y = 0; y < improvementManager.searalizableImprovements[i].rule.possibleFeatures.Length; y++)
* {
* writer.WriteStartElement("Feature");
* writer.WriteElementString("feature", improvementManager.searalizableImprovements[i].rule.possibleFeatures[i].ToString());
* writer.WriteEndElement();
* }
* writer.WriteEndElement();
*
* writer.WriteEndElement();
*
* writer.WriteEndElement();
* }
* writer.WriteEndElement();
*
* writer.WriteEndElement();
*
#endregion
*/
#endregion
#region Chunk
for (int x = 0; x < worldManager.hexChunks.GetLength(0); x++)
{
for (int y = 0; y < worldManager.hexChunks.GetLength(1); y++)
{
Chunk chunk = worldManager.hexChunks[x, y];
writer.WriteStartElement("Chunk");
writer.WriteAttributeString("xChunkLoc", XmlConvert.ToString(x));
writer.WriteAttributeString("yChunkLoc", XmlConvert.ToString(y));
for (int _x = 0; _x < chunk.hexArray.GetLength(0); _x++)
{
for (int _y = 0; _y < chunk.hexArray.GetLength(1); _y++)
{
Hex hex = chunk.hexArray[_x, _y];
#region Hex
writer.WriteStartElement("Hexagon");
writer.WriteAttributeString("xHexLoc", XmlConvert.ToString(_x));
writer.WriteAttributeString("yHexLoc", XmlConvert.ToString(_y));
writer.WriteAttributeString("xParentChunk", XmlConvert.ToString(x));
writer.WriteAttributeString("yParentChunk", XmlConvert.ToString(y));
//Texture Rect Location
writer.WriteAttributeString("rLeft", XmlConvert.ToString(hex.currentRectLocation.xMin));
writer.WriteAttributeString("rTop", XmlConvert.ToString(hex.currentRectLocation.yMin));
writer.WriteAttributeString("rWidth", XmlConvert.ToString(hex.currentRectLocation.width));
writer.WriteAttributeString("rHeight", XmlConvert.ToString(hex.currentRectLocation.height));
writer.WriteAttributeString("type", hex.terrainType.name);
writer.WriteAttributeString("feature", ((int)hex.terrainFeature).ToString());
writer.WriteAttributeString("resource", hex.currentResource.name);
writer.WriteAttributeString("improvement", hex.currentImprovement.name);
writer.WriteEndElement();
#endregion
}
}
writer.WriteEndElement();
}
}
#endregion
#region CivGridCamera
writer.WriteStartElement("CivGridCamera");
//camera settings
writer.WriteAttributeString("enableWrapping", XmlConvert.ToString(worldManager.civGridCamera.enableWrapping));
writer.WriteAttributeString("cameraHeight", worldManager.civGridCamera.cameraHeight.ToString());
writer.WriteAttributeString("cameraAngle", worldManager.civGridCamera.cameraAngle.ToString());
writer.WriteAttributeString("cameraSpeed", worldManager.civGridCamera.cameraSpeed.ToString());
writer.WriteEndElement();
#endregion
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
void Start()
{
worldManager = GameObject.FindObjectOfType<WorldManager>();
}
void OnEnable()
{
this.title = "Terrain Manager";
worldManager = GameObject.FindObjectOfType<WorldManager>();
improvementManager = GameObject.FindObjectOfType<ImprovementManager>();
resourceManager = GameObject.FindObjectOfType<ResourceManager>();
tileManager = GameObject.FindObjectOfType<TileManager>();
if (worldManager == null || improvementManager == null)
{
Debug.LogError("Need to have WorldManager and ImprovementManager in current scene");
}
int length = 0;
foreach(Resource r in resourceManager.resources)
{
if (r.replaceGroundTexture == true) { length++; }
}
foreach(Improvement i in improvementManager.improvements)
{
if (i.replaceGroundTexture == true) { length++; }
}
length += tileManager.tileNames.Length;
for (int i = 0; i < length; i++)
{
AddElement();
}
tileManager.UpdateTileNames();
resourceManager.UpdateResourceNames();
improvementManager.UpdateImprovementNames();
start = true;
}
