Pinball/src/pinball_entities.h

#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"
#include <num/num.h>

#include <vector>

#include <azur/azur.h>
#include <azur/gint/render.h>

enum {
  LEFT = 0,
  RIGHT = 1,
};

class Ball {
public:
  Ball(libnum::num32 radius, libnum::num32 mass, Vector2D pos, Vector2D vel,
       libnum::num32 restitution, uint16_t color) {
    this->radius = radius;
    this->mass = mass;
    this->pos = pos.Clone();
    this->vel = vel.Clone();
    this->restitution = restitution;
    this->color = color;
  }

  ~Ball() {}

  void Render() {
    azrp_filledcircle(CX(this->pos), CY(this->pos), CR(this->radius),
                      this->color);
  }

  void Simulate(libnum::num32 dt, Vector2D gravity) {
    this->vel.Add(gravity, dt);
    this->pos.Add(this->vel, dt);
  }

  libnum::num32 radius, mass, restitution;
  Vector2D pos, vel;
  uint16_t color;
};

class Obstacle {
public:
  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() {}
  Obstacle() {}

  void Render() {
    azrp_filledcircle(CX(this->pos), CY(this->pos), CR(this->radius),
                      this->color);
  }

  libnum::num32 radius, pushVel;
  Vector2D pos;
  uint16_t color;
  uint16_t points;
};

class Target {
public:
  Target(libnum::num32 radius, Vector2D pos, uint16_t color, uint16_t points) {
    this->radius = radius;
    this->pos = pos.Clone();
    this->color = color;
    this->points = points;
  }

  ~Target() {}

  void Render() {
    azrp_circle(CX(this->pos), CY(this->pos), CR(this->radius), this->color);
  }

  libnum::num32 radius;
  Vector2D pos;
  uint16_t color;
  uint16_t points;
};

class Flipper {
public:
  Flipper(libnum::num32 radius, Vector2D pos, libnum::num32 length,
          libnum::num32 restAngle, libnum::num32 maxRotation,
          libnum::num32 angularVelocity, libnum::num32 restitution,
          uint8_t side, uint16_t color) {
    this->radius = radius;
    this->pos = pos.Clone();
    this->length = length;
    this->restAngle = restAngle;
    this->maxRotation = ABS(maxRotation);
    this->sign = SIGN(maxRotation);
    this->angularVelocity = angularVelocity;
    this->rotation = libnum::num32(0);
    this->currentAngularVelocity = libnum::num32(0);
    this->touchIdentifier = libnum::num32(-1);
    this->side = side;
    this->color = color;
  }

  void Simulate(libnum::num32 dt) {
    libnum::num32 prevRotation = this->rotation;
    bool pressed = this->touchIdentifier >= 0;
    if (pressed)
      this->rotation =
          MIN(this->rotation + dt * this->angularVelocity, this->maxRotation);
    else
      this->rotation =
          MAX(this->rotation - dt * this->angularVelocity, libnum::num(0.0));
    this->currentAngularVelocity =
        this->sign * (this->rotation - prevRotation) / dt;
  }

  Vector2D getTip() {
    libnum::num32 angle = this->restAngle + this->sign * this->rotation;
    Vector2D D(COS(angle), SIN(angle));

    Vector2D tip = this->pos.Clone();
    tip.Add(D, this->length);
    return tip;
  }

  void Render() {
    Vector2D start = this->pos;
    Vector2D end = this->getTip();

    Vector2D SE;
    SE.Set(end - start);
    Vector2D Norm;
    Norm.Set(SE.PerpCW());
    Norm.Normalise();

    Vector2D A = start.Clone();
    A.Add(Norm, this->radius);

    Vector2D B = end.Clone();
    B.Add(Norm, this->radius);

    Vector2D C = end.Clone();
    C.Add(Norm, -this->radius);

    Vector2D D = start.Clone();
    D.Add(Norm, -this->radius);

    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, this->color);
    azrp_filledcircle(CX(start), CY(start), CR(this->radius), this->color);
    azrp_filledcircle(CX(end), CY(end), CR(this->radius), this->color);
    azrp_line(CX(start), CY(start), CX(end), CY(end), this->color);
  }

  libnum::num32 radius;
  Vector2D pos;
  libnum::num32 length;
  libnum::num32 restAngle;
  libnum::num32 maxRotation;
  libnum::num32 sign;
  libnum::num32 angularVelocity;
  libnum::num32 rotation;
  libnum::num32 currentAngularVelocity;
  libnum::num32 touchIdentifier;
  uint8_t side;
  uint16_t color;
};

struct Scene {
  Vector2D gravity;
  libnum::num32 dt;
  uint32_t score;
  bool pause;
  std::vector<Vector2D> borders;
  std::vector<Ball> balls;
  std::vector<Obstacle> obstacles;
  std::vector<std::vector<Vector2D>> islands;
  std::vector<Flipper> flippers;
  bopti_image_t *sideimage;

  bool has_locker;
  std::vector<Vector2D> locker;
  bool locker_is_enabled;
  std::vector<Target> Locker_enabler;
};



void CollectionRender( std::vector <Vector2D> collection, uint16_t color )
{
  int mod = collection.size();
  for (int i = 0; i < mod; i++)
    azrp_line(CX(collection[i]), CY(collection[i]),
              CX(collection[(i + 1) % mod]),
              CY(collection[(i + 1) % mod]), color );
}


#endif