From e0f83a323ef264362f8084f6d5cd66fe70d671ab Mon Sep 17 00:00:00 2001
From: SlyVTT <pillot.sylvain@gmail.com>
Date: Mon, 29 May 2023 21:35:20 +0200
Subject: [PATCH] added island stuff to get non circular obstacles - collision
 is buggy right now (issue with normals ?) [WIP]

---
 src/main.cpp           |  55 ++++++++-
 src/pinball_entities.h |   1 +
 src/tables.h           | 259 ++++++++++++++++++++---------------------
 3 files changed, 182 insertions(+), 133 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 596a1de..2995066 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -72,6 +72,7 @@ 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();
 }
 
@@ -118,6 +119,38 @@ void HandleBallObstacleCollision( Ball *ball, Obstacle obstacle )
   MyPinball.score++;
 }
 
+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] );
+    
+    Vector2D dir;
+    dir.SubtractVectors( ball->pos, closest );
+    libnum::num32 d = dir.Length();
+    if ( d==libnum::num32(0) || d > (ball->radius + rad) ) return;
+
+    dir.Normalise();
+
+    libnum::num32 corr = ball->radius + rad - d;
+    ball->pos.Add(dir, corr);
+
+    /* Update velocity */
+
+    Vector2D radius = closest.Clone();
+    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 );
+  }
+}
+
+
 void HandleBallFlipperCollision( Ball *ball, Flipper flipper )
 {
   Vector2D closest = ClosestPointOnSegment( ball->pos, flipper.pos, flipper.getTip() );
@@ -253,6 +286,11 @@ static void update(float dt)
     
     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) );    
+    }
+
     for( int j=0; j<MyPinball.flippers.size(); j++ )    HandleBallFlipperCollision( &MyPinball.balls[i], MyPinball.flippers[j] );
 
     HandleBallBorderCollision( &MyPinball.balls[i], MyPinball.borders );
@@ -268,6 +306,13 @@ static void render(void) {
 
   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++ )
+  {
+    int temp = MyPinball.islands[i].size();
+    for( int j=0; j<MyPinball.islands[i].size(); 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.flippers.size(); i++ )
@@ -361,6 +406,12 @@ static void get_inputs(float dt) {
       MyKeyboard.IsKeyHoldPressed(MYKEY_F3)) {  
       SetupScene(1);
   }
+  if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F4)) {  
+      SetupScene(2);
+  }
+
+
 
 #if (DEBUG_MODE)
   if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
@@ -496,7 +547,9 @@ int main(void) {
 
 
     /* elapsedTime expressed in microseconds when coming from the libprof high accuracy time measurement */
-    elapsedTime = ((float)(time_update + time_render)) / 1000000.0f;
+    //elapsedTime = ((float)(time_update + time_render)) / 1000000.0f;
+
+    elapsedTime = ((float) 1.0f/60.0f);
 
   } while (exitToOS == false);
 
diff --git a/src/pinball_entities.h b/src/pinball_entities.h
index 7b4283b..72b884b 100644
--- a/src/pinball_entities.h
+++ b/src/pinball_entities.h
@@ -120,6 +120,7 @@ struct Scene
     std::vector<Vector2D> borders;
     std::vector<Ball> balls;
     std::vector<Obstacle> obstacles;
+    std::vector< std::vector<Vector2D> > islands;
     std::vector<Flipper> flippers;
 };
 
diff --git a/src/tables.h b/src/tables.h
index 553e340..d83b8f8 100644
--- a/src/tables.h
+++ b/src/tables.h
@@ -5,6 +5,7 @@
 #include "utilities.h"
 #include "vector2D.h"
 #include <num/num.h>
+#include <vector>
 
 extern Scene MyPinball;
 extern libnum::num32 flipperHeight;
@@ -21,8 +22,7 @@ void Setup_Table_0(void) {
   simHeight = libnum::num32(azrp_height) / cScale;
 
   MyPinball.score = 0;
-  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-3.0)));
-  MyPinball.pause = true;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
 
   MyPinball.borders.clear();
   MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
@@ -50,6 +50,8 @@ void Setup_Table_0(void) {
   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));
 
+  for(int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
+  MyPinball.islands.clear();
 
   MyPinball.flippers.clear();
   libnum::num32 flip_radius = libnum::num32(0.03);
@@ -65,11 +67,11 @@ void Setup_Table_0(void) {
   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_LEMONYELLOW));
 
-  Vector2D flip_pos3(libnum::num32(offset), libnum::num32(1.50));
-  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos3, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_LEMONYELLOW));
+//  Vector2D flip_pos3(libnum::num32(offset), libnum::num32(1.50));
+//  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos3, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_LEMONYELLOW));
 
-  Vector2D flip_pos4(libnum::num32(1.0)-offset, libnum::num32(1.25));
-  MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos4, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_LEMONYELLOW));
+//  Vector2D flip_pos4(libnum::num32(1.0)-offset, libnum::num32(1.25));
+//  MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos4, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_LEMONYELLOW));
 }
 
 
@@ -82,34 +84,138 @@ void Setup_Table_1(void) {
   simHeight = libnum::num32(azrp_height) / cScale;
 
   MyPinball.score = 0;
-  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-3.0)));
-  MyPinball.pause = true;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
+
 
   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)));
