int controlPoints; //How many control points to use in generation
#endregion Fields
#region Methods
/// <summary>
/// Find all tiles within a range
/// </summary>
/// <param name="start">Tile to start search on</param>
/// <param name="range">Movement range</param>
/// <returns>List of tiles within range</returns>
public static List<HexTile> HexesWithinRange(HexTile start, int range)
{
List<HexTile> visited = new List<HexTile>();
visited.Add(start);
List<List<HexTile>> fringes = new List<List<HexTile>>();
fringes.Add(new List<HexTile>());
fringes[0].Add(start);
for (int i = 1; i <= range; i++)
{
fringes.Add(new List<HexTile>());
foreach (HexTile ht in fringes[i - 1])
{
for (int j = 0; j < 6; j++)
{
HexTile neighbor_tile = ht.GetNeighbor(ht.Directions[j]);
if (neighbor_tile != null)
if (!visited.Contains(neighbor_tile))
{
visited.Add(neighbor_tile);
fringes[i].Add(neighbor_tile);
}
}
}
}
return visited;
}
protected override void generateMap()
{
// Get the size and extent
Vector2 hexExtent = getHexExtent();
Vector2 hexSize = getHexSize();
_map = new HexTile[(int)MapSize.x, (int)MapSize.y];
// For each row, or each y coordinate
for(int i = 0; i<MapSize.y; i++){
float zpos = StartPosition.y + i*hexExtent.y*1.5F;
float xOffset = hexExtent.x *i;
// For each column or x coordinate
for(int j = 0; j<MapSize.x; j++){
float xPos = j*hexSize.x+xOffset-(i/2)*hexSize.x;
Vector3 pos = new Vector3(xPos, 0, zpos);
GameObject obj = (GameObject)Instantiate(HexPrefab);
HexTile tile = obj.GetComponent<HexTile>();
_map[j,i] = tile;
tile.gameObject.transform.position = pos;
tile.SetLocation(toMapPosition(j, i));
tile.Map = this;
}
}
}
private void initiateMoveToTile( HexTile src, HexTile dst, GameObject unit)
{
// GameObject gm = GameObject.Find("GameMaster");
// Pathfinder pf = gm.GetComponent<Pathfinder>();
GetComponent<Player_CommandList>().CmdMoveUnitToTile( unit, src.gameObject, dst.gameObject);
}
/// <summary>
/// Find water tiles within a range
/// </summary>
/// <param name="start">Tile to start search on</param>
/// <param name="movement">Movement range</param>
/// <returns>List of water tiles within range</returns>
public static List<HexTile> MovementHex(HexTile start, int movement)
{
List<HexTile> visited = new List<HexTile>();
visited.Add(start);
List<List<HexTile>> fringes = new List<List<HexTile>>();
fringes.Add(new List<HexTile>());
fringes[0].Add(start);
for(int i = 1; i <= movement; i++)
{
fringes.Add(new List<HexTile>());
foreach(HexTile ht in fringes[i - 1])
{
for (int j = 0; j < 6; j++)
{
HexTile neighbor_tile = ht.GetNeighbor(ht.Directions[j]);
if (neighbor_tile != null)
if (!visited.Contains(neighbor_tile) && neighbor_tile.IsWater)
{
visited.Add(neighbor_tile);
fringes[i].Add(neighbor_tile);
}
}
}
}
return visited;
}
public void SelectTile( Vector3 _position )
{
if ( b )
{
this.selectedTile = GameManager.instance.terrainManager.GetTileClosestTo( _position );
}
else
{
tile2 = GameManager.instance.terrainManager.GetTileClosestTo( _position );
}
b = !b;
GameManager.instance.terrainManager.RemoveHighlights();
if ( this.selectedTile != null )
{
this.selectedTile.SetHighlight( true );
}
if ( this.selectedTile != null && this.tile2 != null )
{
this.path = GameManager.instance.terrainManager.FindPath( this.selectedTile, this.tile2 );
}
foreach ( HexTile tile in this.path )
{
tile.SetHighlight( true );
}
}
public SearchNode(HexTile tile, int cost, int distToGoal, SearchNode parent)
{
Tile = tile;
Cost = cost;
Tile = tile;
Parent = parent;
}
/// <summary>
/// Move to the specified tile.
/// </summary>
/// <param name='tile'>
/// Tile.
/// </param>
public virtual void move(HexTile tile)
{
if(tile != null){
Map map = Tile.Map;
_path = map.AStarSearch(Tile, tile);
performMove();
}
}
public void VerifyResourcesTest()
{
HexTile tile = new HexTile();
ResourceDictionary resources = HexTile.Constants.Instance;
Assert.AreEqual(HexTile.Constants.HEX_EDGE_LENGTH, resources["HEX_EDGE_LENGTH"]);
Assert.AreEqual(HexTile.Constants.HEX_SIDES, resources["HEX_SIDES"]);
Assert.AreEqual(HexTile.Constants.HEX_TILE_RADIUS_X, resources["HEX_TILE_RADIUS_X"]);
Assert.AreEqual(HexTile.Constants.HEX_POINTS, resources["HEX_POINTS"]);
}
public void buildPath(HexTile pFrom, HexTile destination, Color c)
{
foreach (HexTile til in currentPath)
{
til.changeBackColor();
}
currentPath.Clear();
start = pFrom;
computePath(start, destination, c);
}
private bool canPathToTile( HexTile src, HexTile dst, GameObject unit)
{
GameObject gm = GameObject.Find("GameMaster");
Pathfinder pf = gm.GetComponent<Pathfinder>();
ArrayList reachables = pf.reachables( unit.GetComponent<Moveable>(), src);
if ( reachables.Contains( dst))
return true;
return false;
}
// Instantiates and returns an overlay for the given HexTile
GameObject InstantiateOverlay(HexTile tile)
{
// Instantiate gameObject
GameObject instance = Instantiate(HexOverlayObject, tile.Position, Quaternion.identity) as GameObject;
// Set some attributes
instance.name = "hexOverlay";
var overlayScript = instance.GetComponent<HexOverlay>();
overlayScript.X = tile.X;
overlayScript.Y = tile.Y;
return instance;
}
void Start()
{
map = new HexTile[width, height];
for ( int i=0; i < width; ++i ) {
for ( int j=0; j < height; ++j ) {
var q = j - Mathf.FloorToInt( i * 0.5f );
var r = i;
var trans = Spawn( new CubeCoordinate( q, r ) );
map[ i, j ] = new HexTile( q, r, trans );
}
}
}
internal HexTile Clone()
{
var clone = new HexTile();
for (int i = 0; i < 6; i++)
{
clone.TriTiles[i] = TriTiles[i].CreateClone();
clone.TriTiles[i].HexTile = clone;
clone.IsActive = IsActive;
}
return clone;
}
public IEnumerator MoveToTile(HexTile t, float time)
{
Vector3 startingPos = instanceTrans.position, endingPos = t.hexagon.center+t.hexagon.normal;
Quaternion startingRot = instanceTrans.rotation,
endingRot = Quaternion.LookRotation(endingPos-startingPos, t.hexagon.normal);
for (float i=0; i<time; i+=Time.deltaTime)
{
instanceTrans.position = Vector3.Lerp(startingPos, endingPos, i/time);
instanceTrans.rotation = Quaternion.Slerp(startingRot, endingRot, i/time);
yield return null;
}
}
public HexMap(int w, int h)
{
this.w = w;
this.h = h;
map = new HexTile[w * h];
for (int i = 0; i < w * h; i++) {
map [i] = new HexTile ();
}
void_tile = new HexTile ();
void_tile.go_visible = false;
void_tile.outside = true;
void_tile.darkness = 1;
void_tile.tile = new TileType ();
void_tile.tile.voided = true;
}
//Writes the coordinates on the HexField (Used for testing)
public void setTextCoordinates(HexTile hex, string strCoordinates)
{
GameObject positionText;
TextMesh text;
positionText = hex.transform.Find("Position").gameObject;
if(positionText != null)
{
text = positionText.GetComponent<TextMesh>();
text.text = strCoordinates;
}
else
{
Debug.LogError("Could not find TextMesh object.");
}
}
// Update is called once per frame
void Update()
{
// if ( !isServer)
// {
if ( pathToTake != null && pathToTake.Count != 0 && pathingTo == null)
{
Debug.Log("Hi");
GetComponent<Animator>().Play ("pawn_walk");
pathingTo = ((GameObject)pathToTake[ 0]).GetComponent<HexTile>();
pathingTo.occupants.Remove( gameObject);
float checkMe = occupying.centre.x - pathingTo.centre.x;
if ( checkMe < 0)
{
transform.localScale = new Vector3( -50, 50, 1);
}
else if ( checkMe > 0)
{
transform.localScale = new Vector3( 50, 50, 1);
}
pathToTake.RemoveAt( 0);
}
if ( pathingTo != null)
{
float step = speed * Time.deltaTime;
transform.position = Vector3.MoveTowards( transform.position, pathingTo.centre, step);
if ( transform.position == pathingTo.centre)
{
pathingTo.occupants.Add ( gameObject);
occupying = pathingTo;
pathingTo = null;
GetComponent<Animator>().Play ("pawn_idle");
}
}
// } else {
// LerpPosition();
// }
}
public void Move(int dir) {
bool validMove = ValidMove (dir);
if (validMove && movement != 0) {
tile.character = null;
switch (dir) {
case 1:
tile.NW_Tile.character = this.gameObject;
tile = tile.NW_Tile;
break;
case 2:
tile.NE_Tile.character = this.gameObject;
tile = tile.NE_Tile;
break;
case 3:
tile.E_Tile.character = this.gameObject;
tile = tile.E_Tile;
break;
case 4:
tile.SE_Tile.character = this.gameObject;
tile = tile.SE_Tile;
break;
case 5:
tile.SW_Tile.character = this.gameObject;
tile = tile.SW_Tile;
break;
case 6:
tile.W_Tile.character = this.gameObject;
tile = tile.W_Tile;
break;
default:
break;
}
moving = true;
movement = movement - tile.mov_cost;
}
if (movement == 0) {
Active = false;
}
}
protected void sizeChange(int x, int y)
{
HexTile[,] map = new HexTile[x, y];
// Get the size and extent
Vector2 hexExtent = getHexExtent();
Vector2 hexSize = getHexSize();
// For each row, or each y coordinate
for(int i = 0; i<map.GetLength(1); i++){
float zpos = StartPosition.y + i*hexExtent.y*1.5F;
float xOffset = hexExtent.x *i;
// For each column or x coordinate
for(int j = 0; j<map.GetLength(0); j++){
float xPos = j*hexSize.x+xOffset-(i/2)*hexSize.x;
Vector3 pos = new Vector3(xPos, 0, zpos);
if(j<_map.GetLength(0) && i<_map.GetLength(1)){
map[j, i] = _map[j, i];
}
else{
GameObject obj = (GameObject)Instantiate(HexPrefab);
HexTile tile = obj.GetComponent<HexTile>();
map[j,i] = tile;
tile.gameObject.transform.position = pos;
tile.SetLocation(toMapPosition(j, i));
tile.Map = this;
}
}
}
if(MapSize.x -x >0 || MapSize.y- y >0){
for(int i = 0; i < _map.GetLength(1); i++){
for(int j = 0; j< _map.GetLength(0); j ++){
if(i>=y || j>= x){
Destroy(_map[j,i].gameObject);
}
}
}
}
_map = map;
MapSize = new Vector2(_map.GetLength(0), _map.GetLength(1));
}
public AxialCoord AddDirection( HexTile.TILE_DIRECTION _dir )
{
switch ( _dir )
{
case HexTile.TILE_DIRECTION.EAST:
return new AxialCoord( this.q + 1, this.r );
case HexTile.TILE_DIRECTION.WEST:
return new AxialCoord( this.q - 1, this.r );
case HexTile.TILE_DIRECTION.NORTH_EAST:
return new AxialCoord( this.q + 1, this.r + 1 );
case HexTile.TILE_DIRECTION.NORTH_WEST:
return new AxialCoord( this.q , this.r + 1 );
case HexTile.TILE_DIRECTION.SOUTH_EAST:
return new AxialCoord( this.q, this.r - 1 );
case HexTile.TILE_DIRECTION.SOUTH_WEST:
return new AxialCoord( this.q - 1, this.r - 1 );
default:
throw new ArgumentException();
}
}
void computePath(HexTile from, HexTile destination, Color c)
{
float bestDistance = 99999;
HexTile bestTile = null;
foreach (HexTile til in from.AllNeighbours)
{
if ((til.isPassable() || til == destination) && !visitedTiles.Contains(til) && til.isHighlighted())
{
float currentDistance = getDistance(til, destination);
if (currentDistance < bestDistance)
{
bestDistance = currentDistance;
bestTile = til;
}
}
}
if (bestTile != null)
{
visitedTiles.Add(bestTile);
currentPath.Add(bestTile);
if (!bestTile.boardPosition.Equals(destination.boardPosition))
{
computePath(bestTile, destination, c);
}
else
{
foreach (HexTile til in currentPath)
{
til.changeColor(c);
}
start.unit.GetComponent<BasicUnit>().setPath(currentPath);
visitedTiles.Clear();
}
}
else
{
currentPath.Clear();
computePath(start, destination, c);
}
}
public HexTile SpawnTile; //Tile ships from port are spawned on
#endregion Fields
#region Methods
/// <summary>
/// Finds nearby water tile to set as spawn tile and initializes port market
/// </summary>
public void InitializePort()
{
foreach (HexCoordinate hc in GetComponentInParent<HexTile>().Directions)
{
HexTile neighbor = GetComponentInParent<HexTile>().GetNeighbor(hc);
if (neighbor && neighbor.IsWater)
{
SpawnTile = GetComponentInParent<HexTile>().GetNeighbor(hc);
break;
}
}
Market = new Cargo(Random.Range(0, 500), Random.Range(0, 500), Random.Range(0, 500), Random.Range(0, 500), Random.Range(0, 500));
PortGold = Random.Range(5000, 20000);
PortPrices.Clear();
for (var i = 0; i < 5; i++)
PortPrices.Add(DefaultPortPrices[i] + Random.Range(-PortPriceMods[i], PortPriceMods[i]));
}
void SetUpCubeCoords( HexTile root, Vector3 theCoord)
{
if ( !root.cubeCoordSetUp)
{
root.cubeCoordSetUp = true;
root.cubeCoord = theCoord;
// set up left
Vector3 theNewCoord = theCoord + new Vector3(1, -1, 0);
if ( root.left != null)
SetUpCubeCoords(root.left.GetComponent<HexTile>(), theNewCoord);
// set up up left
theNewCoord = theCoord + new Vector3(1, 0, -1);
if (root.up_left != null)
SetUpCubeCoords(root.up_left.GetComponent<HexTile>(), theNewCoord);
// set up up right
theNewCoord = theCoord + new Vector3(0, 1, -1);
if (root.up_right != null)
SetUpCubeCoords(root.up_right.GetComponent<HexTile>(), theNewCoord);
// set up right
theNewCoord = theCoord + new Vector3(-1, 1, 0);
if (root.right != null)
SetUpCubeCoords(root.right.GetComponent<HexTile>(), theNewCoord);
// set up down right
theNewCoord = theCoord + new Vector3(-1, 0, 1);
if (root.down_right != null)
SetUpCubeCoords(root.down_right.GetComponent<HexTile>(), theNewCoord);
// set up down left
theNewCoord = theCoord + new Vector3(0, -1, 1);
if (root.down_left != null)
SetUpCubeCoords(root.down_left.GetComponent<HexTile>(), theNewCoord);
}
}
public Dictionary<HexTile, HexTile> GetPathToTile( Moveable peep, HexTile source, HexTile destination)
{
Dictionary<HexTile, HexTile> cameFrom = new Dictionary<HexTile, HexTile>();
Dictionary<HexTile, int> costSoFar = new Dictionary<HexTile, int>();
var frontier = new PriorityQueue<HexTile>();
frontier.Enqueue(source, 0);
cameFrom[source] = source;
costSoFar[source] = 0;
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
if (current.Equals(destination))
{
break;
}
foreach (var next in current.Neighbours( peep))
{
GameObject nextObj = (GameObject) next;
HexTile nextTile = nextObj.GetComponent<HexTile>();
int newCost = costSoFar[current] + Cost( current, nextTile);
if (!costSoFar.ContainsKey(nextTile) || newCost < costSoFar[nextTile])
{
costSoFar[nextTile] = newCost;
int priority = newCost + Heuristic(nextTile, destination);
frontier.Enqueue(nextTile, priority);
cameFrom[nextTile] = current;
}
}
}
return cameFrom;
}
/// <summary>
/// Generate a HexGrid by providing a filename to be read, and then generated from.
/// </summary>
/// <param name="grid"></param>
/// <param name="filename"></param>
public static void GenerateFromFile(HexGrid grid, string filename)
{
List <HexMapCsv> file = HexMapFileSaver.ReadFile(filename);
// Create a throwaway tile so that we can get the dimensions of it.
Vector2 spriteSize = GetTileSize();
foreach (HexMapCsv row in file)
{
if (row.TileType != TileType.Empty)
{
Debug.Log("HELLO");
}
int x = row.X;
int z = row.Z;
float mod = z % 2;
Vector2 position = new Vector2((x * spriteSize.x) + ((spriteSize.x * 0.5f) * mod), (z * spriteSize.y) * 0.75f);
grid.Tiles.Add(HexTile.Create(grid, row.TileType, position, new Vector2(x, z)));
}
}
GameObject SpawnNewTile(GameObject pickedTile, int column, int row)
{
GameObject tile = Instantiate(pickedTile);
if (tile)
{
tile.transform.parent = tileMap.transform;
float tileOffset = (row % 2 == 0) ? 0 : 0.5f;
tile.transform.position = new Vector3(column + tileOffset, row * (float)(tileWidth + 2) / tileHeight, 0);
HexTile newHex = tile.GetComponent <HexTile>();
if (newHex)
{
newHex.tileColumn = column;
newHex.tileRow = row;
tilesToGrowFrom.Add(newHex);
Debug.Log("New Hex Tile created at Column " + newHex.tileColumn + ", Row " + newHex.tileRow);
}
availableTileLocations = RemoveTileLocation(availableTileLocations);
}
return(tile);
}
IEnumerator ScanDelayed()
{
yield return(0);
// due to how GetTile works, we need to wait
// perhaps there is a way to do it some other way, but whatever
// look for neighbours before we deactivate tiles out of range
foreach (var tile in Tiles)
{
tile.neighbours = Neighbours(tile);
}
Vector3 center = gameObject.transform.position;
// deactivate tiles out of range, hide instead?
foreach (var tile in Tiles)
{
if (Vector3.Distance(tile.transform.position, center) >= minDistance * tileXOffset)
{
tile.SetHidden();
}
}
if (AstarPath.active == null)
{
Debug.LogError("Astar not active", this);
}
else
{
AstarPath.active.Scan();
}
CenterTile = GetTileAt(new Vector3(0, 0, 0));
onMapReady?.Invoke(Tiles);
}
/// <summary>
/// Reveal tiles around this one
/// </summary>
/// <param name="center"></param>
public bool Reveal(HexTile center)
{
// need a list of surrounding tiles,
bool rescan = false;
int revealedCount = 0;
for (var i = 0; i < center.neighbours.Count; i++)
{
var tile = center.neighbours[i];
bool revealed = tile.Reveal(revealedCount * 0.1f);
if (revealed)
{
revealedCount++;
}
rescan |= revealed;
}
if (!rescan)
{
return(false);
}
// perhaps in real game we could disable certain nodes instead of rescanning
// hidden tiles are deactivate and not visible to Scan() when we first init them
// there can be 'holes' in map, so we can just scan all of them and disable after
// unless we remove them from pathfinding somehow
if (AstarPath.active == null)
{
Debug.LogError("Astar not active", this);
}
else
{
AstarPath.active.Scan();
}
return(true);
}
void SelectTileByScreenPointToRay(Vector3 screenPoint)
{
if (hexNavMapManager == null)
{
return;
}
GameObject hexTileObject = hexNavMapManager.SelectTileByScreenPointToRay(screenPoint, canAttack);
if (hexTileObject != null) //不是空地
{
currentHexTile = hexTileObject.GetComponent <HexTile> ();
pathHexTileList.Add(hexTileObject);
if (currentHexTile.unit != null)
{
Enemy enemy = currentHexTile.unit.GetComponent <Enemy>();
Hero hero = currentHexTile.unit.GetComponent <Hero>();
if (canAttack && enemy != null)
{
PlayBattle();
canAttack = false;
return;
}
if (hero)
{
tempStep = hero.step;
}
}
}
else
{
currentHexTile = null;
}
}
public HexTile[] GetNeighborsInRange(int radius)
{
HashSet <HexTile> tiles = new HashSet <HexTile>();
for (int dx = -radius; dx <= radius; ++dx)
{
for (int dy = Mathf.Max(-radius, -dx - radius); dy <= Mathf.Min(radius, -dx + radius); ++dy)
{
int dz = -dx - dy;
var center = new OffsetCoordinate(this.x, this.y);
var offsetCube = new CubeCoordinate(dx, dy, dz);
HexTile neighbor = HexTile.FindByOffset(center, HexUtils.CubeCoordToOffsetCoord(offsetCube, center.IsEven()));
if (neighbor != null)
{
tiles.Add(neighbor);
}
}
}
HexTile[] results = new HexTile[tiles.Count];
tiles.CopyTo(results);
return(results);
}
public void SetTile(int x, int y, HexTile tile)
{
SetTile(new Point2(x, y), tile);
}
/// <summary>
/// Given a task type, mercenary, and tile, generate a notification that can be parsed and sent to the UI.
/// </summary>
/// <returns>Notification object containing an event.</returns>
public Notification GenerateNotification(TaskType pType, MercenaryData pMercenary, HexTile pTile, EncounterEvent pEndEvent = null)
{
// Get a random event object from the event manifest for the given type. It should contain information as to
// whether the event is clear-required.
int lDayLimit = 0;
foreach (HexTile t in pMercenary.CurrentPath)
{
lDayLimit += HexFunctions.Instance.GetRoughTerrainFactor(t.Type);
}
if (pType.Equals(TaskType.DUNGEONEER))
{
return(new Notification(pType, EncounterController.Instance.DungeoneeringEvent, ParseNotificationLabel(pType, pMercenary), lDayLimit, pMercenary, pTile));
}
// Return the generated notification.
return(new Notification(pType, pEndEvent, ParseNotificationLabel(pType, pMercenary), lDayLimit, pMercenary, pTile));
}
private IEnumerator SetMission()
{
// Get the selected mercenary
selectedTask = TaskType.NONE;
MercenaryData m = AppUI.Instance.SelectedMercenary;
if (m == null)
{
yield break;
}
// Collapse the left menu
AppUI.Instance.ToggleLeftMenu();
// Show the "Select a Tile" text
AppUI.Instance.ToggleSelectTileText(m.Name);
// Wait for a tile to be selected and confirmed
yield return(new WaitUntil(() => (Input.GetButtonDown("Submit") && TileSelector.Instance.TargetTile != null)));
HexTile tile = TileSelector.Instance.TargetTile;
AppUI.Instance.ToggleSelectTileText();
// Pop up the task type selection dialog
// Perform logic here for choosing options to show based on tile type
DialogManager.Instance.ShowDialog(DialogType.TASK_SELECT);
int it = 1;
bool didButtonCheck = false;
if (!didButtonCheck)
{
foreach (RectTransform r in TaskTray.transform)
{
if (r == TaskTray)
{
continue;
}
r.gameObject.GetComponent <Button>().interactable = IsValidTaskForTile((TaskType)it, tile);
it++;
}
}
// wait for a task to be selected
yield return(new WaitUntil(() => (selectedTask != TaskType.NONE)));
// Close the selection dialog
DialogManager.Instance.CloseAllDialogs();
// Pass the task to the mercenary data
AppUI.Instance.SelectedMercenary.SetPath(MercenaryController.Instance.GetTaskPath(m.Location, tile));
// Generate a corresponding notification and push it to the panel
NotificationController.Instance.AddNotification(GenerateNotification(selectedTask, m, tile, EncounterController.Instance.GetRandomEncounter()));
AppUI.Instance.UpdateMercInteractionButton(m);
AppUI.Instance.SwitchPage(0);
// reset selectedtask
selectedTask = TaskType.NONE;
yield return(null);
}
private void BuildBase()
{
HexTile startTile = HexGrid.Instance.CenterTile;
BuildTowerAt(startTile, basePrefab);
}
//移动到目标
void MoveToTarget()
{
GameObject tileStart = moveHexTileList[0] as GameObject; //第一块格子（包括英雄本身的格子）
GameObject tileStop = moveHexTileList[1] as GameObject; //下一块格子
//移动后的朝向
moveForward = tileStop.transform.position - tileStart.transform.position; //移动时的方向
this.gameObject.transform.rotation = Quaternion.FromToRotation(Vector3.forward, moveForward);
if (this.gameObject.transform.up != Vector3.up)
{
this.gameObject.transform.Rotate(0, 0, 180);
}
//this.gameObject.transform.rotation = Quaternion.FromToRotation (Vector3.forward, this.gameObject.transform.right);
usedAp++;
APShow(); //显示AP变化
//移动中网格的状态变化
HexTile theStepTileFirst = tileStop.GetComponent <HexTile> ();
HexTile theStepTileSecond = tileStart.GetComponent <HexTile> ();
theStepTileFirst.Select();
theStepTileSecond.Idle();
HexTile hexTileStart = tileStart.GetComponent <HexTile> ();
hexTileStart.unit = null;
HexTile hexTileStop = tileStop.GetComponent <HexTile> ();
if (hexTileStop.unit != null)
{
Hero hero = hexTileStop.unit.GetComponent <Hero> ();
Prop prop = hexTileStop.unit.GetComponent <Prop> ();
if (prop)
{
hexTileStop.unit.SetActive(false);
heroProp = prop;
hexTileStop.unit = gameObject;
}
if (hero)
{
}
}
else
{
hexTileStop.unit = gameObject;
}
moveHexTileList.RemoveAt(0); //移除第一个元素
GameObject line = moveLineList [0] as GameObject;
moveLineList.RemoveAt(0);
Destroy(line);
if (moveHexTileList.Count > 1)
{
LetIsGo();
}
else
{
theStepTileFirst.Select();
StopMove();
}
}
private void findNeighbors()
{
for (int y = 0; y < height; y++)
{
int maxWidth = width - (y % 2);
int maxWidthAdj = width - ((y + 1) % 2);
for (int x = 0; x < maxWidth; x++)
{
HexTile tile = GetTile(x, y);
if (tile.isOccluded || tile.type == HexTileType.Disabled)
{
continue;
}
if (x > 0)
{
tile.AddPath(GetTile(x - 1, y));
}
if (x < maxWidth - 1)
{
tile.AddPath(GetTile(x + 1, y));
}
if (y > 0 && x < maxWidthAdj)
{
tile.AddPath(GetTile(x, y - 1));
}
if (y < height - 1 && x < maxWidthAdj)
{
tile.AddPath(GetTile(x, y + 1));
}
if (y % 2 == 0)
{
if (y > 0 && x > 0)
{
tile.AddPath(GetTile(x - 1, y - 1));
}
if (y < height - 1 && x > 0)
{
tile.AddPath(GetTile(x - 1, y + 1));
}
}
else
{
if (y > 0 && x < maxWidthAdj - 1)
{
tile.AddPath(GetTile(x + 1, y - 1));
}
if (y < height - 1 && x < maxWidthAdj - 1)
{
tile.AddPath(GetTile(x + 1, y + 1));
}
}
}
}
}
public void SetCurrentHex(HexTile hex)
{
currentHex = hex;
}
public IEnumerator Move(int destination) //A* pathfinding
{
if (!CombatManager.activeWorld.tiles[destination].passable)
{
Debug.Log("Destination not passable");
yield break;
}
Debug.Log("Moving to " + destination);
if (destination == onTile)
{
Debug.Log("Standing on destination");
yield break;
}
List <int> open = new List <int>(); //to check
List <int> closed = new List <int>(); //checked
List <int> path = new List <int>();
List <int> potentialPath = new List <int>();
Dictionary <int, int> costFromStart = new Dictionary <int, int>();
Dictionary <int, int> movementCosts = new Dictionary <int, int>();
//moverange test
foreach (int i in moveRange)
{
CombatManager.activeWorld.tiles[i].MoveUnhighlight();
}
closed.Add(onTile); //add current position to closed
costFromStart.Add(onTile, 0);
movementCosts.Add(onTile, 0);
foreach (int n in CombatManager.activeWorld.tiles[onTile].neighbors) //add neighbors to open
{
HexTile toOpen = CombatManager.activeWorld.tiles[n];
if (toOpen.passable)
{
open.Add(toOpen.index);
//Debug.Log("Opened " + toOpen.index);
int mc = 1;
int c = CombatManager.activeWorld.TileDistanceFromTo(n, destination);
costFromStart.Add(n, mc);
movementCosts.Add(n, mc + c);
}
}
//Now that we are initialized, we recursively find the shortest path
//bool searching = true;
int next = open[0];
int lowestCost = 999;
while (open.Count > 0)
{
if (open.Contains(destination))
{
//closed.Add(destination);
path.Add(destination);
//backtrack to get path
int bCost = 9999;
int back = destination;
for (int p = 0; p < closed.Count; p++)
{
foreach (int b in CombatManager.activeWorld.tiles[back].neighbors)
{
//if(b == onTile){break;}
if (closed.Contains(b))
{
if (costFromStart[b] < bCost)
{
bCost = costFromStart[b];
back = b;
}
}
}
if (back == onTile)
{
break;
}
path.Add(back);
}
//path made now move it
open.Clear();
StartCoroutine(MoveOnPath(path));
break;
}
//go to lowest moveCost in open list
lowestCost = 9999; // movementCosts[next];
foreach (int h in open)
{
if (movementCosts[h] < lowestCost)
{
next = h; //open[h];
lowestCost = movementCosts[h];
}
}
open.Remove(next);
closed.Add(next);
Debug.Log("Closed " + next + " Movecost " + movementCosts[next]);
//on next tile, now check its neighbors
HexTile nextTile = CombatManager.activeWorld.tiles[next];
foreach (int n in nextTile.neighbors)
{
if (closed.Contains(n))
{
continue;
}
//get closed parents to calculate movecost
int nCost = 0; //new movement cost
int lCost = 999;
int cParent = -1;
foreach (int p in CombatManager.activeWorld.tiles[n].neighbors)
{
if (closed.Contains(p))
{
if (costFromStart[p] < lCost)
{
lCost = costFromStart[p];
cParent = p;
}
}
}
if (cParent == -1)
{
Debug.LogError("discontinuous path");
}
else
{
nCost = lCost + 1 + CombatManager.activeWorld.TileDistanceFromTo(n, destination);
}
if (open.Contains(n))
{
//check if score from this path is lower than its current score
if (movementCosts[n] > nCost)
{
movementCosts.Remove(n);
movementCosts.Add(n, nCost);
}
}
else
{
if (CombatManager.activeWorld.tiles[n].passable)
{
open.Add(n);
costFromStart.Add(n, lCost + 1);
movementCosts.Add(n, nCost);
}
}
}
yield return(null);
}
//backtrack from destination to find path
yield return(null);
}
public HexCorner(HexTile pTile, int pDirection, Vector3 wPoint) : base(pTile, pDirection, wPoint)
{
}
/*
* public static List<HexTile> FindHighlight(HexTile originTile, float movementPoints, bool isAttack = false)
* {
* return FindHighlight(originTile, movementPoints, new Vector2[0], isAttack);
* }
*
* public static List<HexTile> FindHighlight(HexTile originTile, float movementPoints, Vector2[] occupied)
* {
* return FindHighlight(originTile, movementPoints, occupied, false);
* }
*
* public static List<HexTile> FindHighlight(HexTile originTile, float movementPoints, Vector2[] occupied, bool isAttack)
* {
* List<HexTile> closed = new List<HexTile>();
* List<HexTilePath> open = new List<HexTilePath>();
*
* HexTilePath originPath = new HexTilePath();
* originPath.AddTile(originTile, isAttack);
*
* open.Add(originPath);
*
* while (open.Count > 0)
* {
* HexTilePath current = open[0];
* open.Remove(open[0]);
* bool isSkip = false;
*
*
* if (open.Where(x => x.lastTile == current.lastTile && x.costOfPath <= current.costOfPath).Count() > 0)
* {
* continue;
* }
*
* if (closed.Contains(current.lastTile) || (current.lastTile != originTile && current.listOfTiles.GetRange(0, current.listOfTiles.Count - 2).Contains(current.lastTile)))
* {
* continue;
* }
* if (current.costOfPath > movementPoints + originTile.m_MovementCost)
* {
* continue;
* }
* closed.Add(current.lastTile);
*
* foreach (HexTile t in current.lastTile.m_Neighbors)
* {
* if (t.m_Impassible || occupied.Contains(t.m_GridPosition) || current.listOfTiles.Contains(t))
* {
* continue;
* }
* HexTilePath newTilePath = new HexTilePath(current);
* newTilePath.AddTile(t, isAttack);
* open.Add(newTilePath);
* }
* }
* closed.Remove(originTile);
* return closed;
* }
*/
public static List <HexTile> FindHighlight(HexTile originTile, float movementPoints, HexCoord[] occupied, bool isAttack)
{
List <HexTile> closed = new List <HexTile>();
List <HexTilePath> open = new List <HexTilePath>();
HexTilePath originPath = new HexTilePath();
originPath.AddTile(originTile, isAttack);
open.Add(originPath);
while (open.Count > 0)
{
HexTilePath current = open[0];
open.Remove(open[0]);
bool isSkip = false;
for (int i = 0; !isSkip && i < open.Count; i++)
{
if (open[i].EvaluationPath(current))
{
isSkip = true;
}
}
for (int i = 0; !isSkip && i < current.listOfTiles.Count - 2; i++)
{
if (current.listOfTiles[i].Equals(current.lastTile))
{
Debug.LogWarning("Skip path by looping");
isSkip = true;
}
}
if (!isSkip && current.costOfPath > movementPoints + originTile.m_MovementCost)
{
isSkip = true;
}
if (isSkip)
{
continue;
}
closed.Add(current.lastTile);
List <HexTile> hexTiles = current.lastTile.m_Neighbors;
for (int i = 0; i < hexTiles.Count; i++)
{
HexTile tile = hexTiles[i];
if (closed.Contains(tile) ||
tile.m_Impassible ||
occupied.Contains(tile.m_Hex) ||
current.listOfTiles.Contains(tile))
{
continue;
}
HexTilePath newTilePath = new HexTilePath(current);
newTilePath.AddTile(tile, isAttack);
open.Add(newTilePath);
}
}
closed.Remove(originTile);
return(closed);
}
protected float HeuristicFunc(HexTile from, HexTile to)
{
return(from.hexTransform.CalcHexManhattanDist(to.hexTransform));
}
public static MiniAction DecideAction(GameState gameState, HexTileController htc)
{
MoveDebug md = GameObject.FindGameObjectWithTag("MoveDebug").GetComponent <MoveDebug>();
int attackRadius = gameState.selfChar.stats.range;
// **** Spencer Notes ******
/* If you can attack, do
* Else evaluate all the locations you could possible move to,
* then take the largest and move to it
*/
//If this character is the hacker, find best possible place to put the attack
if (gameState.selfChar.characterclass == CharacterClass.HACKER)
{
List <HexTile> attackRange = htc.FindRadius(gameState.selfTile, attackRadius);
PriorityQueue attackFringe = new PriorityQueue();
md.ClearAll();
foreach (HexTile hex in attackRange)
{
GameState gs = new GameState(gameState.aiChars, gameState.playerChars, hex, gameState.selfChar);
float value = EvaluateAOEAttackState(gs, htc);
md.SetText(hex, value);
//If this attack will do more damage to yourself, don't add it to the list
if (value < -1)
{
attackFringe.Push((hex, null), value);
}
}
//If there is nothing in the list (No good attacks) Move intead
if (attackFringe.HasNext())
{
((HexTile attackHex, List <int> a), float value) = attackFringe.PopWithVal();
//If this attack only did damage to 1 character (or 1 more than your own chars)
/* *** Come back if you have more time ****
* if (value <= gameState.selfChar.stats.attackdmg)
* {
* //Find see if there is a better place to attack and move to that spot
*
* }*/
return(new MiniAttack()
{
type = "AOEAttack", attackLocation = attackHex.Position
});
}
}
else if (gameState.selfChar.characterclass == CharacterClass.PSYONIC)
{
Character needestChar = null;
Character cantReachChar = null;
float cantReachHealth = 1;
float leastHealth = 1;
foreach (Character character in gameState.aiChars)
{
if (character.CompareTo(gameState.selfChar) != 0)
{
int distance = htc.FindHexDistance(gameState.selfChar.gameCharacter.position, character.gameCharacter.position);
float health = character.stats.health / character.stats.maxHealth;
//If you can heal the character, and the health is less than 1
if (health < leastHealth)
{
if (distance <= attackRadius)
{
leastHealth = health;
needestChar = character;
}
else
{
cantReachHealth = health;
cantReachChar = character;
}
}
}
}
if (leastHealth < 1)
{
return(new MiniAttack()
{
type = "Attack", toAttack = needestChar
});
}
else if (cantReachHealth < 1)
{
//If there is a character in need that you can't reach, move towards it
Debug.Log("Healer Moving towards " + cantReachChar.name);
HexTile toMovTo = MoveTowards(cantReachChar, gameState, htc, true);
return(new MiniMove()
{
type = "Move", Dest = toMovTo
});
}
else
{
//Can't heal yourself*******
//Move towards the Ranger
Character target = GetCharacter(gameState.aiChars, CharacterClass.RANGED);
if (target != null)
{
HexTile toMovTo = MoveTowards(target, gameState, htc, true);
return(new MiniMove()
{
type = "Move", Dest = toMovTo
});
}
target = GetCharacter(gameState.aiChars, CharacterClass.HACKER);
if (target != null)
{
HexTile toMovTo = MoveTowards(target, gameState, htc, true);
return(new MiniMove()
{
type = "Move", Dest = toMovTo
});
}
target = GetCharacter(gameState.aiChars, CharacterClass.MELEE);
if (target != null)
{
HexTile toMovTo = MoveTowards(target, gameState, htc, true);
return(new MiniMove()
{
type = "Move", Dest = toMovTo
});
}
//No other characters but you exist, await the sweet release of death
return(new MiniMove()
{
type = "Move", Dest = gameState.selfTile
});
}
}
else
{
Character weakestChar = null;
Character deadChar = null;
float leastHealth = int.MaxValue;
foreach (Character character in gameState.playerChars)
{
int distance = htc.FindHexDistance(gameState.selfChar.gameCharacter.position, character.gameCharacter.position);
if (distance <= attackRadius)
{
//If your attack would kill this character, target this one above all else
if ((Mathf.Max(0, character.stats.health - gameState.selfChar.stats.attackdmg) / character.stats.maxHealth) <= 0)
{
deadChar = character;
}
if ((character.stats.health / character.stats.maxHealth) < leastHealth)
{
leastHealth = (character.stats.health / character.stats.maxHealth);
weakestChar = character;
}
}
}
//Attack the soon to be dead character if it can
if (deadChar != null)
{
return(new MiniAttack()
{
type = "Attack", toAttack = deadChar
});
}
if (weakestChar != null)
{
return(new MiniAttack()
{
type = "Attack", toAttack = weakestChar
});
}
}
// **** Spencer Notes ******
/* Could not find anything to attack so move to the best possible location
*/
List <HexTile> possibleMoves = htc.FindRadius(gameState.selfTile, gameState.selfChar.stats.speed);
List <Character> allChars = gameState.aiChars.Concat(gameState.playerChars).ToList();
List <(HexTile, List <int>)> possibleMoves2 = ValidateRadius(gameState.selfTile, possibleMoves, gameState.selfChar.stats.speed, allChars, htc);
//possibleMoves = ValidateRadius(gameState.selfTile, possibleMoves, gameState.selfChar.stats.speed, allChars, htc);
possibleMoves = new List <HexTile>();
foreach ((HexTile hex, List <int> path) in possibleMoves2)
{
possibleMoves.Add(hex);
}
PriorityQueue fringe = new PriorityQueue();
foreach (HexTile hex in possibleMoves)
{
GameState gs = new GameState(gameState.aiChars, gameState.playerChars, hex, gameState.selfChar);
fringe.Push((hex, null), EvaluateState(gs, htc));
}
if (!fringe.HasNext())
{
//No avialable moves, move to self
return(new MiniMove()
{
type = "Move", Dest = gameState.selfTile
});
}
(HexTile state, List <int> actions) = fringe.Pop();
return(new MiniMove()
{
type = "Move", Dest = state
});
}
public static HexTile MoveTowards(Character target, GameState gameState, HexTileController htc, bool runFromEnemy = false)
{
//choose the tile you want to move to, either the character directly, or a tile next to the character that is away from the enemy
HexTile targetTile = htc.FindHex(target.gameCharacter.position);
if (runFromEnemy)
{
List <HexTile> tilesAroundTarget = htc.FindRadius(targetTile, 1);
int farthest = 0;
foreach (HexTile hexTile in tilesAroundTarget)
{
if (!hexTile.IsObstacle && hexTile.HoldingObject == null)
{
//Find distance to all player characters
int newDist = 0;
foreach (Character c in gameState.playerChars)
{
newDist += htc.FindHexDistance(hexTile.Position, c.gameCharacter.position);
}
//You want the distance to the player to be largest
if (newDist > farthest)
{
farthest = newDist;
targetTile = hexTile;
}
}
}
}
List <int> moves = GreedySearch(gameState.selfTile, targetTile, htc);
//If run from enemy is false, your target in ON a character, so remove that last step
if (!runFromEnemy)
{
//Remove the last step (the one on the distination character)
if (moves.Count > 0)
{
moves.RemoveAt(moves.Count - 1);
}
}
Debug.Log("Psyonic wants to move ...");
foreach (int i in moves)
{
Debug.Log(i);
}
Debug.Log("To get to " + target.name);
//If you were already right next to the target, don't go anywhere
if (moves.Count == 0)
{
return(gameState.selfTile);
}
//Only keep the number of steps that you are allowed to move
//Starting hex is your own
HexTile hex = gameState.selfTile;
//Repet until you hit your step count, or you run out of moves
for (int i = 0; i < Mathf.Min(gameState.selfChar.stats.speed, moves.Count); i++)
{
//Get the neighbor that the path tells you too
hex = hex.nexts[moves[i]];
}
return(hex);
}
private HexTile lastProcessedDestination; // keep track of last looked for destination tile
#endregion Fields
#region Methods
// Support methods for pathfinding
// Heuristic method to help with pruning in A* algorithm.
// Compute the cube coord distance between both tiles, and use that for heuristics.
public static int Heuristic(HexTile a, HexTile b)
{
return (int) ((Math.Abs (a.cubeCoord.x - b.cubeCoord.x) + Math.Abs (a.cubeCoord.y - b.cubeCoord.y)
+ Math.Abs (a.cubeCoord.z - b.cubeCoord.z)) / 2);
}
//Build random group from editor Chapter
void BuildRandomFromChapter(Chapter c)
{
//Debug.Log( "BuildRandomFromChapter" );
List <Transform> usedPositions = new List <Transform>();
tileManager = Object.FindObjectOfType <TileManager>();
chapter = c;
tileList = new List <Tile>();
//randomTileIndices = GlowEngine.GenerateRandomNumbers( chapter.randomTilePool.Count );
//Debug.Log( "(RANDOM)FOUND " + chapter.randomTilePool.Count + " TILES" );
//Debug.Log( "RANDOM ROOT INDEX: " + randomTileIndices[0] );
//create the parent container
containerObject = new GameObject().transform;
containerObject.name = "TILEGROUP: ";
Tile previous = null;
for (int i = 0; i < c.tileObserver.Count; i++)
{
//HexTile hexroot = new HexTile( chapter.randomTilePool[randomTileIndices[i]], new Vector(), RandomAngle() );
//HexTile hexroot = new HexTile( randomTiles[i], new Vector(), RandomAngle() );
HexTile hexroot = (HexTile)c.tileObserver[i];
hexroot.vposition = new Vector3();
hexroot.angle = RandomAngle();
//provide OnExplore trigger for random tile?
//HexTile hexroot = new HexTile();
//create parent object for prefab tile
GameObject go = new GameObject();
go.name = hexroot.idNumber.ToString();
//instantiate the tile prefab
string side = hexroot.tileSide == "Random" ? (Random.Range(1, 101) < 50 ? "A" : "B") : hexroot.tileSide;
Tile tile = Object.Instantiate(tileManager.GetPrefab(side, hexroot.idNumber), go.transform).GetComponent <Tile>();
//Tile tile = tileManager.GetPrefab( side, hexroot.idNumber );
//set its data
//tile.Init();
tile.gameObject.SetActive(false);
//tile.transform.parent = go.transform;
//tile.transform.localPosition = Vector3.zero;
tile.hexTile = hexroot;
tile.tileGroup = this;
tile.chapter = c;
//rotate go object
tile.transform.parent.localRotation = Quaternion.Euler(0, hexroot.angle, 0);
//set go's parent
tile.transform.parent.transform.parent = containerObject;
containerObject.name += " " + hexroot.idNumber.ToString();
if (previous != null)
{
tile.AttachTo(previous, this);
}
tileList.Add(tile);
previous = tile;
//add fixed tokens
if (tile.hexTile.tokenList.Count > 0)
{
usedPositions.AddRange(AddFixedToken(tile));
}
if (hexroot.isStartTile)
{
startPosition = tile.GetChildren("token attach")[0].position.Y(.26f);
tile.isExplored = true;
}
}
//add random tokens
if (c.usesRandomGroups)
{
AddRandomTokens(usedPositions.ToArray());
}
//***start tile cannot be random, below is no longer needed
//find starting position if applicable
//if ( c.dataName == "Start" )
//{
// bool found = false;
// foreach ( var randomTile in tileList )
// {
// var positions = randomTile.GetChildren( "token attach" );
// var tokens = randomTile.GetChildren( " Token(Clone)" );
// var open = from p in positions
// from t in tokens
// let foo = new { p, t }
// where Vector3.Distance( foo.p.position.Y( 0 ), foo.t.position.Y( 0 ) ) > 1f
// select foo;
// if ( open.Count() > 0 )
// {
// Debug.Log( "placed starting position" );
// startPosition = open.First().p.position.Y( .26f );
// found = true;
// randomTile.hexTile.isStartTile = true;
// Colorize( true );
// break;
// }
// }
// if ( !found )
// {
// Debug.Log( "Starting position not found, using default" );
// int tid = GlowEngine.GenerateRandomNumbers( tileList.Count )[0];
// startPosition = tileList[tid].GetExploretokenPosition();
// tileList[tid].hexTile.isStartTile = true;
// Colorize( true );
// }
//}
GenerateGroupCenter();
}
private void HandleMovingToNewTile(HexTile clickedTile, int attackAmount)
{
bool isEnemyTile = !clickedTile.IsEmpty() &&
currentPlayer.Index != clickedTile.Data.PlayerIndex;
bool isFull = attackAmount == selectedTile.Amount;
if (isFull)
{
if (isEnemyTile)
{
var enemy = players[clickedTile.Data.PlayerIndex];
if (attackAmount > clickedTile.Amount)
{
int difference = attackAmount - clickedTile.Amount;
clickedTile.Player = currentPlayer;
clickedTile.Amount = difference;
selectedTile.Amount = 1;
currentPlayer.TilesCount++;
enemy.TilesCount--;
selectedTile = clickedTile;
pointer.Activate(selectedTile.transform.position);
}
else if (attackAmount == clickedTile.Amount)
{
bool attackerWin = UnityEngine.Random.Range(0, 2) == 0;
if (attackerWin)
{
enemy.TilesCount--;
selectedTile.Amount = 1;
clickedTile.Player = currentPlayer;
clickedTile.Amount = 1;
currentPlayer.TilesCount++;
}
else
{
enemy.TilesCount++;
selectedTile.Player = enemy;
selectedTile.Amount = 1;
clickedTile.Amount = 1;
currentPlayer.TilesCount--;
}
selectedTile = null;
pointer.Deactivate();
}
else if (attackAmount < clickedTile.Amount)
{
int difference = Mathf.Abs(attackAmount - clickedTile.Amount);
selectedTile.Amount = 0;
selectedTile.Player = null;
clickedTile.Amount = difference;
selectedTile = null;
currentPlayer.TilesCount--;
pointer.Deactivate();
}
}
else
{
int newAmount = attackAmount - 1;
clickedTile.Player = currentPlayer;
clickedTile.Amount = newAmount;
selectedTile.Amount = 1;
selectedTile = clickedTile;
currentPlayer.TilesCount++;
if (clickedTile.Amount > 1)
{
pointer.Activate(selectedTile.transform.position);
}
else
{
pointer.Deactivate();
}
//circle.position = clickedTile.Amount > 1 ? clickedTile.transform.position : new Vector3(20, 20);
}
}
else
{
if (attackAmount >= clickedTile.Amount)
{
clickedTile.Player = currentPlayer;
int difference = Math.Max(1, attackAmount - clickedTile.Amount);
clickedTile.Amount = difference;
}
else if (attackAmount < clickedTile.Amount)
{
clickedTile.Amount -= attackAmount;
}
selectedTile.Amount -= attackAmount;
}
CheckPlayerWin();
}
public void CreateTerrain()
{
Clear();
Terrain terrain = GetComponent <Terrain>();
width = (int)((terrain.terrainData.size.x - 2 * border) / _tileSize);
height = (int)((terrain.terrainData.size.z - 2 * border) / (0.866025404f * _tileSize));
tiles = new HexTile[width * height];
tileWidth = instance._tileSize;
tileHeight = 0.75f * instance._tileSize / 0.866025404f;
tileHalfWidth = instance._tileSize / 2.0f;
tileC = tileHeight / 4.0f;
tileM = tileC / tileHalfWidth;
float scale = _tileSize / (hexTextureWidth / 100.0f);
int indexCounter = 0;
for (int z = 0; z < height; z++)
{
for (int x = 0; x < width - (z % 2); x++)
{
HexTile hexTile = Instantiate(hexTilePrefab);
Vector3 tilePosition = new Vector3(border + 0.5f * _tileSize +
_tileSize * x + 0.5f * _tileSize * (z % 2),
0.0f,
z * _tileSize * 0.866025404f + border + 0.5f * _tileSize * (1.0f / 0.866025404f));
hexTile.x = x;
hexTile.y = z;
hexTile.index = indexCounter++;
hexTile.transform.SetParent(transform);
hexTile.transform.localEulerAngles = new Vector3(0.0f, 0.0f, 0.0f);
hexTile.transform.localPosition = tilePosition;
hexTile.gameObject.isStatic = true;
hexTile.GetComponent <LineHexagon>().thickness = lineThickness;
hexTile.GetComponent <LineHexagon>().scale = _tileSize;
hexTile.GetComponent <LineHexagon>().CreateMesh();
// hexTile.gameObject.hideFlags = HideFlags.HideInHierarchy;
Ray tileRay = new Ray(hexTile.transform.position + sampleHeight * Vector3.up, Vector3.down);
int layer_mask = LayerMask.GetMask("Terrain");
RaycastHit info;
if (Physics.Raycast(tileRay, out info, 1000.0f, layer_mask))
{
hexTile.transform.position = new Vector3(hexTile.transform.position.x,
terrain.transform.position.y + sampleHeight - info.distance, hexTile.transform.position.z);
}
else
{
hexTile.isOccluded = true;
}
// hexTile.GetComponent<SpriteRenderer>().sprite = spriteHexTileSolid;
tiles[z * width + x] = hexTile;
}
}
findNeighbors();
DisableOccluded();
}
// Rechables pseudocode
/*
function cube_reachable(start, movement):
var visited = set()
add start to visited
var fringes = []
fringes.append([start])
for each 1 < k ≤ movement:
fringes.append([])
for each cube in fringes[k-1]:
for each 0 ≤ dir < 6:
var neighbor = cube_neighbor(cube, dir)
if neighbor not in visited, not blocked:
add neighbor to visited
fringes[k].append(neighbor)
return visited
*/
public ArrayList reachables( Moveable peep, HexTile root)
{
ArrayList visited = new ArrayList (); // list of visited noted
visited.Add (root); // add root for obvious reasons
ArrayList fringes = new ArrayList ( peep.range + 1); // list of lists
// fringes[k] = all nodes reachable in k
fringes.Add (new ArrayList() { root}); // add [ root] to fringes[ 0]
for (int i = 1; i <= peep.range; i++) {
fringes.Add( new ArrayList());
foreach( HexTile tile in (ArrayList)fringes[ i-1])
{
foreach( GameObject neighbourGO in tile.Neighbours( peep))
{
HexTile neighbour = neighbourGO.GetComponent<HexTile>();
if ( !visited.Contains( neighbour))
{
visited.Add ( neighbour);
((ArrayList) fringes[ i]).Add(neighbour);
}
}
}
}
return visited;
}
internal static List <HexTile> GetTilesInRange(HexTile tile, int range, bool includeSelf = true)
{
return(GetTilesInRange(tile.x, tile.y, range, includeSelf));
}
/*
* Randomly choose a tile from a specific
* biome, and mark it as a city
* */
void PlaceCityOnBiomeTile(List <HexTile> biomeTiles)
{
List <HexTile> cityPlacableBiomeTile = new List <HexTile>();
if (tilesElligibleForCities.Count <= 0)
{
cityCount = cities.Count;
Debug.LogError("There are no more elligible tiles to put a city on!");
}
//check if this biome still has city placable tiles
for (int i = 0; i < biomeTiles.Count; i++)
{
if (tilesElligibleForCities.Contains(biomeTiles[i]))
{
cityPlacableBiomeTile.Add(biomeTiles [i]);
}
}
if (cityPlacableBiomeTile.Count <= 0)
{
//if this point is reached, it means no more tiles in the current biome are available, place a random one anywhere
int randomTileIndex = UnityEngine.Random.Range(0, tilesElligibleForCities.Count);
HexTile chosenTile = tilesElligibleForCities [randomTileIndex];
SetTileAsCity(chosenTile);
HexTile[] neighborTiles = chosenTile.GetTilesInRange(minCityDistance);
for (int i = 0; i < neighborTiles.Length; i++)
{
if (tilesElligibleForCities.Contains(neighborTiles [i]))
{
//Remove all neighbor tiles from elligible tiles
tilesElligibleForCities.Remove(neighborTiles [i]);
}
}
tilesElligibleForCities.Remove(chosenTile);
return;
}
bool choosingCity = true;
while (choosingCity)
{
//Choose random tile from city placable biome tiles
int randomTileIndex = UnityEngine.Random.Range(0, cityPlacableBiomeTile.Count);
HexTile chosenTile = cityPlacableBiomeTile[randomTileIndex];
//check if chosen tile is elligible for city placement
if (tilesElligibleForCities.Contains(chosenTile))
{
choosingCity = false;
SetTileAsCity(chosenTile);
HexTile[] neighborTiles = chosenTile.GetTilesInRange(minCityDistance);
for (int i = 0; i < neighborTiles.Length; i++)
{
if (tilesElligibleForCities.Contains(neighborTiles [i]))
{
//Remove all neighbor tiles from elligible tiles
tilesElligibleForCities.Remove(neighborTiles [i]);
}
}
tilesElligibleForCities.Remove(chosenTile);
}
}
}
public PlaceCharacterAction(HexTile targetTile, Character characterToPlace)
{
this.targetTile = targetTile;
this.characterToPlace = characterToPlace;
}
private void InitiateInteraction (HexTile init, HexTile rec) {
Weapon iWep = init.character.GetComponentInChildren<Weapon> ();
Stats iStat = init.character.GetComponentInChildren<Stats> ();
Stats rStat = rec.character.GetComponentInChildren<Stats> ();
if (iWep.type%2==1) {
rStat.cHP += iWep.Mt + iStat.Mag;
if (rStat.cHP > rStat.mHP) {
rStat.cHP = rStat.mHP;
}
iStat.Xp += iWep.Mt;
}
}
public abstract void Idle(); //Do nothing public abstract void Move(HexTile startTile); //Just move along given path
public void InitiateBattle (HexTile attacker, HexTile defender) {
Weapon aWep = attacker.character.GetComponentInChildren<Weapon> ();
Weapon dWep = defender.character.GetComponentInChildren<Weapon> ();
Stats aStat = attacker.character.GetComponentInChildren<Stats> ();
Stats dStat = defender.character.GetComponentInChildren<Stats> ();
float a_as, d_as;
if (aWep.Wt <= aStat.Str) {
a_as = aStat.Spd;
} else {
a_as = aStat.Spd - (aWep.Wt - aStat.Str);
}
if (dWep.Wt <= dStat.Str) {
d_as = dStat.Spd;
} else {
d_as = dStat.Spd - (dWep.Wt - dStat.Str);
}
int[] repAtt = {0,0};
if (a_as - d_as >= 4) {
repAtt [0] = 1;
} else if (d_as - a_as >= 4) {
repAtt [1] = 1;
}
float a_hr, d_hr;
a_hr = aWep.Hit + aStat.Skl * 2 + aStat.Lck;
d_hr = dWep.Hit + dStat.Skl * 2 + aStat.Lck;
float a_ev, d_ev;
a_ev = a_as + aStat.Lck + attacker.terrainBonus;
d_ev = d_as + dStat.Lck + defender.terrainBonus;
float a_ac, d_ac;
a_ac = a_hr - d_ev;
if (a_ac < 0) {
a_ac = 0;
} else if (a_ac > 100) {
a_ac = 100;
}
d_ac = d_hr - a_ev;
if (d_ac < 0) {
d_ac = 0;
} else if (d_ac > 100) {
d_ac = 100;
}
float a_ap, d_ap;
if (aWep.type%2 == 0) {
a_ap = aStat.Str + (aWep.Mt);
} else {
a_ap = aStat.Mag + (aWep.Mt);
}
if (dWep.type%2 == 0) {
d_ap = dStat.Str + (dWep.Mt);
} else {
d_ap = dStat.Mag + (dWep.Mt);
}
float a_dp, d_dp;
if (dWep.type%2 == 0) {
a_dp = attacker.terrainBonus + aStat.Def;
} else {
a_dp = attacker.terrainBonus + aStat.Res;
}
if (aWep.type%2 == 0) {
d_dp = defender.terrainBonus + dStat.Def;
} else {
d_dp = defender.terrainBonus + dStat.Res;
}
float a_dm, d_dm;
a_dm = a_ap - d_dp;
d_dm = d_ap - a_dp;
if (a_dm < 0) {
a_dm = 0;
}
if (d_dm < 0) {
d_dm = 0;
}
float a_cr, d_cr;
a_cr = aWep.Crit + aStat.Skl / 2;
d_cr = dWep.Crit + dStat.Skl / 2;
float a_ce, d_ce;
a_ce = aStat.Lck;
d_ce = dStat.Lck;
float a_cc, d_cc;
a_cc = a_cr - d_ce;
d_cc = d_cr - a_ce;
float a_xp, d_xp;
if (attacker.character.tag == "Unit") {
battleAnimation [0] = 1;
} else {
battleAnimation [0] = 2;
}
float x = Random.Range(0,100);
if (a_cc>=x) {
a_dm = a_dm * 3;
}
if (a_ac >= x) {
battleAnimation [1] = 1;
if (a_dm == 0) {
a_xp = 1;
} else {
float xp = 10 + (dStat.Lv - aStat.Lv) / 2;
if (xp < 1) {
xp = 1;
}
a_xp = xp;
}
battleAnimation [2] = (int)a_dm;
dStat.cHP -= a_dm;
} else {
battleAnimation [1] = 0;
a_xp = 1;
}
if (dStat.cHP <= 0) {
battleAnimation [3] = -1;
a_xp += (dStat.Lv - aStat.Lv) + 15 + 5;
if (defender.character.CompareTag ("Enemy")) {
a_xp += 40 * defender.character.GetComponent<Enemy> ().special;
}
UpdateXp (aStat,a_xp,dStat,0);
return;
}
if (dWep.Rng.Contains (defender.att_dis)) {
if (defender.character.tag == "Unit") {
battleAnimation [3] = 1;
} else {
battleAnimation [3] = 2;
}
} else {
battleAnimation [3] = 0;
}
x = Random.Range(0,100);
if (d_cc>=x) {
d_dm = d_dm * 3;
}
if (d_ac >= x && dWep.Rng.Contains (defender.att_dis) && dWep.type >= 0) {
battleAnimation [4] = 1;
if (d_dm == 0) {
d_xp = 1;
} else {
float xp = 10 + (aStat.Lv - dStat.Lv) / 2;
if (xp < 1) {
xp = 1;
}
d_xp = xp;
}
battleAnimation [5] = (int)d_dm;
aStat.cHP -= d_dm;
} else {
battleAnimation [4] = 0;
d_xp = 1;
}
if (aStat.cHP <= 0) {
battleAnimation [6] = -1;
d_xp += (aStat.Lv - dStat.Lv) + 15 + 5;
if (attacker.character.CompareTag ("Enemy")) {
d_xp += 40 * attacker.character.GetComponent<Enemy> ().special;
}
UpdateXp (aStat,a_xp,dStat,d_xp);
return;
}
int offset = 3;
if (battleAnimation [3] == 0) {
offset = 0;
}
if (repAtt[0] == 1) {
if (attacker.character.tag == "Unit") {
battleAnimation [3+offset] = 1;
} else {
battleAnimation [3+offset] = 2;
}
x = Random.Range(0,100);
if (a_cc>=x) {
a_dm = a_dm * 3;
}
if (a_ac >= x) {
battleAnimation [4 + offset] = 1;
if (a_dm == 0) {
a_xp += 1;
} else {
float xp = 10 + (dStat.Lv - aStat.Lv) / 2;
if (xp < 1) {
xp = 1;
}
a_xp += xp;
}
battleAnimation [5 + offset] = (int)a_dm;
dStat.cHP -= a_dm;
} else {
battleAnimation [4 + offset] = 0;
a_xp += 1;
}
if (dStat.cHP <= 0) {
battleAnimation [6 + offset] = -1;
a_xp += (dStat.Lv - aStat.Lv) + 15 + 5;
if (defender.character.CompareTag ("Enemy")) {
a_xp += 40 * defender.character.GetComponent<Enemy> ().special;
}
UpdateXp (aStat,a_xp,dStat,d_xp);
return;
}
} else if (repAtt[1] == 1) {
if (dWep.Rng.Contains (defender.att_dis)) {
if (defender.character.tag == "Unit") {
battleAnimation [3 + offset] = 1;
} else {
battleAnimation [3 + offset] = 2;
}
} else {
battleAnimation [3 + offset] = 0;
}
x = Random.Range(0,100);
if (d_cc>=x) {
d_dm = d_dm * 3;
}
if (d_ac >= x && dWep.Rng.Contains (defender.att_dis) && dWep.type >= 0) {
battleAnimation [4 + offset] = 1;
if (d_dm == 0) {
d_xp += 1;
} else {
float xp = 10 + (aStat.Lv - dStat.Lv) / 2;
if (xp < 1) {
xp = 1;
}
d_xp += xp;
}
battleAnimation [5 + offset] = (int)d_dm;
aStat.cHP -= d_dm;
} else {
battleAnimation [4 + offset] = 0;
d_xp += 1;
}
if (aStat.cHP <= 0) {
battleAnimation [6 + offset] = -1;
d_xp += (aStat.Lv - dStat.Lv) + 15 + 5;
if (attacker.character.CompareTag ("Enemy")) {
d_xp += 40 * defender.character.GetComponent<Enemy> ().special;
}
UpdateXp (aStat,a_xp,dStat,d_xp);
return;
}
}
UpdateXp (aStat,a_xp,dStat,d_xp);
}
public void SetMercenaryTask(MercenaryData pMercenary, TaskType pTaskType, HexTile pTile)
{
}
internal void MakeCitizenMove(HexTile startTile, HexTile targetTile)
{
this.transform.position = Vector3.MoveTowards(startTile.transform.position, targetTile.transform.position, 0.5f);
}
public void SetTile(Point2 pos, HexTile tile)
{
tiles[pos.x + (pos.y * _boardWidth)] = tile;
}
//Build fixed group from editor Chapter
void BuildFixedFromChapter(Chapter c)
{
//Debug.Log( "BuildFixedFromChapter" );
List <Transform> usedPositions = new List <Transform>();
tileManager = Object.FindObjectOfType <TileManager>();
chapter = c;
tileList = new List <Tile>();
//Debug.Log( "(FIXED)FOUND " + chapter.tileObserver.Count + " TILES" );
//create the parent container
containerObject = new GameObject().transform;
containerObject.name = "TILEGROUP: ";
for (int i = 0; i < c.tileObserver.Count; i++)
{
//Debug.Log( chapter.tileObserver[i].idNumber );
HexTile h = chapter.tileObserver[i] as HexTile;
containerObject.name += " " + h.idNumber.ToString();
GameObject goc = new GameObject();
goc.name = h.idNumber.ToString();
Tile tile = Object.Instantiate(tileManager.GetPrefab(h.tileSide, h.idNumber), goc.transform).GetComponent <Tile>();
//Tile tile = tileManager.GetPrefab( h.tileSide, h.idNumber );
//set its data
//tile.Init();
tile.gameObject.SetActive(false);
//tile.transform.parent = goc.transform;
//tile.transform.localPosition = Vector3.zero;
tile.chapter = c;
tile.hexTile = h;
tile.tileGroup = this;
if (i > 0)
{
//3D distance between tiles in X = 0.75
//3D distance between tiles in Y = 0.4330127
//EDITOR distance between hextile centers = 55.425626
//3D distance between hextile centers = .8660254
float d = Vector3.Distance(tile.hexTile.vposition, tileList[0].hexTile.vposition);
//Debug.Log( "DIST:" + d );//x48, y27.71281
float scalar = .8660254f * d;
scalar = scalar / 55.425626f;
//Debug.Log( "SCALAR:" + scalar );//x48, y27.71281
//get normalized EDITOR vector to first tile in this group
Vector3 offset = tile.hexTile.vposition - tileList[0].hexTile.vposition;
//convert normalized EDITOR vector to 3D using distance tween hexes
Vector3 n = Vector3.Normalize(offset) * scalar;
//Debug.Log( "offset::" + goc.name + "::" + n );
//reflect to account for difference in coordinate systems quadrant (2D to 3D)
n = Vector3.Reflect(n, new Vector3(0, 0, 1));
//fix tile positions that don't have editor root hex at 0,1
Vector3 tilefix = Vector3.zero;
//convert the string to vector2
string[] s = tile.hexTile.hexRoot.Split(',');
Vector2 p = new Vector2(float.Parse(s[0]), float.Parse(s[1]));
if (p.y != 1)
{
tilefix = new Vector3(0, 0, -.4330127f * (p.y - 1f));
}
if (p.x != 0)
{
tilefix = new Vector3(p.x * .75f, 0, 0);
}
//set tile position using goc's position + reflected offset
tile.SetPosition(tileList[0].transform.parent.transform.position + n + tilefix, h.angle);
//Debug.Log( "ROOTPOS:" + tile.rootPosition.transform.position );
//Debug.Log( "ROOT::" + tileList[0].transform.parent.transform.position );
}
else
{
//fix tile positions that don't have editor root hex at 0,1
Vector3 tilefix = Vector3.zero;
//convert the string to vector2
string[] s = tile.hexTile.hexRoot.Split(',');
Vector2 p = new Vector2(float.Parse(s[0]), float.Parse(s[1]));
if (p.y != 1)
{
tilefix = new Vector3(0, 0, -.4330127f * (p.y - 1f));
}
if (p.x != 0)
{
tilefix = new Vector3(p.x * .75f, 0, 0);
}
tile.SetPosition(Vector3.zero, h.angle);
tile.transform.position += tilefix;
}
tileList.Add(tile);
//set parent of goc
tile.transform.parent.transform.parent = containerObject;
//add a token, if there is one
//if ( !c.usesRandomGroups )
if (tile.hexTile.tokenList.Count > 0)
{
usedPositions.AddRange(AddFixedToken(tile));
}
//find starting position if applicable
if (h.isStartTile)
{
tile.isExplored = true;
startPosition = tile.GetChildren("token attach")[0].position.Y(.26f);
}
}
//add random tokens
if (c.usesRandomGroups && usedPositions.Count > 0)
{
AddRandomTokens(usedPositions.ToArray());
}
GenerateGroupCenter();
}
private void Update()
{
SelectedTile = null;
if (Physics.Raycast(source.ViewportPointToRay(new Vector2(0.5F, 0.5F)), out RaycastHit hitInfo) && GameManager.Instance.Phase == GamePhase.BUILD)
{
if (hitInfo.collider.CompareTag("Tile") || hitInfo.collider.CompareTag("Tower"))
{
SelectedTile = hitInfo.collider.GetComponentInParent <HexTile>();
SelectedTile?.Ping();
}
}
if (hoveredTowerDisplay)
{
if (hitInfo.collider && hitInfo.collider.CompareTag("Tower"))
{
TowerBase t = hitInfo.collider.GetComponent <TowerBase>();
if (!t && hoveredTowerDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredTowerDisplay.transform.parent.gameObject.SetActive(false);
}
if (t)
{
if (!hoveredTowerDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredTowerDisplay.transform.parent.gameObject.SetActive(true);
}
hoveredTowerDisplay.Load(t);
hoveredTowerDisplay.transform.parent.position = hitInfo.point + hoverDisplayOffset;
hoveredTowerDisplay.transform.parent.forward = -hitInfo.normal;
}
}
else if (hoveredTowerDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredTowerDisplay.transform.parent.gameObject.SetActive(false);
}
}
if (hoveredEnemyDisplay)
{
if (hitInfo.collider && hitInfo.collider.CompareTag("Enemy"))
{
Enemy e = hitInfo.collider.GetComponent <Enemy>();
if (!e && hoveredEnemyDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredEnemyDisplay.transform.parent.gameObject.SetActive(false);
}
if (e)
{
if (!hoveredEnemyDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredEnemyDisplay.transform.parent.gameObject.SetActive(true);
}
hoveredEnemyDisplay.Load(e);
hoveredEnemyDisplay.transform.parent.position = hitInfo.point + hoverDisplayOffset;
hoveredEnemyDisplay.transform.parent.forward = -hitInfo.normal;
}
}
else if (hoveredEnemyDisplay.transform.parent.gameObject.activeInHierarchy)
{
hoveredEnemyDisplay.transform.parent.gameObject.SetActive(false);
}
}
}
public abstract bool CheckForEncounter(HexTile tile);
