private static Color GetHexagonColor(TileTerrain terrain)
{
if (terrain == TileTerrain.Grass)
{
return(Color.green);
}
if (terrain == TileTerrain.Road)
{
return(Color.gray);
}
if (terrain == TileTerrain.Arid)
{
return(new Color32(0xDA, 0xA5, 0x20, 1));
}
if (terrain == TileTerrain.Desert)
{
return(Color.yellow);
}
if (terrain == TileTerrain.Marsh)
{
return(new Color32(0x00, 0x64, 0x00, 1));
}
if (terrain == TileTerrain.Snow)
{
return(Color.white);
}
return(Color.black);
}
void createTile(int i, int j, Vector2 pos)
{
GameObject tileGameObject = (GameObject) Instantiate(tilePrefab, pos, Quaternion.identity);
tileGameObject.transform.parent = this.gameObject.transform;
Tile tile = tileGameObject.GetComponent<Tile>();
tile.setId(i*mapWidth+j);
// Terrain
float terrainPixel = terrainTexture.GetPixel(i, j).r;
for(int n=0; n < dataFiles.tileTerrainTypes.Length; n++){
TileTerrain item = dataFiles.tileTerrainTypes[n];
if( (item.range.min <= terrainPixel) && (item.range.max > terrainPixel) ){
tile.setTerrain(ref item);
tile.setDisplayMode(DisplayMode.Terrain);
break;
}
}
// Forestry
float forestryPixel = forestTexture.GetPixel(i, j).r;
forestryPixel = forestryPixel * tile.getTerrain().forestryFactor;
for(int n=0; n < dataFiles.tileForestryTypes.Length; n++){
TileForestry item = dataFiles.tileForestryTypes[n];
if( (item.range.min <= forestryPixel) && (item.range.max > forestryPixel) ){
tile.setForestry(ref item);
break;
}
}
tiles[tile.getId()] = tileGameObject;
}
public bool ValidateMove(GameTile dest)
{
if (dest == null)
{
return(false);
}
TileTerrain type = dest.tileTerrain;
if (type == TileTerrain.ShallowSea && canCrossSS)
{
return(true);
}
else if (type == TileTerrain.DeepSea && canCrossDS)
{
return(true);
}
else if (type == TileTerrain.River && canCrossRiver)
{
return(true);
}
else if (type != TileTerrain.ShallowSea && type != TileTerrain.DeepSea && type != TileTerrain.River)
{
return(true);
}
return(false);
}
private static TerrainType GetHexagonType(TileTerrain terrain)
{
if (terrain == TileTerrain.Grass)
{
return(TerrainType.Grass);
}
if (terrain == TileTerrain.Road)
{
return(TerrainType.Road);
}
if (terrain == TileTerrain.Arid)
{
return(TerrainType.Arid);
}
if (terrain == TileTerrain.Desert)
{
return(TerrainType.Desert);
}
if (terrain == TileTerrain.Marsh)
{
return(TerrainType.Marsh);
}
if (terrain == TileTerrain.Snow)
{
return(TerrainType.Snow);
}
return(TerrainType.Undefined);
}
private Rectangle HandleCollision(Rectangle bounds, TileTerrain collision, Rectangle tileBounds)
{
Vector2 depth = RectangleExtensions.GetIntersectionDepth(bounds, tileBounds);
if (depth != Vector2.Zero)
{
float absDepthX = Math.Abs(depth.X);
float absDepthY = Math.Abs(depth.Y);
if (collision == TileTerrain.Passable) // Ignore platforms.
{
// Resolve the collision along the X axis.
if (direction == Direction.dLeft || direction == Direction.dRight)
{
position = new Vector2(position.X + depth.X, position.Y);
}
else
{
position = new Vector2(position.X, position.Y + depth.Y);
}
// Perform further collisions with the new bounds.
bounds = BoundingRectangle;
}
}
return(bounds);
}
private void TerrainOverlay_TextChanged(object sender, TextChangedEventArgs e)
{
TileTerrain selectedTerrain = (TileTerrain)TerrainList.SelectedItem;
if (selectedTerrain != null)
{
try
{
TileBlockOverlay overlay = JsonConvert.DeserializeObject <TileBlockOverlay>(TerrainOverlay.Text);
if (overlay != null && (overlay.PaletteIndex < 0 || overlay.PaletteIndex >= 8))
{
throw new Exception();
}
TerrainOverlay.Foreground = new SolidColorBrush(Colors.White);
selectedTerrain.Overlay = overlay;
BlockSelector.Update(tileIndex: BlockSelector.SelectedBlockValue);
UpdateTileBlock();
SetUnsaved();
}
catch
{
TerrainOverlay.Foreground = new SolidColorBrush(Colors.Red);
}
}
}
public void AddGoodTerrain()
{
TileTerrain t = new TileTerrain("marsh");
Assert.AreEqual(t.TravelCost, 1.75, 0.0001);
Assert.AreEqual(t.TerrainType, "marsh");
}
private void CheckCollisions()
{
Rectangle bounds = BoundingRectangle;
int leftTile = (int)Math.Floor((float)bounds.Left / Tile.Width);
int rightTile = (int)Math.Ceiling(((float)bounds.Right / Tile.Width)) - 1;
int topTile = (int)Math.Floor((float)bounds.Top / Tile.Height);
int bottomTile = (int)Math.Ceiling(((float)bounds.Bottom / Tile.Height)) - 1;
// For each potentially colliding tile...
for (int y = topTile; y <= bottomTile; ++y)
{
for (int x = leftTile; x <= rightTile; ++x)
{
// If this tile is collidable,
TileTerrain collision = level.GetTileCollision(x, y);
if (collision != TileTerrain.Water)
{
// Determine collision depth (with direction) and magnitude.
Rectangle tileBounds = level.GetTileBounds(x, y);
bounds = HandleCollision(bounds, collision, tileBounds);
}
}
}
}
private void checkGroundType()
{
TileTerrain currentTerrain = currentTileMap.GetTile(currentTileMap.WorldToCell(footstepPosition.position)) as TileTerrain;
if (currentTerrain != null)
{
switch (currentTerrain.TerrainType)
{
case TileTerrain.TerrainList.Grass:
//gm.GetComponent<AudioManager>().PlaySound(AudioManager.SoundList.StepGrass);
currentSound = AudioManager.SoundList.StepGrass;
break;
case TileTerrain.TerrainList.Stone:
currentSound = AudioManager.SoundList.StepStone;
break;
case TileTerrain.TerrainList.Wood:
break;
}
audioManager.PlaySound(currentSound);
}
else
{
audioManager.PlaySound(currentSound);
}
}
public void SetTerrainOnTile(TileTerrain terrain)
{
terrainOnTile = terrain;
if (terrain == null)
{
tileTerrainType = TileTerrainType.floor;
}
else if (terrain is Stairs)
{
Stairs s = terrain as Stairs;
if (s.IsUp)
{
tileTerrainType = TileTerrainType.stairsUp;
}
else
{
tileTerrainType = TileTerrainType.stairsDown;
}
}
else if (terrain is Trap)
{
tileTerrainType = TileTerrainType.trap;
}
}
public void PlayerLanded()
{
TileTerrain currentTerrain = currentTileMap.GetTile(currentTileMap.WorldToCell(footstepPosition.position)) as TileTerrain;
if (currentTerrain != null)
{
switch (currentTerrain.TerrainType)
{
case TileTerrain.TerrainList.Grass:
// gm.GetComponent<AudioManager>().PlaySound(AudioManager.SoundList.LandGrass);
currentSound = AudioManager.SoundList.LandGrass;
break;
case TileTerrain.TerrainList.Stone:
// gm.GetComponent<AudioManager>().PlaySound(AudioManager.SoundList.LandStone);
currentSound = AudioManager.SoundList.LandStone;
break;
case TileTerrain.TerrainList.Wood:
// gm.GetComponent<AudioManager>().PlaySound(AudioManager.SoundList.LandGrass);
break;
}
audioManager.PlaySound(currentSound);
}
else
{
audioManager.PlaySound(currentSound);
}
}
// CAUTION - called once per frame by this.visual
public void Update()
{
// changes terrain based on elevation
terrain = TileTerrain.LAND;
waterbool = false;
if (elevation <= Config.reg.SeaLevel)
{
terrain = TileTerrain.WATER;
waterbool = true;
}
if (elevation >= Config.reg.RockLevel)
{
terrain = TileTerrain.ROCK;
}
if (elevation >= Config.reg.SnowLevel)
{
terrain = TileTerrain.SNOW;
}
// changes the border status based on amount of neighbours
if (GetNeighbourCount() < 6)
{
border = true;
}
else
{
border = false;
}
// updates corners
for (int i = 0; i < cornerNum; i++)
{
corners[i].border = border;
}
}
public Tile(TileType pTileType, Coord pCPos, float pSize, Vector3 pWPos)
{
index = "T:[ " + pCPos.q.ToString() + ", " + pCPos.r.ToString() + " ]";
tileType = pTileType;
cornerNum = Utils.GetTileCornerNum(tileType);
// add to registry
Utils.instance.allTiles.Add(this);
// positions
cPos = pCPos;
wPos = pWPos;
// terrain
terrain = TileTerrain.WATER;
// refs
neighbors = new Tile[Utils.GetTileCornerNum(tileType)];
corners = new Corner[Utils.GetTileCornerNum(tileType)];
borders = new Edge[Utils.GetTileCornerNum(tileType)];
// geometry
size = pSize;
}
private static MapObject GetHexagonTile(TileTerrain terrain)
{
if (terrain == TileTerrain.Grass)
{
return(MapObject.GrassTile);
}
if (terrain == TileTerrain.Road)
{
return(MapObject.RoadTile);
}
if (terrain == TileTerrain.Desert)
{
return(MapObject.DesertTile);
}
if (terrain == TileTerrain.Marsh)
{
return(MapObject.MarshTile);
}
if (terrain == TileTerrain.Snow)
{
return(MapObject.SnowTile);
}
throw new ArgumentException();
}
public void EditCorrectlyFixesTravelCost()
{
var t = new TileTerrain("grass");
Assert.AreEqual(t.TravelCost, 1, 0.0001);
t.TerrainType = "arid";
Assert.AreEqual(t.TravelCost, 1.25, 0.0001);
}
public PuzzleTile(int x, int y, PuzzleType type, int id)
{
collision = TileTerrain.Passable;
position = new Vector2(x, y);
this.type = type;
this.id = id;
puzzleCompleted = false;
}
public void CreateHexagon(TileTerrain terrain, Location location)
{
var x = location.X;
var y = location.Y;
var hexId = string.Format("Tile {0} {1}", x, y);
engine.CreateObject(hexId, GetHexagonTile(terrain), x, y);
}
public Enc(string t, List <EncChoice> c, TileTerrain tt, TileFeatures tf)
{
text = t;
choices = c;
terrainType = tt;
featureType = tf;
encounters = new List <string>();
}
private void CreateTileObject(TileObject tileObject, TileTerrain terrain, MapSize mapSize)
{
if (tileObject == null)
{
return;
}
var x = tileObject.location.X;
var y = tileObject.location.Y;
if (tileObject is IBuilding)
{
var buildingLocation = ((IBuilding)tileObject).BuildingLocation;
x = buildingLocation.X;
y = buildingLocation.Y;
}
if (tileObject is Mine)
{
tileObject.UnityId = $"Mine {counter[MapObject.Mine]++}";
objectsCreationHelper.CreateMine((Mine)tileObject);
}
if (tileObject is Dwelling)
{
tileObject.UnityId = $"Dwelling {counter[MapObject.Dwelling]++}";
objectsCreationHelper.CreateDwelling((Dwelling)tileObject, mapSize);
}
if (tileObject is ResourcePile)
{
tileObject.UnityId = $"Resources pile {counter[MapObject.ResourcesPile]++}";
objectsCreationHelper.CreateResourcePile((ResourcePile)tileObject);
}
if (tileObject is NeutralArmy)
{
tileObject.UnityId = $"Neutral army {counter[MapObject.Infantry]++}";
objectsCreationHelper.CreateArmy((NeutralArmy)tileObject, tileObject.location);
}
if (tileObject is Wall)
{
tileObject.UnityId = $"Wall {counter[MapObject.Wall]++}";
objectsCreationHelper.CreateWall((Wall)tileObject, terrain);
}
if (tileObject.UnityId == null)
{
throw new ArgumentException($"Got TileObject of unknown type: {tileObject.GetType().Name}");
}
if (tileObject is CapturableObject)
{
var owner = (tileObject as CapturableObject).Owner;
hommEngine.SetFlag(tileObject.UnityId, owner?.Name ?? string.Empty);
}
ConnectTileObject(tileObject);
}
public GameTile GetNearestTile(GameTile tile, TileTerrain terrain, TileFeatures feature, int distance)
{
List <GameTile> allowed = new List <GameTile>();
if (terrain == TileTerrain.Land)
{
allowed.AddRange(regionLand);
}
else if (terrain == TileTerrain.River)
{
allowed.AddRange(regionRiver);
}
else if (terrain == TileTerrain.DeepSea)
{
allowed.AddRange(regionDeepSea);
}
else if (terrain == TileTerrain.ShallowSea)
{
allowed.AddRange(regionSea);
}
else if (terrain == TileTerrain.Sand)
{
allowed.AddRange(regionSand);
}
else if (terrain == TileTerrain.Grass || terrain == TileTerrain.Grass2)
{
allowed.AddRange(regionGrass);
}
else if (terrain == TileTerrain.Mountain || terrain == TileTerrain.Mountain2)
{
allowed.AddRange(regionMountain);
}
else if (terrain == TileTerrain.Snow || terrain == TileTerrain.Snow2)
{
allowed.AddRange(regionSnow);
}
allowed = allowed.OrderBy(o => o.DistanceTo(tile)).ToList();
while (true)
{
for (int i = 0; i < allowed.Count; i++)
{
if (tile.DistanceTo(allowed[i]) > distance && allowed[i].tileFeatures == feature)
{
return(allowed[i]);
}
}
distance = Mathf.Clamp(distance - 2, 1, distance);
}
}
public void PlaceTerrainOn(int x, int z, TileTerrain ter)
{
if (walkCostsMap != null && ter.GetPathfindingCost() != 1f) // Might have to recalculate now that something has moved.
{
walkCostsMap[x, z] = map[x, z].GetPathfindingCost();
walkGrid.UpdateGrid(walkCostsMap);
}
ter.xPos = x;
ter.zPos = z;
map[x, z].SetTerrainOnTile(ter);
}
private List <Enc> GetEncounterByTerrainAndFeature(List <Enc> list, TileTerrain terrain, TileFeatures feature)
{
List <Enc> newList = new List <Enc>();
for (int i = 0; i < list.Count; i++)
{
if (list[i].terrainType == terrain && list[i].featureType == feature)
{
newList.Add(list[i]);
}
}
return(newList);
}
// Метод заполянющий выбранную ячейку
private void FillCurrentCell(int w, int h)
{
var temp = GetCurrentCell(w, h);
// Если клетка находится в тумане войны
if (temp == null)
{
return;
}
else
{
// Если стена, то пройти нельзя
if (temp.Wall != null)
{
cells[w, h].travel_cost = -1;
}
// Если не стена
else
{
// Записываем стоймость передвижения по клетке
cells[w, h].travel_cost = TileTerrain.Parse(temp.Terrain.ToString()[0]).TravelCost;
// Если на этой клетке находится таверна, добавляем ее в список таверн
if (temp.Dwelling != null)
{
if (w == 0 && h == 0 && sensorData.MyRespawnSide.Equals("Right") || w == weight - 1 && h == height - 1 && sensorData.MyRespawnSide.Equals("Left"))
{
}
else
{
dwellings.Add(new TopItem(w, h, temp.Dwelling));
}
}
// Если на этой клетке находится шахта, добавляем ее в список шахт
if (temp.Mine != null)
{
mines.Add(new TopItem(w, h, temp.Mine));
}
// Если здесь нейтралы
if (temp.NeutralArmy != null)
{
neutrals.Add(new TopItem(w, h, temp.NeutralArmy));
}
// Если здесь кучка ресурсов
if (temp.ResourcePile != null)
{
resources.Add(new TopItem(w, h, temp.ResourcePile));
}
}
}
}
private void TerrainList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
TileTerrain selectedTerrain = (TileTerrain)TerrainList.SelectedItem;
InteractionList.ItemsSource = selectedTerrain.Interactions;
InteractionList.SelectedIndex = (int)(BlockSelector.SelectedTileBlock.Property & TileInteraction.Mask);
BlockSelector.SelectedTileBlock.Property = selectedTerrain.Value | ((TileInteraction)InteractionList.SelectedItem).Value;
TerrainOverlay.Text = JsonConvert.SerializeObject(selectedTerrain.Overlay, Formatting.Indented);
BlockSelector.Update(tileIndex: BlockSelector.SelectedBlockValue);
UpdateTileBlock();
SetUnsaved();
}
public int GetNeighbourCountByTerrain(TileTerrain query)
{
int res = 0;
for (int i = 0; i < cornerNum; i++)
{
if (neighbors[i] != null)
{
if (neighbors[i].terrain == query)
{
res++;
}
}
}
return(res);
}
private Color GetColor(IEnumerable <TileObject> objects, TileTerrain terrain,
bool drawWalls = false,
bool drawTerrain = false,
bool drawPiles = false,
bool drawDwellings = false,
bool drawMines = false,
bool drawEnemies = false)
{
foreach (var obj in objects)
{
if (obj is Mine && drawMines)
{
return(resourceColor[(obj as Mine).Resource]);
}
if (obj is ResourcePile && drawPiles)
{
return(resourceColor[(obj as ResourcePile).Resource]);
}
if (obj is Dwelling && drawDwellings)
{
return(dwellingColor[(obj as Dwelling).Recruit.UnitType]);
}
if (obj is NeutralArmy && drawEnemies)
{
return(Color.FromArgb(255 - (int)(((NeutralArmy)obj).Army.Values.First() / 50.0 * 255), 0, 0));
}
if (obj != null && !obj.IsPassable && drawWalls)
{
return(Color.DarkSlateGray);
}
}
if (terrainColor.ContainsKey(terrain) && drawTerrain)
{
return(terrainColor[terrain]);
}
return(Color.Transparent);
}
} // add ReturnListTilesNeighbours(tileToBlight) tiles to listFrontier
private void BlightTile(GameObject tileToBlight) // blight single uncaputured tile
{
TileTerrain tile = tileToBlight.GetComponent <TileTerrain>();
tile.TileCaptured = true;
tile.BlightTimer = ReturnBlightTime();
tileToBlight.transform.GetChild(1).GetComponent <MeshRenderer>().enabled = false;
tile.enabled = false;
managerTerrain.TilesBlighted++;
if (managerGame.InGame)
{
listTilesBlightedNew.Add(tileToBlight);
}
else
{
listTilesBlighted.Add(tileToBlight);
}
}
public void Initialize(Transform parent, int x, int y, TileTerrain tT)
{
pathTile = new PathTile(this);
name = "x: " + x + ", y:" + y;
coordinates = new Vector2(x, y);
tileTerrain = tT;
SetPositionRaycast(transform.position, Vector3.down);
Encounter = null;
if (EncQuestionMark != null)
{
DestroyObject(EncQuestionMark);
EncQuestionMark = null;
}
if (parent != null)
{
transform.parent = parent;
}
label.Initialize(x, y);
}
public bool Move(Direction direction)
{
if (_isMoving)
{
return(false);
}
Point destPt = _world.GetPointAdjacentToPosition(Position.X, Position.Y, direction);
if (_world.GetTileCollision(destPt.X, destPt.Y) != TileTerrain.Blocked)
{
_previousPosition = _position;
_distSinceMove = 0.0f;
Point tilePos = _world.GetPointFromPosition(_position.X, _position.Y);
_currentTerrain = _world.GetTileCollision(tilePos.X, tilePos.Y);
_direction = direction;
_isMoving = true;
}
return(_isMoving);
}
private Color GetColor(TileObject obj, TileTerrain terrain,
bool drawObjects, bool drawWalls, bool drawTerrain)
{
if (obj as Impassable != null && drawWalls)
{
return(Color.DarkSlateGray);
}
if (obj as Mine != null && drawObjects)
{
return(resourceColor[(obj as Mine).Resource]);
}
if (terrainColor.ContainsKey(terrain) && drawTerrain)
{
return(terrainColor[terrain]);
}
return(Color.Transparent);
}
