diff --git a/CMakeLists.txt b/CMakeLists.txt
index d1c0e0c..a8e4a72 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,6 +23,8 @@ set(ASSETS
 
 set(ASSETS_cg
   assets-cg/font.png
+  assets-cg/font_pinball.png
+  assets-cg/abyss.png
   # ...
 )
 
diff --git a/TODO.txt b/TODO.txt
index 8a092de..5a830a0 100644
--- a/TODO.txt
+++ b/TODO.txt
@@ -10,7 +10,13 @@ Add targets and enable bonus
 
 Add the possibilty to have connected tables using a kind on tunnel
 
-Add ball launcher with user controle initial velocity
+Add ball launcher with user control initial velocity
+
+Add "Board Importation" system with "scanf" feature
+
+[DONE] Create a "Pinball" font
+
+Create text effect like :
+- rolling texts
 
-Add Board Importation system with "scanf" feature
 
diff --git a/assets-cg/abyss.png b/assets-cg/abyss.png
new file mode 100644
index 0000000..e378366
Binary files /dev/null and b/assets-cg/abyss.png differ
diff --git a/assets-cg/example.png b/assets-cg/example.png
deleted file mode 100644
index 8826800..0000000
Binary files a/assets-cg/example.png and /dev/null differ
diff --git a/assets-cg/font_pinball.png b/assets-cg/font_pinball.png
new file mode 100644
index 0000000..a3ac2d9
Binary files /dev/null and b/assets-cg/font_pinball.png differ
diff --git a/assets-cg/fxconv-metadata.txt b/assets-cg/fxconv-metadata.txt
index 5e3f5a8..8dd4e20 100644
--- a/assets-cg/fxconv-metadata.txt
+++ b/assets-cg/fxconv-metadata.txt
@@ -1,3 +1,8 @@
+abyss.png:
+  type: bopti-image
+  name_regex: img_abyss
+  profile: p8
+
 *.png:
   type: bopti-image
   name_regex: (.*)\.png img_\1
diff --git a/assets-cg/icon-cg.xcf b/assets-cg/icon-cg.xcf
deleted file mode 100644
index 5b854f0..0000000
Binary files a/assets-cg/icon-cg.xcf and /dev/null differ
diff --git a/fxlink-image-2023.05.30-21h28-1.png b/fxlink-image-2023.05.30-21h28-1.png
new file mode 100644
index 0000000..5cfa1c6
Binary files /dev/null and b/fxlink-image-2023.05.30-21h28-1.png differ
diff --git a/src/main.cpp b/src/main.cpp
index 33e143e..7091829 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,3 +1,5 @@
+#include "gint/display-cg.h"
+#include "gint/display.h"
 #include "parameters.h"
 
 #include <azur/azur.h>
@@ -29,8 +31,8 @@
 
 #include <vector>
 
-#include <math.h>
 #include "tables.h"
+#include <math.h>
 
 bool screenshot = false;
 bool record = false;
@@ -62,30 +64,38 @@ libnum::num32 simWidth;
 libnum::num32 simHeight;
 
 /* return the scaled x component of a vector */
-uint16_t CX(Vector2D pos) { return (int) (pos.x * cScale); }
+uint16_t CX(Vector2D pos) { return (int)(pos.x * cScale) + 25; }
 
 /* return the scaled y component of a vector */
-uint16_t CY(Vector2D pos) { return (int) (libnum::num32(azrp_height) - pos.y * cScale); }
-
-/* create the pinball board */
-void SetupScene( int which_table ) {
-  
-  if (which_table==0) Setup_Table_0();
-  else if (which_table==1) Setup_Table_1();
-  else if (which_table==2) Setup_Table_2();
-  else Setup_Table_0();
+uint16_t CY(Vector2D pos) {
+  return (int)(libnum::num32(azrp_height) - pos.y * cScale);
 }
 
-void HandleBallBallCollision( Ball *ball1, Ball *ball2 )
-{
-  libnum::num32 restitution = MIN( ball1->restitution, ball2->restitution );
+/* create the pinball board */
+void SetupScene(int which_table) {
+
+  if (which_table == 0)
+    Setup_Table_0();
+  else if (which_table == 1)
+    Setup_Table_1();
+  else if (which_table == 2)
+    Setup_Table_2();
+  else if (which_table == 3)
+    Setup_Table_3();
+  else
+    Setup_Table_0();
+}
+
+void HandleBallBallCollision(Ball *ball1, Ball *ball2) {
+  libnum::num32 restitution = MIN(ball1->restitution, ball2->restitution);
   Vector2D dir = ball2->pos - ball1->pos;
   libnum::num32 d = dir.Length();
-  if ( d==libnum::num32(0) || d > (ball1->radius + ball2->radius) ) return;
+  if (d == libnum::num32(0) || d > (ball1->radius + ball2->radius))
+    return;
 
   dir.Normalise();
 
-  libnum::num32 corr = (ball1->radius + ball2->radius-d) / libnum::num32(2);
+  libnum::num32 corr = (ball1->radius + ball2->radius - d) / libnum::num32(2);
   ball1->pos.Add(dir, -corr);
   ball2->pos.Add(dir, corr);
 
@@ -95,42 +105,43 @@ void HandleBallBallCollision( Ball *ball1, Ball *ball2 )
   libnum::num32 m1 = ball1->mass;
   libnum::num32 m2 = ball2->mass;
 
-  libnum::num32 newV1 = (m1*v1 + m2*v2 - m2*(v1-v2)*restitution / (m1+m2) );
-  libnum::num32 newV2 = (m1*v1 + m2*v2 - m1*(v2-v1)*restitution / (m1+m2) );
+  libnum::num32 newV1 =
+      (m1 * v1 + m2 * v2 - m2 * (v1 - v2) * restitution / (m1 + m2));
+  libnum::num32 newV2 =
+      (m1 * v1 + m2 * v2 - m1 * (v2 - v1) * restitution / (m1 + m2));
 
-  ball1->vel.Add(dir, newV1-v1 );
-  ball2->vel.Add(dir, newV2-v2 );
+  ball1->vel.Add(dir, newV1 - v1);
+  ball2->vel.Add(dir, newV2 - v2);
 }
 
-void HandleBallObstacleCollision( Ball *ball, Obstacle obstacle )
-{
+void HandleBallObstacleCollision(Ball *ball, Obstacle obstacle) {
   Vector2D dir = ball->pos - obstacle.pos;
   libnum::num32 d = dir.Length();
-  if ( d==libnum::num32(0) || d > (ball->radius + obstacle.radius) ) return;
+  if (d == libnum::num32(0) || d > (ball->radius + obstacle.radius))
+    return;
 
   dir.Normalise();
 
-  libnum::num32 corr = ball->radius + obstacle.radius-d;
+  libnum::num32 corr = ball->radius + obstacle.radius - d;
   ball->pos.Add(dir, corr);
 
   libnum::num32 v = ball->vel.Dot(dir);
-  ball->vel.Add(dir, obstacle.pushVel-v );
-  
-  MyPinball.score++;
+  ball->vel.Add(dir, obstacle.pushVel - v);
+
+  MyPinball.score += obstacle.points;
 }
 
-void HandleBallIslandCollision( Ball *ball, std::vector<Vector2D> island, libnum::num32 rad )
-{
+void HandleBallIslandCollision(Ball *ball, std::vector<Vector2D> island,
+                               libnum::num32 rad) {
   int mod = island.size();
-  for(int i=0; i<mod; i++ )
-  {
-    Vector2D closest = ClosestPointOnSegment( ball->pos, island[i], island[(i+1)%mod] );
-    
+  for (int i = 0; i < mod; i++) {
+    Vector2D closest =
+        ClosestPointOnSegment(ball->pos, island[i], island[(i + 1) % mod]);
+
     Vector2D dir;
-    dir.SubtractVectors( ball->pos, closest );
+    dir.SubtractVectors(ball->pos, closest);
     libnum::num32 d = dir.Length();
-    if (!( d==libnum::num32(0) || d > (ball->radius + rad) )) 
-    {
+    if (!(d == libnum::num32(0) || d > (ball->radius + rad))) {
       dir.Normalise();
 
       libnum::num32 corr = ball->radius + rad - d;
@@ -139,52 +150,51 @@ void HandleBallIslandCollision( Ball *ball, std::vector<Vector2D> island, libnum
       /* Update velocity */
 
       Vector2D radius = closest.Clone();
-      radius.Add( dir, rad );
-      radius.Subtract( island[i], libnum::num32(1) );
-      
-      libnum::num32 v = ball->vel.Dot( dir );
+      radius.Add(dir, rad);
+      radius.Subtract(island[i], libnum::num32(1));
+
+      libnum::num32 v = ball->vel.Dot(dir);
       libnum::num32 newV = ABS(v) * ball->restitution;
-      ball->vel.Add( dir, newV - v );
+      ball->vel.Add(dir, newV - v);
     }
   }
 }
 
+void HandleBallFlipperCollision(Ball *ball, Flipper flipper) {
+  Vector2D closest =
+      ClosestPointOnSegment(ball->pos, flipper.pos, flipper.getTip());
 
-void HandleBallFlipperCollision( Ball *ball, Flipper flipper )
-{
-  Vector2D closest = ClosestPointOnSegment( ball->pos, flipper.pos, flipper.getTip() );
-  
   Vector2D dir;
-  dir.SubtractVectors( ball->pos, closest );
+  dir.SubtractVectors(ball->pos, closest);
   libnum::num32 d = dir.Length();
-  if ( d==libnum::num32(0) || d > (ball->radius + flipper.radius) ) return;
+  if (d == libnum::num32(0) || d > (ball->radius + flipper.radius))
+    return;
 
   dir.Normalise();
 
-  libnum::num32 corr = ball->radius + flipper.radius-d;
+  libnum::num32 corr = ball->radius + flipper.radius - d;
   ball->pos.Add(dir, corr);
 
   /* Update velocity */
 
   Vector2D radius = closest.Clone();
-  radius.Add( dir, flipper.radius );
-  radius.Subtract( flipper.pos, libnum::num32(1) );
-  
+  radius.Add(dir, flipper.radius);
+  radius.Subtract(flipper.pos, libnum::num32(1));
+
   Vector2D surfaceVel = radius.PerpCW();
-  surfaceVel.Scale( flipper.currentAngularVelocity ); 
+  surfaceVel.Scale(flipper.currentAngularVelocity);
 
-  libnum::num32 v = ball->vel.Dot( dir );
-  libnum::num32 newV = surfaceVel.Dot( dir );
+  libnum::num32 v = ball->vel.Dot(dir);
+  libnum::num32 newV = surfaceVel.Dot(dir);
 
-  ball->vel.Add( dir, newV - v );
+  ball->vel.Add(dir, newV - v);
 }
 
-
-void HandleBallBorderCollision( Ball *ball, std::vector<Vector2D> border )
-{
+void HandleBallBorderCollision(Ball *ball, std::vector<Vector2D> border) {
   int mod = border.size();
 
-  if (mod<3) return;
+  if (mod < 3)
+    return;
 
   /* Find closest segment */
 
@@ -192,18 +202,16 @@ void HandleBallBorderCollision( Ball *ball, std::vector<Vector2D> border )
 
   libnum::num32 minDist = libnum::num32(0);
 
-  for( int i=0; i<mod; i++)
-  {
+  for (int i = 0; i < mod; i++) {
     Vector2D a = border[i];
-    Vector2D b = border[(i+1) % mod];
-    Vector2D c = ClosestPointOnSegment( ball->pos, a, b );
+    Vector2D b = border[(i + 1) % mod];
+    Vector2D c = ClosestPointOnSegment(ball->pos, a, b);
     d.SubtractVectors(ball->pos, c);
     libnum::num32 dist = d.Length();
 
-    if (i==0 || dist <minDist)
-    {
+    if (i == 0 || dist < minDist) {
       minDist = dist;
-      closest.Set( c );
+      closest.Set(c);
       ab.SubtractVectors(b, a);
       normal = ab.PerpCW();
     }
@@ -211,34 +219,30 @@ void HandleBallBorderCollision( Ball *ball, std::vector<Vector2D> border )
 
   /* Push out */
 
-  d.SubtractVectors( ball->pos, closest );
+  d.SubtractVectors(ball->pos, closest);
   libnum::num32 dist = d.Length();
 
-  if (dist == libnum::num32(0))
-  {
-    d.Set( normal );
+  if (dist == libnum::num32(0)) {
+    d.Set(normal);
     dist = normal.Length();
   }
   d.Normalise();
 
-  if( d.Dot( normal ) >= libnum::num32(0) )
-  {
-    if ( dist > ball->radius ) return;
+  if (d.Dot(normal) >= libnum::num32(0)) {
+    if (dist > ball->radius)
+      return;
 
-    ball->pos.Add( d, ball->radius - dist );
-  }
-  else ball->pos.Add( d, -(ball->radius + dist) );
-  
+    ball->pos.Add(d, ball->radius - dist);
+  } else
+    ball->pos.Add(d, -(ball->radius + dist));
 
   /* Update velocity */
-  libnum::num32 v = ball->vel.Dot( d );
+  libnum::num32 v = ball->vel.Dot(d);
   libnum::num32 newV = ABS(v) * ball->restitution;
 
-  ball->vel.Add( d, newV - v );
+  ball->vel.Add(d, newV - v);
 }
 
-
-
 static void hook_prefrag(int id, void *fragment, int size) {
   if (!screenshot && !record)
     return;
@@ -270,29 +274,39 @@ static void hook_prefrag(int id, void *fragment, int size) {
   }
 }
 
-static void update(float dt)
-{
-  MyPinball.dt = libnum::num32( dt );
+static void update(float dt) {
+  MyPinball.dt = libnum::num32(dt);
 
+  for (int i = 0; i < MyPinball.flippers.size(); i++)
+    MyPinball.flippers[i].Simulate(MyPinball.dt);
 
-  for( int i=0; i<MyPinball.flippers.size(); i++ )   MyPinball.flippers[i].Simulate( MyPinball.dt );
+  for (int i = 0; i < MyPinball.balls.size(); i++) {
+    /* Update the position of the flippers */
+    MyPinball.balls[i].Simulate(MyPinball.dt, MyPinball.gravity);
 
-  for( int i=0; i<MyPinball.balls.size(); i++ )
-  {
-    MyPinball.balls[i].Simulate( MyPinball.dt, MyPinball.gravity );
-
-    for( int j=0; j<MyPinball.balls.size(); j++ )       HandleBallBallCollision( &MyPinball.balls[i], &MyPinball.balls[j] );
-    
-    for( int j=0; j<MyPinball.obstacles.size(); j++ )   HandleBallObstacleCollision( &MyPinball.balls[i], MyPinball.obstacles[j] );
-
-    for( int j=0; j<MyPinball.islands.size(); j++ )
-    {
-      HandleBallIslandCollision( &MyPinball.balls[i], MyPinball.islands[j], libnum::num(0.01) );    
+    /* Update the balls and check for collisions between balls (if more than two
+     * balls) */
+    if (MyPinball.balls.size() >= 2) {
+      for (int j = 0; j < MyPinball.balls.size(); j++)
+        HandleBallBallCollision(&MyPinball.balls[i], &MyPinball.balls[j]);
     }
 
-    for( int j=0; j<MyPinball.flippers.size(); j++ )    HandleBallFlipperCollision( &MyPinball.balls[i], MyPinball.flippers[j] );
+    /* Check for collision with bumpers (improve the score) */
+    for (int j = 0; j < MyPinball.obstacles.size(); j++)
+      HandleBallObstacleCollision(&MyPinball.balls[i], MyPinball.obstacles[j]);
 
-    HandleBallBorderCollision( &MyPinball.balls[i], MyPinball.borders );
+    /* Check for collision with islands (geometric forms to deviate the balls)*/
+    for (int j = 0; j < MyPinball.islands.size(); j++) {
+      HandleBallIslandCollision(&MyPinball.balls[i], MyPinball.islands[j],
+                                libnum::num(0.01));
+    }
+
+    /* Check for collision with flippers */
+    for (int j = 0; j < MyPinball.flippers.size(); j++)
+      HandleBallFlipperCollision(&MyPinball.balls[i], MyPinball.flippers[j]);
+
+    /* Check for collision with the pinball borders */
+    HandleBallBorderCollision(&MyPinball.balls[i], MyPinball.borders);
   }
 }
 
@@ -300,69 +314,88 @@ static void render(void) {
 
   azrp_clear(C_BLACK);
 
+  if (MyPinball.sideimage != nullptr)
+    azrp_image_p8(azrp_width - MyPinball.sideimage->width - 25, 5,
+                  MyPinball.sideimage, DIMAGE_NONE);
+
   int mod = MyPinball.borders.size();
-  for( int i=0; i<MyPinball.borders.size(); i++ )     azrp_line( CX(MyPinball.borders[i]), CY(MyPinball.borders[i]), CX(MyPinball.borders[(i+1) % mod]), CY(MyPinball.borders[(i+1) % mod]), C_WHITE );
+  for (int i = 0; i < MyPinball.borders.size(); i++)
+    azrp_line(CX(MyPinball.borders[i]), CY(MyPinball.borders[i]),
+              CX(MyPinball.borders[(i + 1) % mod]),
+              CY(MyPinball.borders[(i + 1) % mod]), C_WHITE);
 
-  for( int i=0; i<MyPinball.obstacles.size(); i++ )   azrp_filledcircle( CX(MyPinball.obstacles[i].pos), CY(MyPinball.obstacles[i].pos), (int) (MyPinball.obstacles[i].radius*cScale), MyPinball.obstacles[i].color );
+  for (int i = 0; i < MyPinball.obstacles.size(); i++)
+    azrp_filledcircle(CX(MyPinball.obstacles[i].pos),
+                      CY(MyPinball.obstacles[i].pos),
+                      (int)(MyPinball.obstacles[i].radius * cScale),
+                      MyPinball.obstacles[i].color);
 
-  for( int i=0; i<MyPinball.islands.size(); i++ )
-  {
+  for (int i = 0; i < MyPinball.islands.size(); i++) {
     int temp = MyPinball.islands[i].size();
-    for( int j=0; j<temp; j++ )     azrp_line( CX(MyPinball.islands[i][j]), CY(MyPinball.islands[i][j]), CX(MyPinball.islands[i][(j+1)%temp]), CY(MyPinball.islands[i][(j+1)%temp]), C_WHITE );
+    for (int j = 0; j < temp; j++)
+      azrp_line(CX(MyPinball.islands[i][j]), CY(MyPinball.islands[i][j]),
+                CX(MyPinball.islands[i][(j + 1) % temp]),
+                CY(MyPinball.islands[i][(j + 1) % temp]), C_WHITE);
   }
 
+  for (int i = 0; i < MyPinball.balls.size(); i++)
+    azrp_filledcircle(CX(MyPinball.balls[i].pos), CY(MyPinball.balls[i].pos),
+                      (int)(MyPinball.balls[i].radius * cScale),
+                      MyPinball.balls[i].color);
 
-  for( int i=0; i<MyPinball.balls.size(); i++ )       azrp_filledcircle( CX(MyPinball.balls[i].pos), CY(MyPinball.balls[i].pos), (int) (MyPinball.balls[i].radius*cScale), MyPinball.balls[i].color );
-
-  for( int i=0; i<MyPinball.flippers.size(); i++ )
-  {
+  for (int i = 0; i < MyPinball.flippers.size(); i++) {
     Vector2D start = MyPinball.flippers[i].pos;
-    Vector2D end   = MyPinball.flippers[i].getTip();
-    
+    Vector2D end = MyPinball.flippers[i].getTip();
+
     Vector2D SE;
-    SE.Set( end-start );
+    SE.Set(end - start);
     Vector2D Norm;
-    Norm.Set( SE.PerpCW() );
+    Norm.Set(SE.PerpCW());
     Norm.Normalise();
 
     Vector2D A = start.Clone();
-    A.Add( Norm, MyPinball.flippers[i].radius);
+    A.Add(Norm, MyPinball.flippers[i].radius);
 
     Vector2D B = end.Clone();
-    B.Add( Norm, MyPinball.flippers[i].radius);
+    B.Add(Norm, MyPinball.flippers[i].radius);
 
     Vector2D C = end.Clone();
-    C.Add( Norm, -MyPinball.flippers[i].radius);
+    C.Add(Norm, -MyPinball.flippers[i].radius);
 
     Vector2D D = start.Clone();
-    D.Add( Norm, -MyPinball.flippers[i].radius);
+    D.Add(Norm, -MyPinball.flippers[i].radius);
 
-    int Xpoly[4] = { CX(A), CX(B), CX(C), CX(D) };
-    int Ypoly[4] = { CY(A), CY(B), CY(C), CY(D) };
+    int Xpoly[4] = {CX(A), CX(B), CX(C), CX(D)};
+    int Ypoly[4] = {CY(A), CY(B), CY(C), CY(D)};
 
-    azrp_filledpoly(Xpoly, Ypoly, 4, MyPinball.flippers[i].color );
+    azrp_filledpoly(Xpoly, Ypoly, 4, MyPinball.flippers[i].color);
 
-    azrp_filledcircle( CX(start), CY(start), (int) (MyPinball.flippers[i].radius*cScale), MyPinball.flippers[i].color );
-    azrp_filledcircle( CX(end), CY(end), (int) (MyPinball.flippers[i].radius*cScale), MyPinball.flippers[i].color );
-    azrp_line(CX(start), CY(start), CX(end), CY(end), MyPinball.flippers[i].color );
+    azrp_filledcircle(CX(start), CY(start),
+                      (int)(MyPinball.flippers[i].radius * cScale),
+                      MyPinball.flippers[i].color);
+    azrp_filledcircle(CX(end), CY(end),
+                      (int)(MyPinball.flippers[i].radius * cScale),
+                      MyPinball.flippers[i].color);
+    azrp_line(CX(start), CY(start), CX(end), CY(end),
+              MyPinball.flippers[i].color);
   }
-  
 
-  azrp_draw_text(150, 0, "FPS  = %.0f - Mem Free = %d", (float)(1.0f / elapsedTime), _uram_stats->free_memory + extram_stats->free_memory);
+  azrp_draw_text(150, 0, "FPS  = %.0f - Mem Free = %d",
+                 (float)(1.0f / elapsedTime),
+                 _uram_stats->free_memory + extram_stats->free_memory);
 
-  azrp_draw_text(150, 20, "Score : %d", MyPinball.score );
+  azrp_draw_pinball(220, 200, RGB565_DEEPPURPLE, "Score:%d", MyPinball.score);
+  /*
+    azrp_draw_text(150, 40, "Ball1 : " );
+    azrp_draw_text(200, 40, "X = : %.2f", (float) MyPinball.balls[0].pos.x );
+    azrp_draw_text(200, 50, "Y = : %.2f", (float) MyPinball.balls[0].pos.y );
 
-  azrp_draw_text(150, 40, "Ball1 : " );
-  azrp_draw_text(200, 40, "X = : %.2f", (float) MyPinball.balls[0].pos.x );
-  azrp_draw_text(200, 50, "Y = : %.2f", (float) MyPinball.balls[0].pos.y );
-
-  azrp_draw_text(150, 70, "Ball2 : " );
-  azrp_draw_text(200, 70, "X = : %.2f", (float) MyPinball.balls[1].pos.x );
-  azrp_draw_text(200, 80, "Y = : %.2f", (float) MyPinball.balls[1].pos.y );
+    azrp_draw_text(150, 70, "Ball2 : " );
+    azrp_draw_text(200, 70, "X = : %.2f", (float) MyPinball.balls[1].pos.x );
+    azrp_draw_text(200, 80, "Y = : %.2f", (float) MyPinball.balls[1].pos.y );
+  */
 }
 
-
-
 static void get_inputs(float dt) {
 
   /* EXIT THE GAME */
@@ -373,44 +406,43 @@ static void get_inputs(float dt) {
 
   /* LEFT FLIPPER */
   if (MyKeyboard.IsKeyPressed(MYKEY_F1)) {
-      for(int i=0; i<MyPinball.flippers.size();i++)
-        if (MyPinball.flippers[i].side == LEFT)
-          MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
-  }
-  else {
-      for(int i=0; i<MyPinball.flippers.size();i++)
-        if (MyPinball.flippers[i].side == LEFT)
-          MyPinball.flippers[i].touchIdentifier = libnum::num32(-1);
+    for (int i = 0; i < MyPinball.flippers.size(); i++)
+      if (MyPinball.flippers[i].side == LEFT)
+        MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
+  } else {
+    for (int i = 0; i < MyPinball.flippers.size(); i++)
+      if (MyPinball.flippers[i].side == LEFT)
+        MyPinball.flippers[i].touchIdentifier = libnum::num32(-1);
   }
 
   /* RIGHT FLIPPER */
   if (MyKeyboard.IsKeyPressed(MYKEY_F6)) {
-      for(int i=0; i<MyPinball.flippers.size();i++)
-        if (MyPinball.flippers[i].side == RIGHT)
-          MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
+    for (int i = 0; i < MyPinball.flippers.size(); i++)
+      if (MyPinball.flippers[i].side == RIGHT)
+        MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
+  } else {
+    for (int i = 0; i < MyPinball.flippers.size(); i++)
+      if (MyPinball.flippers[i].side == RIGHT)
+        MyPinball.flippers[i].touchIdentifier = libnum::num32(-1);
   }
-  else {
-      for(int i=0; i<MyPinball.flippers.size();i++)
-        if (MyPinball.flippers[i].side == RIGHT)
-          MyPinball.flippers[i].touchIdentifier = libnum::num32(-1);
-  }
-
 
   /* RESET THE GAME */
-  if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
-      MyKeyboard.IsKeyHoldPressed(MYKEY_F2)) {  
-      SetupScene(0);
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F2)) {
+    SetupScene(0);
   }
-  if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
-      MyKeyboard.IsKeyHoldPressed(MYKEY_F3)) {  
-      SetupScene(1);
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F3)) {
+    SetupScene(1);
   }
-  if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
-      MyKeyboard.IsKeyHoldPressed(MYKEY_F4)) {  
-      SetupScene(2);
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F4)) {
+    SetupScene(2);
+  }
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F5)) {
+    SetupScene(3);
   }
-
-
 
 #if (DEBUG_MODE)
   if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
@@ -544,11 +576,11 @@ int main(void) {
     prof_leave(perf_render);
     time_render = prof_time(perf_render);
 
+    /* elapsedTime expressed in microseconds when coming from the libprof high
+     * accuracy time measurement */
+    // elapsedTime = ((float)(time_update + time_render)) / 1000000.0f;
 
-    /* elapsedTime expressed in microseconds when coming from the libprof high accuracy time measurement */
-    //elapsedTime = ((float)(time_update + time_render)) / 1000000.0f;
-
-    elapsedTime = ((float) 1.0f/60.0f);
+    elapsedTime = ((float)1.0f / 60.0f);
 
   } while (exitToOS == false);
 
diff --git a/src/pinball_entities.h b/src/pinball_entities.h
index 72b884b..7165ed2 100644
--- a/src/pinball_entities.h
+++ b/src/pinball_entities.h
@@ -1,6 +1,8 @@
 #ifndef PINBALL_ENTITIES_H
 #define PINBALL_ENTITIES_H
 
+#include "gint/defs/types.h"
+#include "gint/display-cg.h"
 #include "stdint-gcc.h"
 #include "utilities.h"
 #include "vector2D.h"
@@ -42,11 +44,12 @@ public:
 
 class Obstacle {
 public:
-  Obstacle(libnum::num32 radius, Vector2D pos, libnum::num32 pushVel, uint16_t color) {
+  Obstacle(libnum::num32 radius, Vector2D pos, libnum::num32 pushVel, uint16_t color, uint16_t points) {
     this->radius = radius;
     this->pos = pos.Clone();
     this->pushVel = pushVel;
     this->color = color;
+    this->points = points;
   }
 
   Obstacle() {}
@@ -54,6 +57,7 @@ public:
   libnum::num32 radius, pushVel;
   Vector2D pos;
   uint16_t color;
+  uint16_t points;
 };
 
 
@@ -111,6 +115,7 @@ public:
 };
 
 
+
 struct Scene
 {
     Vector2D gravity;
@@ -122,6 +127,7 @@ struct Scene
     std::vector<Obstacle> obstacles;
     std::vector< std::vector<Vector2D> > islands;
     std::vector<Flipper> flippers;
+    bopti_image_t *sideimage;
 };
 
 
diff --git a/src/tables.h b/src/tables.h
index d83b8f8..4ca1670 100644
--- a/src/tables.h
+++ b/src/tables.h
@@ -13,6 +13,10 @@ extern libnum::num32 cScale;
 extern libnum::num32 simWidth;
 extern libnum::num32 simHeight;
 
+extern bopti_image_t img_abyss;
+
+
+
 void Setup_Table_0(void) {
   libnum::num32 offset = libnum::num32(0.02);
 
@@ -24,6 +28,8 @@ void Setup_Table_0(void) {
   MyPinball.score = 0;
   MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
 
+  MyPinball.sideimage = nullptr;
+
   MyPinball.borders.clear();
   MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
   MyPinball.borders.push_back( Vector2D(libnum::num32(1.0) - offset, libnum::num32(0.4)));
@@ -45,10 +51,10 @@ void Setup_Table_0(void) {
   MyPinball.balls.push_back( Ball(ball_radius, ball_mass, ball_pos2, ball_vel2, 0.2, RGB565_BLOODYRED ));
 
   MyPinball.obstacles.clear();
-  MyPinball.obstacles.push_back( Obstacle(0.1, Vector2D(libnum::num32(0.25), libnum::num32(0.6)), 2.0, RGB565_OCEANBLUE));
-  MyPinball.obstacles.push_back( Obstacle(0.1, Vector2D(libnum::num32(0.75), libnum::num32(0.5)), 2.0, RGB565_OCEANBLUE));
-  MyPinball.obstacles.push_back( Obstacle(0.12, Vector2D(libnum::num32(0.7), libnum::num32(1.0)), 2.0, RGB565_OCEANBLUE));
-  MyPinball.obstacles.push_back( Obstacle(0.1, Vector2D(libnum::num32(0.2), libnum::num32(1.2)), 2.0, RGB565_OCEANBLUE));
+  MyPinball.obstacles.push_back( Obstacle(0.10, Vector2D(libnum::num32(0.25), libnum::num32(0.6)), 2.0, RGB565_OCEANBLUE, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.10, Vector2D(libnum::num32(0.75), libnum::num32(0.5)), 2.0, RGB565_OCEANBLUE, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.12, Vector2D(libnum::num32(0.70), libnum::num32(1.0)), 2.0, RGB565_OCEANBLUE, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.10, Vector2D(libnum::num32(0.20), libnum::num32(1.2)), 2.0, RGB565_OCEANBLUE, 25));
 
   for(int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
   MyPinball.islands.clear();
@@ -85,7 +91,8 @@ void Setup_Table_1(void) {
 
   MyPinball.score = 0;
   MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
-
+  
+  MyPinball.sideimage = nullptr;
 
   MyPinball.borders.clear();
   MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
@@ -119,14 +126,14 @@ void Setup_Table_1(void) {
 
 
   MyPinball.obstacles.clear();
-  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.13), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.87), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.60)), 1.5, RGB565_GREEN));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.60)), 1.5, RGB565_GREEN));
+  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.13), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.87), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
 
   for(int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
   MyPinball.islands.clear();
@@ -157,6 +164,7 @@ void Setup_Table_2(void) {
   MyPinball.score = 0;
   MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
 
+  MyPinball.sideimage = nullptr;
 
   MyPinball.borders.clear();
   MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
@@ -190,14 +198,14 @@ void Setup_Table_2(void) {
 
 
   MyPinball.obstacles.clear();
-  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.13), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.87), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.60)), 1.5, RGB565_GREEN));
-  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.60)), 1.5, RGB565_GREEN));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.13), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.87), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
 
 
   for(int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
@@ -233,4 +241,224 @@ void Setup_Table_2(void) {
   MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos2, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE));
 }
 
