The Arkanoid scene shows you a physically accurate version of the famous Pong game. The goal is to bounce the ball around and hit as many bricks as possible: the Bat can be controlled by moving the mouse left/right.
The Bat is the Entity that the player controls to hit the ball. Relevant components:
Physics Shape, to make the Bat collide with the ball and bounce it back.
By examining the
Physics Shapeproperties we can see that bot the Material and the Collision properties are set.
The Bouncy Material (
Physics Materials/Bouncy.physics_material) has a Restitution Coefficient of 1. This is what makes the ball "bounce".
The Bat Collision (
Physics Materials/Bat.physics_collision) specifies the fact that shapes with this collision should only collide with entities that Have the
Default Collision type. (Which can itself be found in the
Physics Materials folder).
As you can imagine then, the Ball will have the Default collision set on its Shape.
Physics Body, to make the Bat movement around the world Physically accurate.
Physics Bodyproperties, we notice that the
Kinematiccheckbox is flagged: this means that the position of the Bat Entity won't be driven by the Physics simulation itself, but that it will be driven by the position that is present in the transform component instead. In this case we'll alter the transform component position via the
Entity Graphof the Bat: then the position of the
transform componentwill be reflected automatically in the Physics simulation.
Entity Graph, which is used to:
a) move the Bat via the mouse
b) Push the ball in the opposite direction when the bat and the ball collides.
You may be wondering why it's not enough to just push the ball in the correct direction to make it bounce, and we have to set the restitution coefficient to 1 in addition to doing so. The answer is that if we leave the restitution coefficient to 0, the ball will loose all of its "energy" when it collides with the Bat, thus even if we later on push it in the correct direction it will still move very slowly.
The walls in the scene are just static Entities with a
Physic Shape component and a scaled Box child Entity.
They're practially very similar to the Bat entity, just that they don't have:
Physics bodycomponent (we don't want walls to be able to move around).
Entity Graphcomponent, as we don't need any logic applied to them: walls are just static entities.
The "standard" brick (the one without a fancy blue ball on it) Is nothing more than a static Shape like walls are, with a small addition: we want bricks to be destroyed when they collide with the ball.
To accomplish that, they:
- Have the
Notify Touchcollision type, so that collisions with the ball are notified.
- Have an
Entity Graphcomponent that implements this very simple logic: they register the
Physx on contact eventand, once that triggers, they just delete themselves from the game by calling
This special kind of brick works exactly like a standard brick, but with a simple addition: its
Entity Graph is made so that when hit it will spawn an additional ball spawn in the game.
To see how it works, lets dive into his Entity Graph component, which is pretty similar to the standard brick's one.
In there we can see that, just after self-destroying itself, it will execute the
Spawn a new Ball subgraph, which will simply spawn a new ball and push it.
Notice how we're using a
vec3variable to store the position at which we want to spawn the additional ball in the
Save Position for New Ballsubgraph.
The Lost ball trigger is the Entity responsible for re-spawning the ball when it goes out of bounds.
The way it works is by having a
Physic Shape (you can see it in yellow by clicking on it in the Entity Tree) With the
Notify Touch Collision type and with the
is_trigger checkbox flagged:
Physics Shapes flagged with the
is_triggercheckbox will still exists in the Physical world, but when a collision with them happen the collision will be notified but the objects will be allowed to "interpenetrate" with each other.
This means that it won't collide with the Ball (which has the Default collision, remember), and once the collision happens the
Physx On Trigger event will be triggered: (We can find it in the Entity Graph)
Here we can see that once it's triggered, this event will:
- destroy the ball (Which is the Touched entity, notice the difference between this trigger and the one in the Brick's graph: there we are deleting the brick itself)
- call the
Lost Ballevent on the parent entity (the parent entity is found via the Entity From Path Node specifying
..as the path, which in this case is the Arkanoid Entity itself).
In addition to containing all the other entities as children, the Arkanoid entity also has the Entity Graph component that is used for Spawning a ball when the game starts (or when the ball goes out of bounds).
You can see that the Spawn Ball event is called both at the beginning of the Game (When the Init event will be called) but also when a
Lost ball event is triggered.
This concludes the tour of the Arkanoid scene, try to experiment it a bit and don't be scared of breaking stuff, you can always re-download the sample if you screw things up.