public void RecalculateTerrain(TriCell cell, bool buildable)
{
Vector3 nextCorner, prevCorner;
EdgeVertices edge;
for (TriDirection direction = TriDirection.VERT; direction <= TriDirection.RIGHT; direction++)
{
Vector3 center = cell.Position, v1, v2;
//entityMenu.transform.localPosition = center + new Vector3(0, 20, 0);
v1 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetSecondSolidCorner(direction);
edge = new EdgeVertices(v1, v2);
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
AddTriangle(nextCorner, edge.v1, edge.v2);
AddTriangle(prevCorner, edge.v4, edge.v5);
AddTriangle(center, edge.v2, edge.v4);
AddTriangle(center, edge.v4, prevCorner);
AddTriangle(center, nextCorner, edge.v2);
Color c = buildable ? Color.blue : Color.red;
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
}
}
public static Building Load(BinaryReader reader)
{
BuildingType type = (BuildingType)reader.ReadInt32();
TriDirection entDir = (TriDirection)reader.ReadInt32();
bool underconstruct = reader.ReadBoolean();
bool working = reader.ReadBoolean();
float constructTime = reader.ReadSingle();
Building ret = null;
switch (type)
{
case BuildingType.INN:
ret = Inn.Load(reader);
break;
case BuildingType.COMPANY:
ret = Company.Load(reader);
break;
case BuildingType.WORKSITE:
ret = Worksite.Load(reader);
break;
}
ret.entranceDirection = entDir;
ret.type = type;
ret.UnderConstruct = underconstruct;
ret.Working = working;
ret.ConstructTime = constructTime;
return(ret);
}
void SetClimateData(int cellIndex, float moisture, float clouds)
{
TriDirection d = TriDirection.VERT;
TriCell current, k;
ClimateData t;
current = k = grid.GetCell(cellIndex);
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
t = new ClimateData();
t.moisture = moisture;
t.clouds = clouds;
climate[k.Index] = t;
k = k.GetNeighbor(d);
if (current.inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
}
void Triangulate(TriCell cell)
{
for (TriDirection d = TriDirection.VERT; d <= TriDirection.RIGHT; d++)
{
Triangulate(d, cell);
}
}
public void RecalculateTerrain(TriCell cell)
{
Vector3 nextCorner, prevCorner;
EdgeVertices edge;
for (TriDirection direction = TriDirection.VERT; direction <= TriDirection.RIGHT; direction++)
{
Vector3 center = cell.Position, v1, v2;
v1 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetSecondSolidCorner(direction);
edge = new EdgeVertices(v1, v2);
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
terrainSelectionViewer.AddTriangle(nextCorner, edge.v1, edge.v2);
terrainSelectionViewer.AddTriangle(prevCorner, edge.v4, edge.v5);
terrainSelectionViewer.AddTriangle(center, edge.v2, edge.v4);
terrainSelectionViewer.AddTriangle(center, edge.v4, prevCorner);
terrainSelectionViewer.AddTriangle(center, nextCorner, edge.v2);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
}
}
public BuildCommand(TriCell location, TriDirection dir, Entity target)
{
this.location = location;
this.dir = dir;
this.target = target;
type = CommandType.BUILD;
}
public void StartCalculateTerrain()
{
terrainSelectionViewer.Clear();
switch (terrainType)
{
case SizeType.HEX:
TriCell k = selectedCell;
int elev = selectedCell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
RecalculateTerrain(k);
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
case SizeType.SINGLE:
RecalculateTerrain(selectedCell);
break;
}
terrainSelectionViewer.Apply();
}
public static new BuildCommand Load(BinaryReader reader)
{
TriGrid instance = TriGrid.Instance;
TriCell tCell = instance.GetCell(TriCoordinates.Load(reader));
TriDirection tDir = (TriDirection)reader.ReadInt32();
Entity prefab = TriIsland.GetBuildingPrefabs(reader.ReadInt32(), reader.ReadInt32(), 0);
return(new BuildCommand(tCell, tDir, prefab));
}
public IEnumerator <Coroutine> LoadBuilding(string path)
{
ClearBuildings();
using (BinaryReader reader = new BinaryReader(File.OpenRead(Path.Combine(path, "building.dat")))) {
int header = reader.ReadInt32();
if (header <= 0)
{
int counter = reader.ReadInt32();
for (int i = 0; i < counter; i++)
{
TriCoordinates coord = TriCoordinates.Load(reader);
Building loaded = Building.Load(reader);
if (loaded.type == BuildingType.HALL)
{
camp = loaded as Hall;
}
if (loaded)
{
loaded.ID = i;
loaded.Location = grid.GetCell(coord);
loaded.EntranceDirection = loaded.EntranceDirection;
switch (loaded.sizeType)
{
case SizeType.SINGLE:
loaded.Location.Statics = loaded;
break;
case SizeType.HEX:
TriCell k = loaded.Location;
TriDirection tDir = loaded.EntranceDirection.Previous();
for (int j = 0; j < 6; j++)
{
if (!k)
{
break;
}
k.Statics = loaded;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
}
loaded.transform.SetParent(BuildingGroup);
AddBuilding(loaded);
}
// if (i % Strings.refreshLimit == 0) yield return null;
}
}
else
{
Debug.LogWarning("Unknown building format " + header);
}
}
yield return(null);
}
public override List <BuildState> GetBuildStatus(TriCoordinates coord, TriDirection dir)
{
List <BuildState> ret = new List <BuildState>();
TriCell cell = TriGrid.Instance.GetCell(coord);
int elev = cell.Elevation;
ret.Add(new BuildState(coord, cell.IsBuildable()));
cell = cell.GetNeighbor(dir);
ret.Add(new BuildState(cell.coordinates, cell.IsBuildable() && Mathf.Abs(elev - cell.Elevation) < 2));
return(ret);
}
public void SetRiver(TriDirection direction)
{
if (!isRiver[(int)direction])
{
isRiver[(int)direction] = true;
RefreshSelfOnly();
TriCell neighbor = GetNeighbor(direction);
neighbor.isRiver[(int)direction] = true;
neighbor.RefreshSelfOnly();
}
}
public virtual List <BuildState> GetBuildStatus(TriCoordinates coord, TriDirection dir)
{
List <BuildState> ret = new List <BuildState>();
TriGrid grid = TriGrid.Instance;
TriCell cell = grid.GetCell(coord);
int elev = cell.Elevation;
ret.Add(new BuildState(cell.coordinates, cell.IsBuildable()));
cell = grid.GetCell(coord).GetNeighbor(dir);
ret.Add(new BuildState(cell.coordinates, cell.IsBuildable() && Mathf.Abs(cell.Elevation - elev) < 2));
return(ret);
}
public void RemoveRiver(TriDirection direction)
{
if (isRiver[(int)direction])
{
isRiver[(int)direction] = false;
RefreshSelfOnly();
TriCell neighbor = GetNeighbor(direction);
neighbor.isRiver[(int)direction] = false;
neighbor.RefreshSelfOnly();
}
}
public Building CreateBuilding(TriDirection dir, TriCell cell, Building prefab)
{
List <BuildState> result = prefab.GetBuildStatus(cell.coordinates, dir);
bool buildable = true;
foreach (BuildState i in result)
{
if (!i.value)
{
buildable = false;
}
}
if (cell && buildable)
{
Building ret = Instantiate(prefab);
ret.ID = entities.BuildingCount;
ret.Location = cell;
switch (ret.sizeType)
{
case SizeType.SINGLE:
cell.Statics = ret;
break;
case SizeType.HEX:
TriCell k = cell;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Statics = ret;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
}
ret.EntranceDirection = dir;
ret.personList = personList;
entities.AddBuilding(ret);
island.ShowSummary = island.ShowSummary;
Debug.Log(ret + " built");
return(ret);
}
else
{
Debug.Log("building failed");
return(null);
}
}
int CreateRiver(TriCell origin)
{
int length = 0;
TriCell cell = origin;
TriDirection direction = TriDirection.VERT;
while (!cell.IsUnderwater)
{
flowDirections.Clear();
for (TriDirection d = TriDirection.VERT; d <= TriDirection.RIGHT; d++)
{
TriCell neighbor = cell.GetNeighbor(d);
if (!neighbor || neighbor.HasRiver)
{
continue;
}
int delta = neighbor.Elevation - cell.Elevation;
if (delta > 0)
{
continue;
}
if (delta < 0)
{
flowDirections.Add(d);
flowDirections.Add(d);
flowDirections.Add(d);
}
if (
length == 1 ||
(d != direction.Next2() && d != direction.Previous2())
)
{
flowDirections.Add(d);
}
flowDirections.Add(d);
}
if (flowDirections.Count == 0)
{
return(length > 1 ? length : 0);
}
direction = flowDirections[Random.Range(0, flowDirections.Count)];
cell.SetRiver(direction);
cell.GetNeighbor(direction).SetRiver(direction);
length += 1;
cell = cell.GetNeighbor(direction);
}
return(length);
}
public void CreateHall(TriDirection dir, TriCell cell)
{
Hall ret = (Hall)CreateBuilding(dir, cell, (Building)TriIsland.GetBuildingPrefabs((int)BuildingType.HALL, (int)HallType.BASE, 0));
if (ret)
{
TriIsland.Instance.entities.camp = ret;
for (int i = 0; i < 4; i++)
{
Unit t = CreateUnit(ret.EntranceLocation, (Unit)TriIsland.GetUnitPrefabs((int)UnitType.PERSON, 0));
((Human)t).Home = null;
t.AddCommand(new GetInCommand(ret));
}
ret.Working = true;
}
}
void ValidateDrag(TriCell currentCell)
{
for (
dragDirection = TriDirection.VERT;
dragDirection <= TriDirection.RIGHT;
dragDirection++
)
{
if (previousCell.GetNeighbor(dragDirection) == currentCell)
{
isDrag = true;
return;
}
}
isDrag = false;
}
public static Natural Load(BinaryReader reader)
{
NaturalType type = (NaturalType)reader.ReadInt32();
TriDirection entDir = (TriDirection)reader.ReadInt32();
Natural ret = null;
switch (type)
{
case NaturalType.TREE:
ret = Tree.Load(reader);
break;
}
ret.entranceDirection = entDir;
ret.type = type;
return(ret);
}
private void LateUpdate()
{
if (ordering)
{
tCell = GetRay();
if (tCell)
{
nowCell = tCell;
}
if (Input.GetKeyDown(KeyCode.R))
{
dir = dir.Next();
}
if (subject && Input.GetKeyDown(KeyCode.Escape))
{
CancelCommand();
}
if (Input.GetMouseButtonDown(0))
{
switch (command.type)
{
case CommandType.CHANGEHOME:
((ChangeHomeCommand)command).target = (Inn)nowCell.Statics;
break;
case CommandType.CHANGEJOB:
((ChangeJobCommand)command).target = (Company)nowCell.Statics;
break;
case CommandType.CHANGEWORK:
((ChangeWorkCommand)command).target = (Building)nowCell.Statics;
break;
case CommandType.BUILD:
if (!IsBuildable())
{
Debug.Log("invalid build site.");
return;
}
((BuildCommand)command).dir = dir;
((BuildCommand)command).location = nowCell;
break;
}
SendCommand();
}
}
}
void Triangulate(TriDirection direction, TriCell cell)
{
int inverter = 0;
if (cell.inverted)
{
inverter = -1;
}
else
{
inverter = 1;
}
Vector3 center = cell.Position, v1, v2;
v1 = center + inverter * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + inverter * TriMetrics.GetSecondSolidCorner(direction);
EdgeVertices e = new EdgeVertices(v1, v2);
if (cell.IsUnderwater)
{
TriangulateWater(center, e);
}
if (cell.HasRiverThroughEdge(direction))
{
TriangulateWithRiver(cell, direction, center, e, cell.Color);
}
else
{
TriangulateEdgeFan(center, e, cell.Color);
}
if (cell.inverted)
{
if (direction != TriDirection.LEFT)
{
TriangulateConnection(direction, cell, e, inverter);
}
}
else
{
if (direction == TriDirection.LEFT)
{
TriangulateConnection(direction, cell, e, inverter);
}
}
}
public override void BindCells(bool flag)
{
TriCell k = Location;
int elev = k.Elevation;
TriDirection tDir = EntranceDirection.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Statics = flag?this:null;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
}
void TriangulateConnection(TriDirection direction, TriCell cell, EdgeVertices e1, int inverter)
{
Vector3 center = cell.transform.localPosition;
TriCell neighbor = cell.GetNeighbor(direction);
if (neighbor == null)
{
return;
}
Vector3 bridge = TriMetrics.GetBridge(direction);
bridge.y = neighbor.Position.y - cell.Position.y;
EdgeVertices e2 = new EdgeVertices(
e1.v1 + bridge,
e1.v5 + bridge
);
TriangulateEdgeStrip(terrain, e1, cell.Color, e2, neighbor.Color, cell.HasRiverThroughEdge(direction));
}
bool IsBuildable()
{
if (nowCell)
{
if (!nowCell.GetNeighbor(dir).IsBuildable())
{
return(false);
}
if (sizeType != null)
{
switch (sizeType)
{
case SizeType.HEX:
TriCell k = nowCell;
int elev = nowCell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k || !k.IsBuildable())
{
return(false);
}
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
return(true);
case SizeType.SINGLE:
return(nowCell.IsBuildable());
default:
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
public Building CreateBuilding(TriDirection dir, TriCell cell, Building prefab)
{
if (cell && Entity.IsBuildable(dir, cell.coordinates, prefab.sizeType))
{
Building ret = Instantiate(prefab);
ret.ID = entities.BuildingCount;
ret.Location = cell;
switch (ret.sizeType)
{
case SizeType.SINGLE:
cell.Statics = ret;
break;
case SizeType.HEX:
TriCell k = cell;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Statics = ret;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
}
ret.EntranceDirection = dir;
ret.personList = personList;
entities.AddBuilding(ret);
Debug.Log("camp built");
return(ret);
}
else
{
Debug.Log("building failed");
return(null);
}
}
public override List <BuildState> GetBuildStatus(TriCoordinates coord, TriDirection dir)
{
List <BuildState> ret = new List <BuildState>();
TriCell k = TriGrid.Instance.GetCell(coord);
int elev = k.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
ret.Add(new BuildState(k.coordinates, k.IsBuildable() && elev == k.Elevation));
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
TriCell entrance = TriGrid.Instance.GetCell(coord).GetNeighbor(dir);
ret.Add(new BuildState(entrance.coordinates, entrance.IsBuildable() && Mathf.Abs(entrance.GetNeighbor(dir).Elevation - elev) < 2));
return(ret);
}
public static bool IsBuildable(TriDirection dir, TriCoordinates coord, SizeType sizeType)
{
switch (sizeType)
{
case SizeType.SINGLE:
if (TriGrid.Instance.GetCell(coord).Statics)
{
return(false);
}
else
{
return(true);
}
case SizeType.HEX:
TriCell cell = TriGrid.Instance.GetCell(coord);
int elevation = cell.Elevation;
TriCell k = cell;
int elev = cell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k || !k.IsBuildable())
{
return(false);
}
if (elev != k.Elevation)
{
return(false);
}
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
return(true);
default:
return(false);
}
}
public override void OnBuilt()
{
base.OnBuilt();
if (workType == TerrainModdingType.LANDFILL)
{
TriCell k = Location;
for (int j = 0; j < 3; j++)
{
TriDirection tDir = (TriDirection)j;
for (int i = 0; i < 6; i++)
{
k.Elevation = k.Elevation < 1 ? 1 : k.Elevation;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
}
}
else
{
location.Elevation += (int)workType;
}
SelfWorking = true;
DeconstructionStart(null);
}
public void CalculateTerrain()
{
Clear();
if (selector.nowCell)
{
TriCell neighbor = selector.nowCell.GetNeighbor(selector.dir);
if (neighbor)
{
RecalculateTerrain(neighbor, neighbor.IsBuildable() && neighbor.Elevation <= selector.nowCell.Elevation + 1 && neighbor.Elevation >= selector.nowCell.Elevation - 1);
}
switch (selector.sizeType)
{
case SizeType.HEX:
k = selector.nowCell;
int elev = selector.nowCell.Elevation;
TriDirection tDir = selector.dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
RecalculateTerrain(k, k.IsBuildable() && k.Elevation == elev);
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
case SizeType.SINGLE:
RecalculateTerrain(selector.nowCell, selector.nowCell.IsBuildable());
break;
}
}
Apply();
}
void EditHex(TriCell cell)
{
TriCell k = cell;
bool inverted = cell.inverted;
TriDirection d = TriDirection.VERT;
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
EditCell(k);
k = k.GetNeighbor(d);
if (inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
}
void TriangulateWithRiver(TriCell cell, TriDirection direction, Vector3 center, EdgeVertices edge, Color color)
{
Vector3 riverOffset = new Vector3(0, TriMetrics.streamBedElevationOffset - TriMetrics.waterElevationOffset, 0);
Vector3 nextCorner, prevCorner;
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
Vector3 underCenter = center, underNextCorner = nextCorner, underPrevCorner = prevCorner;
underCenter.y += TriMetrics.streamBedElevationOffset;
underNextCorner.y += TriMetrics.streamBedElevationOffset;
underPrevCorner.y += TriMetrics.streamBedElevationOffset;
EdgeVertices underEdge = edge;
underEdge.v1.y += TriMetrics.streamBedElevationOffset;
underEdge.v2.y += TriMetrics.streamBedElevationOffset;
underEdge.v3.y += TriMetrics.streamBedElevationOffset;
underEdge.v4.y += TriMetrics.streamBedElevationOffset;
underEdge.v5.y += TriMetrics.streamBedElevationOffset;
terrain.AddTriangle(nextCorner, edge.v1, edge.v2);
terrain.AddTriangle(prevCorner, edge.v4, edge.v5);
terrain.AddTriangle(underCenter, underEdge.v2, underEdge.v4);
terrain.AddTriangleColor(color);
terrain.AddTriangleColor(color);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underCenter - riverOffset, underEdge.v2 - riverOffset, underEdge.v4 - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
if (cell.HasRiverThroughEdge(direction.Next()))
{
terrain.AddTriangle(underEdge.v4, underPrevCorner, underCenter);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underEdge.v4 - riverOffset, underPrevCorner - riverOffset, underCenter - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
terrain.AddQuad(underPrevCorner, prevCorner, underEdge.v4, edge.v4);
terrain.AddQuadColor(color, color);
}
else
{
terrain.AddTriangle(center, edge.v4, prevCorner);
terrain.AddQuad(underCenter, center, underEdge.v4, edge.v4);
terrain.AddTriangleColor(color);
terrain.AddQuadColor(color, color);
}
if (cell.HasRiverThroughEdge(direction.Previous()))
{
terrain.AddTriangle(underEdge.v2, underCenter, underNextCorner);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underEdge.v2 - riverOffset, underCenter - riverOffset, underNextCorner - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
terrain.AddQuad(underEdge.v2, edge.v2, underNextCorner, nextCorner);
terrain.AddQuadColor(color, color);
}
else
{
terrain.AddTriangle(center, nextCorner, edge.v2);
terrain.AddQuad(underEdge.v2, edge.v2, underCenter, center);
terrain.AddTriangleColor(color);
terrain.AddQuadColor(color, color);
}
}
