private void PrintSet(StringBuilder output, Dictionary <HashSet <MatPairStruct>, int> material)
{
foreach (var item in material)
{
if (item.Key.Count == 0)
{
output.AppendFormat("Found {0} empty instances.", item.Value).AppendLine();
}
else
{
output.Append("Found ").Append(item.Value).Append(" instances of:").AppendLine();
output.Append(item.Key.Count).Append("; ");
MatPairStruct[] matList = new MatPairStruct[item.Key.Count];
item.Key.CopyTo(matList);
Array.Sort(matList);
foreach (var mat in matList)
{
if (MaterialRaws.Instance.ContainsKey(mat))
{
output.Append(MaterialRaws.Instance[mat].id).Append("; ");
}
else
{
output.Append(mat).Append("; ");
}
}
output.AppendLine();
}
}
}
bool GetMaterialRef(MatPairStruct material, MapDataStore.Tile tile, MeshLayer layer, out T value)
{
Content cont;
if (materialMatcher.TryGetValue(material, out cont))
{
if (thisMaterialMatcher == null)
{
value = cont.GetValue(tile, layer);
return(true);
}
else if (cont.overloadedItem != null)
{
if (cont.overloadedItem.GetValue(tile, layer, out value))
{
return(true);
}
}
}
if (thisMaterialMatcher != null && thisMaterialMatcher.TryGetValue(material, out value))
{
return(true);
}
value = default(T);
return(false);
}
public static ClothingTexture GetTexture(MatPairStruct item)
{
if (!Application.isPlaying)
{
var cloth = Resources.Load <ClothingTexture>("Clothing/" + ItemRaws.Instance[item].id);
if (cloth == null)
{
cloth = Resources.Load <ClothingTexture>("Clothing/DEFAULT");
}
return(cloth);
}
if (clothingLookup == null)
{
clothingLookup = new Dictionary <MatPairStruct, ClothingTexture>();
}
if (!clothingLookup.ContainsKey(item))
{
clothingLookup[item] = Resources.Load <ClothingTexture>("Clothing/" + ItemRaws.Instance[item].id);
}
if (clothingLookup[item] == null)
{
clothingLookup[item] = Resources.Load <ClothingTexture>("Clothing/DEFAULT");
}
return(clothingLookup[item]);
}
static private void PopulateWordLists()
{
foreach (var race in _creatureRawList)
{
foreach (var caste in race.caste)
{
MatPairStruct id = new MatPairStruct(race.index, caste.index);
if (_casteIds == null)
{
_casteIds = new Dictionary <string, Dictionary <string, MatPairStruct> >();
}
if (!_casteIds.ContainsKey(race.creature_id))
{
_casteIds[race.creature_id] = new Dictionary <string, MatPairStruct>();
}
_casteIds[race.creature_id][caste.caste_id] = id;
}
{
MatPairStruct id = new MatPairStruct(race.index, -1);
if (_casteIds == null)
{
_casteIds = new Dictionary <string, Dictionary <string, MatPairStruct> >();
}
if (!_casteIds.ContainsKey(race.creature_id))
{
_casteIds[race.creature_id] = new Dictionary <string, MatPairStruct>();
}
_casteIds[race.creature_id]["*"] = id;
}
}
}
public Texture2D CreateImage(ArtImage artImage)
{
for (int i = 0; i < indexWidth * indexWidth; i++)
{
colors[i] = new Color32(0, 1, 0, 0);
}
MatPairStruct id = artImage.id;
if (generatedImages.ContainsKey(id))
{
return(generatedImages[id]);
}
Texture2D texture = null;
Rect[][] imagePattern = GetFullPattern(artImage);
for (int i = 0; i < imagePattern.Length; i++)
{
foreach (var item in imagePattern[i])
{
CopyElement(item, GetElementTile(artImage.elements[i]));
}
}
texture = new Texture2D(16, 16, TextureFormat.RGBAHalf, false, true);
texture.SetPixels(colors);
texture.Apply();
texture.name = id.ToString();
texture.filterMode = FilterMode.Point;
generatedImages[id] = texture;
return(texture);
}
public T this[MatPairStruct mat]
{
set
{
BaseContainer[mat] = value;
}
}
static void AddCreature(string race, string caste, MatPairStruct id)
{
if (_casteIds == null)
_casteIds = new Dictionary<string, Dictionary<string, MatPairStruct>>();
if (!_casteIds.ContainsKey(race))
_casteIds[race] = new Dictionary<string, MatPairStruct>();
_casteIds[race][caste] = id;
}
public static Color GetGrowthColor(GrowthPeriod period, int growthID, MatPairStruct mat)
{
if (period == GrowthPeriod.Fresh)
{
return(GetColor(mat));
}
if (mat.mat_index >= DFConnection.Instance.NetPlantRawList.plant_raws.Count)
{
return(GetColor(mat));
}
if (growthID >= DFConnection.Instance.NetPlantRawList.plant_raws[mat.mat_index].growths.Count)
{
return(GetColor(mat));
}
var growth = DFConnection.Instance.NetPlantRawList.plant_raws[mat.mat_index].growths[growthID];
int currentTicks = TimeHolder.DisplayedTime.CurrentYearTicks;
RemoteFortressReader.GrowthPrint freshPrints = null;
RemoteFortressReader.GrowthPrint currentPrint = null;
RemoteFortressReader.GrowthPrint stalePrint = null;
int minTicks = int.MaxValue;
int maxTicks = int.MinValue;
foreach (var print in growth.prints)
{
if ((print.timing_start == -1 || print.timing_start <= currentTicks) && (print.timing_end == -1 || print.timing_end >= currentTicks))
{
currentPrint = print;
}
if (print.timing_start == -1 || print.timing_start < minTicks)
{
minTicks = print.timing_start;
freshPrints = print;
}
if (print.timing_end == -1 || print.timing_end > maxTicks)
{
maxTicks = print.timing_end;
stalePrint = print;
}
}
if (currentPrint == null)
{
currentPrint = stalePrint;
}
switch (period)
{
case GrowthPeriod.Current:
return(DfColor.MorphColor(GetColor(mat), freshPrints.color, currentPrint.color));
case GrowthPeriod.Stale:
return(DfColor.MorphColor(GetColor(mat), freshPrints.color, stalePrint.color));
}
return(GetColor(mat));
}
public static int GetShapeIndex(MatPairStruct mat)
{
MaterialTextureSet textureSet;
if (Instance.MaterialTextures.TryGetValue(mat, out textureSet))
{
return(textureSet.shapeIndex);
}
return(Instance.DefaultShapeTexIndex);
}
void Count(Dictionary <MatPairStruct, int> dict, MatPairStruct value)
{
if (!dict.ContainsKey(value))
{
dict[value] = 1;
}
else
{
dict[value] = dict[value] + 1;
}
}
public T this[MatPairStruct mat]
{
set
{
if (itemList == null)
{
itemList = new Dictionary <MatPairStruct, T>();
}
itemList[mat] = value;
}
}
void TrySetMatch(MaterialMatch match, MatPairStruct mat)
{
if (matList.ContainsKey(mat))
{
if (matList[mat].difference < match.difference) //overwrite existing exact matches
{
return; //the comparitor can be changed to <= if that behavior is not desired.
}
}
matList[mat] = match;
}
static void AddCreature(string race, string caste, MatPairStruct id)
{
if (_casteIds == null)
{
_casteIds = new Dictionary <string, Dictionary <string, MatPairStruct> >();
}
if (!_casteIds.ContainsKey(race))
{
_casteIds[race] = new Dictionary <string, MatPairStruct>();
}
_casteIds[race][caste] = id;
}
internal static void AddFakeCreaturesToList(Dictionary <MatPairStruct, MaterialDefinition> creatures, string prefix)
{
foreach (string template in templateList)
{
MatPairStruct creatureCaste = new MatPairStruct(count, -1);
MaterialDefinition creatureDef = new MaterialDefinition();
creatureDef.mat_pair = creatureCaste;
creatureDef.id = prefix.ToUpper() + "_" + template.ToUpper() + ":DEFAULT";
creatureDef.name = prefix.ToLower() + " " + template.ToLower();
creatures[creatureCaste] = creatureDef;
count--;
}
}
public int GetItemTile(MatPairStruct item)
{
if (ItemSpriteMap.ContainsKey(item))
{
return(ItemSpriteMap[item]);
}
item = new MatPairStruct(item.mat_type, -1);
if (ItemSpriteMap.ContainsKey(item))
{
return(ItemSpriteMap[item]);
}
return(7);
}
public T this[MatPairStruct caste]
{
set
{
if (creatureRaceList == null)
{
creatureRaceList = new Dictionary <MatPairStruct, RaceMatch>();
}
RaceMatch newItem;
newItem.item = value;
newItem.difference = 0;
creatureRaceList[caste] = newItem;
}
}
/// <summary>
/// Gets a color for a given item type and material combination, including any seasonal variations.
/// </summary>
/// <param name="item">Item type</param>
/// <param name="mat">Material</param>
/// <returns></returns>
public static Color GetColor(MatPairStruct item, MatPairStruct mat)
{
switch (item.mat_type)
{
case 55: //PLANT_GROWTH
{
return(GetGrowthColor(GrowthPeriod.Current, item.mat_index, mat));
}
default:
break;
}
return(GetColor(mat));
}
public static int GetShapeIndex(MatPairStruct mat)
{
MaterialTextureSet textureSet;
if (MaterialCollection.Instance.TryGetValue(mat, out textureSet))
{
return(textureSet.shapeIndex);
}
if (Instance == null)
{
return(0);
}
return(Instance.DefaultShapeTexIndex);
}
void TrySetMatch(RaceMatch match, MatPairStruct mat)
{
if (creatureRaceList == null)
{
creatureRaceList = new Dictionary <MatPairStruct, RaceMatch>();
}
if (creatureRaceList.ContainsKey(mat))
{
if (creatureRaceList[mat].difference < match.difference) //overwrite existing exact matches
{
return; //the comparitor can be changed to <= if that behavior is not desired.
}
}
creatureRaceList[mat] = match;
}
/// <summary>
/// sets an object to the specified race/caste ID.
/// This will always take precedence over objects set by string tokens.
/// </summary>
/// <param name="caste">numerical race/caste</param>
/// <returns></returns>
public T this[MatPairStruct caste]
{
set
{
if (creatureRaceList == null)
{
creatureRaceList = new Dictionary <MatPairStruct, T>();
}
creatureRaceList[caste] = value;
}
get
{
return(creatureRaceList[caste]);
}
}
private static void PopulateWordLists()
{
foreach (var race in _creatureRawList)
{
foreach (var caste in race.caste)
{
MatPairStruct id = new MatPairStruct(race.index, caste.index);
if (_casteIds == null)
_casteIds = new Dictionary<string, Dictionary<string, MatPairStruct>>();
if (!_casteIds.ContainsKey(race.creature_id))
_casteIds[race.creature_id] = new Dictionary<string, MatPairStruct>();
_casteIds[race.creature_id][caste.caste_id] = id;
}
}
}
public void Modify(int?tileType = null,
MatPairStruct?material = null,
MatPairStruct?base_material = null,
MatPairStruct?layer_material = null,
MatPairStruct?vein_material = null,
int?waterLevel = null,
int?magmaLevel = null,
MatPairStruct?construction_item = null,
int?rampType = null)
{
if (tileType != null)
{
this.tileType = tileType.Value;
}
if (material != null)
{
this.material = material.Value;
}
if (base_material != null)
{
this.base_material = base_material.Value;
}
if (layer_material != null)
{
this.layer_material = layer_material.Value;
}
if (vein_material != null)
{
this.vein_material = vein_material.Value;
}
if (waterLevel != null)
{
this.waterLevel = waterLevel.Value;
}
if (magmaLevel != null)
{
this.magmaLevel = magmaLevel.Value;
}
if (construction_item != null)
{
this.construction_item = construction_item.Value;
}
if (rampType != null)
{
this.rampType = rampType.Value;
}
}
public bool TryGetValue(MatPairStruct caste, out T value)
{
if (creatureRaceList != null)
{
if (creatureRaceList.TryGetValue(caste, out value))
{
return(true);
}
caste = new MatPairStruct(caste.mat_type, -1);
if (creatureRaceList.TryGetValue(caste, out value))
{
return(true);
}
}
value = default(T);
return(false);
}
public bool TryGetValue(MatPairStruct mat, out T value)
{
MaterialMatch output;
if (matList.TryGetValue(mat, out output))
{
value = output.item;
return(true);
}
mat = new MatPairStruct(mat.mat_type, -1); //Try once more with a more generic value.
if (matList.TryGetValue(mat, out output))
{
value = output.item;
return(true);
}
value = default(T);
return(false);
}
public static ItemModel InstantiateItem(Item item, Transform parent, bool worldPositionStays = true)
{
MatPairStruct type = item.type;
ItemModel placedItem;
var prefab = Instance.defaultItem;
if (itemPrefabs.Count == 0)
{
Instance.ForceLoadItems();
}
if (!itemPrefabs.ContainsKey(type))
{
type = new MatPairStruct(type.mat_type, -1);
}
if (!itemPrefabs.ContainsKey(type))
{
type = new MatPairStruct(-1, -1);
}
if (itemPrefabs.ContainsKey(type))
{
prefab = itemPrefabs[type];
}
if (worldPositionStays)
{
placedItem = Instantiate(prefab, GameMap.DFtoUnityCoord(item.pos), Quaternion.identity);
}
else
{
placedItem = Instantiate(prefab);
}
if (ItemRaws.Instance.ContainsKey(item.type))
{
placedItem.name = ItemRaws.Instance[item.type].id + "_" + item.id;
}
placedItem.transform.SetParent(parent, worldPositionStays);
placedItem.transform.parent = parent;
placedItem.UpdateMaterial(item);
return(placedItem);
}
/// <summary>
/// Get the color associated with a material, falling back to DF state color.
/// </summary>
/// <param name="mat"></param>
/// <returns></returns>
public static Color GetColor(MatPairStruct mat)
{
MaterialTextureSet textureSet;
if (MaterialCollection.Instance.TryGetValue(mat, out textureSet))
{
return(textureSet.color);
}
if (!MaterialRaws.Instance.ContainsKey(mat))
{
return(new Color32(128, 128, 128, 128));
}
var stateColor = MaterialRaws.Instance[mat].state_color;
if (stateColor == null)
{
return(new Color32(128, 128, 128, 128));
}
return(new Color32((byte)stateColor.red, (byte)stateColor.green, (byte)stateColor.blue, 128));
}
/// <summary>
/// Get the color associated with a material, falling back to DF state color.
/// </summary>
/// <param name="mat"></param>
/// <returns></returns>
public static Color GetColor(MatPairStruct mat)
{
MaterialTextureSet textureSet;
if (Instance.MaterialTextures.TryGetValue(mat, out textureSet))
{
return(textureSet.color);
}
if (!GameMap.materials.ContainsKey(mat))
{
return(new Color32(128, 128, 128, 128));
}
var stateColor = GameMap.materials[mat].state_color;
if (stateColor == null)
{
return(new Color32(128, 128, 128, 128));
}
return(new Color32((byte)stateColor.red, (byte)stateColor.green, (byte)stateColor.blue, 128));
}
public bool Get(MatPairStruct mat, out T value)
{
if (itemList != null)
{
T output;
if (itemList.TryGetValue(mat, out output))
{
value = output;
return(true);
}
mat = new MatPairStruct(mat.Type, -1); //Try once more with a more generic value.
if (itemList.TryGetValue(mat, out output))
{
value = output;
return(true);
}
}
value = default(T);
return(false);
}
private void LoadLayeredSpriteSets()
{
var spriteSetList = Resources.LoadAll <CreatureSpriteCollection>("Creatures");
foreach (var spriteSet in spriteSetList)
{
MatPairStruct raceID = new MatPairStruct(-1, -1);
//With generated creatures, the same sprite can potentially match more than one creature.
var raceRawList = GeneratedCreatureTranslator.GetCreatureRaw(spriteSet.race);
if (raceRawList == null)
{
continue;
}
foreach (var raceRaw in raceRawList)
{
raceID = new MatPairStruct(raceRaw.index, -1);
if (!string.IsNullOrEmpty(spriteSet.caste))
{
var casteRaw = raceRaw.caste.Find(x => x.caste_id == spriteSet.caste);
if (casteRaw == null)
{
continue;
}
raceID = new MatPairStruct(raceID.Race, casteRaw.index);
}
if (!spriteSets.ContainsKey(raceID.Race))
{
spriteSets[raceID.Race] = new ProfessionDictionary();
}
if (!spriteSets[raceID.Race].ContainsKey(spriteSet.profession))
{
spriteSets[raceID.Race][spriteSet.profession] = new SpecialDictionary();
}
if (!spriteSets[raceID.Race][spriteSet.profession].ContainsKey(spriteSet.special))
{
spriteSets[raceID.Race][spriteSet.profession][spriteSet.special] = new CasteDictionary();
}
spriteSets[raceID.Race][spriteSet.profession][spriteSet.special][raceID.Caste] = spriteSet;
}
}
}
public T this[MatPairStruct mat]
{
//get
//{
// T output;
// if (!TryGetValue(mat, out output))
// output = default(T);
// return output;
//}
set
{
if (matList == null)
{
matList = new Dictionary <MatPairStruct, MaterialMatch>();
}
MaterialMatch newItem;
newItem.item = value;
newItem.difference = 0; //a material pair will always be an exact match.
matList[mat] = newItem; //actually, is that desired?
}
}
public static bool TryGetCasteID(string token, out MatPairStruct id)
{
string[] parts = token.Split(':');
string race = parts[0];
string caste = "*";
if (parts.Length > 1)
{
caste = parts[1];
}
if (!CasteIDs.ContainsKey(race))
{
id = new MatPairStruct(-1, -1);
return(false);
}
if (!CasteIDs[race].ContainsKey(caste))
{
caste = "*";
}
id = CasteIDs[race][caste];
return(true);
}
public T this[MatPairStruct mat]
{
get
{
if (!TryGetValue(mat, out T output))
{
throw new KeyNotFoundException();
}
return(output);
}
set
{
if (matList == null)
{
matList = new Dictionary <MatPairStruct, MaterialMatch>();
}
MaterialMatch newItem;
newItem.item = value;
newItem.difference = 0; //a material pair will always be an exact match.
matList[mat] = newItem; //actually, is that desired?
}
}
public void Modify (int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null,
BuildingStruct? buildingType = null,
MatPairStruct? buildingMaterial = null,
DFCoord2d? buildingLocalPos = null,
BuildingDirection? buildingDirection = null,
bool? hidden = null)
{
if (tileType != null) {
this.tileType = tileType.Value;
}
if (material != null) {
this.material = material.Value;
}
if (base_material != null) {
this.base_material = base_material.Value;
}
if (layer_material != null) {
this.layer_material = layer_material.Value;
}
if (vein_material != null) {
this.vein_material = vein_material.Value;
}
if (waterLevel != null) {
this.waterLevel = waterLevel.Value;
}
if (magmaLevel != null) {
this.magmaLevel = magmaLevel.Value;
}
if (construction_item != null)
{
this.construction_item = construction_item.Value;
}
if(rampType != null)
{
this.rampType = rampType.Value;
}
if(buildingType != null)
{
this.buildingType = buildingType.Value;
}
if(buildingMaterial != null)
{
this.buildingMaterial = buildingMaterial.Value;
}
if (buildingLocalPos != null)
this.buildingLocalPos = buildingLocalPos.Value;
if (buildingDirection != null)
this.buildingDirection = buildingDirection.Value;
if (hidden != null)
this.hidden = hidden.Value;
}
public void InitOrModifyTile(DFCoord coord,
int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null,
BuildingStruct? buildingType = null,
MatPairStruct? buildingMaterial = null,
DFCoord2d? buildingLocalPos = null,
BuildingDirection? buildingDirection = null,
bool? hidden = null)
{
DFCoord local = WorldToLocalSpace(coord);
if (!InSliceBoundsLocal(local.x, local.y, local.z)) {
throw new UnityException("Can't modify tile outside of slice");
}
if (tiles[local.x, local.y, local.z] == null)
tiles[local.x, local.y, local.z] = new Tile(this, local);
tiles[local.x, local.y, local.z].Modify(tileType, material, base_material, layer_material, vein_material, waterLevel, magmaLevel, construction_item, rampType, buildingType, buildingMaterial, buildingLocalPos, buildingDirection, hidden);
}
/// <summary>
/// This is the function that actually decides what mesh and texture each tile gets
/// </summary>
/// <param name="buffer">Buffer to put the chosen meshes into for combining</param>
/// <param name="layer">layer currently being worked on</param>
/// <param name="tile">The tile to get all the needed info from.</param>
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile, Vector3 pos)
{
buffer = new MeshCombineUtility.MeshInstance();
Vector2 index1 = Vector2.zero;
Vector2 index2 = Vector2.zero;
MeshContent meshContent = null;
buffer.color = Color.grey;
if (layer == MeshLayer.Collision)
{
if (!ContentLoader.Instance.CollisionMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
if (meshContent.MeshData.ContainsKey(MeshLayer.Collision))
buffer.meshData = meshContent.MeshData[MeshLayer.Collision];
else if (meshContent.MeshData.ContainsKey(MeshLayer.StaticMaterial))
buffer.meshData = meshContent.MeshData[MeshLayer.StaticMaterial];
else
{
buffer.meshData = null;
return;
}
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
if (layer == MeshLayer.BuildingCollision)
{
if (tile.buildingType == default(BuildingStruct) || !ContentLoader.Instance.BuildingCollisionMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
if (meshContent.MeshData.ContainsKey(MeshLayer.Collision))
buffer.meshData = meshContent.MeshData[MeshLayer.Collision];
else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterial))
buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterial];
else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterialCutout))
buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterialCutout];
else if (meshContent.MeshData.ContainsKey(MeshLayer.BuildingMaterialTransparent))
buffer.meshData = meshContent.MeshData[MeshLayer.BuildingMaterialTransparent];
else
{
buffer.meshData = null;
return;
}
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
if (ContentLoader.Instance.DesignationMeshConfiguration.GetValue(tile, layer, out meshContent))
{
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
if (TextureStorage.UsingArray)
{
if (meshContent.MaterialTexture != null)
index1.x = meshContent.MaterialTexture.ArrayIndex;
else
index1.x = ContentLoader.Instance.DefaultMatTexArrayIndex;
if (meshContent.ShapeTexture != null)
index1.y = meshContent.ShapeTexture.ArrayIndex;
else
index1.y = ContentLoader.Instance.DefaultShapeTexArrayIndex;
if (meshContent.SpecialTexture != null)
index2.x = meshContent.SpecialTexture.ArrayIndex;
else
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
}
else
{
if (meshContent.MaterialTexture != null)
buffer.uv1Transform = meshContent.MaterialTexture.UVTransform;
else
buffer.uv1Transform = ContentLoader.Instance.DefaultMatTexTransform;
if (meshContent.ShapeTexture != null)
buffer.uv2Transform = meshContent.ShapeTexture.UVTransform;
else
buffer.uv2Transform = ContentLoader.Instance.DefaultShapeTexTransform;
if (meshContent.SpecialTexture != null)
buffer.uv3Transform = meshContent.SpecialTexture.UVTransform;
else
buffer.uv3Transform = ContentLoader.Instance.DefaultSpecialTexTransform;
}
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
return;
}
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent:
case MeshLayer.GrowthTransparent1:
case MeshLayer.GrowthTransparent2:
case MeshLayer.GrowthTransparent3:
{
switch (tile.tiletypeMaterial)
{
case TiletypeMaterial.PLANT:
case TiletypeMaterial.ROOT:
case TiletypeMaterial.TREE_MATERIAL:
case TiletypeMaterial.MUSHROOM:
if (!ContentLoader.Instance.GrowthMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
break;
default:
buffer.meshData = null;
return;
}
}
break;
case MeshLayer.BuildingMaterial:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.BuildingMaterialTransparent:
case MeshLayer.NoMaterialBuildingTransparent:
{
if (tile.buildingType == default(BuildingStruct))
{
buffer.meshData = null;
return;
}
if (!ContentLoader.Instance.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
default:
{
if (layer == MeshLayer.NaturalTerrain)
{
if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.HandleShape(tile) && !VoxelGenerator.UseBoth(tile))
layer = MeshLayer.StaticMaterial;
else
{
buffer.meshData = null;
return;
}
}
else if (VoxelGenerator.IsNatural(tile) && !VoxelGenerator.UseBoth(tile))
{
buffer.meshData = null;
return;
}
if (!ContentLoader.Instance.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
}
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
Matrix4x4 matTexTransform = ContentLoader.Instance.DefaultMatTexTransform;
Matrix4x4 shapeTextTransform = ContentLoader.Instance.DefaultShapeTexTransform;
Matrix4x4 specialTexTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (meshContent.ShapeTexture == null)
{
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if (ContentLoader.Instance.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
index1.y = tileTexContent.ArrayIndex;
}
}
else
{
if (ContentLoader.Instance.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
{
shapeTextTransform = tileTexContent.UVTransform;
index1.y = tileTexContent.ArrayIndex;
}
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
index1.y = meshContent.ShapeTexture.ArrayIndex;
}
if (meshContent.MaterialTexture != null
&& (layer == MeshLayer.NoMaterial
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.NoMaterialBuildingTransparent
|| layer == MeshLayer.NoMaterialCutout
|| layer == MeshLayer.NoMaterialTransparent))
{
matTexTransform = meshContent.MaterialTexture.UVTransform;
index1.x = meshContent.MaterialTexture.ArrayIndex;
}
else
{
TextureContent matTexContent;
if (ContentLoader.Instance.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
{
matTexTransform = matTexContent.UVTransform;
index1.x = matTexContent.ArrayIndex;
}
}
if (meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
index2.x = meshContent.SpecialTexture.ArrayIndex;
}
else
{
specialTexTransform = ContentLoader.Instance.DefaultSpecialTexTransform;
index2.x = ContentLoader.Instance.DefaultSpecialTexArrayIndex;
}
ColorContent newColorContent;
Color newColor;
if (ContentLoader.Instance.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.color;
}
else
{
MatPairStruct mat = new MatPairStruct(-1, -1);
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
case MeshLayer.StaticTransparent:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
case MeshLayer.BaseTransparent:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
case MeshLayer.LayerTransparent:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
case MeshLayer.VeinTransparent:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.NoMaterialBuildingTransparent:
case MeshLayer.NoMaterialTransparent:
break;
case MeshLayer.BuildingMaterial:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.BuildingMaterialTransparent:
mat = tile.buildingMaterial;
break;
default:
break;
}
MaterialDefinition mattie;
if (materials.TryGetValue(mat, out mattie))
{
ColorDefinition color = mattie.state_color;
if (color == null)
newColor = Color.cyan;
else
newColor = new Color(color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f, 1);
}
else
{
newColor = Color.grey;
}
}
buffer.color = newColor;
if (TextureStorage.UsingArray)
{
buffer.uv1Transform = Matrix4x4.identity;
buffer.uv2Force = index1;
buffer.uv3Force = index2;
}
else
{
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.uv3Transform = specialTexTransform;
}
buffer.hiddenFaces = CalculateHiddenFaces(tile, meshContent.Rotation);
}
public RegionTile(RemoteFortressReader.RegionTile tile)
{
elevation = tile.elevation;
water_elevation = tile.water_elevation;
rainfall = tile.rainfall;
vegetation = tile.vegetation;
temperature = tile.temperature;
evilness = tile.evilness;
drainage = tile.drainage;
volcanism = tile.volcanism;
savagery = tile.savagery;
salinity = tile.salinity;
rivers = tile.river_tiles;
surfaceMaterial = tile.surface_material;
plantMaterials = new List<MatPairStruct>();
foreach (var item in tile.plant_materials)
{
plantMaterials.Add(item);
}
buildings = tile.buildings;
stoneMaterials = new List<MatPairStruct>();
foreach (var item in tile.stone_materials)
{
stoneMaterials.Add(item);
}
treeMaterials = new List<MatPairStruct>();
foreach (var item in tile.tree_materials)
{
treeMaterials.Add(item);
}
snow = tile.snow;
}
void OnConnectToDF()
{
Debug.Log("Connected");
enabled = true;
mesher = BlockMesher.GetMesher(meshingThreads);
// Initialize materials, if available
if (DFConnection.Instance.NetMaterialList != null)
{
if (materials == null)
materials = new Dictionary<MatPairStruct, RemoteFortressReader.MaterialDefinition>();
materials.Clear();
foreach (RemoteFortressReader.MaterialDefinition material in DFConnection.Instance.NetMaterialList.material_list)
{
materials[material.mat_pair] = material;
}
SaveMaterialList(materials, "MaterialList.csv");
}
// Initialize items, if available
if (DFConnection.Instance.NetItemList != null)
{
if (items == null)
items = new Dictionary<MatPairStruct, RemoteFortressReader.MaterialDefinition>();
items.Clear();
foreach (MaterialDefinition material in DFConnection.Instance.NetItemList.material_list)
{
items[material.mat_pair] = material;
}
SaveMaterialList(items, "ItemList.csv");
}
if (DFConnection.Instance.NetBuildingList != null)
{
if (buildings == null)
buildings = new Dictionary<BuildingStruct, BuildingDefinition>();
buildings.Clear();
foreach (BuildingDefinition building in DFConnection.Instance.NetBuildingList.building_list)
{
buildings[building.building_type] = building;
}
SaveBuildingList();
}
if (DFConnection.Instance.NetCreatureRawList != null)
{
if (creatures == null)
creatures = new Dictionary<MatPairStruct, MaterialDefinition>();
foreach (CreatureRaw creatureRaw in DFConnection.Instance.NetCreatureRawList.creature_raws)
{
foreach (var caste in creatureRaw.caste)
{
MatPairStruct creatureCaste = new MatPairStruct(creatureRaw.index, caste.index);
MaterialDefinition creatureDef = new MaterialDefinition();
creatureDef.mat_pair = creatureCaste;
creatureDef.id = creatureRaw.creature_id + ":" + caste.caste_id;
creatureDef.name = caste.caste_name[0];
creatureDef.state_color = creatureRaw.color;
creatures[creatureCaste] = creatureDef;
}
}
SaveMaterialList(creatures, "CreatureList.csv");
}
SaveTileTypeList();
UpdateView();
blockListTimer.Start();
cullTimer.Start();
lazyLoadTimer.Start();
InitializeBlocks();
}
public Tile(MapDataStore container, DFCoord position)
{
this.container = container;
this.position = position;
tileType = default(int);
material = default(MatPairStruct);
base_material = default(MatPairStruct);
layer_material = default(MatPairStruct);
vein_material = default(MatPairStruct);
construction_item = default(MatPairStruct);
waterLevel = default(int);
magmaLevel = default(int);
rampType = 0;
buildingMaterial = default(MatPairStruct);
buildingType = default(BuildingStruct);
buildingLocalPos = default(DFCoord2d);
buildingDirection = 0;
Hidden = false;
trunkPercent = 0;
positionOnTree = default(DFCoord);
digDesignation = TileDigDesignation.NO_DIG;
spatters = null;
}
public void InitOrModifyTile(DFCoord coord,
int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null,
BuildingStruct? buildingType = null,
MatPairStruct? buildingMaterial = null,
DFCoord2d? buildingLocalPos = null,
BuildingDirection? buildingDirection = null,
bool? hidden = null,
byte? trunkPercent = null,
DFCoord? positionOnTree = null,
TileDigDesignation? digDesignation = null,
List<Spatter> spatters = null)
{
if (!InSliceBounds(coord)) {
throw new UnityException("Can't modify tile outside of slice");
}
if (this[coord] == null)
this[coord] = new Tile(this, coord);
this[coord].Modify(
tileType,
material,
base_material,
layer_material,
vein_material,
waterLevel,
magmaLevel,
construction_item,
rampType,
buildingType,
buildingMaterial,
buildingLocalPos,
buildingDirection,
hidden,
trunkPercent,
positionOnTree,
digDesignation,
spatters
);
}
public void Modify(int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null,
BuildingStruct? buildingType = null,
MatPairStruct? buildingMaterial = null,
DFCoord2d? buildingLocalPos = null,
BuildingDirection? buildingDirection = null,
bool? hidden = null,
byte? trunkPercent = null,
DFCoord? positionOnTree = null,
TileDigDesignation? digDesignation = null,
List<Spatter> spatters = null)
{
if (tileType != null) {
this.tileType = tileType.Value;
}
if (material != null) {
this.material = material.Value;
}
if (base_material != null) {
this.base_material = base_material.Value;
}
if (layer_material != null) {
this.layer_material = layer_material.Value;
}
if (vein_material != null) {
this.vein_material = vein_material.Value;
}
if (waterLevel != null) {
this.waterLevel = waterLevel.Value;
}
if (magmaLevel != null) {
this.magmaLevel = magmaLevel.Value;
}
if (construction_item != null)
{
this.construction_item = construction_item.Value;
}
if(rampType != null)
{
this.rampType = rampType.Value;
}
if(buildingType != null)
{
this.buildingType = buildingType.Value;
}
if(buildingMaterial != null)
{
this.buildingMaterial = buildingMaterial.Value;
}
if (buildingLocalPos != null)
this.buildingLocalPos = buildingLocalPos.Value;
if (buildingDirection != null)
this.buildingDirection = buildingDirection.Value;
if (hidden != null)
Hidden = hidden.Value;
if (trunkPercent != null)
this.trunkPercent = trunkPercent.Value;
if (positionOnTree != null)
this.positionOnTree = positionOnTree.Value;
if (digDesignation != null)
this.digDesignation = digDesignation.Value;
if (spatters != null)
this.spatters = spatters;
}
public void CopyFrom(Tile orig)
{
container = orig.container;
position = orig.position;
tileType = orig.tileType;
material = orig.material;
base_material = orig.base_material;
layer_material = orig.layer_material;
vein_material = orig.vein_material;
construction_item = orig.construction_item;
waterLevel = orig.waterLevel;
magmaLevel = orig.magmaLevel;
RampType = orig.RampType;
buildingType = orig.buildingType;
buildingMaterial = orig.buildingMaterial;
buildingLocalPos = orig.buildingLocalPos;
buildingDirection = orig.buildingDirection;
Hidden = orig.Hidden;
trunkPercent = orig.trunkPercent;
positionOnTree = orig.positionOnTree;
digDesignation = orig.digDesignation;
spatters = orig.spatters;
}
public Tile(MapDataStore container, DFCoord position)
{
this.container = container;
this.position = position;
tileType = default(int);
material = default(MatPairStruct);
base_material = default(MatPairStruct);
layer_material = default(MatPairStruct);
vein_material = default(MatPairStruct);
construction_item = default(MatPairStruct);
waterLevel = default(int);
magmaLevel = default(int);
rampType = 0;
}
private void PrintSet(StringBuilder output, Dictionary<HashSet<MatPairStruct>, int> material)
{
foreach (var item in material)
{
if (item.Key.Count == 0)
output.AppendFormat("Found {0} empty instances.", item.Value).AppendLine();
else
{
output.Append("Found ").Append(item.Value).Append(" instances of:").AppendLine();
output.Append(item.Key.Count).Append("; ");
MatPairStruct[] matList = new MatPairStruct[item.Key.Count];
item.Key.CopyTo(matList);
Array.Sort(matList);
foreach (var mat in matList)
{
if (GameMap.materials.ContainsKey(mat))
output.Append(GameMap.materials[mat].id).Append("; ");
else
output.Append(mat).Append("; ");
}
output.AppendLine();
}
}
}
/// <summary>
/// This is the function that actually decides what mesh and texture each tile gets
/// </summary>
/// <param name="buffer">Buffer to put the chosen meshes into for combining</param>
/// <param name="layer">layer currently being worked on</param>
/// <param name="tile">The tile to get all the needed info from.</param>
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile, Vector3 pos)
{
buffer = new MeshCombineUtility.MeshInstance();
MeshContent meshContent = null;
if(contentLoader.DesignationMeshConfiguration.GetValue(tile, layer, out meshContent))
{
if(!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
if (meshContent.MaterialTexture != null)
buffer.uv1Transform = meshContent.MaterialTexture.UVTransform;
else
buffer.uv1Transform = contentLoader.DefaultMatTexTransform;
if (meshContent.ShapeTexture != null)
buffer.uv2Transform = meshContent.ShapeTexture.UVTransform;
else
buffer.uv2Transform = contentLoader.DefaultShapeTexTransform;
if (meshContent.SpecialTexture != null)
buffer.uv3Transform = meshContent.SpecialTexture.UVTransform;
else
buffer.uv3Transform = contentLoader.DefaultSpecialTexTransform;
buffer.hiddenFaces = CalculateHiddenFaces(tile);
return;
}
switch (layer)
{
case MeshLayer.GrowthMaterial:
case MeshLayer.GrowthMaterial1:
case MeshLayer.GrowthMaterial2:
case MeshLayer.GrowthMaterial3:
case MeshLayer.GrowthCutout:
case MeshLayer.GrowthCutout1:
case MeshLayer.GrowthCutout2:
case MeshLayer.GrowthCutout3:
case MeshLayer.GrowthTransparent:
case MeshLayer.GrowthTransparent1:
case MeshLayer.GrowthTransparent2:
case MeshLayer.GrowthTransparent3:
{
switch (tile.tiletypeMaterial)
{
case TiletypeMaterial.PLANT:
case TiletypeMaterial.ROOT:
case TiletypeMaterial.TREE_MATERIAL:
case TiletypeMaterial.MUSHROOM:
if (!contentLoader.GrowthMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
break;
default:
buffer.meshData = null;
return;
}
}
break;
case MeshLayer.BuildingMaterial:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.BuildingMaterialTransparent:
case MeshLayer.NoMaterialBuildingTransparent:
{
if (tile.buildingType == default(BuildingStruct))
{
buffer.meshData = null;
return;
}
if (!contentLoader.BuildingMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
default:
{
if (!contentLoader.TileMeshConfiguration.GetValue(tile, layer, out meshContent))
{
buffer.meshData = null;
return;
}
}
break;
}
if (!meshContent.MeshData.ContainsKey(layer))
{
buffer.meshData = null;
return;
}
buffer.meshData = meshContent.MeshData[layer];
buffer.transform = Matrix4x4.TRS(pos, meshContent.GetRotation(tile), Vector3.one);
Matrix4x4 shapeTextTransform = contentLoader.DefaultShapeTexTransform;
NormalContent tileTexContent;
if (meshContent.ShapeTexture == null)
{
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if (contentLoader.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
else
{
if (contentLoader.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
}
else
{
shapeTextTransform = meshContent.ShapeTexture.UVTransform;
}
Matrix4x4 matTexTransform = contentLoader.DefaultMatTexTransform;
if (meshContent.MaterialTexture != null
&& (layer == MeshLayer.NoMaterial
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.NoMaterialBuildingTransparent
|| layer == MeshLayer.NoMaterialCutout
|| layer == MeshLayer.NoMaterialTransparent))
{
matTexTransform = meshContent.MaterialTexture.UVTransform;
}
else
{
TextureContent matTexContent;
if (contentLoader.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
matTexTransform = matTexContent.UVTransform;
}
Matrix4x4 specialTexTransform = Matrix4x4.identity;
if(meshContent.SpecialTexture != null)
{
specialTexTransform = meshContent.SpecialTexture.UVTransform;
}
else
{
specialTexTransform = contentLoader.DefaultSpecialTexTransform;
}
ColorContent newColorContent;
Color newColor;
if (contentLoader.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
else
{
MatPairStruct mat = new MatPairStruct(-1, -1);
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
case MeshLayer.StaticTransparent:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
case MeshLayer.BaseTransparent:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
case MeshLayer.LayerTransparent:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
case MeshLayer.VeinTransparent:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.NoMaterialBuildingTransparent:
case MeshLayer.NoMaterialTransparent:
break;
case MeshLayer.BuildingMaterial:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.BuildingMaterialTransparent:
mat = tile.buildingMaterial;
break;
default:
break;
}
MaterialDefinition mattie;
if (materials.TryGetValue(mat, out mattie))
{
ColorDefinition color = mattie.state_color;
if (color == null)
newColor = Color.cyan;
else
newColor = new Color(color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f, 1);
}
else
{
newColor = Color.grey;
}
}
buffer.color = newColor;
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.uv3Transform = specialTexTransform;
buffer.hiddenFaces = CalculateHiddenFaces(tile);
}
public void InitOrModifyTile(DFCoord coord,
int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null)
{
DFCoord local = WorldToLocalSpace(coord);
if (!InSliceBoundsLocal(local.x, local.y, local.z)) {
throw new UnityException("Can't modify tile outside of slice");
}
tilesPresent[PresentIndex(local.x, local.y, local.z)] = true;
tiles[local.x, local.y, local.z].Modify(tileType, material, base_material, layer_material, vein_material, waterLevel, magmaLevel, construction_item, rampType);
}
/// <summary>
/// This is the function that actually decides what mesh and texture each tile gets
/// </summary>
/// <param name="buffer">Buffer to put the chosen meshes into for combining</param>
/// <param name="layer">layer currently being worked on</param>
/// <param name="tile">The tile to get all the needed info from.</param>
void FillMeshBuffer(out MeshCombineUtility.MeshInstance buffer, MeshLayer layer, MapDataStore.Tile tile)
{
buffer = new MeshCombineUtility.MeshInstance();
MeshContent mesh = null;
if (tile.hidden)
{
buffer.meshData = null;
return;
}
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if(tile.buildingType == default(BuildingStruct))
{
buffer.meshData = null;
return;
}
if (!contentLoader.BuildingMeshConfiguration.GetValue(tile, layer, out mesh))
{
buffer.meshData = null;
return;
}
}
else
{
if (!contentLoader.TileMeshConfiguration.GetValue(tile, layer, out mesh))
{
buffer.meshData = null;
return;
}
}
buffer.meshData = mesh.MeshData[(int)layer];
buffer.transform = Matrix4x4.TRS(GameMap.DFtoUnityCoord(tile.position), mesh.GetRotation(tile), Vector3.one);
Matrix4x4 shapeTextTransform = Matrix4x4.identity;
NormalContent tileTexContent;
if (mesh.NormalTexture == null)
{
if (layer == MeshLayer.BuildingMaterial
|| layer == MeshLayer.BuildingMaterialCutout
|| layer == MeshLayer.NoMaterialBuilding
|| layer == MeshLayer.NoMaterialBuildingCutout
|| layer == MeshLayer.BuildingMaterialTransparent
|| layer == MeshLayer.NoMaterialBuildingTransparent
)
{
if (contentLoader.BuildingShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
else
{
if (contentLoader.ShapeTextureConfiguration.GetValue(tile, layer, out tileTexContent))
shapeTextTransform = tileTexContent.UVTransform;
}
}
else
{
shapeTextTransform = mesh.NormalTexture.UVTransform;
}
Matrix4x4 matTexTransform = Matrix4x4.identity;
TextureContent matTexContent;
if (contentLoader.MaterialTextureConfiguration.GetValue(tile, layer, out matTexContent))
matTexTransform = matTexContent.UVTransform;
ColorContent newColorContent;
Color newColor;
if (contentLoader.ColorConfiguration.GetValue(tile, layer, out newColorContent))
{
newColor = newColorContent.value;
}
else
{
MatPairStruct mat = new MatPairStruct(-1, -1);
switch (layer)
{
case MeshLayer.StaticMaterial:
case MeshLayer.StaticCutout:
case MeshLayer.StaticTransparent:
mat = tile.material;
break;
case MeshLayer.BaseMaterial:
case MeshLayer.BaseCutout:
case MeshLayer.BaseTransparent:
mat = tile.base_material;
break;
case MeshLayer.LayerMaterial:
case MeshLayer.LayerCutout:
case MeshLayer.LayerTransparent:
mat = tile.layer_material;
break;
case MeshLayer.VeinMaterial:
case MeshLayer.VeinCutout:
case MeshLayer.VeinTransparent:
mat = tile.vein_material;
break;
case MeshLayer.NoMaterial:
case MeshLayer.NoMaterialCutout:
case MeshLayer.NoMaterialBuildingCutout:
case MeshLayer.NoMaterialBuilding:
case MeshLayer.NoMaterialBuildingTransparent:
case MeshLayer.NoMaterialTransparent:
break;
case MeshLayer.Growth0Cutout:
break;
case MeshLayer.Growth1Cutout:
break;
case MeshLayer.Growth2Cutout:
break;
case MeshLayer.Growth3Cutout:
break;
case MeshLayer.BuildingMaterial:
case MeshLayer.BuildingMaterialCutout:
case MeshLayer.BuildingMaterialTransparent:
mat = tile.buildingMaterial;
break;
default:
break;
}
MaterialDefinition mattie;
if (materials.TryGetValue(mat, out mattie))
{
ColorDefinition color = mattie.state_color;
if (color == null)
newColor = Color.cyan;
else
newColor = new Color(color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f, 1);
}
else
{
newColor = Color.grey;
}
}
buffer.color = newColor;
buffer.uv1Transform = matTexTransform;
buffer.uv2Transform = shapeTextTransform;
buffer.hiddenFaces = MeshCombineUtility.HiddenFaces.None;
if (tile.North != null && tile.North.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.North;
if (tile.South != null && tile.South.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.South;
if (tile.East != null && tile.East.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.East;
if (tile.West != null && tile.West.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.West;
if (tile.Up != null && tile.Up.isSolidBase)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Up;
if (tile.Down != null && tile.Down.isWall)
buffer.hiddenFaces |= MeshCombineUtility.HiddenFaces.Down;
}
public void Modify(int? tileType = null,
MatPairStruct? material = null,
MatPairStruct? base_material = null,
MatPairStruct? layer_material = null,
MatPairStruct? vein_material = null,
int? waterLevel = null,
int? magmaLevel = null,
MatPairStruct? construction_item = null,
int? rampType = null)
{
if (tileType != null) {
this.tileType = tileType.Value;
}
if (material != null) {
this.material = material.Value;
}
if (base_material != null) {
this.base_material = base_material.Value;
}
if (layer_material != null) {
this.layer_material = layer_material.Value;
}
if (vein_material != null) {
this.vein_material = vein_material.Value;
}
if (waterLevel != null) {
this.waterLevel = waterLevel.Value;
}
if (magmaLevel != null) {
this.magmaLevel = magmaLevel.Value;
}
if (construction_item != null)
{
this.construction_item = construction_item.Value;
}
if(rampType != null)
{
this.rampType = rampType.Value;
}
}
void Count(Dictionary<MatPairStruct, int> dict, MatPairStruct value)
{
if (!dict.ContainsKey(value))
dict[value] = 1;
else
dict[value] = dict[value] + 1;
}
