nortega/spaceshipsim
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Port to C++.

Browse Source
This commit is contained in:
Nicolás Ortega
2026-07-09 11:50:45 +02:00
parent 978bf41ab0
commit 28ed600954
13 changed files with 440 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+11 -4
View File
@@ -20,7 +20,7 @@ project(spaceshipsim
SPDX_LICENSE "GPL-3.0-or-later"
DESCRIPTION "A simulation of a 2D space ship in the frictionless environment of space."
HOMEPAGE_URL "https://code.ortegas.org/nortega/spaceshipsim"
LANGUAGES C)
LANGUAGES C CXX)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "release")
@@ -35,6 +35,12 @@ set(CMAKE_C_FLAGS_RELEASE "-O3 -ffast-math")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "-g -O3 -ffast-math")
set(CMAKE_C_FLAGS_MINSIZEREL "-Os")
set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wextra -Werror")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ffast-math")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3 -ffast-math")
set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os")
find_package(PkgConfig REQUIRED)
pkg_check_modules(ALLEG5 REQUIRED allegro-5>=5.1.9)
pkg_check_modules(ALLEG5-PRIM REQUIRED allegro_primitives-5)
@@ -45,9 +51,9 @@ include_directories(
set(SRCS
"src/event_manager.c"
"src/main.c"
"src/planet.c"
"src/ship.c"
"src/main.cpp"
"src/planet.cpp"
"src/ship.cpp"
"src/starfield.c"
)
@@ -57,6 +63,7 @@ set(HDRS
"src/planet.h"
"src/ship.h"
"src/starfield.h"
"src/vec.h"
)
add_definitions(-DVERSION="${PROJECT_VERSION}")
src/event_manager.c
+23 -17
View File
@@ -26,8 +26,8 @@
#include <assert.h>
#include <allegro5/allegro.h>
static ALLEGRO_EVENT_QUEUE *event_queue;
static ALLEGRO_TIMER *timer;
static ALLEGRO_EVENT_QUEUE *event_queue = NULL;
static ALLEGRO_TIMER *timer = NULL;
static int keys[KEY_MAX];
int evnt_mngr_init(ALLEGRO_DISPLAY *display) {
@@ -35,24 +35,23 @@ int evnt_mngr_init(ALLEGRO_DISPLAY *display) {
if(!al_install_keyboard())
return 0;
#ifdef DEBUG
puts("Initialized keyboard.");
puts("[DEBUG] Initialized keyboard.");
#endif
timer = al_create_timer(1.0f / FPS);
if(!timer)
return 0;
#ifdef DEBUG
puts("Initialized timer.");
puts("[DEBUG] Initialized timer.");
#endif
event_queue = al_create_event_queue();
if(!event_queue)
{
if(!event_queue) {
al_destroy_timer(timer);
return 0;
}
#ifdef DEBUG
puts("Initialized event queue.");
puts("[DEBUG] Initialized event queue.");
#endif
al_register_event_source(event_queue,
al_get_display_event_source(display));
@@ -70,19 +69,28 @@ int evnt_mngr_init(ALLEGRO_DISPLAY *display) {
}
void evnt_mngr_deinit() {
al_destroy_timer(timer);
if(al_is_keyboard_installed()) {
al_uninstall_keyboard();
#ifdef DEBUG
puts("Destroyed timer.");
puts("[DEBUG] Uninstalled keyboard.");
#endif
al_destroy_event_queue(event_queue);
}
if(timer) {
al_destroy_timer(timer);
#ifdef DEBUG
puts("Destroyed event queue.");
puts("[DEBUG] Destroyed timer.");
#endif
}
if(event_queue) {
al_destroy_event_queue(event_queue);
#ifdef DEBUG
puts("[DEBUG] Destroyed event queue.");
#endif
}
}
void set_key(int keycode, int value) {
switch(keycode)
{
switch(keycode) {
case ALLEGRO_KEY_UP:
keys[KEY_UP] = value;
break;
@@ -120,10 +128,8 @@ void handle_event() {
ALLEGRO_EVENT evnt;
al_wait_for_event(event_queue, &evnt);
do
{
switch(evnt.type)
{
do {
switch(evnt.type) {
case ALLEGRO_EVENT_TIMER:
redraw = 1;
break;
src/event_manager.h
+8
View File
@@ -20,6 +20,10 @@
#include <allegro5/allegro.h>
#ifdef __cplusplus
extern "C" {
#endif
enum {
KEY_UP = 0x0,
KEY_DOWN = 0x1,
@@ -62,3 +66,7 @@ void handle_event();
* @return If down 1 will be returned, else 0.
*/
int key_is_down(int code);
#ifdef __cplusplus
}
#endif
src/globals.h
+13 -5
View File
@@ -18,6 +18,11 @@
#pragma once
#include <math.h>
#ifndef M_PI
# define M_PI 3.14159265f
#endif
#ifndef VERSION
# define VERSION "[version]"
#endif
@@ -49,16 +54,19 @@
# define ZOOM_STEP 0.1f
#endif
#include <math.h>
#ifndef M_PI
# define M_PI 3.14159265f
#endif
#define RAD_TO_DEG(x) (x * 180 / M_PI)
#include <allegro5/allegro.h>
#ifdef __cplusplus
extern "C" {
#endif
extern int redraw; ///< Whether or not to redraw the screen.
extern int run; ///< Whether or not to continue running the simulation.
extern int show_help; ///< Whether or not to show the help info.
extern int show_info; ///< Whether or not to show simulation info.
#ifdef __cplusplus
}
#endif
src/main.c → src/main.cpp
+117 -100
View File
@@ -21,13 +21,16 @@
#include "ship.h"
#include "starfield.h"
#include "planet.h"
#include "vec.h"
int run;
int redraw;
int show_help;
int show_info;
#include <stdio.h>
#include <cstdlib>
#include <iostream>
#include <string>
#include <allegro5/allegro.h>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_font.h>
@@ -53,65 +56,112 @@ const char *info_format =
"velX: %f px/sec\n"
"velY: %f px/sec";
struct allegro_components {
int primitives_addon;
int font_addon;
ALLEGRO_DISPLAY *display;
int evnt_system;
ALLEGRO_FONT *font;
};
void cleanup_allegro(struct allegro_components *allegro) {
if(allegro->font) {
al_destroy_font(allegro->font);
#ifdef DEBUG
std::cout << "[DEBUG] Destroyed font." << std::endl;
#endif
allegro->font = nullptr;
}
if(allegro->evnt_system) {
evnt_mngr_deinit();
allegro->evnt_system = 0;
}
if(allegro->display) {
al_destroy_display(allegro->display);
#ifdef DEBUG
std::cout << "[DEBUG] Destroyed display." << std::endl;
#endif
allegro->display = nullptr;
}
if(allegro->font_addon) {
al_shutdown_font_addon();
#ifdef DEBUG
std::cout << "[DEBUG] Shutdown font addon." << std::endl;
#endif
allegro->font_addon = 0;
}
if(allegro->primitives_addon) {
al_shutdown_primitives_addon();
#ifdef DEBUG
std::cout << "[DEBUG] Shutdown primitives addon." << std::endl;
#endif
allegro->primitives_addon = 0;
}
}
int main() {
char title[32];
const std::string title = "SpaceShipSim v" + std::string(VERSION);
float zoom = 1.0f;
float display_width = WINDOW_WIDTH;
float display_height = WINDOW_HEIGHT;
struct allegro_components allegro __attribute__((cleanup(cleanup_allegro))) = {
0,
0,
nullptr,
0,
nullptr
};
sprintf(title, "SpaceShipSim v%s", VERSION);
puts(title);
std::cout << title << std::endl;
if(!al_init())
{
if(!al_init()) {
fprintf(stderr, "alleg5: failed to initialize Allegro.\n");
return 1;
return EXIT_FAILURE;
}
#ifdef DEBUG
puts("Initialized allegro system.");
std::cout << "[DEBUG] Initialized allegro system." << std::endl;
#endif
if(!al_init_primitives_addon())
{
if(!(allegro.primitives_addon = al_init_primitives_addon())) {
fprintf(stderr, "alleg5: failed to initialize primitives addon.\n");
return 1;
return EXIT_FAILURE;
}
#ifdef DEBUG
puts("Initialized primitives addon.");
std::cout << "[DEBUG] Initialized primitives addon." << std::endl;
#endif
if(!al_init_font_addon())
{
if(!(allegro.font_addon = al_init_font_addon())) {
fprintf(stderr, "alleg5: failed to initialize font addon.\n");
return 1;
return EXIT_FAILURE;
}
ALLEGRO_DISPLAY *display = al_create_display(WINDOW_WIDTH, WINDOW_HEIGHT);
if(!display)
{
fprintf(stderr, "alleg5: failed to initialize display.\n");
return 1;
}
al_set_window_title(display, title);
#ifdef DEBUG
puts("Created display.");
std::cout << "[DEBUG] Initialized font addon." << std::endl;
#endif
if(!evnt_mngr_init(display))
{
allegro.display = al_create_display(WINDOW_WIDTH, WINDOW_HEIGHT);
if(!allegro.display) {
fprintf(stderr, "alleg5: failed to initialize display.\n");
return EXIT_FAILURE;
}
al_set_window_title(allegro.display, title.c_str());
#ifdef DEBUG
std::cout << "[DEBUG] Created display." << std::endl;
#endif
if(!(allegro.evnt_system = evnt_mngr_init(allegro.display))) {
fprintf(stderr, "alleg5: failed to initialize event queue.\n");
al_destroy_display(display);
return 1;
return EXIT_FAILURE;
}
// initialize the spaceship at the center of the screen
struct ship ship;
ship_init(&ship, 400, 300);
Ship ship(400, 300);
// initialize the planet
struct planet planet;
planet_init(&planet, 400.0f, 300.0f, 250.0f);
Planet planet(400.0f, 300.0f, 250.0f);
ALLEGRO_FONT *font = al_create_builtin_font();
allegro.font = al_create_builtin_font();
#ifdef DEBUG
std::cout << "[DEBUG] Created font." << std::endl;
#endif
// begin running the simulation
run = 1;
@@ -122,17 +172,15 @@ int main() {
int old_paused = 0;
int just_toggled_fullscreen = 0;
int zoom_pressed = 0;
while(run)
{
while(run) {
handle_event();
// only redraw or run simulation if the timer event has occurred
if(redraw)
{
if(just_toggled_fullscreen)
{
display_width = al_get_display_width(display);
display_height = al_get_display_height(display);
if(redraw) {
if(just_toggled_fullscreen) {
display_width = al_get_display_width(allegro.display);
display_height = al_get_display_height(allegro.display);
}
if(paused == old_paused && key_is_down(KEY_PAUSE))
@@ -140,51 +188,36 @@ int main() {
else if(paused != old_paused && !key_is_down(KEY_PAUSE))
old_paused = paused;
if(!paused)
{
if(!paused) {
if(key_is_down(KEY_RESET))
ship_init(&ship, (float)WINDOW_WIDTH / 2, (float)WINDOW_HEIGHT / 2);
else
{
float gravity_x, gravity_y;
planet_get_gravity(&planet, ship.x, ship.y, &gravity_x, &gravity_y);
ship_update(&ship, gravity_x, gravity_y);
ship.reset((float)WINDOW_WIDTH / 2, (float)WINDOW_HEIGHT / 2);
else {
ship.update(planet.getGravity(ship));
}
}
if (key_is_down(KEY_FULLSCREEN) && !just_toggled_fullscreen)
{
if(al_get_display_flags(display) & ALLEGRO_FULLSCREEN_WINDOW)
{
al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, 0);
}
if (key_is_down(KEY_FULLSCREEN) && !just_toggled_fullscreen) {
if(al_get_display_flags(allegro.display) & ALLEGRO_FULLSCREEN_WINDOW)
al_set_display_flag(allegro.display, ALLEGRO_FULLSCREEN_WINDOW, 0);
else
{
al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, 1);
}
al_set_display_flag(allegro.display, ALLEGRO_FULLSCREEN_WINDOW, 1);
just_toggled_fullscreen = 1;
}
else if (!key_is_down(KEY_FULLSCREEN) && just_toggled_fullscreen)
{
} else if (!key_is_down(KEY_FULLSCREEN) && just_toggled_fullscreen) {
just_toggled_fullscreen = 0;
}
if(key_is_down(KEY_SHIFT) && key_is_down(KEY_ZOOM) && !zoom_pressed)
{
if(key_is_down(KEY_SHIFT) && key_is_down(KEY_ZOOM) && !zoom_pressed) {
zoom -= ZOOM_STEP;
if(zoom < ZOOM_MIN)
zoom = ZOOM_MIN;
zoom_pressed = 1;
}
else if(key_is_down(KEY_ZOOM) && !zoom_pressed)
{
} else if(key_is_down(KEY_ZOOM) && !zoom_pressed) {
zoom += ZOOM_STEP;
if(zoom > ZOOM_MAX)
zoom = ZOOM_MAX;
zoom_pressed = 1;
}
else if(!key_is_down(KEY_ZOOM) && zoom_pressed)
{
} else if(!key_is_down(KEY_ZOOM) && zoom_pressed) {
zoom_pressed = 0;
}
@@ -194,35 +227,34 @@ int main() {
al_identity_transform(&transform);
al_scale_transform(&transform, zoom, zoom);
al_translate_transform(&transform,
display_width / 2.0f - ship.x * zoom,
display_height / 2.0f - ship.y * zoom);
display_width / 2.0f - ship.getPos().x * zoom,
display_height / 2.0f - ship.getPos().y * zoom);
al_use_transform(&transform);
starfield_draw(ship.x, ship.y, zoom, display_width, display_height);
planet_draw(&planet);
ship_draw(&ship);
starfield_draw(ship.getPos().x, ship.getPos().y, zoom,
display_width, display_height);
planet.draw();
ship.draw();
al_identity_transform(&transform);
al_use_transform(&transform);
if(show_info)
{
if(show_info) {
char info[256];
sprintf(info, info_format,
ship.x, ship.y,
ship.direction,
RAD_TO_DEG(ship.direction),
ship.velX * FPS, ship.velY * FPS);
al_draw_multiline_text(font,
ship.getPos().x, ship.getPos().y,
ship.getDirection(),
RAD_TO_DEG(ship.getDirection()),
ship.getVel().x * FPS, ship.getVel().y * FPS);
al_draw_multiline_text(allegro.font,
al_map_rgb(0xFF, 0xFF, 0xFF),
5, 5, (int)display_width, 10.0f,
ALLEGRO_ALIGN_LEFT,
info);
}
if(show_help)
{
al_draw_multiline_text(font,
if(show_help) {
al_draw_multiline_text(allegro.font,
al_map_rgb(0xFF, 0xFF, 0xFF),
display_width / 2, display_height / 2 - 50,
(int)display_width, 10.0f,
@@ -234,20 +266,5 @@ int main() {
}
}
al_destroy_font(font);
evnt_mngr_deinit();
al_destroy_display(display);
#ifdef DEBUG
puts("Destroyed display.");
#endif
al_shutdown_font_addon();
#ifdef DEBUG
puts("Shutdown font addon.");
#endif
al_shutdown_primitives_addon();
#ifdef DEBUG
puts("Shutdown primitives addon.");
#endif
return 0;
return EXIT_SUCCESS;
}
src/planet.c → src/planet.cpp
+18 -39
View File
@@ -17,62 +17,41 @@
*/
#include "planet.h"
#include <math.h>
#include <assert.h>
#include <cmath>
#include <cassert>
#include <allegro5/allegro_primitives.h>
#define GRAVITY_CONSTANT 1.0f // Gravitational constant scaled for simulation
#define GRAVITY_CONSTANT 1.0f // Gravitational constant scaled for simulation
#define SHIP_MASS 1.0f // Assumed constant ship mass
#define MASS_TO_RADIUS 1.5f // Radius scale factor: radius = MASS_TO_RADIUS * mass^(1/3)
void planet_init(struct planet *planet, float x, float y, float mass) {
assert(planet);
Planet::Planet(const float x, const float y, const float mass) :
pos(x, y), mass(mass), radius(MASS_TO_RADIUS * cbrtf(mass))
{}
planet->x = x;
planet->y = y;
planet->mass = mass;
planet->radius = MASS_TO_RADIUS * cbrtf(planet->mass);
}
Vec<float> Planet::getGravity(const Ship &ship) const {
const Vec<float> distance = this->pos - ship.getPos();
void planet_get_gravity(struct planet *planet, float ship_x, float ship_y,
float *accel_x, float *accel_y) {
assert(planet);
assert(accel_x);
assert(accel_y);
float dx = planet->x - ship_x;
float dy = planet->y - ship_y;
float distance = sqrtf(dx * dx + dy * dy);
if(distance < planet->radius) {
*accel_x = 0.0f;
*accel_y = 0.0f;
return;
}
if(distance.length() < this->radius)
return Vec<float>(0, 0);
// F = G * m1 * m2 / r^2
float force = GRAVITY_CONSTANT * SHIP_MASS * planet->mass / (distance * distance);
const float force = GRAVITY_CONSTANT * SHIP_MASS * this->mass / (distance.length() * distance.length());
// a = F / m_ship = G * m_planet / r^2
float acceleration = force / SHIP_MASS;
// a = F / m_ship = G * m_this / r^2
const float acceleration = force / SHIP_MASS;
// Normalize direction and apply acceleration
float norm_x = dx / distance;
float norm_y = dy / distance;
*accel_x = norm_x * acceleration;
*accel_y = norm_y * acceleration;
return distance.normalized() * acceleration;
}
void planet_draw(struct planet *planet) {
assert(planet);
void Planet::draw() {
// Color intensity based on mass (brighter = more massive)
float color_scale = fminf(1.0f, planet->mass / 1000.0f);
float color_scale = fminf(1.0f, this->mass / 1000.0f);
int r = (int)(100 + 155 * color_scale);
int g = (int)(100 + 50 * color_scale);
int b = (int)(150 - 100 * color_scale);
al_draw_filled_circle(planet->x, planet->y, planet->radius,
al_map_rgb(r, g, b));
al_draw_filled_circle(this->pos.x, this->pos.y, this->radius,
al_map_rgb(r, g, b));
}
src/planet.h
+34 -35
View File
@@ -18,45 +18,44 @@
#pragma once
#include "ship.h"
#include "vec.h"
/**
* Function pointer type for calculating planet mass.
* Takes no parameters and returns the mass value.
*/
typedef float (*planet_mass_func)(void);
struct planet {
float x, y; ///< The x and y coordinates of the planet center.
float mass; ///< The mass of the planet.
float radius; ///< The radius of the planet (derived from mass).
class Planet {
private:
Vec<float> pos; ///< The x and y coordinates of the planet center.
const float mass; ///< The mass of the planet.
const float radius; ///< The radius of the planet (derived from mass).
public:
/**
* @brief Initialize a planet at a position with a specified mass.
*
* @param x Initial x position of the planet center.
* @param y Initial y position of the planet center.
* @param mass The mass of the planet.
*/
Planet(const float x, const float y, const float mass);
/**
* @brief Calculate the gravitational acceleration on a ship at a given position.
*
* Returns the acceleration vector components due to the planet's gravity.
*
* @param ship Reference to ship.
*
* @returns A Vec<float> representing the gravitational acceleration (ax, ay).
*/
Vec<float> getGravity(const Ship &ship) const;
/**
* @brief Draw the planet.
*/
void draw();
};
/**
* @brief Initialize a planet at a position with a specified mass.
*
* @param planet A pointer to the planet object.
* @param x Initial x position of the planet center.
* @param y Initial y position of the planet center.
* @param mass The mass of the planet.
*/
void planet_init(struct planet *planet, float x, float y, float mass);
/**
* @brief Calculate the gravitational acceleration on a ship at a given position.
*
* Returns the acceleration vector components due to the planet's gravity.
*
* @param planet A pointer to the planet object.
* @param ship_x X position of the ship.
* @param ship_y Y position of the ship.
* @param accel_x Pointer to store the x component of acceleration.
* @param accel_y Pointer to store the y component of acceleration.
*/
void planet_get_gravity(struct planet *planet, float ship_x, float ship_y,
float *accel_x, float *accel_y);
/**
* @brief Draw the planet.
*
* @param planet Planet object to draw.
*/
void planet_draw(struct planet *planet);
src/ship.c
-87
View File
@@ -1,87 +0,0 @@
/*
* Copyright (C) 2018,2026 Ortega Froysa, Nicolás <nicolas@ortegas.org>
* Author: Ortega Froysa, Nicolás <nicolas@ortegas.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ship.h"
#include "event_manager.h"
#include "globals.h"
#include <math.h>
#include <assert.h>
#include <allegro5/allegro_primitives.h>
#define SHIP_RADIUS 10.0f // radius of the ship in pixels
void ship_init(struct ship *ship, float x, float y) {
assert(ship);
ship->x = x;
ship->y = y;
ship->velX = ship->velY = 0;
ship->direction = 0;
}
void ship_update(struct ship *ship, float gravity_x, float gravity_y) {
assert(ship);
if(key_is_down(KEY_RIGHT))
ship->direction += TURN_ACCEL;
if(key_is_down(KEY_LEFT))
ship->direction -= TURN_ACCEL;
// keep direction within bounds
if(ship->direction >= M_PI * 2)
ship->direction -= M_PI * 2;
else if(ship->direction < 0)
ship->direction += M_PI * 2;
if(key_is_down(KEY_UP))
{
ship->velX += cos(ship->direction) * ACCEL;
ship->velY += sin(ship->direction) * ACCEL;
}
if(key_is_down(KEY_DOWN))
{
// moving backwards is slower than moving forward
ship->velX -= cos(ship->direction) * (ACCEL / 2);
ship->velY -= sin(ship->direction) * (ACCEL / 2);
}
// Apply gravitational acceleration
ship->velX += gravity_x;
ship->velY += gravity_y;
ship->x += ship->velX;
ship->y += ship->velY;
}
void ship_draw(struct ship *ship) {
assert(ship);
const float x0 = ship->x + (cos(ship->direction) *
SHIP_RADIUS);
const float y0 = ship->y + (sin(ship->direction) *
SHIP_RADIUS);
const float x1 = ship->x + (cos(ship->direction +
M_PI * 0.8f) * SHIP_RADIUS);
const float y1 = ship->y + (sin(ship->direction +
M_PI * 0.8f) * SHIP_RADIUS);
const float x2 = ship->x + (cos(ship->direction +
M_PI * 1.2f) * SHIP_RADIUS);
const float y2 = ship->y + (sin(ship->direction +
M_PI * 1.2f) * SHIP_RADIUS);
al_draw_filled_triangle(x0, y0, x1, y1, x2, y2,
al_map_rgb(0xFF, 0x0, 0x0));
}
src/ship.cpp
+69
View File
@@ -0,0 +1,69 @@
/*
* Copyright (C) 2018,2026 Ortega Froysa, Nicolás <nicolas@ortegas.org>
* Author: Ortega Froysa, Nicolás <nicolas@ortegas.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ship.h"
#include "event_manager.h"
#include "globals.h"
#include <cmath>
#include <cassert>
#include <allegro5/allegro_primitives.h>
#define SHIP_RADIUS 10.0f // radius of the ship in pixels
Ship::Ship(const float x, const float y) :
pos(x, y), vel(0, 0), direction(0)
{}
void Ship::update(const Vec<float> &grav) {
if(key_is_down(KEY_RIGHT))
this->direction += TURN_ACCEL;
if(key_is_down(KEY_LEFT))
this->direction -= TURN_ACCEL;
// keep direction within bounds
if(this->direction >= M_PI * 2)
this->direction -= M_PI * 2;
else if(this->direction < 0)
this->direction += M_PI * 2;
if(key_is_down(KEY_UP)) {
this->vel.x += cos(this->direction) * ACCEL;
this->vel.y += sin(this->direction) * ACCEL;
}
if(key_is_down(KEY_DOWN)) {
// moving backwards is slower than moving forward
this->vel.x -= cos(this->direction) * (ACCEL / 2);
this->vel.y -= sin(this->direction) * (ACCEL / 2);
}
// Apply gravitational acceleration
this->vel += grav;
this->pos += this->vel;
}
void Ship::draw() const {
const float x0 = this->pos.x + (cos(this->direction) * SHIP_RADIUS);
const float y0 = this->pos.y + (sin(this->direction) * SHIP_RADIUS);
const float x1 = this->pos.x + (cos(this->direction + M_PI * 0.8f) * SHIP_RADIUS);
const float y1 = this->pos.y + (sin(this->direction + M_PI * 0.8f) * SHIP_RADIUS);
const float x2 = this->pos.x + (cos(this->direction + M_PI * 1.2f) * SHIP_RADIUS);
const float y2 = this->pos.y + (sin(this->direction + M_PI * 1.2f) * SHIP_RADIUS);
al_draw_filled_triangle(x0, y0, x1, y1, x2, y2,
al_map_rgb(0xFF, 0x0, 0x0));
}
src/ship.h
+45 -29
View File
@@ -18,40 +18,56 @@
#pragma once
#include "vec.h"
#include <allegro5/allegro.h>
struct ship {
float x, y; ///< The x and y coordinates of the ship.
float velX, velY; ///< The x and y velocities of the ship.
class Ship {
private:
/// Position of the ship in pixels.
Vec<float> pos;
/// Velocity of the ship in pixels per frame.
Vec<float> vel;
/**
* The direction that the ship is facing in radians, where
* 0 is right facing.
*/
float direction;
public:
/**
* @brief Initialize ship.
*
* @param x Initial X position.
* @param y Initial Y position.
*/
Ship(const float x, const float y);
/**
* @brief Updates the ship's variables according to keyboard
* input and gravitational forces.
*
* @param grav Vector of gravitational acceleration in pixels per frame squared.
*/
void update(const Vec<float> &grav);
/**
* @brief Reset ship to position.
*
* @param x X position to reset to.
* @param y Y position to reset to.
*/
inline void reset(float x, float y) {
this->pos.set(x, y);
this->vel.set(0, 0);
this->direction = 0;
}
/**
* @brief Draw the ship.
*/
void draw() const;
inline Vec<float> getPos() const { return pos; }
inline Vec<float> getVel() const { return vel; }
inline float getDirection() const { return direction; }
};
/**
* @brief Initialize the ship at a position.
*
* @param ship A pointer to the ship object.
* @param x Initial x position of the ship.
* @param y Initial y position of the ship.
*/
void ship_init(struct ship *ship, float x, float y);
/**
* @brief Updates the ship's variables according to keyboard
* input and gravitational forces.
*
* @param ship A pointer to the ship object.
* @param gravity_x Gravitational acceleration in x direction.
* @param gravity_y Gravitational acceleration in y direction.
*/
void ship_update(struct ship *ship, float gravity_x, float gravity_y);
/**
* @brief Draw the ship.
*
* @param ship Ship object to draw.
*/
void ship_draw(struct ship *ship);
src/starfield.c
+3 -7
View File
@@ -17,7 +17,6 @@
*/
#include "starfield.h"
#include "globals.h"
#include <stdlib.h>
#include <math.h>
@@ -42,8 +41,7 @@ static void generate_chunk_stars(int chunk_x, int chunk_y) {
float base_x = chunk_x * CHUNK_SIZE;
float base_y = chunk_y * CHUNK_SIZE;
for(int i = 0; i < STARS_PER_CHUNK; ++i)
{
for(int i = 0; i < STARS_PER_CHUNK; ++i) {
float star_x = base_x + (float)(rand() % CHUNK_SIZE);
float star_y = base_y + (float)(rand() % CHUNK_SIZE);
@@ -65,10 +63,8 @@ void starfield_draw(float camera_x, float camera_y, float zoom, float width, flo
int chunk_top = (int)floor(top / CHUNK_SIZE);
int chunk_bottom = (int)floor(bottom / CHUNK_SIZE);
for(int cy = chunk_top; cy <= chunk_bottom; ++cy)
{
for(int cx = chunk_left; cx <= chunk_right; ++cx)
{
for(int cy = chunk_top; cy <= chunk_bottom; ++cy) {
for(int cx = chunk_left; cx <= chunk_right; ++cx) {
generate_chunk_stars(cx, cy);
}
}
src/starfield.h
+8
View File
@@ -18,6 +18,10 @@
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Draw stars in the visible area of the starfield.
*
@@ -28,3 +32,7 @@
* @param height The display height in pixels.
*/
void starfield_draw(float camera_x, float camera_y, float zoom, float width, float height);
#ifdef __cplusplus
}
#endif
src/vec.h
+91
View File
@@ -0,0 +1,91 @@
/*
* Copyright (C) 2026 Ortega Froysa, Nicolás <nicolas@ortegas.org>
* Author: Ortega Froysa, Nicolás <nicolas@ortegas.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <cmath>
template <typename T>
class Vec {
public:
T x, y;
Vec() : x(0), y(0) {}
Vec(T x, T y) : x(x), y(y) {}
inline void set(T x, T y) {
this->x = x;
this->y = y;
}
inline T length() const {
return std::sqrt(static_cast<double>(x * x + y * y));
}
inline Vec<T> normalized() const {
const T len = length();
if (len == 0)
return Vec<T>(0, 0);
return Vec<T>(x / len, y / len);
}
inline Vec<T>& operator+=(const Vec<T> &other) {
this->x += other.x;
this->y += other.y;
return *this;
}
inline Vec<T>& operator*=(const T scalar) {
this->x *= scalar;
this->y *= scalar;
return *this;
}
inline Vec<T> operator+(const Vec<T> &other) const {
return Vec<T>(this->x + other.x, this->y + other.y);
}
inline Vec<T> operator+(const T scalar) const {
return Vec<T>(this->x + scalar, this->y + scalar);
}
inline Vec<T>& operator-=(const Vec<T> &other) {
this->x -= other.x;
this->y -= other.y;
return *this;
}
inline Vec<T>& operator-=(const T scalar) {
this->x -= scalar;
this->y -= scalar;
return *this;
}
inline Vec<T> operator-(const Vec<T> &other) const {
return Vec<T>(this->x - other.x, this->y - other.y);
}
inline Vec<T> operator-(const T scalar) const {
return Vec<T>(this->x - scalar, this->y - scalar);
}
inline Vec<T> operator*(const T scalar) const {
return Vec<T>(this->x * scalar, this->y * scalar);
}
inline Vec<T> operator/(const T scalar) const {
return Vec<T>(this->x / scalar, this->y / scalar);
}
};