Solving Dynamic Pathfinding Programming Assignments in Unity

• Environment: A large, rectangular building with benches along one side and dense shelving on the other.
• Assets: Free assets, but make robots and people visually distinct (cubes vs. cylinders).
• Agents: Robots use grid-based (Manhattan) movement; people move continuously. Both must avoid collisions.
• Behaviour: Robots and people choose destinations (shelves/benches), pause at destinations, then repeat.
• Randomization: Shelf lengths and occupant positions, behaviours occasionally deviate.
• Performance: Measure ratio of successful destination visits vs. abandoned attempts under varying populations.
• Deliverables: Unity source code, algorithm description, performance writeup.

Practical Tip: Highlight grading criteria. The rubric emphasizes correctness, readability, algorithm design, documentation, and performance. Your solution must excel in all of these, not just correct outputs!

2. Planning Your Solution

A. Modeling The Physical Environment

• Draw or mock up the building in Unity. Define the size, bench and shelf locations, row spacing, and the rules for randomization.
• Random shelf lengths: Use Unity’s Random.Range to vary shelf length each game run, making sure that the logic enforces navigable gaps but denies parallel passing.
• Camera control: Code WASD for horizontal motion and mouse-based rotation for isometric viewing. This makes debugging much easier later.

B. Choosing Agent Models

• Robots using a grid, discrete Manhattan movement.
• People using continuous, freeform movement.

Distinguish agents through both visual representation and collision properties. Use Unity’s physics colliders (e.g., BoxCollider) to enforce boundaries for both types.

3. Implementing Pathfinding Algorithms

A. Grid-Based Pathfinding (for Robots)

1. Grid Setup: Create a 2D array where each cell maps to a traversable position (except benches/shelves/obstacles). For each shelf and bench, mark occupied grid cells.
2. Movement Model: Implement Manhattan distance logic: only up/down/left/right moves allowed. Each robot picks a destination, plans with a pathfinding algorithm (A*, BFS, DFS—A* is recommended).
3. Collision Avoidance: Before moving into a cell, check if another robot/person is present. Use a shared grid “occupancy” array, updated every frame.
4. Deadlock Prevention: Set a timeout: if stuck for several seconds, pick a new destination or replan route. Introduce randomness to prevent permanent blockage.

Common Pitfalls: Failing to update grid cell occupancy in real-time can cause invisible overlaps. Forgetting to recalculate a robot’s path if its destination cell is newly occupied by another agent.

B. Continuous Pathfinding (for People)

• Navigation Mesh (NavMesh) is banned. Instead, implement your own waypoint-based A* or Dijkstra algorithm.
• Split open areas into waypoints connected by edges that don’t intersect obstacles.
• Randomly select a shelf or bench; plan a path avoiding collisions.
• Use raycasting or bounding-box checks to anticipate and avoid upcoming collisions.
• If blocked, pause, backtrack, or select another route. Introduce yield behaviour.

4. Coding Standards and Documentation

A. Code Structure and Readability

• Organize scripts by responsibilities.
• Use explicit variable names.
• Comment every non-trivial logic block.
• Maintain modular code.

B. Professional Documentation

• Include descriptive headers in each script.
• Provide a high-level README summarizing your project’s flow.
• Write a concise PDF explaining algorithm selection and deadlock prevention.

5. Experimental Analysis and Reporting

A. Experimenting With r and p (Robot and People Counts)

• Define several combinations (low/high r and p).
• Log attempts, successes, and abandoned routes for each run.
• Calculate success rate as successful/total.

B. Measuring and Reporting Variance

Run each configuration multiple times. Tabulate averages, deviations, and provide graphs.

C. Textual Analysis

Interpret results meaningfully. For example: “Increasing robots from 5 to 25 produced a noticeable drop in the success rate, as gridlocks became common in shelf rows.”

6. Common Challenges and Practical Strategies

• Seed random values for reproducibility.
• Test with both minimum and maximum values of r and p.
• Use gizmos to visualize grid occupancy.
• Print debug statements for every replanning.
• Avoid external pathfinding plugins.

7. Submitting and Presenting Your Solution

• Remove unnecessary assets before submission.
• Zip the entire Unity project.
• Prepare algorithm and performance documents with clear summaries and graphs.
• Test your project in a clean Unity install.

Conclusion

Assignments like COMP 521’s dynamic pathfinding task in Unity combine game design, algorithmic problem solving, and rigorous software engineering. By grounding your approach in the assignment’s particular constraints—while applying sound technical and experimental methods—you position yourself for top marks and skills transferrable to more advanced projects and real-world challenges.

Key takeaways: Break down requirements meticulously, tailor algorithms to agent behaviour, emphasize collision avoidance, experiment systematically, document clearly, and prepare professionally for submission.