Project: step 4.1
Waves

Disclaimer: the automatically generated English translation is provided only for convenience and it may contain wording flaws. The original French document must be taken as reference!

Goals: Model the waves emitted by lizards during their movements

Waves

We will adopt the following simplified model for the waves emitted by the lizard:

it will be circular waves (like for sound) with a constant speed v;
the radius of the wave at time t (after the start of wave propagation) will be given by the formula r(t) = v * t + r ₀ , where r ₀ is the initial radius of the wave;
the energy of the wave decreases exponentially with respect to the propagation distance. The energy at time t (after the start of wave propagation) will therefore be given by the formula E(t) = E0 * exp(-r(t)/µ) where µ is a constant characteristic of the wave and E0 its initial energy;
the intensity (of the wave) at a given point is defined as the energy per unit length of the wave front. Thus, the intensity after a time t is given by the formula:
```
  I(t) = E0 * exp(-r(t)/µ) / (2 * PI * r(t)) = E0 * exp(-t*v/µ) / (2 * PI * r(t))
```
(because energy is distributed uniformly on a circle with perimeter 2 * PI * r(t))
The wave can be fragmented if it hits solid obstacles during its propagation:

[Video: wave "breaking" on obstacles]

To draw wave fragments, it is convenient to store them in an attribute modeled as a set of arcs ; an arc being characterized by a start angle and an end angle. Initially, there would be only one arc in this set, going from -PI to PI . This arc could then be fragmented into several sub-arcs if the wave crosses an obstacle (which we will discuss a little later). The constant PI is provided in the file Utility/Constants.hpp .

You are now asked to code a class Wavecharacterized by:

the starting point of the wave (origin, a Vec2d);
the initial energy level and the initial radius of the wave (some doubles);
the constant µ , as described previously (a double );
the wave propagation speed (also a double);

Collision tests with the wave (for example to know if it crosses an obstacle) will have to be done during the simulation. A wave can therefore be seen as a Collider.
To be compatible with the provided test files, the attributes will be initialized by the constructor in the described order, using values passed as parameters.
You can code the Wave class in the Environment/ directory.
The predefined type pair (see here) can be used to model arcs (an arc being modeled by a pair of angles: the one that characterizes the beginning and the one that characterizes the end of the arc).

To draw the wave, you will need to draw the arcs that make it up. The buildArc method provided in Utility[.hpp][cpp] can be used. The line thickness can be proportional to the wave intensity according to a factor getAppConfig().wave_intensity_thickness_ratio .

For the sake of simplicity, the wave will neither be drawn nor simulated in a toroidal world (you can code it as a bonus if you wish).
For the moment, you will not worry about the possible presence of obstacles in the environment.

[Question Q4.1] What inheritance relationship seems relevant to establish when coding the Wave class?

[Question Q4.2] How do you account for the time elapsed since the beginning of the wave propagation to evolve its radius ? Answer these questions in your file file REPONSES and adapt your code accordingly.

Modification to the `Environment` class

You will consider that waves belong to the environment and add to the Environment class a method addWave(Wave*) .

A wave whose intensity is too weak (below getAppConfig().wave_intensity_threshold) must disappear from the environment.

[Question Q4.3] What changes do you need to make to the Environment to take into account the presence of waves and see them propagate and form? Answer this question in your file ANSWERS .

Test 23: wave propagation

The provided test WaveTest.cpp , which you can launch using the waveTest target, allows you to test wave propagation and graphical representation. This test is programmed so that a left mouse click creates a wave. The wave should then propagate according to the model shown in the following short video (restart it if necessary):

[Video: wave propagation]

Obstacles on the wave's path

It is now about simulating the fact that the wave can fragment on obstacles. The wave update must therefore also take into account the possibility of a collision with an obstacle. For simplicity, we will consider that all obstacles are Collider.

Define Rock as a subclass of Collider representing a solid obstacle (you are free to extend this design and code a hierarchy of solid obstacles from which Rock will be derived). A rock is a drawable object with an orientation (angle). Its constructor will take its position (a Vec2d ) as a parameter and will randomly draw its orientation between -PI and PI using the random function uniform (provided in Random/Random.[hpp/cpp] ). The radius of a Rock will be randomly drawn between getAppConfig().simulation_world_size/50 and 2*getAppConfig().simulation_world_size/50 , but will be at least 1 .

The texture rock.png can be used for drawing. You can enrich your configuration files accordingly (this texture was not included). If you do so, it is recommended that this addition be made in app.json (which is the default configuration file from this step), appPPS.json , appTest.json , reprod.json and in any other configuration files you may have created yourself. This way, these specific configuration files will remain consistent with the evolution of the code in this stage of the project.

Modify Environment to make it compatible with the newObstacle method of WaveTest (once uncommented).

[Question Q4.4] What other changes do you need to make to the Environment class after adding the newObstacle method?

Next, modify the update method of Wave so that it also includes collision detection with environmental obstacles. A collision is detected with an environmental obstacle if it collides with the wave or is inside it (as a Collider ). For simplicity, we will only consider obstacles whose position is within one of the arcs of the wave:

← the second obstacle does not fragment the wave into smaller arcs even if one of the arcs touches it slightly
(the center of the obstacle must be within an arc for it to have an effect on it)

To find if the obstacle is in one of the arcs, arc _i , of the wave, it is enough to test that the angle (obstacle_position - origin).angle() , is contained in arc _i (greater than or equal to the beginning of arc _i and less than or equal to its end). origin is the origin of the wave and obstacle_position the position of the obstacle.

You will fragment the arc by following the indications of the following diagram:

← the angle α that splits the blue arc into two red arcs
can be calculated using the formula 2 * std::atan2(r, R + r)
(the circle in the figure represents the obstacle).
R is the radius of the wave and r that of the obstacle.

Test 24: wave fragmentation

To test this part, you can again use WaveTest.cpp which you can launch using the command waveTest .

Uncomment beforehand in this test the newObstacle method as well as the right-click handling on the mouse.

Create multiple obstacles and waves, you should be able to observe the fragmentation of your waves according to the following example:

[Video: wave propagation with obstacles]

You can refine the model by preventing the emission of waves from an obstacle.

Wave-emitting lizards

A wave-emitting lizard (class WaveLizard ) is a Lizard that has the additional feature of emitting waves every 1.0/getAppConfig().wave_lizard_frequency seconds.

The emitted waves will of course be generated originating from the position of the lizard and added to the environment.

The other characteristics of the wave will be as follows:

initial energy: getAppConfig().wave_default_energy
initial radius: getAppConfig().wave_default_radius
µ : getAppConfig().wave_default_mu
speed: getAppConfig().wave_default_speed

You can code the WaveLizard class in a Animal/NeuronalScorpion/ directory.

Constructors

To be compatible with the provided test files, the WaveLizard will have constructors with signatures similar to those coded for Lizard .

You will ensure to carry out the remaining necessary initializations.

Test 25: wave-emitting lizard

You can now start using the main program corresponding to your entire project: FinalApplication.cpp. This program allows you to test the newly created lizard type.

The launch conditions of the test will be as follows:

start by launching the test using the application target;
then switch to "individual scale simulation" mode using the Tab key;
put the simulation in pause mode using the space bar;
create a WaveLizard using the W key;
restart the simulation again using the space bar

You should see a lizard moving randomly while emitting waves at a regular frequency, as shown in the following video:

[Video: wave-emitting lizards]

Back to the project statement (part 4) Next module (part 4.2)

Project: step 4.1 Waves