Merge branch 'dev'

CMakeLists.txt

@@ -14,11 +14,11 @@ find_package(LibProf 2.4 REQUIRED)
 
 set(SOURCES
   src/main.cpp
-  src/circle.cpp
-  src/poly.cpp
-  src/filledcircle.cpp
-  src/filledpoly.cpp
-  src/line.cpp
+  src/Shaders/circle.cpp
+  src/Shaders/poly.cpp
+  src/Shaders/filledcircle.cpp
+  src/Shaders/filledpoly.cpp
+  src/Shaders/line.cpp
   # ...
 )
 # Shared assets, fx-9860G-only assets and fx-CG-50-only assets
@@ -29,7 +29,7 @@ set(ASSETS
 set(ASSETS_cg
   assets-cg/font.png
   assets-cg/font_pinball.png
-  assets-cg/abyss.png
+  # assets-cg/abyss.png
   # ...
 )
 

src/Pinball/pinball_entities.h

@@ -4,8 +4,8 @@
 #include "gint/defs/types.h"
 #include "gint/display-cg.h"
 #include "stdint-gcc.h"
-#include "utilities.h"
-#include "vector2D.h"
+#include "../Utilities/utilities.h"
+#include "../Utilities/vector2D.h"
 #include <num/num.h>
 
 #include <vector>
@@ -42,6 +42,25 @@ public:
     this->pos.Add(this->vel, dt);
   }
 
+  void SetSpeed( Vector2D speed ){
+    this->vel = speed.Clone();
+  }
+
+  void SetPosition( Vector2D position ){
+    this->pos = position.Clone();
+  }
+
+  bool IsStopped( void ) {
+    if (this->vel.Length() <= libnum::num32( 0.02 ) ) return true;
+    else return false;
+  }
+
+  bool IsInBucket( Vector2D BucketMin, Vector2D BucketMax ) {
+    if (this->pos.x >= BucketMin.x && this->pos.y >= BucketMin.y &&
+        this->pos.x <= BucketMax.x && this->pos.y <= BucketMax.y) return true;
+    else return false;
+  }
+
   libnum::num32 radius, mass, restitution;
   Vector2D pos, vel;
   uint16_t color;
@@ -201,6 +220,11 @@ struct Scene
   Vector2D Lock_pos;
   uint16_t Lock_color;
 
+  Vector2D BucketMin, BucketMax;
+
+  uint8_t CurrentBallToLaunch;
+  Vector2D InitialPosition;
+
 };
 
 

src/Pinball/simulations.h

@@ -1,7 +1,7 @@
 #ifndef SIMULATIONS_H
 #define SIMULATIONS_H
 
-#include "vector2D.h"
+#include "../Utilities/vector2D.h"
 #include <num/num.h>
 #include "pinball_entities.h"
 

src/Pinball/tables.h

@@ -2,8 +2,9 @@
 #define TABLES_H
 
 #include "pinball_entities.h"
-#include "utilities.h"
-#include "vector2D.h"
+#include "../Utilities/utilities.h"
+#include "../Utilities/vector2D.h"
+#include "stdint-gcc.h"
 #include <num/num.h>
 #include <vector>
 
@@ -15,9 +16,13 @@ libnum::num32 cScale;
 libnum::num32 simWidth;
 libnum::num32 simHeight;
 