+void Setup_Table_3(void) {
+  libnum::num32 offset = libnum::num32(0.02);
+
+  flipperHeight = libnum::num32(1.7);
+  cScale = libnum::num32(azrp_height) / flipperHeight;
+  simWidth = libnum::num32(azrp_width) / cScale;
+  simHeight = libnum::num32(azrp_height) / cScale;
+
+  MyPinball.score = 0;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
+
+  MyPinball.sideimage = &img_abyss;
+
+  MyPinball.borders.clear();
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.98), libnum::num32(0.40)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.98), libnum::num32(1.20)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.96), libnum::num32(1.34)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.90), libnum::num32(1.46)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.81), libnum::num32(1.56)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.70), libnum::num32(1.64)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.57), libnum::num32(1.68)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.43), libnum::num32(1.68)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.30), libnum::num32(1.64)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.19), libnum::num32(1.56)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.10), libnum::num32(1.46)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.04), libnum::num32(1.34)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.02), libnum::num32(1.20))); 
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.02), libnum::num32(0.40)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.25)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.02)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.02)));
+
+
+  MyPinball.balls.clear();
+  libnum::num32 ball_radius = libnum::num32(0.03);
+  libnum::num32 ball_mass = libnum::num32(PI) * ball_radius * ball_radius;
+  Vector2D ball_pos1(libnum::num32(0.70), libnum::num32(0.70));
+  Vector2D ball_vel1(libnum::num32(0.2), libnum::num32(3.5));
+  MyPinball.balls.push_back( Ball(ball_radius, ball_mass, ball_pos1, ball_vel1, 0.2, RGB565_LEMONYELLOW)); 
+  Vector2D ball_pos2(libnum::num32(0.30), libnum::num32(0.70));
+  Vector2D ball_vel2(libnum::num32(-0.2), libnum::num32(3.5));
+  MyPinball.balls.push_back( Ball(ball_radius, ball_mass, ball_pos2, ball_vel2, 0.2, RGB565_LEMONYELLOW ));
+
+
+  MyPinball.obstacles.clear();
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.30), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.70), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+
+
+
+  for( int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
+  MyPinball.islands.clear();
+
+  std::vector<Vector2D> island1;
+    island1.push_back( Vector2D(libnum::num32(0.50), libnum::num32(1.10)) );
+    island1.push_back( Vector2D(libnum::num32(0.40), libnum::num32(1.20)) );
+    island1.push_back( Vector2D(libnum::num32(0.50), libnum::num32(1.30)) );
+    island1.push_back( Vector2D(libnum::num32(0.60), libnum::num32(1.20)) );
+  MyPinball.islands.push_back( island1 );
+
+  std::vector<Vector2D> island2;
+    island2.push_back( Vector2D(libnum::num32(0.50), libnum::num32(0.60)) );
+    island2.push_back( Vector2D(libnum::num32(0.40), libnum::num32(0.80)) );
+    island2.push_back( Vector2D(libnum::num32(0.50), libnum::num32(0.82)) );
+    island2.push_back( Vector2D(libnum::num32(0.60), libnum::num32(0.80)) );
+  MyPinball.islands.push_back( island2 );
+
+
+  std::vector<Vector2D> island3;
+    island3.push_back( Vector2D(libnum::num32(0.12), libnum::num32(0.45)) );
+    island3.push_back( Vector2D(libnum::num32(0.12), libnum::num32(0.65)) );
+    island3.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.37)) );
+  MyPinball.islands.push_back( island3 );
+
+  std::vector<Vector2D> island4;
+    island4.push_back( Vector2D(libnum::num32(0.88), libnum::num32(0.65)) );
+    island4.push_back( Vector2D(libnum::num32(0.88), libnum::num32(0.45)) );
+    island4.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.37)) );
+  MyPinball.islands.push_back( island4 );
+
+
+  MyPinball.flippers.clear();
+  libnum::num32 flip_radius = libnum::num32(0.03);
+  libnum::num32 flip_length = libnum::num32(0.2);
+  libnum::num32 flip_maxRotation = libnum::num32(1.0);
+  libnum::num32 flip_restAngle = libnum::num32(0.5);
+  libnum::num32 flip_angularVelocity = libnum::num32(10.0);
+  libnum::num32 flip_restitution = libnum::num32(0.0);
+
+  Vector2D flip_pos1(libnum::num32(0.26), libnum::num32(0.22));
+  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos1, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE));
+
+  Vector2D flip_pos2(libnum::num32(0.74), libnum::num32(0.22));
+  MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos2, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE));
+}
+
+
+void Setup_Table_4(void) {
+  libnum::num32 offset = libnum::num32(0.02);
+
+  flipperHeight = libnum::num32(1.7);
+  cScale = libnum::num32(azrp_height) / flipperHeight;
+  simWidth = libnum::num32(azrp_width) / cScale;
+  simHeight = libnum::num32(azrp_height) / cScale;
+
+  MyPinball.score = 0;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
+
+  MyPinball.sideimage = &img_abyss;
+
+  MyPinball.borders.clear();
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.98), libnum::num32(0.40)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.98), libnum::num32(1.20)));
+
+//  MyPinball.borders.push_back( Vector2D(libnum::num32(0.96), libnum::num32(1.34)));
+
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.99), libnum::num32(1.20)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.99), libnum::num32(0.10)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(1.10), libnum::num32(0.10)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(1.10), libnum::num32(1.20)));
+
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.90), libnum::num32(1.46)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.81), libnum::num32(1.56)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.70), libnum::num32(1.64)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.57), libnum::num32(1.68)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.43), libnum::num32(1.68)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.30), libnum::num32(1.64)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.19), libnum::num32(1.56)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.10), libnum::num32(1.46)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.04), libnum::num32(1.34)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.02), libnum::num32(1.20))); 
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.02), libnum::num32(0.40)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.25)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.02)));
+  MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.02)));
+
+  MyPinball.balls.clear();
+  libnum::num32 ball_radius = libnum::num32(0.03);
+  libnum::num32 ball_mass = libnum::num32(PI) * ball_radius * ball_radius;
+//  Vector2D ball_pos1(libnum::num32(0.70), libnum::num32(0.70));
+//  Vector2D ball_vel1(libnum::num32(0.2), libnum::num32(3.5));
+
+  Vector2D ball_pos1(libnum::num32(1.05), libnum::num32(0.15));
+  Vector2D ball_vel1(libnum::num32(0.0), libnum::num32(3.5));
+
+  MyPinball.balls.push_back( Ball(ball_radius, ball_mass, ball_pos1, ball_vel1, 0.2, RGB565_LEMONYELLOW));
+  
+  Vector2D ball_pos2(libnum::num32(0.30), libnum::num32(0.70));
+  Vector2D ball_vel2(libnum::num32(-0.2), libnum::num32(3.5));
+  MyPinball.balls.push_back( Ball(ball_radius, ball_mass, ball_pos2, ball_vel2, 0.2, RGB565_LEMONYELLOW ));
+
+
+  MyPinball.obstacles.clear();
+  MyPinball.obstacles.reserve( 16 );
+
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.06, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.30), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+  MyPinball.obstacles.push_back( Obstacle(0.04, Vector2D(libnum::num32(0.70), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10));
+
+
+
+  for( int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
+  MyPinball.islands.clear();
+
+  std::vector<Vector2D> island1;
+    island1.push_back( Vector2D(libnum::num32(0.50), libnum::num32(1.10)) );
+    island1.push_back( Vector2D(libnum::num32(0.40), libnum::num32(1.20)) );
+    island1.push_back( Vector2D(libnum::num32(0.50), libnum::num32(1.30)) );
+    island1.push_back( Vector2D(libnum::num32(0.60), libnum::num32(1.20)) );
+  MyPinball.islands.push_back( island1 );
+
+  std::vector<Vector2D> island2;
+    island2.push_back( Vector2D(libnum::num32(0.50), libnum::num32(0.60)) );
+    island2.push_back( Vector2D(libnum::num32(0.40), libnum::num32(0.80)) );
+    island2.push_back( Vector2D(libnum::num32(0.50), libnum::num32(0.82)) );
+    island2.push_back( Vector2D(libnum::num32(0.60), libnum::num32(0.80)) );
+  MyPinball.islands.push_back( island2 );
+
+
+  std::vector<Vector2D> island3;
+    island3.push_back( Vector2D(libnum::num32(0.12), libnum::num32(0.45)) );
+    island3.push_back( Vector2D(libnum::num32(0.12), libnum::num32(0.65)) );
+    island3.push_back( Vector2D(libnum::num32(0.26), libnum::num32(0.37)) );
+  MyPinball.islands.push_back( island3 );
+
+  std::vector<Vector2D> island4;
+    island4.push_back( Vector2D(libnum::num32(0.88), libnum::num32(0.65)) );
+    island4.push_back( Vector2D(libnum::num32(0.88), libnum::num32(0.45)) );
+    island4.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.37)) );
+  MyPinball.islands.push_back( island4 );
+
+
+  MyPinball.flippers.clear();
+  libnum::num32 flip_radius = libnum::num32(0.03);
+  libnum::num32 flip_length = libnum::num32(0.2);
+  libnum::num32 flip_maxRotation = libnum::num32(1.0);
+  libnum::num32 flip_restAngle = libnum::num32(0.5);
+  libnum::num32 flip_angularVelocity = libnum::num32(10.0);
+  libnum::num32 flip_restitution = libnum::num32(0.0);
+
+  Vector2D flip_pos1(libnum::num32(0.26), libnum::num32(0.22));
+  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos1, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE));
+
+  Vector2D flip_pos2(libnum::num32(0.74), libnum::num32(0.22));
+  MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos2, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE));
+}
+
 #endif
\ No newline at end of file
diff --git a/src/utilities.h b/src/utilities.h
index e5bed39..4a2ed55 100644
--- a/src/utilities.h
+++ b/src/utilities.h
@@ -25,6 +25,26 @@ void azrp_draw_text(int x, int y, char const *fmt, ...)
     }
 }
 
+void azrp_draw_pinball(int x, int y, uint16_t color, char const *fmt, ...)
+{
+    char str[128];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(str, 128, fmt, args);
+    va_end(args);
+
+    extern bopti_image_t img_font_pinball;
+
+    for(int i = 0; str[i]; i++) {
+        if(str[i] < 32 || str[i] >= 0x7f) continue;
+
+        int row = (str[i] - 32) >> 4;
+        int col = (str[i] - 32) & 15;
+        azrp_subimage_p8_dye(x + 11 * i, y, &img_font_pinball, 14 * col + 1, 20 * row + 2, 11, 14, IMAGE_DYE, color);
+    }
+}
+
+
 libnum::num32 COS( libnum::num32 angle )
 {