private void HighlightPath(IEnumerable <IPathNode <HexNode> > path)
{
if (path == null)
{
return;
}
Dictionary <ITile, bool> tiles = new Dictionary <ITile, bool>();
IEnumerator <IPathNode <HexNode> > enumerator = path.GetEnumerator();
//enumerator.MoveNext(); // Skips first //
//tiles.Add(enumerator.Current.GetNode().Tile, true);
while (enumerator.MoveNext())
{
IPathNode <HexNode> node = enumerator.Current;
HexNode hexNode = node.GetNode();
ITile tile = hexNode.Tile;
if (tiles.ContainsKey(tile))
{
continue;
}
tiles.Add(tile, true);
Vector3 position = new Vector3(tile.PosX, tile.PosY + 0.05f, tile.PosZ);
Quaternion rotation = Quaternion.Euler(90, hexNode.Direction.DirectionRotation() - 90, 0);
GameObject highlight = Instantiate(pathArrowPrefab, position, rotation, transform);
highlightedPath.Add(highlight);
lastPathArrowRotation = rotation;
}
}
void Start()
{
node = GetComponent <HexNode>();
grid = GameObject.FindObjectsOfType <HexGrid>()[0];
Clickable c = GetComponent <Clickable>();
c.Click += (Clickable sender) =>
{
HexNode[,] nodes = this.grid.GetNodes();
for (int x = 0; x < nodes.GetLength(0); x++)
{
for (int y = 0; y < nodes.GetLength(1); y++)
{
nodes[x, y].ResetColor();
}
}
this.node.SetSelected();
List <HexNode> nodesInRange = this.grid.GetWithinRange(this.node.gridPosition.x, this.node.gridPosition.y, this.selectRange);
foreach (HexNode node in nodesInRange)
{
node.SetHighlighted();
}
};
}
public void CreateGrid()
{
Nodes = new HexNode[width, height];
worldNodes = new WorldNode[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
bool offset = false;
GameObject go = new GameObject("Node : " + x + ", " + y); //GameObject.CreatePrimitive(PrimitiveType.Sphere);
go.transform.parent = this.transform;
if (y % 2 == 1)
{
go.transform.position = new Vector3(x + radialOffest, y, 0);
offset = true;
}
else
{
go.transform.position = new Vector3(x, y, 0);
}
worldNodes[x, y] = go.AddComponent <WorldNode>();
HexNode newNode = new HexNode(x, y, offset);
Nodes[x, y] = newNode;
worldNodes[x, y].hexNode = newNode;
//Debug.Log("node " +x+ " ," +y+ " has this many neighbours --> " +newNode.GetNeighbours().Count);
}
}
}
private static IActor CreateActor(IMap map, HexNode startNode)
{
var playerMock = new Mock <IPlayer>();
var player = playerMock.Object;
var personMock = new Mock <IPerson>();
personMock.SetupGet(x => x.PhysicalSize).Returns(PhysicalSize.Size1);
var person = personMock.Object;
IGraphNode currentNode = startNode;
var actorMock = new Mock <IActor>();
actorMock.SetupGet(x => x.Node).Returns(() => currentNode);
actorMock.Setup(x => x.MoveToNode(It.IsAny <IGraphNode>()))
.Callback <IGraphNode>(node => currentNode = node);
// ReSharper disable once UnusedVariable
var actor = actorMock.Object;
// Исправить и убрать отключение инспекции для actor.
var actor2 = new Actor(person, player, startNode);
map.HoldNode(startNode, actor2);
return(actor2);
}
/// <summary>
/// Returns a List of all HexNodes that are within 'range' of the specified coordinate (except itself)
/// </summary>
/// <param name="xCoord"></param>
/// <param name="yCoord"></param>
/// <param name="range"></param>
/// <returns></returns>
public List <HexNode> GetWithinRange(int xCoord, int yCoord, int range)
{
List <HexNode> inRange = new List <HexNode>();
HexNode baseNode = GetNode(xCoord, yCoord);
if (baseNode == null)
{
return(null);
}
HexNode currentNode = null;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
if (Mathf.Abs(x + y) > range)
{
continue; // "cut out the corners"
}
if (x == 0 && y == 0)
{
continue; // skip basenode itself
}
currentNode = GetNode(xCoord + x, yCoord + y);
if (currentNode != null)
{
inRange.Add(currentNode);
}
}
}
return(inRange);
}
private void Update()
{
// Spawn a grid of prefabs!
if (Input.GetKeyDown(KeyCode.Space))
{
if (!this.spawned)
{
this.spawned = true;
SpawnNodes();
}
}
// Select [3,3] and highlight everything in 1 range!
if (Input.GetKeyDown(KeyCode.LeftAlt))
{
HexNode selectedNode = GetNode(3, 3);
selectedNode.SetSelected();
List <HexNode> adjacentNodes = GetWithinRange(3, 3, 2);
foreach (HexNode n in adjacentNodes)
{
n.SetHighlighted();
}
}
}
void Start () {
hx = new HexNode();
hx.initCoords(0,0);
hx.addHexNbrs();
HexNode[] hhh = new HexNode[hx.HexNbrs.Count];
hx.HexNbrs.Values.CopyTo(hhh,0);
foreach(HexNode h in hhh){
h.addHexNbrs();
}
foreach(HexNode h in NodeHolder.instance().HexList.Values){
GameObject go = GameObject.Instantiate(hex);
go.transform.position = h.coordTransform();
h.addSettNbrs();
/* Debug.Log ("Hex at " + h.coords.asString() + " with neighbours at " +
h.HexNbrs[0].coords.asString() + ", " +
h.HexNbrs[1].coords.asString() + ", " +
h.HexNbrs[2].coords.asString() + ", " +
h.HexNbrs[3].coords.asString() + ", " +
h.HexNbrs[4].coords.asString() + ", " +
h.HexNbrs[5].coords.asString() + ", ");*/
}
foreach(SettNode s in NodeHolder.instance().SettList.Values){
GameObject whamo = GameObject.Instantiate(sett);
whamo.transform.position = s.coordTransform();
}
}
private void CreateOneRoomNodes(ISectorMap map, HashSet <string> edgeHash, Room room, Size cellSize)
{
var interiorObjects = _randomSource.RollInteriorObjects(room.Width, room.Height);
for (var x = 0; x < room.Width; x++)
{
for (var y = 0; y < room.Height; y++)
{
var nodeX = x + room.PositionX * cellSize.Width;
var nodeY = y + room.PositionY * cellSize.Height;
var isObstacle = false;
var interiorObjectMetas = interiorObjects
.SingleOrDefault(o => o.Coords.CompsEqual(x, y));
if (interiorObjectMetas != null)
{
//TODO Сделать так, чтобы укрытия не генерировались на узлах с выходами
// Как вариант - если выбираем узел, как выход, то снимаем флаг укрытия.
// Вообще, нужно поискать алгоритмы, которые бы расставляли укрытия и выходы, оставляя комнату проходимой.
isObstacle = true;
}
var node = new HexNode(nodeX, nodeY, isObstacle);
room.Nodes.Add(node);
map.AddNode(node);
RoomHelper.AddAllNeighborToMap(map, edgeHash, room, node);
}
}
CreateTransitions(map, room);
}
void Start()
{
hx = new HexNode();
hx.initCoords(0, 0);
hx.addHexNbrs();
HexNode[] hhh = new HexNode[hx.HexNbrs.Count];
hx.HexNbrs.Values.CopyTo(hhh, 0);
foreach (HexNode h in hhh)
{
h.addHexNbrs();
}
foreach (HexNode h in NodeHolder.instance().HexList.Values)
{
GameObject go = GameObject.Instantiate(hex);
go.transform.position = h.coordTransform();
h.addSettNbrs();
/* Debug.Log ("Hex at " + h.coords.asString() + " with neighbours at " +
* h.HexNbrs[0].coords.asString() + ", " +
* h.HexNbrs[1].coords.asString() + ", " +
* h.HexNbrs[2].coords.asString() + ", " +
* h.HexNbrs[3].coords.asString() + ", " +
* h.HexNbrs[4].coords.asString() + ", " +
* h.HexNbrs[5].coords.asString() + ", ");*/
}
foreach (SettNode s in NodeHolder.instance().SettList.Values)
{
GameObject whamo = GameObject.Instantiate(sett);
whamo.transform.position = s.coordTransform();
}
}
public override void BeginState()
{
Agent.SetWalkAnimation(true);
_targetNode = Agent.WalkPath[0];
_targetRotation = Quaternion.LookRotation(_targetNode.Position - Agent.Position);
_rotationAccumulator = 0.0f;
}
/// <summary>
/// Проверяем, что к сундуку есть подход.
/// </summary>
private static void ValidatePassability(
HexNode currentContainerHex,
ISectorMap sectorMap,
IGraphNode[] allContainerNodes)
{
var neighborNodes = sectorMap.GetNext(currentContainerHex);
var hasFreeNeighbor = false;
foreach (var neighborNode in neighborNodes)
{
var neighborHex = (HexNode)neighborNode;
var isContainer = allContainerNodes.Contains(neighborHex);
if (!isContainer)
{
hasFreeNeighbor = true;
break;
}
}
if (!hasFreeNeighbor)
{
throw new SectorValidationException($"Контейнер {currentContainerHex} не имеет подступов.");
}
}
public override void Update()
{
if (!_finishedSelection)
{
HexNode playerNode = _player.GetCurrentNode();
HexNode enemyNode = Enemy.GetCurrentNode();
Manager.Pathfinder.Search(enemyNode, playerNode);
List <HexNode> path = Manager.Pathfinder.Path;
if (path != null)
{
SelectInteraction(path, playerNode);
}
else
{
Debug.Log("no valid path was found! for " + Enemy.name);
_finishedSelection = true;
}
}
else
{
Manager.ChangePhase(typeof(TurnPhaseEnemyAction));
}
}
public void Search(HexNode start, int expansionLimit)
{
_done = false;
start.Expansion = 0;
_frontier = new Queue <HexNode>();
_frontier.Enqueue(start);
_visited = new HashSet <HexNode>();
_visited.Add(start);
while (_frontier.Count > 0)
{
HexNode current = _frontier.Dequeue();
foreach (HexNode next in current.Neighbors)
{
if (!_visited.Contains(next))
{
next.Expansion = current.Expansion + 1;
if (next.Expansion < expansionLimit)
{
_frontier.Enqueue(next);
_visited.Add(next);
}
}
}
}
_done = true;
}
private void Start()
{
_manager = Manager.GetComponent <HexNodesManager>();
_node = _manager.ReturnClosestHexNode(transform.position);
transform.position = _node.Position;
_manager.RegisterRadationTile(this);
}
private void MouseClick(Ray mouseRay)
{
if (Input.GetMouseButtonDown(0))
{
Debug.Log(Player.CurrentNode.Index);
RaycastHit mouseClickHit;
if (Physics.Raycast(mouseRay, out mouseClickHit))
{
if (mouseClickHit.collider.CompareTag("selectionhex"))
{
var hex = mouseClickHit.transform.GetComponent <SelectionHexRenderer>();
if (hex != null)
{
HexNode hexNode = hex.GetUnderlyingNode();
Manager.Pathfinder.Search(Player.CurrentNode, hexNode);
Debug.Log(Manager.Pathfinder);
List <HexNode> path = Manager.Pathfinder.Path;
if (path != null)
{
SelectInteraction(path, hexNode);
}
}
}
}
}
}
public void SetNodesFromInfoContainer(HexCellInfoContainer[] infoContainers, bool cullBadConnections = false)
{
// Debug.Log(infoContainers);
HexNode[] nodes = new HexNode[infoContainers.Length];
for (int i = 0; i < infoContainers.Length; i++)
{
nodes[i] = new HexNode(infoContainers[i]);
}
for (int i = 0; i < nodes.Length; i++)
{
List <HexNode> nodeNeighbors = new List <HexNode>();
int[] nIndexes = infoContainers[i].NeighborIndexes;
foreach (var nIndex in nIndexes)
{
nodeNeighbors.Add(nodes[nIndex]);
}
nodes[i].Neighbors = nodeNeighbors.ToArray();
}
if (cullBadConnections)
{
_nodes = CullBadConnections(nodes);
}
else
{
_nodes = nodes;
}
}
/// <summary>
/// Преобразовывет черновые регионы в узлы реальной карты.
/// </summary>
private static void MapDraftRegionsToSectorMap(Matrix <bool> matrix, RegionDraft[] draftRegions, ISectorMap map)
{
var cellMap = matrix.Items;
var mapWidth = matrix.Width;
var mapHeight = matrix.Height;
var regionNodeCoords = draftRegions.SelectMany(x => x.Coords);
var hashSet = new HashSet <OffsetCoords>(regionNodeCoords);
for (var x = 0; x < mapWidth; x++)
{
for (var y = 0; y < mapHeight; y++)
{
if (cellMap[x, y])
{
var offsetCoord = new OffsetCoords(x, y);
if (!hashSet.Contains(offsetCoord))
{
var node = new HexNode(x, y);
map.AddNode(node);
}
}
}
}
}
private static Edge GetExistsEdge(IMap map, HexNode node, HexNode neighbor)
{
return((Edge)(from edge in map.Edges
where edge.Nodes.Contains(node)
where edge.Nodes.Contains(neighbor)
select edge).SingleOrDefault());
}
/// <summary>
/// Возвращает ребро, соединяющее указанные узлы.
/// </summary>
/// <param name="edgeHash"> Хеш ребер карты. </param>
/// <param name="node"> Искомый узел. </param>
/// <param name="neighbor"> Узел, с которым соединён искомый. </param>
/// <returns> Ребро или null, если такого ребра нет на карте. </returns>
public static bool IsExistsEdge(HashSet <string> edgeHash, HexNode node, HexNode neighbor)
{
if (edgeHash is null)
{
throw new System.ArgumentNullException(nameof(edgeHash));
}
if (node is null)
{
throw new System.ArgumentNullException(nameof(node));
}
if (neighbor is null)
{
throw new System.ArgumentNullException(nameof(neighbor));
}
var hashKey1 = $"{node}-{neighbor}";
if (edgeHash.Contains(hashKey1))
{
return(true);
}
var hashKey2 = $"{neighbor}-{node}";
return(edgeHash.Contains(hashKey2));
}
/// <summary>
/// Создаёт на карте ребро, соединяющее два узла этой карты.
/// </summary>
/// <param name="targetMap"> Целевая карта, для которой нужно создать ребро. </param>
/// <param name="edgeHash"> Хеш ребер карты. </param>
/// <param name="node"> Исходное ребро карты. </param>
/// <param name="neighbor"> Соседнее ребро карты, с которым будет соединено исходное. </param>
public static void AddEdgeToMap(IMap targetMap, HashSet <string> edgeHash, HexNode node, HexNode neighbor)
{
if (targetMap is null)
{
throw new System.ArgumentNullException(nameof(targetMap));
}
if (edgeHash is null)
{
throw new System.ArgumentNullException(nameof(edgeHash));
}
if (node is null)
{
throw new System.ArgumentNullException(nameof(node));
}
if (neighbor is null)
{
throw new System.ArgumentNullException(nameof(neighbor));
}
var hashKey1 = $"{node}-{neighbor}";
edgeHash.Add(hashKey1);
targetMap.AddEdge(node, neighbor);
}
/// <summary>
/// Adds a single hex to the character's mental map.
/// </summary>
/// <param name="hex">The hex to add.</param>
public void UpdateMap(Hex hex)
{
HexNode hexNode;
if (!map.ContainsKey(hex.position))
{
hexNode = new HexNode(hex);
map[hex.position] = hexNode;
}
else
{
hexNode = map[hex.position];
}
foreach (Hex neighbor in hex.neighbors)
{
if (!neighbor.walkable)
{
continue;
}
if (!map.ContainsKey(neighbor.position))
{
map[neighbor.position] = new HexNode(neighbor);
}
if (!hexNode.HasConnection(map[neighbor.position]))
{
hexNode.SetConnection(map[neighbor.position]);
}
}
}
public IStaticObject Create(ISector sector, HexNode node, int id)
{
if (sector is null)
{
throw new ArgumentNullException(nameof(sector));
}
var staticObject = new StaticObject(node, Purpose, id);
// Все залежи изначально имеют пустой модуль контейнера.
// Он будет заполняться по мере добычи.
var containerModule = new DepositContainer();
staticObject.AddModule(containerModule);
var dropScheme = _schemeService.GetScheme <IDropTableScheme>(_dropTableSchemeSid);
var depositModule = new PropDepositModule(containerModule, dropScheme, _dropResolver, _toolTags,
ExhausingValue, Difficulty);
staticObject.AddModule(depositModule);
var lifetimeModule = new DepositLifetimeModule(sector.StaticObjectManager, staticObject);
staticObject.AddModule(lifetimeModule);
var durabilityModule = new DepositDurabilityModule(depositModule, lifetimeModule, 10);
staticObject.AddModule(durabilityModule);
return(staticObject);
}
/// <summary>
/// Проверяем, что сундук не стоит на препятствии.
/// </summary>
private static void ValidateObstacleOverlap(HexNode hex)
{
if (hex.IsObstacle)
{
throw new SectorValidationException();
}
}
public void Setup()
{
int mapSize = 1000;
int baseX = 50;
int baseY = 50;
_radius = 5;
// ARRANGE
var map = new SectorHexMap(1000);
for (var i = 0; i < mapSize; i++)
{
for (var j = 0; j < mapSize; j++)
{
var hexNode = new HexNode(i, j);
map.AddNode(hexNode);
}
}
_fowData = new HumanSectorFowData();
_baseNode = map.HexNodes.Single(x => x.OffsetCoords.X == baseX && x.OffsetCoords.Y == baseY);
_fowContextMock = new TestFowContext(map);
}
private static void CreateNodes(IMap map,
int startX,
int startY,
int mapSize,
OptionsDelegate optionsDelegate)
{
var nodeIdCounter = 1;
for (var row = startY; row < startY + mapSize; row++)
{
for (var col = startX; col < startX + mapSize; col++)
{
HexNodeOptions options;
if (optionsDelegate != null)
{
options = optionsDelegate(col, row);
}
else
{
options = new HexNodeOptions
{
IsObstacle = false
};
}
var node = new HexNode(col, row, options.IsObstacle)
{
Id = nodeIdCounter++
};
map.AddNode(node);
}
}
}
/*
* Get all the nearby filtered neighbours
*/
public List <HexNode> GetConnectedNodes(NodeType filteredNodeType)
{
List <HexNode> nodes = new List <HexNode>();
int[] hitAngles = new int[6] {
30, 90, 150, 210, 270, 330
};
for (int i = 0; i < hitAngles.Length; i++)
{
Vector3 direction = Quaternion.Euler(0, 0, hitAngles[i]) * Vector3.right;
Ray ray = new Ray(this.transform.position, direction);
RaycastHit2D[] rayHit = Physics2D.RaycastAll(ray.origin, ray.direction, this.rayDistance);
for (int k = 0; k < rayHit.Length; k++)
{
if (rayHit[k].collider.gameObject.tag == "HexNode" && rayHit[k].collider.gameObject != this.gameObject)
{
HexNode hxNode = rayHit[k].collider.gameObject.GetComponent <HexNode>();
if (hxNode.nodeType == filteredNodeType)
{
nodes.Add(hxNode);
}
}
}
}
return(nodes);
}
private static void CreateOneRoomNodes(IMap map, HashSet <string> edgeHash, Room room)
{
for (var x = 0; x < room.Width; x++)
{
for (var y = 0; y < room.Height; y++)
{
var nodeX = x + room.PositionX * ROOM_CELL_SIZE;
var nodeY = y + room.PositionY * ROOM_CELL_SIZE;
var node = new HexNode(nodeX, nodeY);
room.Nodes.Add(node);
map.Nodes.Add(node);
var neighbors = HexNodeHelper.GetNeighbors(node, room.Nodes);
foreach (var neighbor in neighbors)
{
var isExists = IsExistsEdge(edgeHash, node, neighbor);
if (!isExists)
{
AddEdgeToMap(map, edgeHash, node, neighbor);
}
}
}
}
}
private void RecursiveRoute(HexNode node, List <HexNode> route)
{
route.Add(node);
if (node.fromAdd != null)
{
if (node.routeAddFlage == false)
{
node.routeAddFlage = true;
RecursiveRoute(node.fromAdd, route);
}
else
{
if (node.from != null)
{
RecursiveRoute(node.from, route);
}
}
}
else
{
if (node.from != null)
{
RecursiveRoute(node.from, route);
}
}
}
public static HexNode CreateCorridorNode(IMap map, HashSet <string> edgeHash, HexNode currentNode, int currentX, int currentY)
{
if (map is null)
{
throw new System.ArgumentNullException(nameof(map));
}
var node = map.Nodes.OfType <HexNode>()
.SingleOrDefault(x => x.OffsetCoords.X == currentX && x.OffsetCoords.Y == currentY);
if (node == null)
{
node = new HexNode(currentX, currentY);
map.AddNode(node);
}
var isExists = IsExistsEdge(edgeHash, node, currentNode);
if (!isExists)
{
AddEdgeToMap(map, edgeHash, currentNode, node);
}
return(node);
}
public void addHexNbr(int location)
{
int x = this.coords.x;
int y = this.coords.y;
if (location != 3 && location != 0)
{
if (location < 3)
{
x++;
}
else
{
x--;
}
}
if (location != 1 && location != 4)
{
if (location < 4 && location > 1)
{
y--;
}
else
{
y++;
}
}
HexNbrs[location] = new HexNode();
if (!HexNbrs[location].initCoords(x, y))
{
HexNbrs[location] = NodeHolder.instance().HexList[new Point(x, y)];
}
HexNbrs[location].HexNbrs[(location + 3) % 6] = this;
}
private void SetInteractionState(HexNode target)
{
Player.InteractionTarget = target;
if (target.HasEnemy)
{
Player.UpcomingInteractionState = typeof(PlayerStateInteractionEnemy);
}
else if (target.HasNPC)
{
Player.UpcomingInteractionState = typeof(PlayerStateInteractionNPC);
}
else if (target.HasBuilding)
{
Player.UpcomingInteractionState = typeof(PlayerStateInteractionBuilding);
}
else if (target.HasProp)
{
Player.UpcomingInteractionState = typeof(PlayerStateInteractionProp);
}
else
{
Player.InteractionTarget = null;
Debug.Log("Player got desynced somehow!");
}
Debug.Log("Selected next phase: " + Player.UpcomingInteractionState);
}
void CreateNode(int x, int z, int i)
{
Vector3 position;
position.x = (x + z * 0.5f - z / 2) * InnerRadius * 2f;
position.y = 0f;
position.z = z * outerRadius * 1.5f;
HexNode node = nodes [i] = new HexNode ();
node.Init (position, new Vector3(x,0,z));
}
void Triangulate(HexNode cell)
{
Vector3 center = cell.position;
for (int i = 0; i < 6; i++)
{
AddTriangle(
center,
center + cell.corners[i],
center + cell.corners[i+1]
);
}
}
//STATIC
//RAYCAST ON TILE LAYER AND RETURN THE TILE THAT WAS HIT, NULL IF NONE WAS HIT
public static bool TileRaycast(Vector3 origin, Vector3 direction, out HexNode tInfo, LayerMask layer)
{
RaycastHit hit;
if (Physics.Raycast(origin, direction, out hit, Mathf.Infinity, layer)) {
tInfo = hit.collider.gameObject.GetComponent<HexNode>();
return true;
}
tInfo = null;
return false;
}
public void addHexNbr(int location){
int x = this.coords.x;
int y = this.coords.y;
if(location!=3 && location!=0){
if(location<3){ x++;}
else{ x--;}
}
if(location!=1 && location!=4){
if(location<4 && location >1){ y--;}
else{ y++;}
}
HexNbrs[location] = new HexNode();
if(!HexNbrs[location].initCoords(x,y)){
HexNbrs[location] = NodeHolder.instance().HexList[new Point(x,y)];
}
HexNbrs[location].HexNbrs[(location+3)%6] = this;
}
public void Triangulate(HexNode[] cells)
{
GetComponent<MeshFilter>().mesh = hexMesh = new Mesh();
hexMesh.name = "Hex Mesh";
vertices = new List<Vector3>();
triangles = new List<int>();
hexMesh.Clear();
vertices.Clear();
triangles.Clear();
for (int i = 0; i < cells.Length; i++)
{
Triangulate(cells[i]);
}
hexMesh.vertices = vertices.ToArray();
hexMesh.triangles = triangles.ToArray();
hexMesh.RecalculateNormals();
}
/*
public Vector3 SetDesiredDirec(Vector3 position) {
//desiredDirec = direc.normalized;
desiredDirecEndpoint = position;
return desiredDirec;
}
*/
/// <summary>
/// Move the Agent in the directoin formed by the line from the star to the end. Returns true when Agent reaches end
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
protected bool MoveToLocation(HexNode start, HexNode end)
{
//transform.position = Vector3.MoveTowards(transform.position, end.transform.position, moveSpeed * Time.deltaTime);
Debug.DrawRay(transform.position, desiredDirec, JBirdEngine.MoreColors.orange);
//SetDesiredDirec(Vector3.Normalize(end.transform.position - transform.position));
transform.position = MoveToLocationMethod(transform.position,
desiredPoint,//HACK: start using _trueDirec
moveSpeed * Time.deltaTime);
//update current tile to the one the Agent is currently over
if (Vector3.Distance(transform.position, start.transform.position) > Vector3.Distance(transform.position, end.transform.position)) {
end.entityOnTile = BattleManager.singleton.selectedAgent;
start.entityOnTile = null;
currentTile = end;
}
if (transform.position == end.transform.position) {
//Debug.Log("at location");
tilesMoved++;
return true;
}
return false;
}
public void SetHoveredTile(HexNode tile)
{
if (!currentBattleState.canHoverGrid) {//we can't hover over a tile in this state, prevent it from happening
if (hoveredTile != null) {//clean up any hovered tile if we need to
hoveredTile.SetNormalMat();
hoveredTile = null;
}
return;
}
if (hoveredTile != tile) {//swap out the currently hovered tile
if (hoveredTile != null) {
hoveredTile.SetNormalMat();
}
hoveredTile = tile;//set parameters of hovered tile
hoveredTile.SetHoverMat();
}
}
public void ClearFrameInfo()
{
selectedTile = null;
targetTile = null;
selectedAgent = null;
selectedAction = null;
}
