We modified a previous scene which included 3D agents, with a different camera angle to make it more comparable with the video from the following site How do we walk together.
Trails after each agent was also added to make it easier to analyze.
Here is our video
Finaly we modified it even further by using theses agent in a kth setting.
Here we use formations together with RVO2 to create a potential crosswalk scene. Each group is assigned a random formation from a set of three and a random color. The goal for each group is to get to the oppisite side of the screen.
Here is a video of 10 agents changing formations. First we can see the magnificent creation of a horizontal row formation, then the group quickly changes into a stable vertical line formation and finally they end up in a triangle formation without colliding.
The movement of the agents are working and most of them seem to be moving towards the opposite side of the circle (as specified as the goal for the agent). However, the agents doesn't seem to be avoiding each other nor do they change direction during the simulation, which they should do at some point.
But the simulation does run at a reasonable fps, so the computations aren't too heavy on the CPU.
Today we have experimented with some group formations. We have implemented an abstract base class for making the agents align in a specific formation. To use this class one has to inherit it and implement the method CreateTemplate(). In this method there needs to be specified how the relative positions to the leader of the group are placed. Also, the nr of agents has to be stated in the inspector and which of the agents is the leader.
Here is a demo of a group formation for walking on a line:
Here is a demo of a group walking in a triangle formation:
In this scene we have made different approaches to making the agents avoid each other. First we tried using the UnitySteer script "Steer For Spherical Obstacles" on one of the agents. This script was not supposed to be used in that way, we found out. Then we tried with the script "Steer For Evasion". This script uses another agent as the reference to avoid. The disadvantage with that is that the agent can only avoid one other object for each script.
The hard part in the simulation was to find out which parameter to change in order to avoid collisions between the agents. We needed to find the radius parameter for which represented the agents "comfort zone". In the end we found this to be a combination of the "Safety Distance" and the vehicles radius. The result is shown in the video above. In the video above ther's a slight offset in the vertical axis between the two agents.
If there's no offset the agents will do the same movements for a while and then diverge from each other. This is something that can happen in the real world too, but maybe not this extreme.
Today we experimented with different types of collision avoidance for our agent. The following scene in these videos is composed of one agent and one obstacle. The agent will collide straight on the obstacle, without any angle of incidence. The agent's goal is to pass the obstacle and end up on the other side.
In this scene we used Unitysteer's biped ve script for our agent. By using this our agent got stuck and didn't make any progress.
Our nex step was to try Unitysteer's Autonomous Vehicle scrip with the same scene setup as above. When we tried this the agent managed to avoid the obstacle and steer around it.
This far in the project we have downloaded the UnitySteer package from GitHub (link found below). This package contains several implemented steering methods, for example following a path or avoiding obstacles.
Here is a video of an agent trying to follow a specific path while also trying to avoid the spherical obstacles:
Some problems with this implementation is that the agent sometimes breakes the physical laws and walks inside the obstacle. Also the steering is jagged which does not look realistic. When a human spots an obstacle it doesn't turn the opposite way like the agent seems to do. Instead it turns just enough to not intersect with the obstacle.
A more smooth implementation of obstacle avoidance is shown in a previous post.
Today we finally solved the problems we had with git.
The problems were that when we merged a clone of UnitySteer into our repository, pushed it and then pulled it on another computer it arised several compile errors in the scripts from UnitySteer. After several tries we managed to solve this problem.
We had a problem with the linking of the UnitySteer scripts in our agent prefab when pulling from git. The script components were still attatched to the agent but they were empty. This was due to some changes in the meta files in the UnitySteer package. When we renewed the UnitySteer package this problem was solved.
We also implemented obstacle avoidance by taking advantage of Unitys' built in RayTracing function, the method we used is described in this video, Obstacle Avoidance
Here is a demo on what we have achieved so far
The framerate drops randomly at certain times. This might be the case because our agent model is quite complex and the laptop we ran this on has a weak GPU. For our next iteration we plan on using 2D sprites while in the development stage, to not be limited by our GPU when using even more agents.
This week we have done some research by reading a few research papers, including state of the art algorithms for simulating group formations and dense groups using fluid dynamics. This has given us some insight to what we might achieve in our final product.
For the moment we need to do more research to be able to reach the level of the implementation above. We will first try to simulate one or a few agents walking a certain path in a static environment. Then we will try to implement the following Steering Algorithm. This our first step towards a group formation simulation.
For this we have set a deadline at next Wednesday (3/2-2016).