-  MyPinball.borders.push_back( Vector2D(libnum::num32(1.0) - offset, flipperHeight - offset));
-  MyPinball.borders.push_back( Vector2D(offset, flipperHeight - offset));
-  MyPinball.borders.push_back( Vector2D(offset, libnum::num32(0.4)));
+  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(offset)));
-  MyPinball.borders.push_back( Vector2D(libnum::num32(0.74), libnum::num32(offset)));
+  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.92), libnum::num32(0.5));
+  Vector2D ball_pos1(libnum::num32(0.60), libnum::num32(0.5));
   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.08), libnum::num32(0.5));
-  Vector2D ball_vel2(libnum::num32(0.2), libnum::num32(3.5));
+  Vector2D ball_pos2(libnum::num32(0.40), libnum::num32(0.5));
+  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.1, Vector2D(libnum::num32(0.25), libnum::num32(0.6)), 2.0, RGB565_DEEPPURPLE));
-  MyPinball.obstacles.push_back( Obstacle(0.1, Vector2D(libnum::num32(0.75), libnum::num32(0.5)), 2.0, RGB565_DEEPPURPLE));
-  MyPinball.obstacles.push_back( Obstacle(0.12, Vector2D(libnum::num32(0.7), libnum::num32(1.0)), 2.0, RGB565_DEEPPURPLE));
-  MyPinball.obstacles.push_back( Obstacle(0.1, Vector2D(libnum::num32(0.2), libnum::num32(1.2)), 2.0, RGB565_DEEPPURPLE));
+  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));
+
+  for(int i=0; i<MyPinball.islands.size(); i++ )    MyPinball.islands[i].clear();
+  MyPinball.islands.clear();
+
+  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_2(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.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.5));
+  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.5));
+  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));
+  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));
+
+
+  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.50)) );
+    island2.push_back( Vector2D(libnum::num32(0.40), libnum::num32(0.70)) );
+    island2.push_back( Vector2D(libnum::num32(0.50), libnum::num32(0.72)) );
+    island2.push_back( Vector2D(libnum::num32(0.60), libnum::num32(0.70)) );
+  MyPinball.islands.push_back( island2 );
 
 
   MyPinball.flippers.clear();
@@ -125,117 +231,6 @@ void Setup_Table_1(void) {
 
   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));
-
-  Vector2D flip_pos3(libnum::num32(offset), libnum::num32(1.50));
-  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos3, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE));
-
-  Vector2D flip_pos4(libnum::num32(1.0)-offset, libnum::num32(1.25));
-  MyPinball.flippers.push_back(Flipper( flip_radius, flip_pos4, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE));
 }
 
-/*void Setup_Table_1(void) {
-  flipperHeight = libnum::num32(2.0);
-  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(-0.80)));
-  MyPinball.pause = true;
-
-  MyPinball.borders.clear();
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.74), libnum::num32(0.25)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.995), libnum::num32(0.4)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.995), libnum::num32(1.4)));
-
-  libnum::num arcRadius = libnum::num32(0.5);
-
-  libnum::num32 arcStartAngle = libnum::num32(0);
-  libnum::num32 arcEndAngle = libnum::num32(numPI);
-  libnum::num32 arcSegments = libnum::num32(11);
-  libnum::num32 arcAngleStep = (arcEndAngle - arcStartAngle) / arcSegments;
-  for (int i = 1; i <= (int)arcSegments; i++) {
-    libnum::num32 angle = arcStartAngle + libnum::num32(i) * arcAngleStep;
-    MyPinball.borders.push_back(
-        Vector2D(libnum::num32(0.5) + arcRadius * COS(angle),
-                 libnum::num32(1.375) + arcRadius * SIN(angle)));
-  }
-
-  MyPinball.borders.push_back(Vector2D(libnum::num32(0), libnum::num32(0.4)));
-  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.05)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.74), libnum::num32(0.05)));
-
-  MyPinball.borders.clear();
-  libnum::num32 offset = libnum::num32(0.02);
-  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)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(1.0) - offset, flipperHeight - offset));
-  MyPinball.borders.push_back(Vector2D(offset, flipperHeight - offset));
-  MyPinball.borders.push_back(Vector2D(offset, libnum::num32(0.4)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.26), libnum::num32(0.25)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.26), libnum::num32(offset)));
-  MyPinball.borders.push_back(
-      Vector2D(libnum::num32(0.74), libnum::num32(offset)));
-
-  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.92), libnum::num32(0.5));
-  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));
-  Vector2D ball_pos2(libnum::num32(0.08), libnum::num32(0.5));
-  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));
-
-  MyPinball.obstacles.clear();
-  MyPinball.obstacles.push_back(
-      Obstacle(0.04, Vector2D(libnum::num32(0.10), libnum::num32(1.68)), 0.8));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.08, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.08, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.08, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.04, Vector2D(libnum::num32(0.13), libnum::num32(0.80)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.04, Vector2D(libnum::num32(0.87), libnum::num32(0.80)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.60)), 1.5));
-  MyPinball.obstacles.push_back(
-      Obstacle(0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.60)), 1.5));
-
-  MyPinball.flippers.clear();
-  libnum::num32 flip_radius = libnum::num32(0.035);
-  libnum::num32 flip_length = libnum::num32(0.175);
-  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));
-  Vector2D flip_pos2(libnum::num32(0.74), libnum::num32(0.22));
-  MyPinball.flippers.push_back(Flipper(flip_radius, flip_pos1, flip_length,
-                                       -flip_restAngle, flip_maxRotation,
-                                       flip_angularVelocity, flip_restitution, LEFT));
-  MyPinball.flippers.push_back(Flipper(
-      flip_radius, flip_pos2, flip_length, libnum::num32(PI) + flip_restAngle,
-      -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT));
-}*/
-
 #endif
\ No newline at end of file