Port to C++.

CMakeLists.txt

@@ -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/main.cpp"
-	"src/planet.c"
+	"src/planet.cpp"
-	"src/ship.c"
+	"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

@@ -26,8 +26,8 @@
 #include <assert.h>
 #include <allegro5/allegro.h>
 
-static ALLEGRO_EVENT_QUEUE *event_queue;
+static ALLEGRO_EVENT_QUEUE *event_queue = NULL;
-static ALLEGRO_TIMER *timer;
+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
+	do {
-	{
+		switch(evnt.type) {
-		switch(evnt.type)
-		{
 			case ALLEGRO_EVENT_TIMER:
 				redraw = 1;
 				break;

src/event_manager.h

@@ -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

@@ -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.cpp

@@ -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);
+	std::cout << title << std::endl;
-	puts(title);
 
-	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 EXIT_FAILURE;
-		return 1;
 	}
 
 	// initialize the spaceship at the center of the screen
-	struct ship ship;
+	Ship ship(400, 300);
-	ship_init(&ship, 400, 300);
 
 	// initialize the planet
-	struct planet planet;
+	Planet planet(400.0f, 300.0f, 250.0f);
-	planet_init(&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(redraw) {
-		{
+			if(just_toggled_fullscreen) {
-			if(just_toggled_fullscreen)
+				display_width = al_get_display_width(allegro.display);
-			{
+				display_height = al_get_display_height(allegro.display);
-				display_width = al_get_display_width(display);
-				display_height = al_get_display_height(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);
+					ship.reset((float)WINDOW_WIDTH / 2, (float)WINDOW_HEIGHT / 2);
-				else
+				else {
-				{
+					ship.update(planet.getGravity(ship));
-					float gravity_x, gravity_y;
-					planet_get_gravity(&planet, ship.x, ship.y, &gravity_x, &gravity_y);
-					ship_update(&ship, gravity_x, gravity_y);
 				}
 			}
 
-			if (key_is_down(KEY_FULLSCREEN) && !just_toggled_fullscreen)
+			if (key_is_down(KEY_FULLSCREEN) && !just_toggled_fullscreen) {
-			{
+				if(al_get_display_flags(allegro.display) & ALLEGRO_FULLSCREEN_WINDOW)
-				if(al_get_display_flags(display) & ALLEGRO_FULLSCREEN_WINDOW)
+					al_set_display_flag(allegro.display, ALLEGRO_FULLSCREEN_WINDOW, 0);
-				{
-					al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, 0);
-				}
 				else
-				{
+					al_set_display_flag(allegro.display, ALLEGRO_FULLSCREEN_WINDOW, 1);
-					al_set_display_flag(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_width / 2.0f - ship.getPos().x * zoom,
-					display_height / 2.0f - ship.y * zoom);
+								   display_height / 2.0f - ship.getPos().y * zoom);
 			al_use_transform(&transform);
 
-			starfield_draw(ship.x, ship.y, zoom, display_width, display_height);
+			starfield_draw(ship.getPos().x, ship.getPos().y, zoom,
-			planet_draw(&planet);
+						   display_width, display_height);
-			ship_draw(&ship);
+			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.getPos().x, ship.getPos().y,
-						ship.direction,
+						ship.getDirection(),
-						RAD_TO_DEG(ship.direction),
+						RAD_TO_DEG(ship.getDirection()),
-						ship.velX * FPS, ship.velY * FPS);
+						ship.getVel().x * FPS, ship.getVel().y * FPS);
-				al_draw_multiline_text(font,
+				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)
+			if(show_help) {
-			{
+				al_draw_multiline_text(allegro.font,
-				al_draw_multiline_text(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);
+	return EXIT_SUCCESS;
-	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;
 }

src/planet.cpp

@@ -17,62 +17,41 @@
  */
 
 #include "planet.h"
-#include <math.h>
+#include <cmath>
-#include <assert.h>
+#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) {
+Planet::Planet(const float x, const float y, const float mass) :
-	assert(planet);
+	pos(x, y), mass(mass), radius(MASS_TO_RADIUS * cbrtf(mass))
+{}
 
-	planet->x = x;
+Vec<float> Planet::getGravity(const Ship &ship) const {
-	planet->y = y;
+	const Vec<float> distance = this->pos - ship.getPos();
-	planet->mass = mass;
-	planet->radius = MASS_TO_RADIUS * cbrtf(planet->mass);
-}
 
-void planet_get_gravity(struct planet *planet, float ship_x, float ship_y,
+	if(distance.length() < this->radius)
-						float *accel_x, float *accel_y) {
+		return Vec<float>(0, 0);
-	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;
-	}
 
 	// 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
+	// a = F / m_ship = G * m_this / r^2
-	float acceleration = force / SHIP_MASS;
+	const float acceleration = force / SHIP_MASS;
 
 	// Normalize direction and apply acceleration
-	float norm_x = dx / distance;
+	return distance.normalized() * acceleration;
-	float norm_y = dy / distance;
-
-	*accel_x = norm_x * acceleration;
-	*accel_y = norm_y * acceleration;
 }
 
-void planet_draw(struct planet *planet) {
+void Planet::draw() {
-	assert(planet);
-
 	// 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_draw_filled_circle(this->pos.x, this->pos.y, this->radius,
-			al_map_rgb(r, g, b));
+						  al_map_rgb(r, g, b));
 }

src/planet.h

@@ -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 {
+class Planet {
-	float x, y;       ///< The x and y coordinates of the planet center.
+private:
-	float mass;       ///< The mass of the planet.
+	Vec<float> pos;      ///< The x and y coordinates of the planet center.
-	float radius;     ///< The radius of the planet (derived from mass).
+	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

@@ -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

@@ -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

@@ -18,40 +18,56 @@
 
 #pragma once
 
+#include "vec.h"
 #include <allegro5/allegro.h>
 
-struct ship {
+class Ship {
-	float x, y; ///< The x and y coordinates of the ship.
+private:
-	float velX, velY; ///< The x and y velocities of the ship.
+	/// 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

@@ -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 cy = chunk_top; cy <= chunk_bottom; ++cy) {
-	{
+		for(int cx = chunk_left; cx <= chunk_right; ++cx) {
-		for(int cx = chunk_left; cx <= chunk_right; ++cx)
-		{
 			generate_chunk_stars(cx, cy);
 		}
 	}

src/starfield.h

@@ -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

@@ -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);
+	}
+};