The tileset shown previously proved to have a few flaws and has been reworked slightly, but now initial functionality has been added towards implementing the required search algorithm.

Red gizmos represent those within a radius that have been highlighted to be searched, green gizmos represent those that can currently be ‘seen’ by the object. Currently this only represents the primary vision arc, and does not factor in obstacles (but that functionality has been implemented elsewhere).

Using the arc meshes for such detection proved troublesome/impossible as the project is actually in 3D rather than 2D. The work-around was:

// Get the normalised forward vector of the ‘entity’ object

Vector3 sight = forward.normalized;

// Get the normalised direction vector from the entity to this search node

Vector3 distanceVector = mSearchNodes[ i ].transform.position – center;
Vector3 direction = distanceVector.normalized;

// Dot product returns 1 (same direction), to 0 (90 degrees)
float cosine = Vector3.Dot( sight, direction );

// Use arc cos and convert from radians to degrees
float degrees = Mathf.Acos( cosine ) * Mathf.Rad2Deg;

The intended angles were about 40 degrees (primary) to 140 degrees (peripheral)  achieved if the returned value was less than half of either value.

An early version of the area system has also been implemented – checking if a search area is within the radius before doing the calculation above for each search node within. Currently this relies on collider checks (returning obstacles and walls as well), but does cut down on unnecessary checks.

This version of the test environment has been built using a set of tile prefabs – each containing its own search nodes and walls. At this time some manual adjustment of wall placement is still required (deleting many, otherwise moving on a 0.25f grid). Construction of levels should now be much faster, and now allows some automation!

The white spheres represent the grid search node structure (1.0f spacing). The walls have been adjusted to match this levels layout.

I was able to utilize the MavMesh (once baked) to automatically detect any SearchNodes that cannot be reached, and flag them as blocked (black).

The next step will implementing the required search functionality.

Before commencing further work into the implementation of a suitable method of searching the environment, I decided to build a prototype tileset. The outer loop is built out of many individual tiles – but the NavMesh correctly correctly joins them together (with a few small glitches).

If built in such a way, the tiles would be Unity Prefabs – most importantly containing the required node structure to allow for a grid search. Each ’tile’ or prefab would contain its own container of nodes, therefore allowing a general sweep of each tile before accessing the nodes within.

Current construction does not allow me to fill in the room in the middle correctly – scaling the square tile would be possible, but this would also scale any node structure later included within. I will be looking either to design the tileset a little more carefully, or include a wider range of rectangular sections to fill the gaps.