public void Init()
{
GameObject go = Instantiate(Astar);
go.transform.parent = this.transform;
AStarGrid = go.GetComponent <AStarGrid>();
}
public void SetGrid(AStarGrid <PathNode> grid)
{
m_grid = grid;
m_grid.showDebug = true;
m_grid.ShowDebug();
m_grid.OnGridObjectChanged += Grid_OnGridValueChanged;
}
// set up the singleton and grid to be used for the generation
void Awake()
{
Instance = this;
nodeDiamater = NodeRadius * 2;
gridSizeX = Mathf.RoundToInt(GridWorldSize.x / nodeDiamater);
gridSizeY = Mathf.RoundToInt(GridWorldSize.y / nodeDiamater);
}
private void CreateHallways()
{
List <Rect> roomRects = GetRoomRects();
AStarGrid grid = new AStarGrid(roomRects, positionMeta);
debugData.Grid = grid.Grid;
HallwayMeshGenerator meshGenerator = new HallwayMeshGenerator(grid, hallwayTiling);
foreach (HallwayMeta hw in hallwayMeta)
{
HallwayAStar routing = new HallwayAStar(hw.StartDoor, hw.EndDoor, grid);
List <Square> path = routing.BuildPath();
debugData.AddPath(path);
AddLevelMetadataPath(path);
meshGenerator.AddPath(path);
}
Mesh mesh = meshGenerator.GenerateMesh(true);
GameObject hallways = new GameObject("Hallways");
hallways.isStatic = setIsStatic;
hallways.tag = "ChunkInstance";
hallways.layer = LayerMask.NameToLayer("LevelGeometry");
MeshFilter meshFilter = hallways.AddComponent <MeshFilter> ();
meshFilter.sharedMesh = mesh;
MeshRenderer meshRenderer = hallways.AddComponent <MeshRenderer> ();
meshRenderer.sharedMaterials = hallwayMaterials;
hallways.AddComponent <MeshCollider> ();
FillHallways(grid, hallways);
}
public PathFinding2D(int width, int height)
{
m_instance = this;
m_grid = new AStarGrid <PathNode>(width, height, 1f, Vector3.zero,
(AStarGrid <PathNode> grid, int x, int y) => new PathNode(grid, x, y));
m_grid.showDebug = true;
}
void SetupLevel()
{
bool laddarSpawned = false; // bool will control if a ladder has already been spawned
bool playerSpawned = false;
cellularAutomata = GameObject.Find("MeshGenerator").GetComponent <CellularAutomata>(); // finds the cellular automata script in the scene
aStarGrid = GameObject.Find("A*").GetComponent <AStarGrid>(); // finds the AStarGrid
for (int x = 0; x < cellularAutomata.gridWidth; x++) // loops through the grids x
{
for (int y = 0; y < cellularAutomata.gridHeight; y++) // loops through the grids y
{
if (x != 0 && x != cellularAutomata.grid.GetLength(0) - 2 && y != 0 && y != cellularAutomata.grid.GetLength(1) - 2) // if we are within the bounds the array
{
if (cellularAutomata.GetAmountOfNeighbours(x, y, 2) == 0 && aStarGrid.grid[x, y].walkable) // using the overloaded methoed of get neighbours to have a larger search area to stop things from spawning on walls and checks if the tile is walkable in the AStarGrid
{ //
if (GetRandomNumber() <= probabilityToSpawnEnemy) // generate a random number and if it is within probabilty
{
Instantiate(enemy, aStarGrid.grid[x, y].worldPosition, Quaternion.identity); // spawn an enemy
}
else if (!laddarSpawned)
{
laddarSpawned = Instantiate(ladder, aStarGrid.grid[x, y].worldPosition, Quaternion.identity); // if no spawn a ladder and set the ladderspawned varaible to true
}
else if (!playerSpawned && (x == (cellularAutomata.grid.GetLength(0) / 2) || y == (cellularAutomata.grid.GetLength(1) / 2)))
{
playerSpawned = Instantiate(player, aStarGrid.grid[x, y].worldPosition, Quaternion.identity);
}
}
}
}
}
}
// this finds the NEAREST NODES to the start and goal location
// this will likely need to be modified later to make a more robust node-finder that
// will not assign units 1-st node as a node on another height level (rounding error)
private AStarNode[] findNearestNodes(AStarGrid grid, Vector2 s, Vector2 g)
{
float nearestS = 9999f, nearestG = 9999f;
float sMag, gMag;
AStarNode startNode = new AStarNode(0, 0, 1);
AStarNode goalNode = new AStarNode(0, 0, 1);
foreach (AStarNode an in grid.nodes)
{
sMag = (s - new Vector2(an.x, an.y)).sqrMagnitude;
gMag = (g - new Vector2(an.x, an.y)).sqrMagnitude;
if (sMag < nearestS)
{
startNode = an;
nearestS = sMag;
}
if (gMag < nearestG)
{
goalNode = an;
nearestG = gMag;
}
}
return(new AStarNode[] { startNode, goalNode });
}
void AddAroundGrid(AStarGrid curgrid, AStarGrid endgrid)
{
for (int i = 0; i < aroundpos.GetLength(0); i++)
{
var x = curgrid.X + aroundpos[i, 0];
var y = curgrid.Y + aroundpos[i, 1];
if (IsInList(x, y, maps) && !IsInList(x, y, closelist) && !IsInList(x, y, barrierlist))
{
if (IsInList(x, y, openlist))
{
var grid = GetGridWithList(x, y, openlist);
grid.data.G = aroundpos[i, 2];
}
else
{
int gvalue = aroundpos[i, 2];
int hvalue = GetHValue(x, y, endgrid);
var grid = new AStarGrid(x, y, gvalue, hvalue);
if (CanMoveGrid(grid))
{
grid.parent = curgrid;
openlist.Add(grid);
}
}
}
}
}
public AStarGrid CreatStart(int x, int y)
{
AStarGrid grid = new AStarGrid(x, y, 0, 0);
openlist.Add(grid);
return(grid);
}
private PathNode m_previousPathNode; // Node came from
public PathNode(AStarGrid <PathNode> grid, int x, int y)
{
m_grid = grid;
m_x = x;
m_y = y;
isWalkable = true;
}
public AStarSearch(AStarGrid grid, Vector2 startLoc, Vector2 goalLoc)
{
vStart = startLoc;
vGoal = goalLoc;
aGrid = grid;
isDone = false;
}
int GetHValue(int x, int y, AStarGrid endgrid)
{
int xcount = Mathf.Abs(endgrid.X - x);
int ycount = Mathf.Abs(endgrid.Y - y);
int Hvalue = (xcount + ycount) * 10;
return(Hvalue);
}
// Start is called before the first frame update
#endregion
void Start()
{
vie = 3;
pathfinder = GameObject.Find("PathFindAstar").GetComponent <AStarPathfinding>();
anim = this.GetComponent <Animator>();
astargrid = GameObject.Find("GridAStar").GetComponent <AStarGrid>();
Player = GameObject.Find("Heros").transform;
startTime = Time.time;
}
/// <summary>
/// Called by unity.
/// </summary>
public void Start()
{
// This example assumes that there is a valid AStar grid component in the scene.
// The included TileManager script can be used in this case.
AStarGrid grid = AStarGridManager.DefaultGrid;
// Issue a pathfinding request
grid.findPath(new Index(0, 0), new Index(1, 1), onPathFound);
}
private IEnumerator searchForGrid()
{
while (grid == null)
{
grid = FindObjectOfType <AStarGrid>();
yield return(null);
}
StartCoroutine(mainLoop());
}
// Methods
public override void OnEnable()
{
grid = target as AStarGrid;
// Construct the UI elements
createUI();
base.OnEnable();
}
// CHANGE the discomfort field - initial functionality will focus on obstructors, like buildings
public void modifyDiscomfortField(int globalX, int globalY, float[,] gm)
{
// overwrite our Map_Data_Package
theCCDynamicFieldManager.theMapData.overwriteDiscomfortData(globalX, globalY, gm);
// since the absolute discomfort grid g denotes unpassable regions
// we now have to regenerate our AStarGrid
theAStarGrid = new AStarGrid(theCCDynamicFieldManager.theMapData.getCompleteHeightMap(),
theCCDynamicFieldManager.theMapData.getCompleteDiscomfortMap(), nodeDimensions);
}
private AStarGrid grid; //The grid used by the AStar algorithm, used to retrieve the segment positions
public HallwayHelper(AStarGrid grid, LevelGeneratorPreset preset, GameObject hallwayObject)
{
this.preset = preset;
this.chunkInstantiator = ChunkInstantiator.Instance;
//this.preset = preset;
this.grid = grid;
this.hallwayObject = hallwayObject;
this.hallwayTemplates = new List <HallwayTemplateMeta> ();
BuildMetadata();
}
public HallwayAStar(DoorDefinition start, DoorDefinition end, AStarGrid grid)
{
this.openList = new List <Square> ();
this.closedList = new List <Square> ();
this.finalPath = new List <Square> ();
this.startDoor = start;
Square.Grid = grid;
this.endDoor = end;
this.grid = grid;
}
public AStarSearch(AStarNode start, AStarNode end, AStarGrid grid, eHeuristicType heuristic = eHeuristicType.ManHattan)
{
mStartNode = start;
mEndNode = end;
mNodeGrid = grid;
mHeuristic = heuristic;
mOpenSet = new List <AStarNode>();
mClosedSet = new List <AStarNode>();
}
private MatchResult IsMatchingMaskAt(AStarGrid grid, GridPosition pos)
{
foreach (List <MaskSegment> rotatedMask in relativePositions)
{
if (IsMatchingMaskAt(grid, rotatedMask, pos))
{
return(new MatchResult(true, new int[] { pos.i, pos.j }, rotatedMask [0].RotatedBy));
}
}
return(new MatchResult(false, new int[] { 0, 0 }, 0));
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
AStarGrid navMesh = (AStarGrid)target;
if (GUILayout.Button("Bake navigation mesh"))
{
navMesh.Bake();
}
}
//Marks the positions of the mask relative to the given position in the grid
//This will hinder other masks from matching at this position, thus instantiating several hallways
//at the same position
public void MarkPositionAsUsed(AStarGrid grid, MatchResult match)
{
List <MaskSegment> _mask = FindMaskByRotation(match.Rotation);
foreach (MaskSegment relative in _mask)
{
int x = relative.Offset [0] + match.Position [0];
int y = relative.Offset [1] + match.Position [1];
grid.Grid [x, y].UsedByHallwayTemplate = true;
}
}
bool CanMoveGrid(AStarGrid grid)
{
if (grid.data.G == 14 && barrierlist.Count > 0)
{
var minbarrier = GetHMinBarrier(grid.X, grid.Y);
if ((minbarrier.X + 1 == grid.X || minbarrier.X - 1 == grid.X) || (minbarrier.Y + 1 == grid.Y || minbarrier.Y - 1 == grid.Y))
{
return(false);
}
}
return(true);
}
/// <summary>
/// 设置地图
/// </summary>
void InitMap()
{
maps.Clear();
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 6; j++)
{
var AStarGrid = new AStarGrid(i, j);
maps.Add(AStarGrid);
}
}
}
public static MaskState GetState(int x, int y, AStarGrid _grid)
{
if (_grid.Grid [x, y].IsPartOfPath)
{
return(MaskState.FILL);
}
else if (_grid.Grid [x, y].ShouldBeEmpty)
{
return(MaskState.EMPTY);
}
return(MaskState.UNUSED);
}
private void Awake()
{
if (g == null)
{
g = this;
}
nodeDiameter = nodeRadius * 2;
gridSize.x = Mathf.RoundToInt(gridDimensions.x / nodeDiameter);
gridSize.y = Mathf.RoundToInt(gridDimensions.y / nodeDiameter);
GenerateGrid();
}
void Start()
{
//Get the referende to the grid attached to the gridObject.
if (gridObject == null)
{
Debug.LogError("Pathfinding grid object not initialised!");
return;
}
grid = gridObject.GetComponent <AStarGrid> ();
previousTargetPosition = transform.position;
timeLeftUntilPathUpdate = 0;
timeKeeper = Time.time;
}
public void OnEnable()
{
grid = new AStarGrid(extends);
squares = new List <Square> ();
//Debug.Log ("onenable");
if (mapping == null)
{
Debug.Log("init mapping");
InitMapping();
}
InitGridFromMapping();
DrawGeometry();
}
private bool IsMatchingMaskAt(AStarGrid grid, List <MaskSegment> _mask, GridPosition pos)
{
foreach (MaskSegment segment in _mask)
{
int[] absolutePosition = new int[] { segment.Offset [0] + pos.i, segment.Offset [1] + pos.j };
GridPosition testPosition = grid.Grid [absolutePosition [0], absolutePosition [1]];
bool matchesSegment = IsMatchingSegment(segment.State, testPosition) && !testPosition.UsedByHallwayTemplate;
if (!matchesSegment)
{
return(false);
}
}
return(true);
}
void Awake() {
grid = GetComponent<AStarGrid>();
pathManager = GetComponent<PathManager>();
}
