void startAtMovableTile()
{
//GameObject[] mvTiles = GameObject.FindGameObjectsWithTag("Movable");
int startIndex = 7;
int endIndex = RandomRangeExcept(40, 80, 40);
TileUnit tileStartUnit = greenTiles[startIndex] as TileUnit;
TileUnit tileEndUnit = tileNodes[17, 28]; //greenTiles[endIndex] as TileUnit;
GameObject tileStart = tileStartUnit.getGameObject();
GameObject tileEnd = tileEndUnit.getGameObject();
//Place Player
GameObject pInstance = GameObject.Find("Player");
Vector3 v;
v.x = tileStart.transform.position.x;
v.y = tileStart.transform.position.y;
v.z = tileStart.transform.position.z - 50;
pInstance.transform.position = v;
//Place CaptureFlag
GameObject fInstance = GameObject.Find("CaptureFlag");
Vector3 v2;
v2.x = tileEnd.transform.position.x;
v2.y = tileEnd.transform.position.y;
v2.z = tileEnd.transform.position.z - 50;
fInstance.transform.position = v2;
genPath(tileStartUnit, tileEndUnit);
}
void setTileNeighbour(TileUnit thisTile, int rowNum, int colNum)
{
//Debug.Log("setTileNeighbour: " + rowNum + " " + colNum);
//[24][58]
//Debug.Log(rowNum + " " + colNum);
if (colNum > 0) //Check Left Tile
{
TileUnit t1 = tileNodes[rowNum, colNum - 1] as TileUnit;
//Debug.Log("t1: " + t1.getMovable());
thisTile.setTile("left", t1);
t1.setTile("right", thisTile);
}
if (rowNum > 0) //Check Top Tile
{
TileUnit t2 = tileNodes[rowNum - 1, colNum] as TileUnit;
//Debug.Log("t2: " + t2.getMovable());
thisTile.setTile("top", t2);
t2.setTile("bottom", thisTile);
}
}
TileUnit genNode(string type, Vector3 pos)
{
TileUnit tu = new TileUnit();
GameObject t = null;
switch (type)
{
case "red":
t = Instantiate(Resources.Load("RedCube"), pos, Quaternion.identity) as GameObject;
tu.init(t, null, null, null, null, false);
break;
case "green":
t = Instantiate(Resources.Load("GreenCube"), pos, Quaternion.identity) as GameObject;
tu.init(t, null, null, null, null, true);
break;
}
switch (type)
{
case "green":
greenTiles.Add(tu);
break;
case "red":
redTiles.Add(tu);
break;
}
return(tu);
}
public void handleUnitTick(int x, int y, TileUnit tu)
{
if (tu.anim == TileUnit.Animation.MOVE)
{
// Make sure nothing in the way.
IntVec2 new_pos = new IntVec2(x + tu.animDir.x, y + tu.animDir.y);
if (!isOOB(new_pos) && getItem(new_pos) == null && !player.inTiles().Contains(new_pos))
{
tiles_[x, y] = null;
tiles_[new_pos.x, new_pos.y] = tu;
}
}
if (tu.anim == TileUnit.Animation.HARVEST && tu is HarvesterRobot)
{
(tu as HarvesterRobot).extract(this, new IntVec2(x + tu.animDir.x, y + tu.animDir.y));
}
if (tu.anim == TileUnit.Animation.COLLECT && tu is CollectorRobot)
{
(tu as CollectorRobot).collect(this, new IntVec2(x + tu.animDir.x, y + tu.animDir.y));
}
if (tu.anim == TileUnit.Animation.STORE && tu is CollectorRobot)
{
(tu as CollectorRobot).deposit(this, new IntVec2(x + tu.animDir.x, y + tu.animDir.y));
}
tu.anim = TileUnit.Animation.IDLE;
}
private void GenerateGrid()
{
Vector3 currentPosition = Vector3.zero;
GameObject tile;
tiles = new TileUnit[gridWidth, gridHeight];
for (int i = 0; i < gridWidth; i++)
{
for (int j = 0; j < gridHeight; j++)
{
tile = Instantiate(tileUnitPrefab, currentPosition, Quaternion.identity, transform) as GameObject;
tile.name = $"{tileNameStart}{i},{j})";
TileUnit unit = tile.GetComponent <TileUnit>();
if (unit)
{
tiles[i, j] = unit;
unit.myIndex.x = i;
unit.myIndex.y = j;
}
currentPosition.Set(i, j + 1, 0.0f);
}
currentPosition.Set(i + 1, 0.0f, 0.0f);
}
}
public void buyItem(string s)
{
TileUnit tu = null;
switch (s)
{
case "sawmill":
if (gs.tryBuy(BALANCE_CONSTANTS.SAWMILL_COST))
{
tu = new Storage(Resource.Type.WOOD);
}
break;
case "foundry":
if (gs.tryBuy(BALANCE_CONSTANTS.FOUNDRY_COST))
{
tu = new Storage(Resource.Type.ORE);
}
break;
case "refinery":
if (gs.tryBuy(BALANCE_CONSTANTS.REFINERY_COST))
{
tu = new Storage(Resource.Type.OIL);
}
break;
case "guardtower":
if (gs.tryBuy(BALANCE_CONSTANTS.TOWER_COST))
{
tu = new GuardTower();
}
break;
case "gunsmith":
if (gs.tryBuy(BALANCE_CONSTANTS.GUNSMITH_COST))
{
tu = new GunSmith();
}
break;
}
if (tu == null)
{
return;
}
tu.gr = gr;
var v = gs.placeItemNear(tu, new IntVec2((int)gs.player.location.x, (int)gs.player.location.y));
if (tu is GuardTower)
{
gr.addGuardLight(v);
}
if (tu != null)
{
activate();
}
}
public AddTileUnitViewModel()
{
TileUnit = new TileUnit()
{
Category = "新地形",
Size = new TileUnitSize {
XLength = 1, ZLength = 1
}
};
}
public TileUnitModel(TileUnit tileUnit)
{
TileUnit = tileUnit;
Elements = tileUnit.Tiles.Select((o, i) => new TileUnitElementModel(tileUnit.Tiles, i)).ToArray();
foreach (var item in Elements)
{
item.Updated += Item_Updated;
}
Draw();
}
private void SpawnTables()
{
for (int i = 0; i < tablePositions.Length; i++)
{
NodeIndex index = tablePositions[i];
TileUnit parentTile = tiles[index.x, index.y];
Instantiate(tablePrefab, new Vector3(index.x, index.y, 1.0f), Quaternion.identity, parentTile.gameObject.transform);
parentTile.occupied = true;
}
}
float getHeuristic(TileUnit baseTile, TileUnit tile)
{
float valX, valY;
GameObject objBase = baseTile.getGameObject();
GameObject obj = tile.getGameObject();
valX = Mathf.Abs(objBase.transform.position.x - obj.transform.position.x);
valY = Mathf.Abs(objBase.transform.position.y - obj.transform.position.y);
return(valX + valY);
}
public void init(GameObject pObj, TileUnit pl, TileUnit pr, TileUnit pu, TileUnit pd, bool m)
{
obj = pObj;
l = pl;
r = pr;
u = pu;
d = pd;
movable = m;
}
public void applyAnimSets(List <animSet> l)
{
foreach (var v in l)
{
TileUnit tu = gs.tiles_[v.start.x, v.start.y] as TileUnit;
if (tu is Robot || tu is Baddie)
{
tu.anim = v.animType;
tu.animDir = v.anim;
}
}
}
bool tileAlreadyTraversed(TileUnit tile)
{
bool res = false;
for (int i = 0; i < closedList.Count; i++)
{
if (tile == closedList[i])
{
res = true;
break;
}
}
return(res);
}
public void ClickMakeBuilding(GameObject sender)
{
TileUnit unit = uiFollowTargetObj.GetComponent <TileUnit>();
if (sender.name == "Door")
{
unit.MakeBuilding(buildingSprite[0]);
}
else
{
unit.MakeBuilding(buildingSprite[1]);
}
TurnOnBuildingMenu(uiFollowTargetObj);
}
public void ClickDestroy()
{
TileUnit unit = uiFollowTargetObj.GetComponent <TileUnit>();
if (unit.groundType != GroundType.normal)
{
unit.DestroyObstacle();
}
else
{
unit.DestoryBuilding();
}
TurnOnGroundMenu(uiFollowTargetObj);
}
// void searchNode(TileUnit tile, TileUnit end) {
// Debug.Log("Closed Count: " + closedList.Count);
// TileUnit nextNode = null;
//
// nextNode = getNextNode(tile,end);
// if(nextNode!=null) {
// closedList.Add(nextNode);
// searchNode(nextNode,end);
// }
// walkPath();
// }
void genPath(TileUnit start, TileUnit end) //aStar
//searchNode(start,end);
{
TileUnit nextNode = null;
nextNode = getNextNode(start, end);
if (nextNode != null && nextNode != end)
{
closedList.Add(nextNode);
pathList.Add(nextNode);
genPath(nextNode, end);
}
Debug.Log("a");
walkPath();
}
public override void OnInspectorGUI()
{
tileUnit = target as TileUnit;
EditorGUI.BeginChangeCheck();
serializedObject.Update();
EditorGUILayout.PropertyField(tileType);
serializedObject.ApplyModifiedProperties();
if (EditorGUI.EndChangeCheck())
{
tileUnit.SpawnTileContent();
}
}
public void setTile(string type, TileUnit tile)
{
switch (type)
{
case "left":
l = tile;
break;
case "right":
r = tile;
break;
case "top":
u = tile;
break;
case "bottom":
d = tile;
break;
}
//Debug.Log("YUP!");
}
public TileUnit getNeighbour(string type)
{
TileUnit temp = null;
switch (type)
{
case "left":
if (l != null && l.getMovable())
{
temp = l;
}
break;
case "right":
if (r != null && r.getMovable())
{
temp = r;
}
break;
case "up":
if (u != null && u.getMovable())
{
temp = u;
}
break;
case "down":
if (d != null && d.getMovable())
{
temp = d;
}
break;
}
return(temp);
}
private Color _GetColorOfTypeRange(TileUnit unit)
{
switch (_viewMapStatus)
{
case ViewMapStatus.Biome:
case ViewMapStatus.Terrain:
return(_terrainColor.GetLerpColor(unit.Height));
case ViewMapStatus.Humudity:
return(_weatherColor.GetLerpColor(unit.Humidity));
case ViewMapStatus.Temperature:
return(_weatherColor.GetLerpColor(unit.Temperature));
case ViewMapStatus.Mana:
return(_manaColor.GetLerpColor(unit.Mana));
case ViewMapStatus.River:
return(_rainColor.GetLerpColor(unit.River));
default:
return(Color.clear);
}
}
private IEnumerator _CreateNewWorldMonad()
{
Random.InitState(_seed);
var genTerrainMonad = new BlockMonad <float[]>(r =>
_terrainGen.GenerateHeightMap(
_width,
_height,
Random.Range(0, 10000),
Random.Range(0, 10000),
_paramTerrain,
r));
var genHumidityMonad = new BlockMonad <float[]>(r =>
_humidityGen.GenerateWeatherMap(
_width,
_height,
Random.Range(0, 10000),
Random.Range(0, 10000),
_paramWeather,
r));
var genTemperatureMonad = new BlockMonad <float[]>(r =>
_temperatureGen.GenerateWeatherMap(
_width,
_height,
Random.Range(0, 10000),
Random.Range(0, 10000),
_paramTemperature,
r));
var genManaMonad = new BlockMonad <float[]>(r =>
_manaGen.GenerateManaMap(
_width,
_height,
_paramMana,
r));
Debug.Log("start genTerrainMonad");
yield return(genTerrainMonad.Do());
Debug.Log("start genHumidityMonad");
yield return(genHumidityMonad.Do());
Debug.Log("start genTemperatureMonad");
yield return(genTemperatureMonad.Do());
Debug.Log("start genManaMonad");
yield return(genManaMonad.Do());
var terrainMap = genTerrainMonad.Result;
var humidityMap = genHumidityMonad.Result;
var temperatureMap = genTemperatureMonad.Result;
var manaMap = genManaMonad.Result;
var genRiverMonad = new BlockMonad <float[]>(r =>
_riverGen.GenerateRiverMap(
_width,
_height,
terrainMap,
_paramRain,
r));
Debug.Log("start genRiverMonad");
yield return(genRiverMonad.Do());
var riverMap = genRiverMonad.Result;
var tileUnitMap = new TileUnit[_width * _height];
IBiomeIdentifier identifier = new BasicBiomeIdentifier(_biomeDistribution);
for (int x = 0; x < _width; x++)
{
for (int y = 0; y < _height; y++)
{
var idx = MathUtility.MapIndex(x, y, _height);
var height = terrainMap[idx];
var humidity = humidityMap[idx];
var temperature = temperatureMap[idx];
var mana = manaMap[idx];
var river = riverMap[idx];
BiomeData biome = identifier.IdentifyBiome(humidity, height, temperature);
tileUnitMap[idx] = new TileUnit(
height,
humidity,
temperature,
mana,
river,
biome.Biome);
}
}
_tileData = new TileDataUnit
{
Map = tileUnitMap,
Width = _width,
Height = _height,
};
_noticeTxt = "New world created.";
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mousePos.z = 0f;
Vector3Int currentCell = PlayerLayer.WorldToCell(mousePos);
if (PlayerLayer.HasTile(currentCell))
{
// highlight player
HighlightLayer.ClearAllTiles();
HighlightLayer.SetTile(currentCell, SelectedTileTemplate);
selectedTilePosition = currentCell;
selectedTile = PlayerLayer.GetTile(currentCell) as TileUnit;
// get surroundings positions
Vector3Int[] highlightPositions = selectedTile.Data.getMoveTilePositions(currentCell).Where(pos => !UntargetableLayer.HasTile(pos)).ToArray();
var dict = new Dictionary <Vector3Int, int>()
{
{ currentCell, 0 }
};
int clusterCount = 1;
int i = 0, opCount = 0;
while (i < highlightPositions.Length)
{
Vector3Int position = highlightPositions[i];
int clusterId = clusterCount;
if (!dict.ContainsKey(position))
{
clusterCount++;
dict.Add(position, clusterId);
}
// find smallest adjacent cluster id
clusterId = dict[position];
foreach (Vector3Int neighbor in neighbors)
{
var neighborKey = position + neighbor;
if (dict.ContainsKey(neighborKey))
{
opCount++;
int neighborClusterId = dict[neighborKey];
clusterId = Mathf.Min(clusterId, neighborClusterId);
}
}
// join adjacents cluster to cluster with smallest id
foreach (Vector3Int neighbor in neighbors)
{
var neighborKey = position + neighbor;
if (dict.ContainsKey(neighborKey))
{
opCount++;
int neighborClusterId = dict[neighborKey];
if (neighborClusterId > clusterId)
{
i = 0;
}
//Debug.Log($"i: {i} opCode: {opCount} key: {position}, nei: {neighborKey} clusterId: {clusterId}");
dict[neighborKey] = clusterId;
}
}
dict[position] = clusterId;
i++;
}
//foreach (var kvp in dict)
//{
// Debug.Log(kvp.Key + " : " + kvp.Value);
//}
highlightPositions = dict.Where(kvp => kvp.Value == 0 && kvp.Key != currentCell).Select(kvp => kvp.Key).ToArray();
Debug.Log($"from {currentCell} operations: {opCount} tiles: {highlightPositions.Length}");
// highlight surroundings
foreach (Vector3Int position in highlightPositions)
{
HighlightLayer.SetTile(position, AreaTileTemplate);
}
}
else if (HighlightLayer.HasTile(currentCell) && !PlayerLayer.HasTile(currentCell) && selectedTile != null)
{
HighlightLayer.ClearAllTiles();
PlayerLayer.SetTile(selectedTilePosition, null);
PlayerLayer.SetTile(currentCell, selectedTile);
}
}
}
TileUnit getNextNode(TileUnit start, TileUnit end)
{
float f, g, h, minF = 99999;
TileUnit nextNode = null;
TileUnit n = null;
bool tileAlreadySearched = false;
if (start != null && end != null)
{
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("right"));
if (start.getNeighbour("right") != null && tileAlreadySearched == false)
{
n = start.getNeighbour("right");
g = getHeuristic(start, n);
h = getHeuristic(end, n);
f = g + h * 10;
if (f < minF)
{
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("left"));
if (start.getNeighbour("left") != null && tileAlreadySearched == false)
{
n = start.getNeighbour("left");
g = getHeuristic(start, n);
h = getHeuristic(end, n);
f = g + h * 10;
if (f < minF)
{
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("top"));
if (start.getNeighbour("up") != null && tileAlreadySearched == false)
{
n = start.getNeighbour("up");
g = getHeuristic(start, n);
h = getHeuristic(end, n);
f = g + h * 10;
if (f < minF)
{
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("bottom"));
if (start.getNeighbour("down") != null && tileAlreadySearched == false)
{
n = start.getNeighbour("down");
g = getHeuristic(start, n);
h = getHeuristic(end, n);
f = g + h * 10;
if (f < minF)
{
minF = f;
nextNode = n;
}
}
}
return(nextNode);
}
//public TileSetContext TileSetContext { get; private set; }
public NonPickAnyTileUnitEditViewModel(TileUnit tileUnit)
{
TileUnit = tileUnit;
}
public void setTile(string type, TileUnit tile)
{
switch(type) {
case "left":
l = tile;
break;
case "right":
r = tile;
break;
case "top":
u = tile;
break;
case "bottom":
d = tile;
break;
}
//Debug.Log("YUP!");
}
public void init(GameObject pObj, TileUnit pl, TileUnit pr, TileUnit pu, TileUnit pd, bool m)
{
obj = pObj;
l = pl;
r = pr;
u = pu;
d = pd;
movable = m;
}
bool tileAlreadyTraversed(TileUnit tile)
{
bool res = false;
for(int i=0;i<closedList.Count;i++) {
if(tile==closedList[i]) {
res = true;
break;
}
}
return res;
}
void setTileNeighbour(TileUnit thisTile, int rowNum, int colNum)
{
//Debug.Log("setTileNeighbour: " + rowNum + " " + colNum);
//[24][58]
//Debug.Log(rowNum + " " + colNum);
if(colNum>0) { //Check Left Tile
TileUnit t1 = tileNodes[rowNum,colNum-1] as TileUnit;
//Debug.Log("t1: " + t1.getMovable());
thisTile.setTile("left",t1);
t1.setTile("right",thisTile);
}
if(rowNum>0) { //Check Top Tile
TileUnit t2 = tileNodes[rowNum-1,colNum] as TileUnit;
//Debug.Log("t2: " + t2.getMovable());
thisTile.setTile("top",t2);
t2.setTile("bottom",thisTile);
}
}
TileUnit getNextNode(TileUnit start, TileUnit end)
{
float f,g,h,minF = 99999;
TileUnit nextNode = null;
TileUnit n = null;
bool tileAlreadySearched = false;
if(start!=null&&end!=null) {
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("right"));
if(start.getNeighbour("right")!=null&&tileAlreadySearched==false) {
n = start.getNeighbour("right");
g = getHeuristic(start,n);
h = getHeuristic(end,n);
f = g+h*10;
if(f<minF) {
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("left"));
if(start.getNeighbour("left")!=null&&tileAlreadySearched==false) {
n = start.getNeighbour("left");
g = getHeuristic(start,n);
h = getHeuristic(end,n);
f = g+h*10;
if(f<minF) {
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("top"));
if(start.getNeighbour("up")!=null&&tileAlreadySearched==false) {
n = start.getNeighbour("up");
g = getHeuristic(start,n);
h = getHeuristic(end,n);
f = g+h*10;
if(f<minF) {
minF = f;
nextNode = n;
}
}
tileAlreadySearched = tileAlreadyTraversed(start.getNeighbour("bottom"));
if(start.getNeighbour("down")!=null&&tileAlreadySearched==false) {
n = start.getNeighbour("down");
g = getHeuristic(start,n);
h = getHeuristic(end,n);
f = g+h*10;
if(f<minF) {
minF = f;
nextNode = n;
}
}
}
return nextNode;
}
float getHeuristic(TileUnit baseTile, TileUnit tile)
{
float valX, valY;
GameObject objBase = baseTile.getGameObject();
GameObject obj = tile.getGameObject();
valX = Mathf.Abs(objBase.transform.position.x - obj.transform.position.x);
valY = Mathf.Abs(objBase.transform.position.y - obj.transform.position.y);
return valX + valY;
}
// void searchNode(TileUnit tile, TileUnit end) {
// Debug.Log("Closed Count: " + closedList.Count);
// TileUnit nextNode = null;
//
// nextNode = getNextNode(tile,end);
// if(nextNode!=null) {
// closedList.Add(nextNode);
// searchNode(nextNode,end);
// }
// walkPath();
// }
void genPath(TileUnit start, TileUnit end)
{
//aStar
//searchNode(start,end);
TileUnit nextNode = null;
nextNode = getNextNode(start,end);
if(nextNode!=null&&nextNode!=end) {
closedList.Add(nextNode);
pathList.Add(nextNode);
genPath(nextNode,end);
}
Debug.Log("a");
walkPath();
}
TileUnit genNode(string type, Vector3 pos)
{
TileUnit tu = new TileUnit();
GameObject t = null;
switch(type) {
case "red":
t = Instantiate (Resources.Load("RedCube"), pos ,Quaternion.identity) as GameObject;
tu.init(t,null,null,null,null,false);
break;
case "green":
t = Instantiate (Resources.Load("GreenCube"), pos ,Quaternion.identity) as GameObject;
tu.init(t,null,null,null,null,true);
break;
}
switch(type) {
case "green":
greenTiles.Add(tu);
break;
case "red":
redTiles.Add(tu);
break;
}
return tu;
}
