/// <summary>
/// The sum c1 + c2 is c1 with c2 placed to the right of it.
/// blanks are empty
///
/// This is not an commutative operation. SUCK IT!
/// </summary>
public static City operator +(City c1, City c2)
{
var c1Width = c1.width;
var c2Width = c2.width;
var c1Height = c1.height;
var c2Height = c2.height;
var sumGrid = new CityTile[c1Width + c2Width, Mathf.Max(c1Height, c2Height)];
for (int i = 0; i < sumGrid.GetLength(0); i++)
{
for (int j = 0; j < sumGrid.GetLength(1); j++)
{
bool inC1 = i < c1Width;
if (inC1 && j >= c1Height)
{
continue;
}
if (!inC1 && j >= c2Height)
{
continue; //under c2
}
int x = inC1 ? i : i - c1Width;
sumGrid[i, j] = inC1 ? c1._cityGrid[x, j] : c2._cityGrid[x, j];
}
}
return(new City(sumGrid));
}
public void generateCityTiles()
{
for (int i = 0; i < 16; i++)
{
tiles[i] = new CityTile();
}
}
public void ActivatePath(CityTile tile1, CityTile tile2)
{
Debug.LogWarning("Activate Path between: " + tile1.name + " and " + tile2.name);
tile2.cityAttributes.hexTile.isRoad = true;
List <Tile> pathList = GetPath(tile1.cityAttributes.hexTile.tile, tile2.cityAttributes.hexTile.tile, PATHFINDING_MODE.NORMAL).ToList();
tile2.cityAttributes.hexTile.isRoad = false;
if (pathList == null)
{
Debug.LogError("There is no path between the 2 tiles");
return;
}
for (int i = 0; i < pathList.Count; i++)
{
if ((i + 1) < pathList.Count)
{
CreateLine(pathList[i], pathList [i + 1]);
}
else
{
CreateLine(pathList[i], null);
}
}
if (!checkedCities.Contains(tile2))
{
CheckForAdjacentOccupiedCities(tile2);
}
}
private void RemoveInvalidOpenings(CityTile[,] cityGrid)
{
//foreach (var opening in openings) {
openings.RemoveAll(opening => {
var xDir = opening.dir.X();
var yDir = opening.dir.Y();
var startX = opening.x + xDir;
var startY = opening.y + yDir;
//int x = opening.x + opening.dir.X();
//int y = opening.y + opening.dir.Y();
CityTile[] tiles = opening.row.tiles;
string debug = "checking validity of opening " + tiles.PrettyPrint() + " as " + opening.x + "/" + opening.y + " in the direction " + opening.dir;
for (int i = 0; i < tiles.Length; i++)
{
CityTile cityTile = cityGrid[startX + i * xDir, +startY + i * yDir];
debug += string.Format("\nChecking tile at {0}/{1}, it has the value {2}", startX + i * xDir, startY + i * yDir, cityTile);
if (cityTile != CityTile.Empty)
{
i = tiles.Length;
debug += "\nremoved it!";
Debug.Log(debug);
return(true);
}
}
Debug.Log(debug);
return(false);
});
}
// bool IsLineIntersecting(Vector3 startPoint, Vector3 endPoint){
// for (int i = 0; i < allLines.Count; i++) {
// if(allLines[i].startPoint != startPoint && allLines[i].endPoint != endPoint){
// bool intersection = FasterLineSegmentIntersection (startPoint, endPoint, allLines[i].startPoint, allLines[i].endPoint);
//
// if (intersection == true) {
// return true;
// }
// }
// }
// return false;
// }
//
// bool IsCollinear(Vector3 startPoint, Vector3 endPoint){
// Vector2 A = startPoint;
// Vector2 B = endPoint;
// for (int i = 0; i < allLines.Count; i++) {
// Vector2 C = allLines[i].startPoint;
// Vector2 D = allLines [i].endPoint;
// if(allLines[i].startPoint != startPoint && allLines[i].endPoint != endPoint){
// float line1Slope = (A.y - B.y)/(A.x - B.x);
// float line2Slope = (C.y - D.y) /(C.x - D.x);
// if(line1Slope == line2Slope){
// if (PointOnLineSegment (A, B, C) || PointOnLineSegment (A, B, D) ||
// PointOnLineSegment (C, D, A) || PointOnLineSegment (C, D, B)) {
// return true;
// }
// }
// }
// }
// return false;
// }
//
// public static bool PointOnLineSegment(Vector2 pt1, Vector2 pt2, Vector2 pt, double epsilon = 0.001) {
// if (pt.x - Math.Max(pt1.x, pt2.x) > epsilon ||
// Math.Min(pt1.x, pt2.x) - pt.x > epsilon ||
// pt.y - Math.Max(pt1.y, pt2.y) > epsilon ||
// Math.Min(pt1.y, pt2.y) - pt.y > epsilon)
// return false;
//
// if (Math.Abs(pt2.x - pt1.x) < epsilon)
// return Math.Abs(pt1.x - pt.x) < epsilon || Math.Abs(pt2.x - pt.x) < epsilon;
// if (Math.Abs(pt2.y - pt1.y) < epsilon)
// return Math.Abs(pt1.y - pt.y) < epsilon || Math.Abs(pt2.y - pt.y) < epsilon;
//
// double x = pt1.x + (pt.y - pt1.y) * (pt2.x - pt1.x) / (pt2.y - pt1.y);
// double y = pt1.y + (pt.x - pt1.x) * (pt2.y - pt1.y) / (pt2.x - pt1.x);
//
// return Math.Abs(pt.x - x) < epsilon || Math.Abs(pt.y - y) < epsilon;
// }
//
// static bool FasterLineSegmentIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4) {
//
// Vector2 a = p2 - p1;
// Vector2 b = p3 - p4;
// Vector2 c = p1 - p3;
//
// float alphaNumerator = b.y*c.x - b.x*c.y;
// float alphaDenominator = a.y*b.x - a.x*b.y;
// float betaNumerator = a.x*c.y - a.y*c.x;
// float betaDenominator = a.y*b.x - a.x*b.y;
//
// bool doIntersect = true;
//
// if (p1 == p3 || p1 == p4 || p2 == p3 || p2 == p4) {
// return false;
// }
//
// if (alphaDenominator == 0 || betaDenominator == 0) {
// doIntersect = false;
// } else {
//
// if (alphaDenominator > 0) {
// if (alphaNumerator < 0 || alphaNumerator > alphaDenominator) {
// doIntersect = false;
//
// }
// } else if (alphaNumerator > 0 || alphaNumerator < alphaDenominator) {
// doIntersect = false;
// }
//
// if (doIntersect && betaDenominator > 0) {
// if (betaNumerator < 0 || betaNumerator > betaDenominator) {
// doIntersect = false;
// }
// } else if (betaNumerator > 0 || betaNumerator < betaDenominator) {
// doIntersect = false;
// }
// }
//
// return doIntersect;
// }
#endregion
/*
* Choose Capital Cities, they are the 4 cities
* with richnessLevel closest to 60
* */
void SetCapitalCities()
{
int lastIndex = 0;
capitalCities = new List <CityTile>();
cities.Sort(delegate(HexTile a, HexTile b) {
return(a.gameObject.GetComponent <CityTile>().cityAttributes.richnessLevel.CompareTo(b.gameObject.GetComponent <CityTile>().cityAttributes.richnessLevel));
});
for (int i = 0; i < cities.Count; i++)
{
CityTile currentCity = cities [i].gameObject.GetComponent <CityTile> ();
int richnessLevel = currentCity.cityAttributes.richnessLevel;
if (richnessLevel < 60)
{
continue;
}
else
{
lastIndex = i - 1;
break;
}
}
for (int j = 0; j < capitalCityCount; j++)
{
int capitalCityIndex = lastIndex - j;
cities[capitalCityIndex].GetComponent <CityTile>().cityAttributes.cityType = CITY_TYPE.CAPITAL;
cities [capitalCityIndex].GetCityTile().cityAttributes.population = cities [capitalCityIndex].GetCityTile().cityAttributes.GeneratePopulation();
// cities[capitalCityIndex].SetTileColor(Color.yellow);
capitalCities.Add(cities[capitalCityIndex].GetComponent <CityTile>());
}
}
private void FindPossibleDistrictAccess(int x, int y, CityTile currentCheckedTile, int rotation)
{
var currentCheckedDistrict = currentCheckedTile.district;
if (validPosition(x, y))
{
var tile = m_cityTiles[x, y];
{
if (tile.height == currentCheckedDistrict.height + heightStepSize)
{
// check if there already is similar access
bool alreadyExists = false;
foreach (var item in currentCheckedDistrict.districtAccesses)
{
if (item.accessedDistrict == m_cityTiles[x, y].district)
{
// already exists
alreadyExists = true;
}
}
if (!alreadyExists)
{
var access = new ADistrictAccess();
access.myDistrict = currentCheckedDistrict;
access.accessedDistrict = m_cityTiles[x, y].district;
access.myCityTile = currentCheckedTile;
access.rotation = rotation;
currentCheckedDistrict.districtAccesses.Add(access);
}
}
}
}
}
void CheckForAdjacentOccupiedCities(CityTile tile)
{
for (int i = 0; i < tile.cityAttributes.connectedCities.Count; i++)
{
CityTile cityTileToCompareTo = tile.cityAttributes.connectedCities[i];
if (cityTileToCompareTo.cityAttributes.kingdomTile != null)
{
checkedCities.Add(tile);
ActivatePath(tile, cityTileToCompareTo);
}
}
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0) || InfoPanel.activeSelf) //saves on computation if infopanel is closed, and mouse is not clicked
{
if (!EventSystem.current.IsPointerOverGameObject()) //Does not work over UI
{
Ray ray = GetComponent <Camera>().ScreenPointToRay(Input.mousePosition); //Casts ray to point on screen from cursor
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 100.0f))
{
GameObject hitObject = hit.transform.gameObject;
if (InfoPanel.activeSelf) //If info panel is active
{
tileInfo.UpdateInfo(hitObject);
}
if (Input.GetMouseButtonDown(0)) //If clicked
{
switch (clickType) //Switch to detemine what to do with the click. Clicktype is changed by UI buttons
{
case 0: //Destroy
if (hitObject.GetComponent <CityTile>() != null && hitObject.tag != "TEmpty")
{
CityTile temp = hitObject.GetComponent <CityTile>();
temp.destroying = !hitObject.GetComponent <CityTile>().destroying;
temp.ConstructionToggle();
}
break;
case 1: //Build Home
case 2: //Build Shop
case 3: //Build Factory
//case 4: //Build Destroyed - Not possible
case 5: //Build Power
case 6: //Build Water
case 7: //Build Road
if (hitObject.GetComponent <EmptyTile>() != null)
{
EmptyTile temp = hitObject.GetComponent <EmptyTile>();
temp.destroying = !temp.destroying;
temp.typeToBecome = clickType;
temp.ConstructionToggle();
}
break;
}
;
}
}
}
}
}
private bool IsEqual(CityTile t1, CityTile t2)
{
if (t1 == CityTile.DEBUG && t2 == CityTile.Street)
{
return(true);
}
if (t2 == CityTile.DEBUG && t1 == CityTile.Street)
{
return(true);
}
return(t1 == t2);
}
//TODO: Tag Nacht | Windzone
// the player must be initialized after each height-changing, else the collider is not working
public void createPlayer()
{
int rndCityNumber = Terrainer.rnd.Next(0, this.allCities.Count);
int rndHouseNumber = Terrainer.rnd.Next(0, this.allCities[rndCityNumber].cityObjects.Count);
CityTile currentCityTile = this.allCities[rndCityNumber].cityObjects[rndHouseNumber].objectToRender;
Point playerPos = new Point(currentCityTile.startPoint.x, currentCityTile.renderPoint.y);
float height = ((currentCityTile.height + (currentCityTile.stageHeight * (currentCityTile.stageCount - 2)) / terrainHeightScale) * terrainHeightScale) + 1.5f;
this.Player = this.terr.CreateGameObject(
this.terr.FirstPersonGameObject,
new Vector3(playerPos.y - (int)terrainWidthScale / 2, height, playerPos.x - (int)terrainLengthScale / 2)) as GameObject;
}
/// <summary>
/// Paints the city onto the screen.
/// </summary>
public override void Paint()
{
if (this.GridCell.City == null)
{
return;
}
City city = this.GridCell.City;
CountryBase country = city.ParentCountry;
Era era = country.Era;
Civilization civilization = country.Civilization;
CitySizeClass sizeClass = city.SizeClass;
CityTile tile = this.tileset.CityTiles.GetTile(era, civilization, sizeClass);
this.Graphics.DrawImage(tile.Image, this.Bounds);
}
public City(CityTile[,] cityGrid)
{
_cityGrid = cityGrid.CopyArray();
var upRow = cityGrid.CopyRow(0);
up = upRow.Contains(CityTile.Street) ? new CityRow(upRow) : null;
var downRow = cityGrid.CopyRow(cityGrid.GetLength(0) - 1);
down = downRow.Contains(CityTile.Street) ? new CityRow(downRow) : null;
var rightRow = cityGrid.CopyColumn(cityGrid.GetLength(1) - 1);
right = rightRow.Contains(CityTile.Street) ? new CityRow(rightRow) : null;
var leftRow = cityGrid.CopyColumn(0);
left = leftRow.Contains(CityTile.Street) ? new CityRow(leftRow) : null;
}
/// <summary>
/// Translates a CityTile to a char.
///
/// Note that every char-representation is lower-case
/// </summary>
public static char ToChar(this CityTile tile)
{
switch (tile)
{
case CityTile.House:
return('x');
case CityTile.Street:
return('#');
case CityTile.DEBUG:
return('�');
default:
return(' '); //empty!
}
}
public HexTile FindNearestCityWithConnection(CityTile tile)
{
List <HexTile> cityTilesByDistance = tile.GetAllCitiesByDistance();
for (int i = 0; i < cityTilesByDistance.Count; i++)
{
if (cityTilesByDistance[i].GetCityTile().cityAttributes.numOfRoads > 0)
{
if (i == cityTilesByDistance.Count)
{
Debug.LogError("No more possible connectionssssss");
break;
}
return(cityTilesByDistance[i]);
}
}
return(null);
}
private void FindAndSetSameDistrictNeighbours(int x, int y, CityTile currentCheckedTile)
{
var currentCheckedDistrict = currentCheckedTile.district;
if (validPosition(x, y))
{
var tile = m_cityTiles[x, y];
if (!tile.visited)
{
if (tile.height == currentCheckedDistrict.height)
{
// Same Height -> same district
tile.visited = true;
tile.district = currentCheckedDistrict;
checkNeighbours(x, y);
}
}
}
}
public void CreateBlocks() {
Transform[] allChildren = transform.GetComponentsInChildren<Transform>();
for (int i = 1; i < allChildren.Length; i++) {
DestroyImmediate(allChildren[i].gameObject);
}
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(city));
CityTile[,] tiles = City.FromString(city).cityGrid;
for (int x = 0; x < tiles.GetLength(0); x++) {
for (int y = 0; y < tiles.GetLength(1); y++) {
CityTile tileType = tiles[x, y];
if (tileType == CityTile.Empty)
continue;
Vector3 coordinates = new Vector3(x, 0, -y);
GameObject block = GameObject.CreatePrimitive(PrimitiveType.Cube);
block.transform.position = coordinates;
block.transform.parent = transform;
if (tileType == CityTile.House) {
block.transform.localScale = new Vector3(1, 2, 1);
block.transform.position += Vector3.up * .5f;
block.GetComponent<MeshRenderer>().sharedMaterial = house;
block.name = "House";
}
else if (tileType == CityTile.Street) {
block.GetComponent<MeshRenderer>().sharedMaterial = street;
block.name = "Street";
}
else if (tileType == CityTile.DEBUG) {
block.GetComponent<MeshRenderer>().sharedMaterial = debug;
block.name = "DEBUG";
}
block.name += "(" + x + "," + y + ")";
}
}
}
public City StartCreatingRandomCity()
{
openings = new List <Opening>();
CityTile[,] grid = new CityTile[100, 100];
City city = new City(grid);
List <City> allCities = new List <City>();
foreach (var source in sources)
{
allCities.Add(City.FromString(source));
}
city = InsertInCity(city, allCities[0], 47, 47);
currentGenerator = CityGenerator(city, allCities);
city = showDebugOpenings(city);
return(city);
}
/// <summary>
/// Generates a city from a string.
///
/// Assumes that the input string is rectangular
/// </summary>
/// <param name="str">representation of a city</param>
/// <returns>The generated city</returns>
public static City FromString(string str)
{
string[] splitLines = str.Split('\n');
string[] cityRepr = new string[splitLines.Length];
for (int i = 0; i < cityRepr.Length; i++)
{
cityRepr[i] = splitLines[i].TrimEnd('\n');
}
var grid = new CityTile[cityRepr[0].Length, cityRepr.Length];
for (int y = 0; y < cityRepr.Length; y++)
{
for (int x = 0; x < cityRepr[y].Length; x++)
{
CityTile tile = cityRepr[y][x].ToCityTile();
grid[x, y] = tile;
}
}
return(new City(grid));
}
public void renderPlayObjects()
{
for (int i = 0; i < this.allCities.Count; i++)
{
int rnd = Terrainer.rnd.Next(0, this.allCities[i].cityObjects.Count);
Point tmpPoint = this.allCities[i].cityObjects[rnd].objectToRender.startPoint;
float height = this.allCities[i].cityObjects[rnd].objectToRender.height;
GameObject chestGameObject = this.terr.CreateGameObject(
this.terr.ChestGameObjects[0],
new Vector3(
tmpPoint.y - (terrainLengthScale / 2),
(height * terrainHeightScale),
tmpPoint.x - (terrainWidthScale / 2))) as GameObject;
int rndDiamontNumber = Terrainer.rnd.Next(1, this.terr.CollectableGameObjects.Length);
this.terr.playerDiamondMaxCount += rndDiamontNumber * 10;
GameObject diamondGameObject = this.renderDiamond(tmpPoint, height, rndDiamontNumber, 25);
}
for (int i = 0; i < this.allCities.Count; i++)
{
for (int j = 0; j < 3; j++)
{
int rnd = Terrainer.rnd.Next(0, this.allCities[i].cityObjects.Count);
CityTile tempTile = this.allCities[i].cityObjects[rnd].objectToRender;
float height = tempTile.height + (tempTile.stageHeight * (tempTile.stageCount - 2)) / terrainHeightScale;
Point renderPoint = new Point(tempTile.renderPoint.x, tempTile.renderPoint.y);
int rndKeyNumber = Terrainer.rnd.Next(0, this.terr.KeyGameObjects.Length);
GameObject keyGameObject = this.renderKey(renderPoint, height, rndKeyNumber, 20);
}
}
}
public City CreateEmptyCity(int width = 10, int height = 10)
{
CityTile[,] grid = new CityTile[width, height];
return(new City(grid));
}
public void CreateDistricts()
{
// populate depths:
for (int i = 0; i < arraySize; i++)
{
for (int k = 0; k < arraySize; k++)
{
float height = Random.Range(0.0f, 30.0f);
m_cityTiles[i, k] = new CityTile();
// 0,10,20.... to height
m_cityTiles[i, k].height = (Mathf.FloorToInt(height / 10.0f)) * 10;
m_cityTiles[i, k].worldPosition = new Vector3(i * 10, m_cityTiles[i, k].height / 10, k * 10);
}
}
// iterate and set up districts
for (int i = 0; i < arraySize; i++)
{
for (int k = 0; k < arraySize; k++)
{
if (!m_cityTiles[i, k].visited)
{
m_cityTiles[i, k].visited = true;
if (m_cityTiles[i, k].district == null)
{
var newDistrict = new ADistrict();
m_cityTiles[i, k].district = newDistrict;
newDistrict.name = "District_created_in_" + i + "_" + k;
newDistrict.height = m_cityTiles[i, k].height;
newDistrict.districtAccesses = new List <ADistrictAccess>();
districts.Add(newDistrict);
//newDistrict.color = colors[districts.Count];
}
// look for visited neighbours by flood fill! with same depth - if found, set to same district
// if none found, create a new district
checkNeighbours(i, k);
}
}
}
// Iterate throug tiles and set up district accesses
for (int y = 0; y < arraySize; y++)
{
for (int x = 0; x < arraySize; x++)
{
//top
FindPossibleDistrictAccess(x, y - 1, m_cityTiles[x, y], 0);
// left
FindPossibleDistrictAccess(x - 1, y, m_cityTiles[x, y], 90);
// right
FindPossibleDistrictAccess(x + 1, y, m_cityTiles[x, y], 270);
// bottom
FindPossibleDistrictAccess(x, y + 1, m_cityTiles[x, y], 180);
// compare height to neighbours
// if suitable save possible district access in district
}
}
// Visualization
Debug.Log("Passed");
for (int i = 0; i < arraySize; i++)
{
for (int k = 0; k < arraySize; k++)
{
Debug.Log("Tile " + i + " / " + k + " District: " + m_cityTiles[i, k].district.name);
GameObject visualization = Instantiate(prefab, new Vector3(i * 10, m_cityTiles[i, k].district.height / 10, k * 10), Quaternion.identity);
visualization.GetComponent <Renderer>().material.color = m_cityTiles[i, k].district.color;
}
}
foreach (var district in districts)
{
Debug.Log("District: " + district.name + " " + district.height);
}
foreach (var district in districts)
{
foreach (var access in district.districtAccesses)
{
var position = access.myCityTile.worldPosition;
GameObject visualization = Instantiate(DistrictAccessPrefab, position, Quaternion.identity);
visualization.transform.Rotate(0, access.rotation, 0);
}
}
}
/// <summary>
/// Gets data from the tiles and outputs it to the Text fields
/// </summary>
/// <param name="hover"></param>
public void UpdateInfo(GameObject hover)
{
if (hover != previousObject) //Save computation if no change is found
{
previousObject = hover;
CityTile city = hover.GetComponent <CityTile>();
switch (city.tileType)
{
case 0: //Empty
field1.text = "Empty";
field2.text = "";
field3.text = "";
field4.text = "";
field5.text = "";
field6.text = "";
break;
case 1: //House
HomeTile h = city.GetComponent <HomeTile>();
field1.text = "House";
field2.text = "Cost $" + city.cost;
field3.text = "Income: $" + city.tax;
field4.text = "Resources: " + h.unitsAcquired + "/" + h.unitsRequired;
field5.text = "Power: " + TrueFalse(city.power);
field6.text = "Water: " + TrueFalse(city.water);
break;
case 2: //Shop
ShopTile s = city.GetComponent <ShopTile>();
field1.text = "Shop";
field2.text = "Cost: $" + city.cost;
field3.text = "Income: $" + city.tax;
field4.text = "Resources:" + s.unitsAcquired + "/" + s.unitsRequired + " " + s.peopleUnitsAcquired + "/" + s.unitsRequired;
field5.text = "Power: " + TrueFalse(city.power);
field6.text = "Water: " + TrueFalse(city.water);
break;
case 3: //Factory
IndustryTile n = city.GetComponent <IndustryTile>();
field1.text = "Factory";
field2.text = "Cost: $" + city.cost;
field3.text = "Income: $" + city.tax;
field4.text = "Resources: " + n.unitsAcquired + "/" + n.unitsRequired;
field5.text = "Power: " + TrueFalse(city.power);
field6.text = "Water: " + TrueFalse(city.water);
break;
case 4: //Destroyed?
field1.text = "NULL";
field2.text = "";
field3.text = "";
field4.text = "";
field5.text = "";
field6.text = "";
break;
case 5: //Power
field1.text = "PowerPlant";
field2.text = "Cost: $" + city.cost;
field3.text = "";
field4.text = "Powering city...";
field5.text = "";
field6.text = "";
break;
case 6: //Water
field1.text = "WaterWorks";
field2.text = "Cost: $" + city.cost;
field3.text = "";
field4.text = "Pumping water...";
field5.text = "";
field6.text = "";
break;
case 7: //Road
field1.text = "Road";
field2.text = "Cost: $" + city.cost;
field3.text = "";
field4.text = "";
field5.text = "Power: " + TrueFalse(city.power);
field6.text = "Water: " + TrueFalse(city.water);
break;
}
}
}
/// <summary>
/// Generates a city from a string.
///
/// Assumes that the input string is rectangular
/// </summary>
/// <param name="str">representation of a city</param>
/// <returns>The generated city</returns>
public static City FromString(string str)
{
string[] splitLines = str.Split('\n');
string[] cityRepr = new string[splitLines.Length];
for (int i = 0; i < cityRepr.Length; i++) {
cityRepr[i] = splitLines[i].TrimEnd('\n');
}
var grid = new CityTile[cityRepr[0].Length, cityRepr.Length];
for (int y = 0; y < cityRepr.Length; y++) {
for (int x = 0; x < cityRepr[y].Length; x++) {
CityTile tile = cityRepr[y][x].ToCityTile();
grid[x, y] = tile;
}
}
return new City(grid);
}
private void RemoveInvalidOpenings(CityTile[,] cityGrid)
{
//foreach (var opening in openings) {
openings.RemoveAll(opening => {
var xDir = opening.dir.X();
var yDir = opening.dir.Y();
var startX = opening.x + xDir;
var startY = opening.y + yDir;
//int x = opening.x + opening.dir.X();
//int y = opening.y + opening.dir.Y();
CityTile[] tiles = opening.row.tiles;
string debug = "checking validity of opening " + tiles.PrettyPrint() + " as " + opening.x + "/" + opening.y + " in the direction " + opening.dir;
for (int i = 0; i < tiles.Length; i++) {
CityTile cityTile = cityGrid[startX + i * xDir, +startY + i * yDir];
debug += string.Format("\nChecking tile at {0}/{1}, it has the value {2}", startX + i * xDir, startY + i * yDir, cityTile);
if (cityTile != CityTile.Empty) {
i = tiles.Length;
debug += "\nremoved it!";
Debug.Log(debug);
return true;
}
}
Debug.Log(debug);
return false;
});
}
/// <summary>
/// The sum c1 + c2 is c1 with c2 placed to the right of it.
/// blanks are empty
///
/// This is not an commutative operation. SUCK IT!
/// </summary>
public static City operator +(City c1, City c2)
{
var c1Width = c1.width;
var c2Width = c2.width;
var c1Height = c1.height;
var c2Height = c2.height;
var sumGrid = new CityTile[c1Width + c2Width, Mathf.Max(c1Height, c2Height)];
for (int i = 0; i < sumGrid.GetLength(0); i++) {
for (int j = 0; j < sumGrid.GetLength(1); j++) {
bool inC1 = i < c1Width;
if (inC1 && j >= c1Height)
continue;
if (!inC1 && j >= c2Height)
continue; //under c2
int x = inC1 ? i : i - c1Width;
sumGrid[i, j] = inC1 ? c1._cityGrid[x, j] : c2._cityGrid[x, j];
}
}
return new City(sumGrid);
}
public void GenerateRevenue(CityTile tile)
{
Money += tile.CalculateRevenue(GameManager.Instance.MapManager.Observer.DeltaTime);
}
private bool IsEqual(CityTile t1, CityTile t2)
{
if (t1 == CityTile.DEBUG && t2 == CityTile.Street)
return true;
if (t2 == CityTile.DEBUG && t1 == CityTile.Street)
return true;
return t1 == t2;
}
public CityRow(CityTile[] row)
{
_row = row;
}
public void AddCityAsConnected(CityTile cityTile)
{
this.connectedCities.Add(cityTile);
this.numOfRoads = connectedCities.Count;
}
public City CreateEmptyCity(int width = 10, int height = 10)
{
CityTile[,] grid = new CityTile[width, height];
return new City(grid);
}
public CityPlaceholderObject(CityTile ct)
{
this.objectToRender = ct;
}
public City StartCreatingRandomCity()
{
openings = new List<Opening>();
CityTile[,] grid = new CityTile[100, 100];
City city = new City(grid);
List<City> allCities = new List<City>();
foreach (var source in sources) {
allCities.Add(City.FromString(source));
}
city = InsertInCity(city, allCities[0], 47, 47);
currentGenerator = CityGenerator(city, allCities);
city = showDebugOpenings(city);
return city;
}
public void AddTile(CityTile ct)
{
CityPlaceholderObject cpo = new CityPlaceholderObject(ct);
cityObjects.Add(cpo);
}
public bool CheckMoveMent()
{
Input = CW.ReadKey();
switch (Input.Key)
{
case ConsoleKey.UpArrow:
if (SingleTon.GetMapManagerInstance().CurrentMap.CheckLocation(SingleTon.GetCursorInstance().CurrentTile.Pos.X, SingleTon.GetCursorInstance().CurrentTile.Pos.Y - 1))
{
SingleTon.GetCursorInstance().CurrentTile = SingleTon.GetMapManagerInstance().CurrentMap.Tiles[SingleTon.GetCursorInstance().CurrentTile.Pos.X, SingleTon.GetCursorInstance().CurrentTile.Pos.Y - 1];
SingleTon.GetPlayerController().Steps++;
return(CheckForMonster());
}
else
{
return(false);
}
case ConsoleKey.DownArrow:
if (SingleTon.GetMapManagerInstance().CurrentMap.CheckLocation(SingleTon.GetCursorInstance().CurrentTile.Pos.X, SingleTon.GetCursorInstance().CurrentTile.Pos.Y + 1))
{
SingleTon.GetCursorInstance().CurrentTile = SingleTon.GetMapManagerInstance().CurrentMap.Tiles[SingleTon.GetCursorInstance().CurrentTile.Pos.X, SingleTon.GetCursorInstance().CurrentTile.Pos.Y + 1];
SingleTon.GetPlayerController().Steps++;
return(CheckForMonster());
}
else
{
return(false);
}
case ConsoleKey.LeftArrow:
if (SingleTon.GetMapManagerInstance().CurrentMap.CheckLocation(SingleTon.GetCursorInstance().CurrentTile.Pos.X - 1, SingleTon.GetCursorInstance().CurrentTile.Pos.Y))
{
SingleTon.GetCursorInstance().CurrentTile = SingleTon.GetMapManagerInstance().CurrentMap.Tiles[SingleTon.GetCursorInstance().CurrentTile.Pos.X - 1, SingleTon.GetCursorInstance().CurrentTile.Pos.Y];
SingleTon.GetPlayerController().Steps++;
return(CheckForMonster());
}
else
{
return(false);
}
case ConsoleKey.RightArrow:
if (SingleTon.GetMapManagerInstance().CurrentMap.CheckLocation(SingleTon.GetCursorInstance().CurrentTile.Pos.X + 1, SingleTon.GetCursorInstance().CurrentTile.Pos.Y))
{
SingleTon.GetCursorInstance().CurrentTile = SingleTon.GetMapManagerInstance().CurrentMap.Tiles[SingleTon.GetCursorInstance().CurrentTile.Pos.X + 1, SingleTon.GetCursorInstance().CurrentTile.Pos.Y];
SingleTon.GetPlayerController().Steps++;
return(CheckForMonster());
}
else
{
return(false);
}
case ConsoleKey.S:
DrawStats = !DrawStats;
if (DrawStats)
{
statsD.Draw(CW.GetPos().X + (MapDraw.ViewSize.X * 2) + 6, 2);
return(false);
}
else
{
CW.Clear();
return(true);
}
case ConsoleKey.Enter:
if (SingleTon.GetCursorInstance().CurrentTile is CityTile)
{
CityTile CT = (CityTile)SingleTon.GetCursorInstance().CurrentTile;
DrawInfoBox.AddToBox("You have entered " + CT.CityName);
CT.LoadMap().MapTile = SingleTon.GetCursorInstance().CurrentTile;
SingleTon.GetCursorInstance().CurrentTile = CT.CityMap.SpawnPoint;
SingleTon.GetMapManagerInstance().CurrentMap = CT.LoadMap();
CW.Clear();
return(true);
}
else if (SingleTon.GetCursorInstance().CurrentTile is Dungeon)
{
Dungeon DG = (Dungeon)SingleTon.GetCursorInstance().CurrentTile;
DrawInfoBox.AddToBox("You have entered a dungeon");
DG.ParrentMap = SingleTon.GetMapManagerInstance().CurrentMap;
SingleTon.GetMapManagerInstance().CurrentMap = DG.LoadMap();
DG.DungeonMap.MyTile = SingleTon.GetCursorInstance().CurrentTile;
SingleTon.GetCursorInstance().CurrentTile = DG.LoadMap().SpawnPoint;
PlayManager.State = PlayerState.Dungeon;
return(true);
}
else
{
return(false);
}
case ConsoleKey.Escape:
CityTile cityTile = (CityTile)SingleTon.GetMapManagerInstance().CurrentMap.MapTile;
if (cityTile != null && cityTile.ParrentMap != null)
{
SingleTon.GetCursorInstance().CurrentTile = SingleTon.GetMapManagerInstance().CurrentMap.MapTile;
cityTile = (CityTile)SingleTon.GetMapManagerInstance().CurrentMap.MapTile;
SingleTon.GetMapManagerInstance().CurrentMap = cityTile.ParrentMap;
}
return(true);
case ConsoleKey.O:
if (IntroMenu.test)
{
PlayManager.State = PlayerState.Combat;
new CombatDraw().Draw(new Cord {
X = 2, Y = 2
});
CW.ReadKey();
}
return(false);
case ConsoleKey.I:
PlayManager.State = PlayerState.Inventory;
CW.Clear();
new InventoryDraw().Draw();
return(false);
default:
return(false);
}
}
public void AddTile(CityTile tile)
{
_tiles.Add(tile);
}
public void GenerateConnections(List <HexTile> cities)
{
pendingCityTiles.Add(cities[0].GetCityTile());
for (int i = 0; i < pendingCityTiles.Count; i++)
{
CityTile currentCityTile = cities[i].GetCityTile();
List <HexTile> listOrderedByDistance = currentCityTile.GetAllCitiesByDistance();
int randomNumberOfRoads = currentCityTile.cityAttributes.GenerateNumberOfRoads();
int createdRoads = currentCityTile.cityAttributes.connectedCities.Count;
if (randomNumberOfRoads < createdRoads)
{
currentCityTile.cityAttributes.numOfRoads = createdRoads;
}
for (int j = 0; createdRoads < randomNumberOfRoads; j++)
{
CityTile tileToConnectTo = listOrderedByDistance [j].GetCityTile();
if ((j + 1) == listOrderedByDistance.Count)
{
//if j has reached listOrderedByDistance's upper bound, connect to nearest city
createdRoads++;
if (!currentCityTile.cityAttributes.connectedCities.Contains(listOrderedByDistance [0].GetCityTile()))
{
ConnectCities(currentCityTile.cityAttributes.hexTile, listOrderedByDistance [0]);
if (!pendingCityTiles.Contains(listOrderedByDistance [0].GetCityTile()))
{
pendingCityTiles.Add(listOrderedByDistance [0].GetCityTile());
}
}
break;
}
else
{
if (tileToConnectTo.cityAttributes.numOfRoads < 3 && !currentCityTile.cityAttributes.connectedCities.Contains(tileToConnectTo))
{
createdRoads++;
ConnectCities(currentCityTile.cityAttributes.hexTile, tileToConnectTo.cityAttributes.hexTile);
if (!pendingCityTiles.Contains(tileToConnectTo))
{
pendingCityTiles.Add(tileToConnectTo);
}
}
}
}
if (pendingCityTiles.Count != CityGenerator.Instance.cityCount)
{
Debug.Log("MISSED SOME CITIES!");
Debug.Log("Create Lines for missed out cities");
for (int x = 0; x < cities.Count; x++)
{
if (!pendingCityTiles.Contains(cities [x].GetCityTile()))
{
Debug.Log("======Missed out city: " + cities [x].name + " ======");
CityTile missedOutCity = cities [x].GetCityTile();
HexTile possibleConnectionTile = CityGenerator.Instance.FindNearestCityWithConnection(missedOutCity);
if (possibleConnectionTile != null && !missedOutCity.cityAttributes.connectedCities.Contains(possibleConnectionTile.GetCityTile()))
{
ConnectCities(missedOutCity.cityAttributes.hexTile, possibleConnectionTile);
if (!pendingCityTiles.Contains(missedOutCity))
{
pendingCityTiles.Add(missedOutCity);
}
if (!pendingCityTiles.Contains(possibleConnectionTile.GetCityTile()))
{
pendingCityTiles.Add(possibleConnectionTile.GetCityTile());
}
}
}
}
}
}
Debug.Log("DONE!: " + pendingCityTiles.Count);
}