-extern bopti_image_t img_abyss;
+// extern bopti_image_t img_abyss;
+extern uint8_t CurrentSequence;
+
 
 void Setup_Table_0(void) {
+  CurrentSequence = 0;
+
   libnum::num32 offset = libnum::num32(0.02);
 
   flipperHeight = libnum::num32(1.7);
@@ -105,6 +110,7 @@ void Setup_Table_0(void) {
 }
 
 void Setup_Table_1(void) {
+    CurrentSequence = 1;
   libnum::num32 offset = libnum::num32(0.02);
 
   flipperHeight = libnum::num32(1.7);
@@ -202,6 +208,7 @@ void Setup_Table_1(void) {
 }
 
 void Setup_Table_2(void) {
+  CurrentSequence = 2;
   libnum::num32 offset = libnum::num32(0.02);
 
   flipperHeight = libnum::num32(1.7);
@@ -313,6 +320,7 @@ void Setup_Table_2(void) {
 }
 
 void Setup_Table_3(void) {
+    CurrentSequence = 3;
   libnum::num32 offset = libnum::num32(0.02);
 
   flipperHeight = libnum::num32(1.7);
@@ -325,7 +333,7 @@ void Setup_Table_3(void) {
   MyPinball.score = 0;
   MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
 
-  MyPinball.sideimage = &img_abyss;
+  MyPinball.sideimage = nullptr; // &img_abyss;
 
   MyPinball.borders.clear();
   MyPinball.borders.emplace_back(libnum::num32(0.74), libnum::num32(0.25));
@@ -436,6 +444,7 @@ void Setup_Table_3(void) {
 }
 
 void Setup_Table_4(void) {
+    CurrentSequence = 4;
   libnum::num32 offset = libnum::num32(0.02);
 
   flipperHeight = libnum::num32(1.7);
@@ -448,7 +457,7 @@ void Setup_Table_4(void) {
   MyPinball.score = 0;
   MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-1.0)));
 
-  MyPinball.sideimage = &img_abyss;
+  MyPinball.sideimage = nullptr ; //&img_abyss;
 
   MyPinball.borders.clear();
   MyPinball.borders.emplace_back( libnum::num32(0.74), libnum::num32(0.25) );
@@ -503,10 +512,12 @@ void Setup_Table_4(void) {
   MyPinball.balls.push_back(Ball(ball_radius, ball_mass, ball_pos1, ball_vel1,
                                  0.2, RGB565_LEMONYELLOW));
 
+/*
   Vector2D ball_pos2(libnum::num32(1.075), libnum::num32(0.45));
   Vector2D ball_vel2(libnum::num32(0.0), 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);
@@ -565,4 +576,386 @@ void Setup_Table_4(void) {
     MyPinball.flippers.emplace_back(  flip_radius, flip_pos2, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE );
 }
 
+
+void Setup_Table_5(void) {
+  CurrentSequence = 5;
+  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.has_locker = true;
+
+  MyPinball.score = 0;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-0.5)));
+
+  MyPinball.sideimage = nullptr;
+
+  MyPinball.borders.clear();
+  MyPinball.borders.emplace_back( libnum::num32(0.74), libnum::num32(0.25) );
+  MyPinball.borders.emplace_back( libnum::num32(0.98), libnum::num32(0.40) );
+  MyPinball.borders.emplace_back( libnum::num32(0.98), libnum::num32(1.10) );
+
+  MyPinball.borders.emplace_back( libnum::num32(1.04), libnum::num32(1.10) );
+  MyPinball.borders.emplace_back( libnum::num32(1.04), libnum::num32(0.10) );
+  MyPinball.borders.emplace_back( libnum::num32(1.11), libnum::num32(0.10) );
+  MyPinball.borders.emplace_back( libnum::num32(1.11), libnum::num32(1.20) );
+
+  MyPinball.borders.emplace_back( libnum::num32(0.90), libnum::num32(1.46) );
+  MyPinball.borders.emplace_back( libnum::num32(0.81), libnum::num32(1.56) );
+  MyPinball.borders.emplace_back( libnum::num32(0.70), libnum::num32(1.64) );
+  MyPinball.borders.emplace_back( libnum::num32(0.57), libnum::num32(1.68) );
+
+  MyPinball.borders.emplace_back( libnum::num32(0.50), libnum::num32(1.64) );
+  
+  MyPinball.borders.emplace_back( libnum::num32(0.43), libnum::num32(1.68) );
+  MyPinball.borders.emplace_back( libnum::num32(0.30), libnum::num32(1.64) );
+  MyPinball.borders.emplace_back( libnum::num32(0.19), libnum::num32(1.56) );
+  MyPinball.borders.emplace_back( libnum::num32(0.10), libnum::num32(1.46) );
+  MyPinball.borders.emplace_back( libnum::num32(0.04), libnum::num32(1.34) );
+  MyPinball.borders.emplace_back( libnum::num32(0.02), libnum::num32(1.20) );
+  MyPinball.borders.emplace_back( libnum::num32(0.02), libnum::num32(0.40) );
+  MyPinball.borders.emplace_back( libnum::num32(0.26), libnum::num32(0.25) );
+  MyPinball.borders.emplace_back( libnum::num32(0.26), libnum::num32(0.15) );
+  MyPinball.borders.emplace_back( libnum::num32(0.42), libnum::num32(0.02) );
+  MyPinball.borders.emplace_back( libnum::num32(0.58), libnum::num32(0.02) );
+  MyPinball.borders.emplace_back( libnum::num32(0.74), libnum::num32(0.15) );
+
+
+  MyPinball.has_locker = true;
+  MyPinball.locker.clear();
+  MyPinball.locker.emplace_back( libnum::num32(0.90), libnum::num32(1.46) );
+  MyPinball.locker.emplace_back( libnum::num32(1.11), libnum::num32(1.20) );
+  MyPinball.locker.emplace_back( libnum::num32(1.11), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(1.04), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(0.98), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(0.98), libnum::num32(1.20) );
+  MyPinball.locker.emplace_back( libnum::num32(0.96), libnum::num32(1.34) );
+  MyPinball.locker_is_enabled = false;
+
+
+  MyPinball.Lock_radius = libnum::num(0.03);
+  MyPinball.Lock_pos = Vector2D(libnum::num32(0.50), libnum::num32(1.64));
+  MyPinball.Lock_color = RGB565_LEMONYELLOW;
+
+
+  MyPinball.BucketMin = Vector2D( libnum::num32(0.42), libnum::num32(0.02) );
+  MyPinball.BucketMax = Vector2D( libnum::num32(0.58), libnum::num32(0.10) );
+  
+
+  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(1.075), libnum::num32(0.15));
+//  Vector2D ball_vel1(libnum::num32(0.0), libnum::num32(3.5));
+  Vector2D ball_vel1(libnum::num32(0.0), libnum::num32(0.0));
+
+  MyPinball.balls.push_back(Ball(ball_radius, ball_mass, ball_pos1, ball_vel1,
+                                 0.2, RGB565_LEMONYELLOW));
+
+  MyPinball.CurrentBallToLaunch = 0;
+  MyPinball.InitialPosition = ball_pos1.Clone();
+
+/*
+  Vector2D ball_pos2(libnum::num32(1.075), libnum::num32(0.45));
+  Vector2D ball_vel2(libnum::num32(0.0), 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.emplace_back( 0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(0.15), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(0.85), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(0.30), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10 );
+  MyPinball.obstacles.emplace_back( 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.emplace_back( libnum::num32(0.50), libnum::num32(1.13) );
+    island1.emplace_back( libnum::num32(0.43), libnum::num32(1.20) );
+    island1.emplace_back( libnum::num32(0.50), libnum::num32(1.27) );
+    island1.emplace_back( libnum::num32(0.57), libnum::num32(1.20) );
+    MyPinball.islands.push_back(island1);
+
+    std::vector<Vector2D> island2;
+    island2.emplace_back( libnum::num32(0.49), libnum::num32(0.61) );
+    island2.emplace_back( libnum::num32(0.40), libnum::num32(0.80) );
+    island2.emplace_back( libnum::num32(0.50), libnum::num32(0.82) );
+    island2.emplace_back( libnum::num32(0.60), libnum::num32(0.80) );
+    island2.emplace_back( libnum::num32(0.51), libnum::num32(0.61) );
+    MyPinball.islands.push_back(island2);
+
+    std::vector<Vector2D> island3;
+    island3.emplace_back( libnum::num32(0.12), libnum::num32(0.45) );
+    island3.emplace_back( libnum::num32(0.12), libnum::num32(0.65) );
+    island3.emplace_back( libnum::num32(0.14), libnum::num32(0.65) );
+    island3.emplace_back( libnum::num32(0.26), libnum::num32(0.39) );
+    island3.emplace_back( libnum::num32(0.26), libnum::num32(0.37) );
+    MyPinball.islands.push_back(island3);
+
+    std::vector<Vector2D> island4;
+    island4.emplace_back( libnum::num32(0.88), libnum::num32(0.65) );
+    island4.emplace_back( libnum::num32(0.88), libnum::num32(0.45) );
+    island4.emplace_back( libnum::num32(0.74), libnum::num32(0.37) );
+    island4.emplace_back( libnum::num32(0.74), libnum::num32(0.39) );
+    island4.emplace_back( libnum::num32(0.86), libnum::num32(0.65) );
+    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_length_short = libnum::num32(0.12);
+    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.emplace_back( 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.emplace_back(  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(0.02), libnum::num32(1));
+    MyPinball.flippers.emplace_back( flip_radius, flip_pos3, flip_length_short, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE );
+
+    Vector2D flip_pos4(libnum::num32(0.98), libnum::num32(1));
+    MyPinball.flippers.emplace_back(  flip_radius, flip_pos4, flip_length_short, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE );
+*/
+}
+
+
+
+void Setup_Table_6(void) {
+  CurrentSequence = 6;
+  libnum::num32 offset = libnum::num32(0.02);
+
+  flipperHeight = libnum::num32(1.9);
+  cScale = libnum::num32(azrp_height) / flipperHeight;
+  simWidth = libnum::num32(azrp_width) / cScale;
+  simHeight = libnum::num32(azrp_height) / cScale;
+
+  MyPinball.has_locker = true;
+
+  MyPinball.score = 0;
+  MyPinball.gravity.Set(Vector2D(libnum::num32(0.0), libnum::num32(-0.5)));
+
+  MyPinball.sideimage = nullptr;
+
+  MyPinball.borders.clear();
+  MyPinball.borders.emplace_back( libnum::num32(1.74), libnum::num32(0.25) );
+  MyPinball.borders.emplace_back( libnum::num32(1.98), libnum::num32(0.40) );
+  MyPinball.borders.emplace_back( libnum::num32(1.98), libnum::num32(1.10) );
+  // launcher
+  MyPinball.borders.emplace_back( libnum::num32(2.02), libnum::num32(1.10) );
+  MyPinball.borders.emplace_back( libnum::num32(2.02), libnum::num32(0.80) );
+  MyPinball.borders.emplace_back( libnum::num32(2.09), libnum::num32(0.80) );
+  MyPinball.borders.emplace_back( libnum::num32(2.09), libnum::num32(1.20) );
+  MyPinball.borders.emplace_back( libnum::num32(1.90), libnum::num32(1.46) );
+  // top circular part
+  MyPinball.borders.emplace_back( libnum::num32(1.81), libnum::num32(1.56) );
+  MyPinball.borders.emplace_back( libnum::num32(1.70), libnum::num32(1.64) );
+  MyPinball.borders.emplace_back( libnum::num32(1.57), libnum::num32(1.68) );
+  //MyPinball.borders.emplace_back( libnum::num32(1.50), libnum::num32(1.64) );
+  MyPinball.borders.emplace_back( libnum::num32(1.43), libnum::num32(1.68) );
+  MyPinball.borders.emplace_back( libnum::num32(1.30), libnum::num32(1.64) );
+  MyPinball.borders.emplace_back( libnum::num32(1.19), libnum::num32(1.56) );
+  MyPinball.borders.emplace_back( libnum::num32(1.10), libnum::num32(1.46) );
+  MyPinball.borders.emplace_back( libnum::num32(1.08), libnum::num32(1.40) );
+
+  // bridge between the two parts of the table
+  MyPinball.borders.emplace_back(libnum::num32(0.96), libnum::num32(1.44));
+  MyPinball.borders.emplace_back(libnum::num32(0.90), libnum::num32(1.56));
+  MyPinball.borders.emplace_back(libnum::num32(0.81), libnum::num32(1.66));
+  MyPinball.borders.emplace_back(libnum::num32(0.70), libnum::num32(1.74));
+  MyPinball.borders.emplace_back(libnum::num32(0.57), libnum::num32(1.78));
+  MyPinball.borders.emplace_back(libnum::num32(0.43), libnum::num32(1.78));
+  MyPinball.borders.emplace_back(libnum::num32(0.30), libnum::num32(1.74));
+  MyPinball.borders.emplace_back(libnum::num32(0.19), libnum::num32(1.66));
+  MyPinball.borders.emplace_back(libnum::num32(0.10), libnum::num32(1.56));
+  MyPinball.borders.emplace_back(libnum::num32(0.04), libnum::num32(1.44));
+  MyPinball.borders.emplace_back(libnum::num32(0.02), libnum::num32(1.20));
+
+  MyPinball.borders.emplace_back( libnum::num32(0.02), libnum::num32(1.00) );
+  MyPinball.borders.emplace_back( libnum::num32(0.26), libnum::num32(0.85) );
+  MyPinball.borders.emplace_back( libnum::num32(0.26), libnum::num32(0.70) );
+  MyPinball.borders.emplace_back( libnum::num32(0.42), libnum::num32(0.62) );
+
+  MyPinball.borders.emplace_back( libnum::num32(0.44), libnum::num32(0.60) );
+  MyPinball.borders.emplace_back( libnum::num32(0.44), libnum::num32(0.50) );
+  MyPinball.borders.emplace_back( libnum::num32(1.02), libnum::num32(0.40) );
+
+
+//  MyPinball.borders.emplace_back( libnum::num32(1.02), libnum::num32(0.40) );
+  MyPinball.borders.emplace_back( libnum::num32(1.26), libnum::num32(0.25) );
+  MyPinball.borders.emplace_back( libnum::num32(1.26), libnum::num32(0.10) );
+  MyPinball.borders.emplace_back( libnum::num32(1.42), libnum::num32(0.02) );
+  MyPinball.borders.emplace_back( libnum::num32(1.58), libnum::num32(0.02) );
+  MyPinball.borders.emplace_back( libnum::num32(1.74), libnum::num32(0.10) );
+
+
+  MyPinball.has_locker = true;
+  MyPinball.locker.clear();
+  MyPinball.locker.emplace_back( libnum::num32(1.90), libnum::num32(1.46) );
+  MyPinball.locker.emplace_back( libnum::num32(2.09), libnum::num32(1.20) );
+  MyPinball.locker.emplace_back( libnum::num32(2.09), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(2.02), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(1.98), libnum::num32(1.10) );
+  MyPinball.locker.emplace_back( libnum::num32(1.98), libnum::num32(1.20) );
+  MyPinball.locker.emplace_back( libnum::num32(1.96), libnum::num32(1.34) );
+  MyPinball.locker_is_enabled = false;
+
+
+  MyPinball.Lock_radius = libnum::num(0.03);
+  MyPinball.Lock_pos = Vector2D(libnum::num32(1.50), libnum::num32(1.64));
+  MyPinball.Lock_color = RGB565_LEMONYELLOW;
+
+
+  MyPinball.BucketMin = Vector2D( libnum::num32(1.42), libnum::num32(0.02) );
+  MyPinball.BucketMax = Vector2D( libnum::num32(1.58), libnum::num32(0.10) );
+  
+
+  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(2.075), libnum::num32(0.85));
+//  Vector2D ball_vel1(libnum::num32(0.0), libnum::num32(3.5));
+  Vector2D ball_vel1(libnum::num32(0.0), libnum::num32(0.0));
+
+  MyPinball.balls.push_back(Ball(ball_radius, ball_mass, ball_pos1, ball_vel1,
+                                 0.2, RGB565_LEMONYELLOW));
+
+  MyPinball.CurrentBallToLaunch = 0;
+  MyPinball.InitialPosition = ball_pos1.Clone();
+
+/*
+  Vector2D ball_pos2(libnum::num32(1.075), libnum::num32(0.45));
+  Vector2D ball_vel2(libnum::num32(0.0), 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.emplace_back( 0.04, Vector2D(libnum::num32(1.50), libnum::num32(1.45)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.74), libnum::num32(1.20)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.26), libnum::num32(1.20)), 1.5, RGB565_RED, 100 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.50), libnum::num32(0.95)), 1.5, RGB565_RED, 100 );
+
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.55)), 1.5, RGB565_APPLEGREEN, 250 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.70), libnum::num32(1.40)), 1.5, RGB565_APPLEGREEN, 250 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.30), libnum::num32(1.40)), 1.5, RGB565_APPLEGREEN, 250 );
+  MyPinball.obstacles.emplace_back( 0.06, Vector2D(libnum::num32(0.50), libnum::num32(1.25)), 1.5, RGB565_APPLEGREEN, 250 );
+
+
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.15), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.85), libnum::num32(0.80)), 1.5, RGB565_LEMONYELLOW, 25 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.30), libnum::num32(0.60)), 1.5, RGB565_GREEN, 10 );
+  MyPinball.obstacles.emplace_back( 0.04, Vector2D(libnum::num32(1.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> bigisland;
+    bigisland.emplace_back( libnum::num32(1.02), libnum::num32(1.05) );
+    bigisland.emplace_back( libnum::num32(1.02), libnum::num32(0.50) );
+    bigisland.emplace_back( libnum::num32(0.56), libnum::num32(0.56) );
+    bigisland.emplace_back( libnum::num32(0.58), libnum::num32(0.62) );
+    bigisland.emplace_back( libnum::num32(0.74), libnum::num32(0.70) );
+    bigisland.emplace_back( libnum::num32(0.74), libnum::num32(0.85) );
+    bigisland.emplace_back( libnum::num32(0.98), libnum::num32(1.00) ); 
+    bigisland.emplace_back( libnum::num32(0.98), libnum::num32(1.05) ); 
+    MyPinball.islands.push_back(bigisland);
+  
+  
+  std::vector<Vector2D> island1;
+    island1.emplace_back( libnum::num32(1.50), libnum::num32(1.13) );
+    island1.emplace_back( libnum::num32(1.43), libnum::num32(1.20) );
+    island1.emplace_back( libnum::num32(1.50), libnum::num32(1.27) );
+    island1.emplace_back( libnum::num32(1.57), libnum::num32(1.20) );
+    MyPinball.islands.push_back(island1);
+
+    std::vector<Vector2D> island2;
+    island2.emplace_back( libnum::num32(1.49), libnum::num32(0.61) );
+    island2.emplace_back( libnum::num32(1.40), libnum::num32(0.80) );
+    island2.emplace_back( libnum::num32(1.50), libnum::num32(0.82) );
+    island2.emplace_back( libnum::num32(1.60), libnum::num32(0.80) );
+    island2.emplace_back( libnum::num32(1.51), libnum::num32(0.61) );
+    MyPinball.islands.push_back(island2);
+
+    std::vector<Vector2D> island3;
+    island3.emplace_back( libnum::num32(1.12), libnum::num32(0.45) );
+    island3.emplace_back( libnum::num32(1.12), libnum::num32(0.65) );
+    island3.emplace_back( libnum::num32(1.14), libnum::num32(0.65) );
+    island3.emplace_back( libnum::num32(1.26), libnum::num32(0.39) );
+    island3.emplace_back( libnum::num32(1.26), libnum::num32(0.37) );
+    MyPinball.islands.push_back(island3);
+
+    std::vector<Vector2D> island4;
+    island4.emplace_back( libnum::num32(1.88), libnum::num32(0.65) );
+    island4.emplace_back( libnum::num32(1.88), libnum::num32(0.45) );
+    island4.emplace_back( libnum::num32(1.74), libnum::num32(0.37) );
+    island4.emplace_back( libnum::num32(1.74), libnum::num32(0.39) );
+    island4.emplace_back( libnum::num32(1.86), libnum::num32(0.65) );
+    MyPinball.islands.push_back(island4);
+
+    std::vector<Vector2D> island5;
+    island5.emplace_back( libnum::num32(0.12), libnum::num32(1.06) );
+    island5.emplace_back( libnum::num32(0.12), libnum::num32(1.16) );
+    island5.emplace_back( libnum::num32(0.19), libnum::num32(1.16) );
+    island5.emplace_back( libnum::num32(0.28), libnum::num32(0.95) );
+    island5.emplace_back( libnum::num32(0.28), libnum::num32(0.93) );
+    MyPinball.islands.push_back(island5);
+
+    std::vector<Vector2D> island6;
+    island6.emplace_back( libnum::num32(0.88), libnum::num32(1.16) );
+    island6.emplace_back( libnum::num32(0.88), libnum::num32(1.06) );
+    island6.emplace_back( libnum::num32(0.72), libnum::num32(0.93) );
+    island6.emplace_back( libnum::num32(0.72), libnum::num32(0.95) );
+    island6.emplace_back( libnum::num32(0.81), libnum::num32(1.16) );
+    MyPinball.islands.push_back(island6);
+
+
+    MyPinball.flippers.clear();
+    libnum::num32 flip_radius = libnum::num32(0.03);
+    libnum::num32 flip_length = libnum::num32(0.2);
+    libnum::num32 flip_length_short = libnum::num32(0.12);
+    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(1.26), libnum::num32(0.22) );
+    MyPinball.flippers.emplace_back( flip_radius, flip_pos1, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE );
+
+    Vector2D flip_pos2(libnum::num32(1.74), libnum::num32(0.22));
+    MyPinball.flippers.emplace_back( 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(0.26), libnum::num32(0.81));
+    MyPinball.flippers.emplace_back( flip_radius, flip_pos3, flip_length, -flip_restAngle, flip_maxRotation, flip_angularVelocity, flip_restitution, LEFT, RGB565_OCEANBLUE );
+
+    Vector2D flip_pos4(libnum::num32(0.74), libnum::num32(0.81));
+    MyPinball.flippers.emplace_back( flip_radius, flip_pos4, flip_length, libnum::num32(PI) + flip_restAngle, -flip_maxRotation, flip_angularVelocity, flip_restitution, RIGHT, RGB565_OCEANBLUE );
+
+}
+
 #endif

src/Utilities/utilities.h

@@ -66,7 +66,9 @@ extern libnum::num32 simWidth;
 extern libnum::num32 simHeight;
 
 /* return the scaled x component of a vector */
-uint16_t CX(Vector2D pos) { return (int)(pos.x * cScale) + 25; }
+uint16_t CX(Vector2D pos) {
+  return (int)(pos.x * cScale);
+}
 
 /* return the scaled y component of a vector */
 uint16_t CY(Vector2D pos) {
@@ -75,7 +77,9 @@ uint16_t CY(Vector2D pos) {
 
 /* return the scaled disctance given in argument (typically for circles radii)
  */
-uint16_t CR(libnum::num distance) { return (int)(distance * cScale); }
+uint16_t CR(libnum::num distance) {
+  return (int)(distance * cScale);
+}
 
 
 /* Some usefull macros */

src/main.cpp

@@ -5,7 +5,7 @@
 #include <azur/azur.h>
 #include <azur/gint/render.h>
 
-#include "AzurShaders.h"
+#include "./Shaders/AzurShaders.h"
 
 #include <gint/drivers/r61524.h>
 #include <gint/rtc.h>
@@ -29,29 +29,29 @@
 
 #include <num/num.h>
 
-#include "extrakeyboard.h"
-#include "pinball_entities.h"
-#include "simulations.h"
+#include "./Utilities/extrakeyboard.h"
+#include "./Pinball/pinball_entities.h"
+#include "./Pinball/simulations.h"
 #include "stdint-gcc.h"
-#include "tables.h"
-#include "utilities.h"
-#include "vector2D.h"
+#include "./Pinball/tables.h"
+#include "./Utilities/utilities.h"
+#include "./Utilities/vector2D.h"
 
 #include <vector>
 
-#include "tables.h"
+#include "./Pinball/tables.h"
 #include <math.h>
 
-#if (DEBUG_MODE)
-  bool screenshot = false;
-  bool record = false;
-  bool textoutput = false;
-#endif
+
+bool screenshot = false;
+bool record = false;
+bool textoutput = false;
+
 
 bool exitToOS = false;
 
 uint8_t texttodraw = 1;
-
+uint8_t CurrentSequence = 0;
 
 float elapsedTime = 0.0f;
 float realDeltaTime = 0.0f;
@@ -64,7 +64,7 @@ KeyboardExtra MyKeyboard;
 Scene MyPinball;
 
 /* TODO : this is for debugging purpose only to be removed when fixed */
-bool targetline = true;
+bool targetline = false;
 
 
 /* create the pinball board */
@@ -80,15 +80,17 @@ void SetupScene(int which_table) {
     Setup_Table_3();
   else if (which_table == 4)
     Setup_Table_4();
-  else
-    Setup_Table_0();
+  else if (which_table == 5)
+    Setup_Table_5();
+  else if (which_table == 6)
+    Setup_Table_6();
 
   cumulatedTime = 0.0f;
 }
 
-static void hook_prefrag(int id, void *fragment, int size) {
-  if (!screenshot && !record)
-    return;
+  static void hook_prefrag(int id, void *fragment, int size) {
+    if (!screenshot && !record)
+      return;
 
 #if !(CALCEMU)
   /* Screenshot takes precedence */
@@ -185,6 +187,7 @@ static void render(void) {
     /* draw the locker : red if inactive and white if active and considered as a border*/
     CollectionRender( MyPinball.locker, MyPinball.locker_is_enabled ? RGB565_WHITE : RGB565_BLOODYRED);
 
+  #if(0)
     /* TODO this is for debugging */
     /* Something is buggy when azrp_filled_circle is used !!! */
     /* wile it is working when lines are drawn - strange bug, need to be fixed */
@@ -193,6 +196,8 @@ static void render(void) {
       azrp_line(CX(MyPinball.Lock_pos), CY(MyPinball.Lock_pos)-5,CX(MyPinball.Lock_pos), CY(MyPinball.Lock_pos)+5, MyPinball.Lock_color);      
     }
     else azrp_filledcircle(CX(MyPinball.Lock_pos), CY(MyPinball.Lock_pos), CR(MyPinball.Lock_radius), MyPinball.Lock_color);
+  #endif
+  
   }
 
   /* Render the circular bumpers that gives score points and push the ball away */
@@ -208,10 +213,17 @@ static void render(void) {
   /* render de flippers */
   for (int i = 0; i < MyPinball.flippers.size(); i++) MyPinball.flippers[i].Render();
 
+
 #if (DEBUG_MODE)
   /* debug info (FPS and current game duration )*/
-  azrp_draw_text(150, 0, "FPS  = %.0f - Time = %.2 f" ,
-                 (float)(1.0f / realDeltaTime));
+  azrp_draw_text(150, 0, "FPS  = %.0f - DeltaTime = %.3f ms" ,
+                 (float)(1.0f / realDeltaTime), realDeltaTime * 1000.0f );
+
+  if (MyPinball.balls[MyPinball.CurrentBallToLaunch].IsInBucket( MyPinball.BucketMin , MyPinball.BucketMax ))
+    azrp_rect( 10, 10, 10, 10, C_GREEN );
+  else
+    azrp_rect( 10, 10, 10, 10, C_RED );
+
 #endif
 
   /* score */
@@ -227,7 +239,7 @@ static void get_inputs(float dt) {
   }
 
   /* LEFT FLIPPER */
-  if (MyKeyboard.IsKeyPressed(MYKEY_F1)) {
+  if (MyKeyboard.IsKeyPressed(MYKEY_F1) || MyKeyboard.IsKeyPressed(MYKEY_LEFT) ) {
     for (int i = 0; i < MyPinball.flippers.size(); i++)
       if (MyPinball.flippers[i].side == LEFT)
         MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
@@ -238,7 +250,7 @@ static void get_inputs(float dt) {
   }
 
   /* RIGHT FLIPPER */
-  if (MyKeyboard.IsKeyPressed(MYKEY_F6)) {
+  if (MyKeyboard.IsKeyPressed(MYKEY_F6) || MyKeyboard.IsKeyPressed(MYKEY_RIGHT) ) {
     for (int i = 0; i < MyPinball.flippers.size(); i++)
       if (MyPinball.flippers[i].side == RIGHT)
         MyPinball.flippers[i].touchIdentifier = libnum::num32(0);
@@ -248,27 +260,53 @@ static void get_inputs(float dt) {
         MyPinball.flippers[i].touchIdentifier = libnum::num32(-1);
   }
 
+
+#if(!DEMO)
+
   /* RESET THE GAME AND CHANGE THE CURRENT TABLE ( [OPTN] + [Fx] loads Table #x )*/
-  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
       MyKeyboard.IsKeyHoldPressed(MYKEY_F1)) {
     SetupScene(0);
   }
-  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
       MyKeyboard.IsKeyHoldPressed(MYKEY_F2)) {
     SetupScene(1);
   }
-  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
       MyKeyboard.IsKeyHoldPressed(MYKEY_F3)) {
     SetupScene(2);
   }
-  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
       MyKeyboard.IsKeyHoldPressed(MYKEY_F4)) {
     SetupScene(3);
   }
-  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
       MyKeyboard.IsKeyHoldPressed(MYKEY_F5)) {
     SetupScene(4);
   }
+  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F6)) {
+    SetupScene(5);
+  }
+
+  if (MyKeyboard.IsKeyPressed(MYKEY_ALPHA) &&
+      MyKeyboard.IsKeyHoldPressed(MYKEY_F1)) {
+    SetupScene(6);
+  }
+
+#endif
+
+
+  if (MyKeyboard.IsKeyPressed(MYKEY_EXE)) {
+    if (MyPinball.balls[MyPinball.CurrentBallToLaunch].IsStopped() || MyPinball.balls[MyPinball.CurrentBallToLaunch].IsInBucket( MyPinball.BucketMin , MyPinball.BucketMax ))
+    {
+      cumulatedTime=0.0f;
+      MyPinball.locker_is_enabled = false;
+      MyPinball.balls[MyPinball.CurrentBallToLaunch].SetPosition( MyPinball.InitialPosition );
+      MyPinball.balls[MyPinball.CurrentBallToLaunch].SetSpeed( Vector2D( libnum::num32(0.0), libnum::num32(3.5)) );
+      
+    }
+  }
 
   // TODO : to be changed to remove cumulatedTime
   if (MyKeyboard.IsKeyReleasedEvent(MYKEY_VARS) && MyPinball.has_locker && cumulatedTime<1.0f) {
@@ -313,7 +351,7 @@ int main(void) {
 
   // TODO : Currently Loads Table #4 that is the most complete one
   // To be adjusted by a menu and based on user input in final version
-  SetupScene(4);
+  SetupScene(6);
 
   prof_init();
 

src/parameters.h

@@ -3,11 +3,13 @@
 
     /* define main macros and usefull parameters */
 
-    #define DEBUG_MODE  1
+    #define DEBUG_MODE  0
     #define BIAS 1
     #define NOBIAS (1-BIAS)
     #define CALCEMU 1
 
     #define SCALE_PIXEL 1
 
+    #define DEMO 1
+
 #endif