asteroids/main.c

#include "raylib.h"
#include "raymath.h"
#include <stdbool.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

#define DRAG -0.001f
#define MAX_BULLETS 1024


typedef struct ship_t {
    Vector2 position;
    Vector2 velocity;
    Vector2 accel;
    Vector2 size;
    Vector2 direction;
    float angle;
} ship;

typedef struct bullet_t {
    Vector2 position;
    Vector2 velocity;
    Vector2 accel;
    Vector2 direction;
    float radius;
    bool active;

} bullet;



typedef struct game_g {
    ship s;
    bullet bullets[MAX_BULLETS];
    size_t bullets_fired;
    size_t active_bullets;
    float last_fire;
    float dt;
} game;

game g;



void ship_draw(const ship* s) { DrawRectangleV(s->position, s->size, BLACK); }

void ship_up(ship* s) {

    Vector2 min = { .x = -1000.0f, .y = -1000.0f };
    Vector2 max = { .x = 1000.0f, .y = 1000.0f };

    Vector2 diff = Vector2Subtract(s->direction, s->position);

    Vector2 accellv = CLITERAL(Vector2) { .x = diff.x, .y = diff.y };
    Vector2Normalize(accellv);
    s->accel = Vector2Add(accellv, s->accel);

    s->accel = Vector2Clamp(s->accel, min, max);
}

void ship_stop(ship* s) {

    Vector2 min = { .x = 1.0, .y = 1.0 };
    Vector2 max = { .x = 0.0, .y = 0.0 };
    s->accel.y -= 0.0001f;
    s->accel.x -= 0.0001f;
    s->accel = Vector2Clamp(s->accel, min, max);
}

void ship_update(ship* s) {
    Vector2 drag = { .x = DRAG * s->velocity.x, .y = DRAG * s->velocity.y };

    float x = cosf(s->angle);
    float y = sinf(s->angle);

    Vector2 polar = CLITERAL(Vector2) { .x = x, .y = y };
    Vector2 pos = Vector2Add(s->position, polar);

    float x1 = 100 * cosf(s->angle);
    float y1 = 100 * sinf(s->angle);

    Vector2 polar1 = CLITERAL(Vector2) { .x = x1, .y = y1 };
    Vector2 pos1 = Vector2Add(s->position, polar1);

    s->direction.x = pos.x;
    s->direction.y = pos.y;

    s->velocity.x += s->accel.x * g.dt;
    s->velocity.y += s->accel.y * g.dt;
    s->velocity = Vector2Add(s->velocity, drag);

    s->position.x += s->velocity.x * g.dt;
    s->position.y += s->velocity.y * g.dt;

    DrawLine(s->position.x, s->position.y, pos1.x, pos1.y, RED);
}

void ship_fire(game* g, ship* s)
{

    //Vector2 min = { .x = -300.0f, .y = -300.0f };
    //Vector2 max = { .x = 300.0f, .y = 300.0f };
    if (g->bullets_fired >= MAX_BULLETS) {
        g->bullets_fired = 0;
        //g->active_bullets -= 1;
    }
    float current_fire = GetFrameTime();
    float allowed_fire = 0.0002;
    if (current_fire > allowed_fire) {

        Vector2 diff = Vector2Subtract(s->direction, s->position);

        Vector2 accellv = CLITERAL(Vector2) { .x = diff.x, .y = diff.y };
        g->bullets[g->bullets_fired].accel = Vector2Zero();//Vector2Scale(diff,3000);//Vector2Add(accellv, s->accel);

        g->bullets[g->bullets_fired].position = s->position;
        g->bullets[g->bullets_fired].radius = 5.0f;
        g->bullets[g->bullets_fired].velocity = Vector2Scale(diff, 3000);
        g->bullets[g->bullets_fired].active = true;

        g->bullets_fired++;
        g->active_bullets += 1;
        g->last_fire = GetFrameTime();
    }

}

void bullets_draw(game* g, bullet* b) {
    
    if (b->active) {
        DrawCircle(b->position.x, b->position.y, b->radius, RED);
    }
    
}

void bullets_update(game* g, bullet* b) {
    
        if (b->active) {
           
            b->velocity.x += b->accel.x * g->dt;
            b->velocity.y += b->accel.y * g->dt;

            b->position.x += b->velocity.x * g->dt;
            b->position.y += b->velocity.y * g->dt;

            b->velocity = Vector2ClampValue(b->velocity, -3000, 3000);
        
            if (b->position.x > (GetScreenWidth() - b->radius) || b->position.y > (GetScreenHeight() - b->radius)) {
                b->active = false;
                g->active_bullets -= 1;
            }

            if (b->position.x < b->radius || b->position.y < b->radius) {
                b->active = false;
                g->active_bullets -= 1;
            }

            //DrawLine(g->s.position.x, g->s.position.y, b->direction.x, b->direction.y, GREEN);
        }

}



void process_inputs(game *g) {

  if (IsKeyDown(KEY_W)) {
    ship_up(&g->s);
  } else {
    ship_stop(&g->s);
  }
  if (IsKeyDown(KEY_D)) {
    g->s.angle += 1.0f * g->dt;
  }
  if (IsKeyDown(KEY_A)) {
    g->s.angle -= 1.0f * g->dt;
  }

  if (IsKeyDown(KEY_SPACE)) {
      ship_fire(g, &g->s);
  }

}

void text(const game *g) {
  char ind[256] = {0};
  sprintf(ind,
          "ship position %fx%f\nship speed %fx%f\nship accel %fx%f\nangle: "
          "%f\ndirection %fx%f\nbullets fired %d\nactive bullets %zu",
          g->s.position.x, g->s.position.y, g->s.velocity.x, g->s.velocity.y,
          g->s.accel.x, g->s.accel.y, g->s.angle, g->s.direction.x,
          g->s.direction.y, g->bullets_fired, g->active_bullets);
  DrawText(ind, 10, 10, 20, BLACK);
}

int main(void) {

  InitWindow(1820, 900, "Hello World");

  ship s1 = {0};
  s1.position.x = 910.0f;
  s1.position.y = 450.0f;

  s1.size.x = 10.0f;
  s1.size.y = 10.0f;
  s1.angle = 3 * PI / 2;

  g.s = s1;

  memset(g.bullets, 0, MAX_BULLETS);

  while (!WindowShouldClose()) {
    BeginDrawing();
    ClearBackground(WHITE);
      
    for (size_t i=0; i < MAX_BULLETS; i++) {
      bullets_draw(&g, &g.bullets[i]);
      bullets_update(&g, &g.bullets[i]);
    }

    ship_draw(&g.s);
    ship_update(&g.s);
    text(&g);
    process_inputs(&g);
    EndDrawing();

    g.dt = GetFrameTime();
  }

  return (0);
}