public void GetObjectData(object obj, SerializationInfo info,
StreamingContext context)
{
TerrainDefinition td = (TerrainDefinition)obj;
info.AddValue("id", td.name);
}
public static void Enclose(Level level, LevelRect rect,
TerrainDefinition terrain)
{
for (int x = rect.x1; x <= rect.x2; x++)
{
for (int y = rect.y1; y <= rect.y2; y++)
{
if (x == rect.x1)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else if (x == rect.x2)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else
{
if (y == rect.y1)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else if (y == rect.y2)
{
level.Map[x, y].Terrain = terrain;
continue;
}
}
}
}
}
public BinarySpacePartition(string terrainID, int minRoomSize, bool tightFill)
{
terrain = ScriptableObject.CreateInstance <TerrainDefinition>();
terrain.name = terrainID;
this.minRoomSize = minRoomSize;
this.tightFill = tightFill;
}
public CellularAutomata(TerrainDefinition wall, TerrainDefinition floor,
int percentWalls)
{
this.wall = wall;
this.floor = floor;
this.percentWalls = percentWalls;
}
public static void Enclose(Level level, TerrainDefinition terrain)
{
for (int x = 0; x < level.Size.x; x++)
{
for (int y = 0; y < level.Size.y; y++)
{
if (x == 0)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else if (x == level.Size.x - 1)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else
{
if (y == 0)
{
level.Map[x, y].Terrain = terrain;
continue;
}
else if (y == level.Size.y - 1)
{
level.Map[x, y].Terrain = terrain;
continue;
}
}
}
}
}
public CellularAutomata(string wall, string floor, int percentWalls)
{
this.wall = ScriptableObject.CreateInstance <TerrainDefinition>();
this.wall.name = wall;
this.floor = ScriptableObject.CreateInstance <TerrainDefinition>();
this.floor.name = floor;
this.percentWalls = percentWalls;
}
public object SetObjectData(object obj, SerializationInfo info,
StreamingContext context, ISurrogateSelector selector)
{
TerrainDefinition td = (TerrainDefinition)obj;
td = Assets.GetTerrain(info.GetString("id"));
obj = td;
return(obj);
}
public static byte GetTerrainIndex(TerrainDefinition terrain)
{
for (byte i = 0; i < Terrains.Length; i++)
{
if (Terrains[i] == terrain)
{
return(i);
}
}
throw new System.Exception(
$"{terrain} not found in asset database.");
}
/// <summary>
/// Initializes a new instance of the <see cref="Core.Models.Region"/> class.
/// Use Only when there are not data. It will create an empty region where nothing can be changed.
/// </summary>
/// <param name="regionPosition">Region position.</param>
public Region(RegionPosition regionPosition)
{
m_regionPosition = regionPosition;
m_terrains = new TerrainDefinition[Constants.REGION_SIZE_X, Constants.REGION_SIZE_Y];
m_entities = new DatedEntities();
m_entities.Entities = new LinkedList <Entity>();
m_territory = new Dictionary <PositionI, Account>();
m_actions = new DatedActions();
m_actions.Actions = new LinkedList <Core.Models.Action>();
m_exist = Cheats.DONT_LOAD_REGIONS_MODE;
m_mutex = new ReaderWriterLockSlim();
}
public static void FillRectTerrain(Level level, LevelRect rect,
TerrainDefinition terrain)
{
for (int x = rect.x1; x < rect.x2; x++)
{
for (int y = rect.y1; y < rect.y2; y++)
{
if (level.TryGetCell(x, y, out Cell c))
{
level.Map[x, y].Terrain = terrain;
}
}
}
}
//Land tiles does not have tileart TEXTURES section.. we need to extract them from terrain definition
public static TextureImageInfo getLandtileTextureID(uint legacyLandtileID)
{
//Fast search
if (landtiles.ContainsKey(legacyLandtileID))
{
return(landtiles[legacyLandtileID]);
}
//Translate the legacy ID to the new pair newID-subtype using legacyterrainMap
if (!legacyTerrainMap.ContainsKey(legacyLandtileID))
{
UOConsole.Fatal("Cannot find {0} in legacyTerrainMap", legacyLandtileID);
return(null);
}
legacyTerrainMap_t landtileID = legacyTerrainMap[legacyLandtileID];
//Get the file from terrain definition using the newID
ulong hash = HashDictionary.HashFileName(string.Format("build/terraindefinition/{0}.bin", landtileID.newID));
if (!uopHashes.terrainHashes.ContainsKey(hash))
{
UOConsole.Fatal("Cannot find {0} in terrainHashes", landtileID.newID);
return(null);
}
uopMapping_t pos = uopHashes.terrainHashes[hash];
MythicPackage _uop = new MythicPackage(fileDirectory + "TerrainDefinition.uop");
byte[] raw = _uop.Blocks[pos.block].Files[pos.file].Unpack(_uop.FileInfo.FullName);
//Read the loaded terrainDefinition file.
TerrainDefinition td;
using (MemoryStream ms = new MemoryStream(raw)) {
using (BinaryReader r = new BinaryReader(ms)) {
td = TerrainDefinition.readTerrainDefinition(r);
}
}
if (td == null)
{
UOConsole.Fatal("Cannot read terrainDefinition file");
return(null);
}
landtiles[legacyLandtileID] = td.textures.texturesArray[landtileID.newSubtype];
//Returns the texture according to subtype
return(td.textures.texturesArray[landtileID.newSubtype]);
}
/// <summary>
/// Displays tags available for terrains to select from and those currently chosen for this terrain
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public void DisplayAvaliableForegrounds(TerrainDefinition t)
{
Color c = TerrainDefinition.GetColor(t.source.foregroundColor);
GUILayout.BeginHorizontal();
GUILayout.Label("Theme Color:");
Color newColor = EditorGUILayout.ColorField(c);
GUILayout.EndHorizontal();
if (newColor != c)
{
uint color = (uint)(newColor.r * 255) << 16 | (uint)(newColor.g * 255) << 8 | (uint)(newColor.b * 255);
t.source.foregroundColor = color.ToString("X");
MHDatabase.SaveDB <MHTerrain>();
}
if (GUILayout.Button("Foreground selector", GUILayout.Width(150)))
{
SpriteSelectorWindow.OpenWindow(t);
}
MHSimpleCounter toRemove = null;
foreach (MHSimpleCounter fgType in t.source.fgTypes)
{
GUILayout.BeginHorizontal();
GUI.color = Color.red;
if (GUILayout.Button("x", GUILayout.Width(19)))
{
toRemove = fgType;
}
GUI.color = Color.white;
GUILayout.Label(fgType.name);
if (IntField(ref fgType.count))
{
MHDatabase.SaveDB <MHTerrain>();
}
GUILayout.EndHorizontal();
}
if (toRemove != null)
{
t.source.fgTypes.Remove(toRemove);
MHDatabase.SaveDB <MHTerrain>();
}
}
private static void GenerateSampleWorldPlan()
{
TerrainDefinition ground = ScriptableObject.CreateInstance <TerrainDefinition>();
ground.name = "Terrain_StoneFloor";
TerrainDefinition wall = ScriptableObject.CreateInstance <TerrainDefinition>();
wall.name = "Terrain_StoneWall";
Tile mockTile = ScriptableObject.CreateInstance <Tile>();
mockTile.name = "StoneStairs_Up";
Builder builder = new Builder
{
ID = "SAMPLE_ID"
};
WorldPlan plan = new WorldPlan()
{
Builders = new Dictionary <string, Builder>()
};
plan.Builders.Add(builder.ID, builder);
string path = Application.dataPath + $"/Sample/sample_plan.json";
if (File.Exists(path))
{
File.Delete(path);
}
JsonSerializerSettings settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto,
SerializationBinder = Binders._entity,
Formatting = Formatting.Indented,
Converters = new List <JsonConverter>()
{
new WorldPlanConverter()
},
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
File.AppendAllText(path, JsonConvert.SerializeObject(plan, settings));
AssetDatabase.Refresh();
Debug.Log($"Wrote sample world plan to {path}.");
}
/// <summary>
/// Displays tags available for terrains to select from and those currently chosen for this terrain
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public void DisplayAvaliableTags(TerrainDefinition t)
{
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
GUI.color = Color.green;
if (GUILayout.Button("+", GUILayout.Width(19)))
{
if (!t.source.typeList.Contains(selectedEnum))
{
t.source.typeList.Add(selectedEnum);
MHDatabase.SaveDB <MHTerrain>();
}
}
GUI.color = Color.white;
selectedEnum = (MHTerrain.Type)EditorGUILayout.EnumPopup(selectedEnum);
GUILayout.EndHorizontal();
int toRemove = -1;
for (int i = 0; i < t.source.typeList.Count; i++)
{
GUILayout.BeginHorizontal();
GUI.color = Color.red;
if (GUILayout.Button("x", GUILayout.Width(19)))
{
toRemove = i;
}
GUI.color = Color.white;
GUILayout.Label(t.source.typeList[i].ToString());
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
if (toRemove >= 0)
{
t.source.typeList.RemoveAt(toRemove);
MHDatabase.SaveDB <MHTerrain>();
}
}
/// <summary>
/// Gracefully-failing vault build for use by console commands.
/// </summary>
/// <param name="position">Lower-left corner.</param>
/// <param name="rotation">Rotation in degrees.</param>
/// <returns>True if vault build was successful.</returns>
public static bool TryBuild(
string id,
World.Level level,
Vector2Int position,
float rotation)
{
if (!Assets.Vaults.TryGetValue(id, out Vault vault))
{
return(false);
}
vault.Initialize();
if (!level.Contains(position + vault.Size))
{
return(false);
}
for (int x = position.x; x < vault.Size.x + position.x; x++)
{
for (int y = position.y; y < vault.Size.y + position.y; y++)
{
TerrainDefinition terrain = vault.GetTerrain(
x - position.x, y - position.y);
if (terrain != null)
{
Vector2Int rot = new Vector2Int(
x - position.x,
y - position.y).Rotate(rotation);
if (level.TryGetCell(rot + position, out World.Cell cell))
{
cell.Terrain = terrain;
}
}
}
}
return(true);
}
/// <summary>
/// Safe vault building function for internal use.
/// </summary>
/// <param name="position">Lower-left corner.</param>
/// <param name="rotation">Rotation in degrees.</param>
/// <returns>The vault definition so its flags can be consumed.</returns>
public static Vault Build(
string id,
World.Level level,
Vector2Int position,
float rotation)
{
if (!Assets.Vaults.TryGetValue(id, out Vault vault))
{
throw new ArgumentException($"Vault {id} not found.");
}
vault.Initialize();
//if (!level.Contains(position + vault.Size))
// throw new ArgumentException
// ("Position too close to level bounds.");
for (int x = position.x; x < vault.Size.x + position.x; x++)
{
for (int y = position.y; y < vault.Size.y + position.y; y++)
{
TerrainDefinition terrain = vault.GetTerrain(
x - position.x, y - position.y);
if (terrain != null)
{
Vector2Int rot = new Vector2Int(
x - position.x,
y - position.y).Rotate(rotation);
if (level.TryGetCell(rot + position, out World.Cell cell))
{
cell.Terrain = terrain;
}
}
}
}
return(vault);
}
private void LoadPilotPositions(SceneryParameters parameters)
{
try
{
comboPilotPos.Clear();
if ((parameters != null) && (parameters.DefinitionFile != null) && (parameters.SceneryType == SceneryParameters.SceneryTypeEnum.Full3D))
{
bool posFound = false;
TerrainDefinition definition = new TerrainDefinition();
definition.Load(parameters.SceneryFolder + parameters.DefinitionFile);
foreach (DataRow dataRow in definition.PilotPositionTable.Rows)
{
comboPilotPos.AddItem(dataRow["Name"].ToString(), dataRow);
Vector3 pos = (Vector3)dataRow["Position"];
if ((pos.X == Program.Instance.PilotPosition.X) && (pos.Z == Program.Instance.PilotPosition.Z))
{
comboPilotPos.SetSelected(dataRow["Name"].ToString());
posFound = true;
}
}
if ((!posFound) && definition.PilotPositionTable.Rows.Count > 0)
{
SetPilotPosition(parameters, definition.PilotPositionTable.Rows[0]);
comboPilotPos.SetSelected(definition.PilotPositionTable.Rows[0]["Name"].ToString());
}
}
else
{
comboPilotPos.AddItem("default", null);
comboPilotPos.SetSelectedByData(null);
SetPilotPosition(parameters, null);
}
}
catch
{
}
}
public static void OpenWindow(TerrainDefinition selectedTerrain)
{
Init();
curentTerrain = selectedTerrain;
}
public BinarySpacePartition(TerrainDefinition terrain, int minRoomSize, bool tightFill)
{
this.terrain = terrain;
this.minRoomSize = minRoomSize;
this.tightFill = tightFill;
}
private static void GenerateSampleBuilder()
{
TerrainDefinition ground = ScriptableObject.CreateInstance <TerrainDefinition>();
ground.name = "Terrain_StoneFloor";
TerrainDefinition wall = ScriptableObject.CreateInstance <TerrainDefinition>();
wall.name = "Terrain_StoneWall";
Tile mockTile = ScriptableObject.CreateInstance <Tile>();
mockTile.name = "StoneStairs_Up";
Builder builder = new Builder
{
ID = "SAMPLE_ID",
LevelID = "SAMPLE_ID",
DisplayName = "SAMPLE_NAME",
Position = new Vector3Int(-2, 1, 1),
Ground = ground,
Wall = wall,
Size = new Vector2Int(80, 80),
Steps = new BuilderStep[]
{
new BinarySpacePartition("Terrain_StoneWall", 10, true),
new CellularAutomata("Terrain_StoneWall", "Terrain_StoneFloor", 45),
new Fill("Terrain_StoneFloor"),
new RandomFill("Terrain_StoneWall", 40)
},
ConnectionRules = new ConnectionRule[]
{
new ConnectionRule()
{
Count = 1,
Key = "Reformatory",
Tile = mockTile
}
},
Population = new GenericRandomPick <string>[]
{
new GenericRandomPick <string>(512, "Coyote"),
new GenericRandomPick <string>(512, "RagingGoose")
}
};
string path = Application.dataPath + $"/Sample/sample_builder.json";
if (File.Exists(path))
{
File.Delete(path);
}
JsonSerializerSettings settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto,
SerializationBinder = Binders._entity,
Formatting = Formatting.Indented,
Converters = new List <JsonConverter>()
{
new RuleTileConverter(),
new TerrainConverter(),
new TileConverter()
},
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
File.AppendAllText(path, JsonConvert.SerializeObject(builder, settings));
AssetDatabase.Refresh();
Debug.Log($"Wrote sample builder to {path}.");
}
public Fill(TerrainDefinition terrain)
{
this.terrain = terrain;
}
/// <summary>
/// ID-only constructor for JSON writing.
/// </summary>
/// <param name="terrainID"></param>
public Fill(string terrainID)
{
terrain = ScriptableObject.CreateInstance <TerrainDefinition>();
terrain.name = terrainID;
}
public TerrainDefinition(TerrainDefinition source)
{
type = source.type;
properties = source.properties;
}
void OnGUI()
{
bool requiresApply = false;
//We now allow to reload definitions of the terrains. Its most likely first thing user have to do when opens this window,
//but may be useful as well later when some changes occurs during window session
if (GUILayout.Button("Reload definitions"))
{
window = (TerrainEditor)EditorWindow.GetWindow(typeof(TerrainEditor));
TerrainDefinition.ReloadDefinitions();
return;
}
if (!DataManager.isInitialized)
{
GUILayout.Label("Missing data manager initialization!");
return;
}
if (window == null)
{
GUILayout.Label("Missing window reference!");
return;
}
List <TerrainDefinition> terrains = TerrainDefinition.definitions;
bool add = false;
int del = -1;
//Button which allows to create new terrain definition slot
GUI.color = Color.green;
if (GUILayout.Button("+"))
{
add = true;
requiresApply = true;
}
GUI.color = Color.white;
//this part will calculate how many items in a row we want to display
Rect r = window.position;
int horizontalCount = Mathf.Max(1, (int)r.width / 610);
scrall = EditorGUILayout.BeginScrollView(scrall);
GUILayout.BeginHorizontal();
for (int i = 0; i < terrains.Count; i++)
{
if (i % horizontalCount == 0)
{
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
if (!EditTerrain(terrains[i], ref requiresApply))
{
del = i;
requiresApply = true;
}
}
GUILayout.EndHorizontal();
//check if any terrain requested removal
if (del > -1)
{
MHTerrain.list.Remove(terrains[del].source);
MHDatabase.SaveDB <MHTerrain>();
TerrainDefinition.ReloadDefinitions();
}
//check if new terrain definition should be initialized
if (add)
{
MHTerrain terrain = new MHTerrain();
terrain.CreateDBIndex();
MHTerrain.list.Add(terrain);
MHDatabase.SaveDB <MHTerrain>();
TerrainDefinition.ReloadDefinitions();
}
EditorGUILayout.EndScrollView();
//if any element noticed change, database will save file
if (requiresApply)
{
MHDatabase.SaveDB <MHTerrain>();
}
}
/// <summary>
/// ID-only constructor for JSON writing.
/// </summary>
public RandomFill(string terrainID, int percent)
{
terrain = ScriptableObject.CreateInstance <TerrainDefinition>();
terrain.name = terrainID;
this.percent = percent;
}
/// <summary>
/// Single terrain definition edit.
/// </summary>
/// <param name="t"> terrain definition to display </param>
/// <param name="requiresApply">returns information if terrain changed</param>
/// <returns></returns>
public bool EditTerrain(TerrainDefinition t, ref bool requiresApply)
{
bool v = true;
GUILayout.BeginVertical("Box", GUILayout.Width(600));
GUI.color = Color.red;
//button which allows to mark terrain for removal
if (GUILayout.Button("x"))
{
v = false;
}
GUI.color = Color.white;
GUILayout.BeginHorizontal();
//terrain specific tags and settings
GUILayout.BeginVertical(GUILayout.Width(200));
GUILayout.BeginHorizontal();
GUI.color = t.source.IsNameUnique() ? Color.white : Color.red;
GUILayout.Label("Terrain Name:");
if (TextField(ref t.source.name, GUILayout.Width(110)))
{
MHDatabase.SaveDB <MHTerrain>();
}
GUI.color = Color.white;
GUILayout.EndHorizontal();
MHTerrain.Mode m = (MHTerrain.Mode)EditorGUILayout.EnumPopup(t.source.mode, GUILayout.Width(180));
if (m != t.source.mode)
{
t.source.mode = m;
MHDatabase.SaveDB <MHTerrain>();
}
DisplayAvaliableTags(t);
GUILayout.EndVertical();
//foreground editor for terrain
GUILayout.BeginVertical("Box", GUILayout.Width(150));
DisplayAvaliableForegrounds(t);
GUILayout.EndVertical();
//texture list used to bake terrain
GUILayout.BeginVertical(GUILayout.Width(250));
if (ObjectField <Texture>("Diffuse:", ref t.diffuse, false))
{
t.source.diffusePath = GetAssetPath(AssetDatabase.GetAssetPath(t.diffuse));
t.source.UseDiffusenameIfNoName();
requiresApply = true;
}
if (ObjectField <Texture>("Height:", ref t.height, false))
{
t.source.heightPath = GetAssetPath(AssetDatabase.GetAssetPath(t.height));
requiresApply = true;
}
if (ObjectField <Texture>("Mixer:", ref t.mixer, false))
{
t.source.mixerPath = GetAssetPath(AssetDatabase.GetAssetPath(t.mixer));
requiresApply = true;
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
return(v);
}
public RandomFill(TerrainDefinition terrain, int percent)
{
this.terrain = terrain;
this.percent = percent;
}
