public void Update()
{
if (loader != null)
{
//TODO: calculate loaders position to the current chunk instead of raycast
Vector2 pixelCoords = new Vector2(loader.position.x, loader.position.z);
Vector3 hexCoords = HexMath.PixelToHex(pixelCoords.x, pixelCoords.y, Game.World.HexData);
//Tile(-33,-8) -> Chunk(-3,-1)
//-33/13 = -2.5 ~= -3, -8/13 = -0.6 ~= -1
int chunkSize = Game.GameConfig.chunkSize;
float x = Mathf.Round(hexCoords.x / chunkSize);
float z = Mathf.Round(hexCoords.y / chunkSize);
float y = Mathf.Round(hexCoords.z / chunkSize);
Vector3 chunkCoords = new Vector3(x, y, z);
Debug.Log(chunkCoords);
/*if (Game.World.Chunks.ContainsKey(chunkCoords))
{
Debug.Log("Exists");
ChangeChunk(chunkCoords);
//currentChunk = Game.World.Chunks[chunkCoords];
//Game.ThreadQueuer.StartThreadedFunction(ManageChunks);
}*/
ChangeChunk(chunkCoords);
}
UpdateChunks();
}
public bool CheckNeighbors()
{
int isPopulated = 0;
int isValid = 0;
Vector3 cubePosition = HexMath.AxialToCube(HexMath.PixelToHex(transform.position));
RaycastHit hit;
int direction;
for (int i = 0; i < 6; i++)
{
if (Physics.Raycast(HexMath.HexToPixel(HexMath.CubeToAxial(cubePosition + HexMath.direction[i])) + Vector3.forward, Vector3.back, out hit))
{
Hex hex = hit.collider.GetComponent <Hex>();
if (hex != null)
{
isPopulated++;
direction = i + 3;
if (direction > 5)
{
direction -= 6;
}
if (hex.CheckValidity(direction, fieldType[i]))
{
isValid++;
}
}
}
}
return((isPopulated != 0) && (isPopulated == isValid));
}
public HashSet <IHexagon> GetTargetsInRange(IHexagon start, int range)
{
Queue <IHexagon> hexQueue = new Queue <IHexagon>();
HashSet <IHexagon> visited = new HashSet <IHexagon>();
HashSet <IHexagon> targetsInRange = new HashSet <IHexagon>();
hexQueue.Enqueue(start);
while (hexQueue.Count != 0)
{
IHexagon currentHex = hexQueue.Dequeue();
if (currentHex.MyHexMap.IsOccupied())
{
if (currentHex.Contents.MyHasTurn != null)
{
targetsInRange.Add(currentHex);
}
}
foreach (IHexagon neighbour in currentHex.MyHexMap.Neighbours)
{
if (HexMath.FindDistance(start, neighbour) <= range && !visited.Contains(neighbour))
{
hexQueue.Enqueue(neighbour);
visited.Add(neighbour);
}
}
}
//algorithm would return the attacker as a target otherwise
targetsInRange.Remove(start);
return(targetsInRange);
}
// Neighbor Test Helper
void NeighborTestHelper(int radius)
{
int neighborCount = 1;
for (int c = 0; c <= radius; c++)
{
neighborCount += c * 6;
}
Tilemap tilemap = GameObject.FindGameObjectWithTag("testTilemap").GetComponent <Tilemap>();
List <Vector3Int> neighborTiles = new List <Vector3Int>();
neighborTiles = HexMath.OddrRange(new Vector3Int(0, 0, 0), radius);
Dictionary <string, int> neighborTestDict = new Dictionary <string, int>();
Assert.AreEqual(neighborTiles.Count, neighborCount);
for (int i = 0; i < neighborTiles.Count; i++)
{
if (neighborTestDict.ContainsKey(tilemap.GetTile(neighborTiles[i]).name))
{
neighborTestDict[tilemap.GetTile(neighborTiles[i]).name]++;
}
else
{
neighborTestDict.Add(tilemap.GetTile(neighborTiles[i]).name, 1);
}
}
foreach (KeyValuePair <string, int> kvp in neighborTestDict)
{
Debug.Log(kvp.Key + ": " + kvp.Value);
}
}
public void UpdateActive(Solver solver)
{
if (Type > 5 && Type < 12 && Type != solver.MetalLevel)
{
return;
}
var count = 0;
for (var i = 0; i < 8; i++)
{
//going around
var x = HexMath.XInDirection(X, Y, i % 6);
var y = HexMath.YInDirection(Y, i % 6);
if (solver.Marbles[x * 13 + y] != null)
{
count = 0;
}
else
{
count++;
}
if (count == 3)
{
solver.ActiveMarbles.Add(this);
return;
}
}
}
public void Run()
{
//todo move into IEnumerator
CubeCoords playerCoords = HexMath.Pix2Hex(_player.Transform.localPosition.x, _player.Transform.localPosition.y, HexSize);
if (_map.LastCoords.x != playerCoords.x || _map.LastCoords.y != playerCoords.y)
{
UnrenderRing(_map.LastCoords, Fow + 1);
RenderRing(playerCoords, Fow);
_map.LastCoords = playerCoords;
}
for (int i = 0; i < _collisionEvents.EntitiesCount; i++)
{
CubeCoords coords = HexMath.Pix2Hex(_collisionEvents.Components1[i].ObstacleTransform.position, HexSize);
}
for (int i = 0; i < _triggerForegroundEvents.EntitiesCount; i++)
{
CubeCoords coords = HexMath.Pix2Hex(_triggerForegroundEvents.Components1[i].ObstacleTransform.position, HexSize);
HexForegroundComponent hexComponent = _map.MapF[coords.x, coords.y];
switch (hexComponent.ForegroundType)
{
case ForegroundTypes.Diamond:
_player.Exp += hexComponent.Value;
RemoveFore(hexComponent, coords);
break;
default:
break;
}
}
}
public void UpdateNeighbours(Solver solver)
{
for (var i = 0; i < 6; i++)
{
solver.Marbles[HexMath.XInDirection(X, Y, i % 6) * 13 + HexMath.YInDirection(Y, i % 6)]?
.UpdateActive(solver);
}
}
// PLACE WATER
public void PlaceWater(Vector3Int tileLocation)
{
// Set the target tile to be a water tile.
tilemap.SetTile(tileLocation, groundTileFromName["Water"]);
// Update groundTiles dictionary.
groundTiles[tileLocation].ThisTile = groundTileFromName["Water"];
groundTiles[tileLocation].DistanceToWater = 0;
// Get the neighbors.
List <Vector3Int> neighbors = HexMath.OddrRange(tileLocation, 5);
foreach (Vector3Int nPosition in neighbors)
{
// Look for the tile in the groundTiles dictionary.
if (groundTiles.ContainsKey(nPosition))
{
// Take a look at the neighbor. Look at its NearbyWaterTiles dictionary and DistanceToWater.
// We want to add this new water into the dictionary and, if DistanceToWater just shrank, update
// the neighbor to the appropriate tile type.
int dTW = HexMath.OddrDistance(tileLocation, nPosition);
if (dTW == 0)
{
// The tile has 0 distance to water, as in, it's looking at itself, so skip this one.
continue;
}
else if (groundTiles[nPosition].NearbyWaterTiles.ContainsKey(dTW))
{
// This value for dTW exists in the dictionary. Merely add this new water tile to the list.
groundTiles[nPosition].NearbyWaterTiles[dTW].Add(tileLocation);
}
else
{
// This value for dTW did not exist in the dictionary. Create a new key value pair.
groundTiles[nPosition].NearbyWaterTiles.Add(dTW, new List <Vector3Int> {
tileLocation
});
}
// Did the neighbor get closer to water?
if (dTW < groundTiles[nPosition].DistanceToWater)
{
// dTW changed, so we can update groundTiles dictionary.
groundTiles[nPosition].DistanceToWater = dTW;
// Which tile should it be, according to its distanceToWater?
Tile nTile = GetTileByWaterDistance(dTW, marshDistance, soilDistance);
// Start a cooroutine to change the tile.
StartCoroutine(DelayedGroundTileChange(nPosition));
}
}
}
// Last but not least, clear any plant on that tile?
plantTileManager.ClearPlants(tileLocation);
}
public void SetSize(Vector2 size)
{
this.size = size;
float xScale = size.x / HexMath.CalculateHexWidth(referenceHeight);
float yScale = size.y / referenceHeight;
float hexScale = Mathf.Min(xScale, yScale);
transform.localScale = new Vector3(hexScale, hexScale, 1);
}
/**
* znamy ilość hexów i oczekiwany rozmiar hexów w unitach, obliczamy rozmiar planszy
*/
private BoardHex BuildCalcBoardSize()
{
// this.SetHexNumber (newColNumber, newRowNumber);
// if (recommendHexHeight <= 0) {
// Debug.LogError("hexHeight musi być większe od 0");
// }
// recommendHexHeight = newHexHeight;
hexWidth = HexMath.CalculateHexWidth(recommendHexHeight);
return(this.BuildCalc());
}
void DebugHexMath()
{
Vector3Int origin = new Vector3Int(0, 0, 0);
Vector3Int target = new Vector3Int(2, 2, 0);
Vector3Int targetCube = new Vector3Int(1, -3, 2);
// Distance testing: Oddr then Cube
Assert.AreEqual(HexMath.OddrDistance(origin, origin), 0);
Assert.AreEqual(HexMath.OddrDistance(origin, origin + HexMath.CubeDirection(0)), 1);
Assert.AreEqual(HexMath.OddrDistance(origin, origin + HexMath.CubeDirection(0) * 2), 2);
Assert.AreEqual(HexMath.OddrDistance(origin, target), 3);
Assert.AreEqual(HexMath.OddrDistance(origin, target + HexMath.CubeDirection(0)), 2);
Assert.AreEqual(HexMath.OddrDistance(origin, new Vector3Int(-6, -6, 0)), 9);
Assert.AreEqual(HexMath.CubeDistance(origin, origin), 0);
Assert.AreEqual(HexMath.CubeDistance(origin, origin + HexMath.CubeDirection(0) * 2), 2);
Assert.AreEqual(HexMath.CubeDistance(origin, new Vector3Int(0, 0, 0)), 0);
Assert.AreEqual(HexMath.CubeDistance(origin, targetCube), 3);
Assert.AreEqual(HexMath.CubeDistance(origin, target + HexMath.CubeDirection(0)), 2);
Assert.AreEqual(HexMath.CubeDistance(origin, new Vector3Int(-1, 4, -3)), 4);
// Cube - Hex conversion testing.
Vector3Int Hex = new Vector3Int(1, 1, 0);
Vector3Int Cube = new Vector3Int(1, -2, 1);
Assert.AreEqual(Hex, HexMath.CubeToOddr(Cube));
Assert.AreEqual(Cube, HexMath.OddrToCube(Hex));
Hex = new Vector3Int(-2, -2, 0);
Cube = new Vector3Int(-1, 3, -2);
Assert.AreEqual(Hex, HexMath.CubeToOddr(Cube));
Assert.AreEqual(Cube, HexMath.OddrToCube(Hex));
Hex = new Vector3Int(1, -2, 0);
Cube = new Vector3Int(2, 0, -2);
Assert.AreEqual(Hex, HexMath.CubeToOddr(Cube));
Assert.AreEqual(Cube, HexMath.OddrToCube(Hex));
Hex = new Vector3Int(-2, 2, 0);
Cube = new Vector3Int(-3, 1, 2);
Assert.AreEqual(Hex, HexMath.CubeToOddr(Cube));
Assert.AreEqual(Cube, HexMath.OddrToCube(Hex));
/* Neighbor Testing: Testing around Origin: (0, 0, 0).
* - Radius 0. It's a marsh, so a neighbor test of radius 0 should simply return one marsh.
* - Radius 1. Should add 6 soil tiles and count equal 7
* - Radius 2. Should add 12 barren tiles and count equal 19.
* No tiles should be water for this setup.
*/
NeighborTestHelper(0);
NeighborTestHelper(1);
NeighborTestHelper(2);
NeighborTestHelper(3);
}
// REMOVE WATER
public void RemoveWater(Vector3Int tileLocation)
{
// Set the target tile to be a marsh tile. (OR WHATEVER REMOVED WATER TURNS INTO)
tilemap.SetTile(tileLocation, groundTileFromName["Marsh"]);
// Update groundTiles dictionary.
groundTiles[tileLocation].ThisTile = groundTileFromName["Marsh"];
// Get the neighbors.
List <Vector3Int> neighbors = HexMath.OddrRange(tileLocation, 5);
foreach (Vector3Int nPosition in neighbors)
{
// Look for the tile in the groundTiles dictionary.
if (groundTiles.ContainsKey(nPosition))
{
// Take a look at the neighbor. Look at its NearbyWaterTiles dictionary and DistanceToWater.
// We want to remove this water from the dictionary and, if DistanceToWater just rose, update
// the neighbor to the appropriate tile type.
int dTW = HexMath.OddrDistance(tileLocation, nPosition);
if (groundTiles[nPosition].NearbyWaterTiles.ContainsKey(dTW))
{
// This value for dTW exists in the dictionary.
if (groundTiles[nPosition].NearbyWaterTiles[dTW].Count >= 2)
{
// Now if it's the not final item in for this key, just remove it from the list.
groundTiles[nPosition].NearbyWaterTiles[dTW].Remove(tileLocation);
}
else
{
// Otherwise, the list of water tiles at this exact dTW was only this tile.
// Therefore, remove the key value pair from the NearbyWaterTiles dictionary.
groundTiles[nPosition].NearbyWaterTiles.Remove(dTW);
}
}
else
{
// SOMETHING HAS GONE TERRIBLY WRONG: This was a water tile and was within the radius of
// influence of this neighbor, yet doesn't show up in the neighbors NearbyWaterTiles?????
Debug.Log("Something has gone wrong, removed water tile, at " + tileLocation + " not found" +
" in neighbor's near by water tiles, at " + nPosition);
}
// Did the neighbor get further from water?
dTW = GetDistanceToWater(nPosition, groundTiles[nPosition].NearbyWaterTiles);
if (dTW != groundTiles[nPosition].DistanceToWater)
{
// dTW changed, so we can update groundTiles dictionary.
groundTiles[nPosition].DistanceToWater = dTW;
// Start a cooroutine to change the tile.
StartCoroutine(DelayedGroundTileChange(nPosition));
}
}
}
}
private void RenderHexForeground(CubeCoords coords)
{
if (!_map.MapF.ExistAt(coords) || _map.MapF[coords.x, coords.y].IsNew)
{
return;
}
HexForegroundComponent foregroundHexComponent = _map.MapF[coords.x, coords.y];
if (foregroundHexComponent.ForegroundType == ForegroundTypes.Empty)
{
return;
}
if (foregroundHexComponent.Parent != null)
{
return; //_poolForeground.Recycle(foregroundHexComponent.Parent);
}
foregroundHexComponent.Parent = _map.PoolF.Get();
foregroundHexComponent.Parent.PoolTransform.localPosition = HexMath.Hex2Pix(coords, HexSize);
switch (foregroundHexComponent.ForegroundType)
{
case ForegroundTypes.Empty:
foregroundHexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = null;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().enabled = false;
return;
case ForegroundTypes.Enemy:
foregroundHexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Enemy;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().enabled = true;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().isTrigger = false;
break;
case ForegroundTypes.Obstacle:
foregroundHexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Obstacle;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().enabled = true;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().isTrigger = false;
break;
case ForegroundTypes.Diamond:
foregroundHexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Diamond;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().enabled = true;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().isTrigger = true;
break;
case ForegroundTypes.Spawn:
//spawn point, dunno why
foregroundHexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = null;
foregroundHexComponent.Parent.PoolTransform.GetComponent <Collider2D>().enabled = false;
break;
default:
throw new Exception("Null object type");
}
foregroundHexComponent.Parent.PoolTransform.gameObject.SetActive(true);
}
private int colNumber, rowNumber; //colNumber-x rowNumber-y
/**
* metoda pozwala przeliczyć rozmiar całej planszy
*/
public void Recalculate()
{
// int colNumber = Mathf.Abs (colMinCoordinate) + Mathf.Abs (colMaxCoordinate) + 1;//+1 ponieważ jakby narysować to na wykresie to w zakres wchodzi też ostatnia wartość jako pełna
// int rowNumber = Mathf.Abs (rowMinCoordinate) + Mathf.Abs (rowMaxCoordinate) + 1;//+1 ponieważ jakby narysować to na wykresie to w zakres wchodzi też ostatnia wartość jako pełna
if (rowNumber > 1 && symmetricHorizontal == false) //jak symmetricHorizontal true to nie ma przesunięcia wynikającego z połowy hexa na szerokość
{
this.size = new Vector2(HexMath.CalculateMultiRowWidth(this.hexSize.x, colNumber), HexMath.CalculateColumnHeight(this.hexSize.y, rowNumber));
}
else
{
this.size = new Vector2(HexMath.CalculateRowWidth(this.hexSize.x, colNumber), HexMath.CalculateColumnHeight(this.hexSize.y, rowNumber));
}
}
/**
* zwraca listę sąsiednich hexów, gdy range 1 to zwraca tylko pierwsze sąsiedztwo, gdy range 2, to kolejny pierścien dodatkowo
*/
public List <HexField> GetNeighbors(Vector3 centerCoordinates, int range = 1)
{
List <HexField> list = new List <HexField>();
List <Vector3> coordinatesList = HexMath.GetRange(centerCoordinates, range, 0); //by pominąć kliknięty hex i zwrócić sąsiedztwo
foreach (Vector3 neigborCoordinates in coordinatesList)
{
HexField hex = this.GetHex(neigborCoordinates);
if (hex != null)
{
list.Add(hex);
}
}
return(list);
}
private void UnrenderRing(CubeCoords playerCoords, int radius)
{
CubeCoords coords = new CubeCoords(playerCoords.x, playerCoords.y + radius);
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < radius; j++)
{
coords.x += HexMath.Directions[i, 0];
coords.y += HexMath.Directions[i, 1];
if (HexMath.HexDistance(playerCoords.x, playerCoords.y, coords.x, coords.y) >= Fow)
{
HideHex(coords);
}
}
}
}
// Update is called once per frame
void Update()
{
if (pointer != null)
{
Vector3 position = Camera.main.ScreenToWorldPoint(Input.mousePosition);
position = HexMath.HexToPixel(HexMath.PixelToHex(position));
pointer.transform.position = position;
if (Input.GetMouseButtonDown(0) && pointer.CheckNeighbors())
{
pointer.EndDrag();
pointer = null;
pointer = InstantiateHex();
pointer.BeginDrag();
}
}
}
public void find_straight_distance()
{
GameObject gameObject = new GameObject();
MapGeneration mapGeneration = gameObject.AddComponent <MapGeneration>();
mapGeneration.HexagonPrefab = new GameObject();
mapGeneration.MapRadius = 10;
mapGeneration.HexDict = new Dictionary <Vector3Int, IHexagon>();
mapGeneration.GenerateMap();
mapGeneration.UpdateHexNeighbours();
IHexagon start_hex = mapGeneration.HexDict[new Vector3Int(0, 0, 0)];
IHexagon end_hex = mapGeneration.HexDict[new Vector3Int(0, -4, 4)];
int distance = 4;
Assert.AreEqual(distance, HexMath.FindDistance(start_hex, end_hex));
}
public void RenderHexBackground(CubeCoords coords)
{
if (!_map.MapB.ExistAt(coords) || _map.MapB[coords.x, coords.y].IsNew)
{
MapGenRandomNeighbours.GenerateHex(coords, _map.MapB, _map.MapF);
}
HexBackgroundComponent hexComponent = _map.MapB[coords.x, coords.y];
if (hexComponent.Parent != null)
{
return; //_poolBackground.Recycle(hexComponent.Parent);
}
hexComponent.Parent = _map.PoolB.Get();
hexComponent.Parent.PoolTransform.localPosition = HexMath.Hex2Pix(coords, HexSize);
switch (hexComponent.BackgroundType)
{
case BackroundTypes.Grass:
hexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Grass;
hexComponent.SpeedDown = 1;
break;
case BackroundTypes.Water:
hexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Water;
hexComponent.SpeedDown = 0.1f;
break;
case BackroundTypes.Swamp:
hexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Swamp;
hexComponent.SpeedDown = 0.02f;
break;
case BackroundTypes.Forest:
hexComponent.Parent.PoolTransform.GetComponent <SpriteRenderer>().sprite = Forest;
hexComponent.SpeedDown = 0.5f;
break;
default:
throw new Exception("Null ground type");
}
hexComponent.Parent.PoolTransform.gameObject.SetActive(true);
}
public Dictionary <int, List <Vector3Int> > GetNearbyWaterTiles(Vector3Int tilePos, Tilemap tilemap, int soilDistance)
{
Dictionary <int, List <Vector3Int> > result = new Dictionary <int, List <Vector3Int> >();
// Use HexMath to get list of nearbyTiles.
List <Vector3Int> neighborPositions = HexMath.OddrRange(tilePos, soilDistance);
// For each neighborPosition, check the tile there, looking out for water tiles.
foreach (Vector3Int nPos in neighborPositions)
{
// Is there even a tile here?
if (!tilemap.HasTile(nPos))
{
continue;
}
// Is this tile water?
if (tilemap.GetTile <Tile>(nPos).name.Equals("Water", System.StringComparison.Ordinal))
{
// Get the distance from this tile to the water tile.
int distanceToWater = HexMath.OddrDistance(tilePos, nPos);
// If the result dictionary has an entry for this distance, add nPos to its value's list.
if (result.ContainsKey(distanceToWater))
{
result[distanceToWater].Add(nPos);
}
// Otherwise, the result dictionary has no entry for this distance yet, so make one.
else
{
result.Add(distanceToWater, new List <Vector3Int> {
nPos
});
}
}
}
return(result);
}
/**
* znamy ilość hexów i rozmiar planszy w unitach. Odpowiada to trybowi FIXED_BOARD_CAL_HEXSIZE
*/
private BoardHex BuildCalcHexSize()
{
// this.SetHexNumber (newColNumber, newRowNumber);
// if (newRecommendWidth <= 0 || newRecommendHeight <= 0) {
// Debug.LogError("boardUnitWidth i boardUnitHeight muszą być większe od 0");
// }
// recommendSize.x = newRecommendWidth;
// recommendSize.y = newRecommendHeight;
float bestHexWidth = HexMath.CalculateHexWidthInRow(recommendSize.x, colNumber);
float bestHexHeight = HexMath.CalculateHexHeightInColumn(recommendSize.y, rowNumber);
hexWidth = HexMath.CalculateHexWidth(bestHexHeight);
if (hexWidth > bestHexWidth) //szerokość obliczona z bestHexHeight jest za duża, przyjmujemy więc bestHexWidth jako referencję i obliczamy
{
hexWidth = bestHexWidth;
recommendHexHeight = HexMath.CalculateHexHeight(hexWidth);
}
else //prawidłowo obliczona została szerokość
{
recommendHexHeight = bestHexHeight;
}
return(this.BuildCalc());
}
void Start()
{
neighbors = new int[6, 2] {
{ 0, 1 },
{ 1, 0 },
{ 1, -1 },
{ 0, -1 },
{ -1, 0 },
{ -1, 1 }
};
gameController = GameObject.FindGameObjectWithTag("GameController");
hexMath = gameController.GetComponent <HexMath>(); // Takes the HexMath script from the Game Control
boardSize = new int[gameController.GetComponent <BoardController>().boardsize[0], gameController.GetComponent <BoardController>().boardsize[1]];
turn = 0;
setUnitParameters();
hasDied = false;
speed = 0.12f;
world_position = transform.position;
actionController = GetComponent <ActionController>();
}
// Get Tendrils: There are 18 unique tendrils that form using a given tile as a base, not including the
// tendrils that are also considered clusters.
private static List <List <Vector3Int> > GetTendrils(Vector3Int baseTilePosition)
{
List <List <Vector3Int> > tileTendrils = new List <List <Vector3Int> >();
// The for loop represents the 6 possible tiles that surround the base tile.
for (int i = 0; i < 6; i++)
{
// Add the center tile since it will be part of every tendril.
List <Vector3Int> tendril = new List <Vector3Int>();
tendril.Add(baseTilePosition);
// Add this loop's tile to this tednril, based on its position relative to the base.
// That is, baseTilePosition + cubeDirections. Of course we have to convert to and from cube coords.
Vector3Int targetCubePosition = HexMath.cubeDirections[i] + HexMath.OddrToCube(baseTilePosition);
Vector3Int targetOddrPosition = HexMath.CubeToOddr(targetCubePosition);
tendril.Add(targetOddrPosition);
// The third tile slightly is more complicated. It can be in any three directions based on the initial
// direction, deviating by -1, 0, and +1, and making sure to wrap from -1 to 5.
for (int d = -1; d <= 1; d++)
{
List <Vector3Int> triple = new List <Vector3Int>();
int newDirection = ((i + d) % 6 + 6) % 6;
targetCubePosition = HexMath.cubeDirections[newDirection] + HexMath.OddrToCube(baseTilePosition);
targetOddrPosition = HexMath.CubeToOddr(targetCubePosition);
triple.Add(targetOddrPosition);
triple.AddRange(tendril);
// Now add this tendril of three tiles to the tileTendrils list.
tileTendrils.Add(triple);
}
}
return(tileTendrils);
}
// Get Clusters: There are 15 unique clusters that form around a central tile.
// This method makes a list of them and returns them.
private static List <List <Vector3Int> > GetClusters(Vector3Int centerTilePosition)
{
List <List <Vector3Int> > tileClusters = new List <List <Vector3Int> >();
// The outer loop represents the 6 possible tiles that surround the central tile.
for (int i = 0; i < 6; i++)
{
// Add the center tile since it will be part of every cluster.
List <Vector3Int> cluster = new List <Vector3Int>();
cluster.Add(centerTilePosition);
// Add the first outer loop tile of this cluster, based on its position relative to center.
// That is, centerTilePosition + cubeDirections. Of course we have to convert to and from cube coords.
Vector3Int targetCubePosition = HexMath.cubeDirections[i] + HexMath.OddrToCube(centerTilePosition);
Vector3Int targetOddrPosition = HexMath.CubeToOddr(targetCubePosition);
cluster.Add(targetOddrPosition);
// The inner loop goes through each unique third tile addition to the group.
for (int j = i + 1; j < 6; j++)
{
List <Vector3Int> triple = new List <Vector3Int>();
// Add the inner loop tile of this cluster, based on its position relative to center.
// That is, centerTilePosition + cubeDirections. Of course we have to convert to and from cube coords.
targetCubePosition = HexMath.cubeDirections[j] + HexMath.OddrToCube(centerTilePosition);
targetOddrPosition = HexMath.CubeToOddr(targetCubePosition);
triple.Add(targetOddrPosition);
triple.AddRange(cluster);
// Now add this cluster of three tiles to the tileClusters list.
tileClusters.Add(triple);
}
}
return(tileClusters);
}
public void Instantiate(HexMath.Cube position)
{
}
/**
* do rzeczywistej budowy potrzebujemy rozmiar hexa i ilość hexów, nie potrzebujemy rozmiaru mapy
*/
private BoardHex BuildCalc()
{
if (board.IsReady() == true) //znaczy że ta plansza jest już zbudowana
{
return(board);
}
hexPattern.gameObject.SetActive(false);
float calcHeigh = HexMath.CalculateColumnHeight(recommendHexHeight, rowNumber);
float halfHeight = calcHeigh / 2; //rowNumber / 2;
float halfWidth = 0;
if (rowNumber > 1 && symmetricHorizontal == false) // jak symmetricHorizontal true to nie ma przesunięcia wynikającego z połowy hexa na szerokość
{
halfWidth = HexMath.CalculateMultiRowWidth(hexWidth, colNumber) / 2;
}
else
{
halfWidth = HexMath.CalculateRowWidth(hexWidth, colNumber) / 2;
}
Transform hexObject;
board.Config(colNumber, rowNumber, new Vector2(hexWidth, recommendHexHeight), isEven, symmetricHorizontal);
this.listenerList.OnBuildStart(hexPattern, colNumber, rowNumber, new Vector2(hexWidth, recommendHexHeight), isEven, symmetricHorizontal);
int inverse = 0; //ponieważ inverse nie jest hexem o y = 0 tylko jest zależny od rowNumber musimy mieć inną wartość inverse
if (isEven == true && rowNumber % 2 == 1)
{
inverse = 0;
}
else if (isEven == true && rowNumber % 2 == 0)
{
inverse = 1;
}
else if (isEven == false && rowNumber % 2 == 1)
{
inverse = 1;
}
else if (isEven == false && rowNumber % 2 == 0)
{
inverse = 0;
}
for (int y = rowNumber - 1; y >= 0; y--)
{
for (int x = 0; x < colNumber; x++)
{
if (symmetricHorizontal && x == colNumber - 1 && inverse == 0)
{
break;
}
Vector3 newCoordinates;
if (isEven)
{
newCoordinates = HexMath.ConvertEvenROffsetToCubeCoordinate(x, y);
}
else
{
newCoordinates = HexMath.ConvertOddROffsetToCubeCoordinate(x, y);
}
bool listenerResult = this.listenerList.OnCreateHexStart(newCoordinates, new Vector2(x, y), (inverse == 1)?true:false);
if (listenerResult == false)
{
continue;
}
hexObject = (Transform)Instantiate(hexPattern.transform, new Vector3(0, 0, 0), Quaternion.identity);
hexObject.gameObject.SetActive(true);
hexObject.transform.parent = board.transform;
HexField hexComponent = hexObject.GetComponent <HexField> ();
hexComponent.Init();
hexComponent.SetPosition(new Vector3(hexWidth * x + hexWidth - inverse * 0.5f * hexWidth - halfWidth, -3 * (y) * recommendHexHeight / 4 + halfHeight - recommendHexHeight / 2, 0));
hexComponent.SetSize(new Vector2(hexWidth, recommendHexHeight));
board.Add(newCoordinates, hexComponent);
hexObject.name = "Hex " + hexComponent.GetCoordinates().ToString() + " " + x + " " + y;
this.listenerList.OnCreateHexEnd(hexComponent);
}
inverse = (inverse == 1)?0:1; //na wysokość co drugi wiersz ma przesunięcie - w ten sposób to oznaczamy
}
// board.SetHexNumber (colNumber, rowNumber);
board.Recalculate();
board.SetReady();
this.listenerList.OnBuildEnd();
return(board);
}
void Start()
{
// sequence to parse textfile
string txtFileAsOneLine = mapTextFile.text;
string[] oneLine;
List <string> txtFileAsLines = new List <string>();
txtFileAsLines.AddRange(txtFileAsOneLine.Split("\n"[0]));
oneLine = txtFileAsLines[0].Split(" "[0]);
boardsize[0] = int.Parse(oneLine[0]);
boardsize[1] = int.Parse(oneLine[1]);
tileProperties = new int[boardsize[0], boardsize[1]];
for (int j = 0; j < boardsize[1]; j++)
{
oneLine = txtFileAsLines[1 + j].Split(" "[0]);
for (int i = 0; i < boardsize[0]; i++)
{
tileProperties[i, j] = int.Parse(oneLine[i]);
}
}
// sequence to parse textfile. This time for heights
txtFileAsOneLine = heightTextFile.text;
txtFileAsLines = new List <string>();
txtFileAsLines.AddRange(txtFileAsOneLine.Split("\n"[0]));
heightProperties = new float[boardsize[0], boardsize[1]];
for (int j = 0; j < boardsize[1]; j++)
{
oneLine = txtFileAsLines[j].Split(" "[0]);
for (int i = 0; i < boardsize[0]; i++)
{
heightProperties[i, j] = float.Parse(oneLine[i]) * 0.1f;
}
}
tileMatrix = new GameObject[boardsize[0], boardsize[1]];
unitMatrix = new GameObject[boardsize[0], boardsize[1]];
nextStepMatrix = new GameObject[boardsize[0], boardsize[1]];
hexMath = gameObject.GetComponent <HexMath>(); // Takes the HexMath script from the Game Control
// find the camera for the move to camera function
Camera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <CameraController>();
for (int i = 0; i < boardsize[0]; i++) // Generate the X hexagons
{
float x = hexMath.matrix2HexX(i);
for (int j = 0; j < boardsize[1]; j++) // Generate the Y hexagons
{
float y = hexMath.matrix2HexY(i, j);
GameObject hexagon = Instantiate(HexagonTile);
hexagon.transform.SetParent(transform); // Puts the tile under TileManager and gives the same transform
hexagon.transform.localPosition = new Vector3(x, heightProperties[i, j], y);
hexagon.transform.GetChild(0).transform.position += new Vector3(0, 0.5f - heightProperties[i, j], 0); // first child is undiscovered
hexagon.GetComponent <HexagonScript>().set(i, j);
if (tileProperties[i, j] == 0)
{
//empty
hexagon.GetComponent <MeshRenderer>().enabled = false;
hexagon.GetComponent <MeshCollider>().enabled = false;
hexagon.transform.GetChild(0).GetComponent <MeshRenderer>().enabled = false;
hexagon.transform.GetChild(1).GetComponent <MeshRenderer>().enabled = false;
}
if (tileProperties[i, j] == 2)
{
//mountain
GameObject mountain = Instantiate(mountainPrefab);
mountain.transform.SetParent(transform); // Puts the tile under TileManager and gives the same transform
mountain.transform.localPosition = new Vector3(x, 0, y);
hexagon.GetComponent <MeshCollider>().enabled = false;
hexagon.GetComponent <MeshRenderer>().enabled = false;
}
if (tileProperties[i, j] == 3)
{
//forrest
GameObject forrest = Instantiate(forrestPrefab);
forrest.transform.SetParent(transform); // Puts the tile under TileManager and gives the same transform
forrest.transform.localPosition = new Vector3(x, 0, y);
}
// Create pathing ring on it instantly
GameObject pathing = Instantiate(pathingRing);
pathing.transform.SetParent(hexagon.transform);
pathing.transform.localPosition = new Vector3(0, 0, 0.05f);
pathing.GetComponent <MeshRenderer>().enabled = false;
tileMatrix[i, j] = hexagon;
}
}
int[] unitLoc = new int[2] {
0, 0
};
// Spawn the first units
Vector3[] angles =
{
new Vector3 {
x = 0, y = 0, z = 0
},
new Vector3 {
x = 0, y = 60, z = 0
},
new Vector3 {
x = 0, y = 120, z = 0
},
new Vector3 {
x = 0, y = 180, z = 0
},
new Vector3 {
x = 0, y = 240, z = 0
},
new Vector3 {
x = 0, y = 300, z = 0
}
};
//player 1's units
unitLoc = new int[2] {
6, 18
};
GameObject Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(0);
Unit.GetComponent <UnitController>().setTeamID(0);
Unit.transform.eulerAngles = angles[0];
unitLoc = new int[2] {
2, 14
};
Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(0);
Unit.GetComponent <UnitController>().setTeamID(0);
Unit.transform.eulerAngles = angles[5];
unitLoc = new int[2] {
6, 6
};
Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(0);
Unit.GetComponent <UnitController>().setTeamID(0);
Unit.transform.eulerAngles = angles[4];
//player 2's units
unitLoc = new int[2] {
14, 14
};
Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(1);
Unit.GetComponent <UnitController>().setTeamID(1);
Unit.transform.eulerAngles = angles[1];
unitLoc = new int[2] {
18, 6
};
Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(1);
Unit.GetComponent <UnitController>().setTeamID(1);
Unit.transform.eulerAngles = angles[2];
unitLoc = new int[2] {
14, 2
};
Unit = Instantiate(Hoplite);
Unit.GetComponent <UnitController>().set(unitLoc[0], unitLoc[1]);
Unit.GetComponent <UnitController>().setTileGoal(unitLoc[0], unitLoc[1], 0);
unitMatrix[unitLoc[0], unitLoc[1]] = Unit;
Unit.transform.position = tileMatrix[unitLoc[0], unitLoc[1]].transform.position;
unitList.Add(Unit);
Unit.GetComponent <UnitController>().setPlayerID(1);
Unit.GetComponent <UnitController>().setTeamID(1);
Unit.transform.eulerAngles = angles[3];
// Start the timer
StartCoroutine(TurnTimer()); // Start the turntimer!!!
}
