Initial commit

3 files changed, 365 insertions, 0 deletions

diff --git a/license.txt b/license.txt
new file mode 100644
index 0000000..2b081bd
--- /dev/null
+++ b/license.txt
@@ -0,0 +1,13 @@
+Copyright (C) 2019 Jordan Halase <jordan@halase.me>
+
+Permission to use, copy, modify, and/or distribute this software for any 
+purpose with or without fee is hereby granted, provided that the above 
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 
+SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 
+OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..cb3ba73
--- /dev/null
+++ b/main.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2019 Jordan Halase <jordan@halase.me>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any 
+ * purpose with or without fee is hereby granted, provided that the above 
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <math.h>
+
+#include <SDL2/SDL.h>
+
+#define SCREEN_WIDTH	800
+#define SCREEN_HEIGHT	600
+#define RENDER_SCALE	16.0f
+#define SCREEN_WIDTH_F	(SCREEN_WIDTH/RENDER_SCALE)
+#define SCREEN_HEIGHT_F	(SCREEN_HEIGHT/RENDER_SCALE)
+#define SCREEN_CENTER_X	(SCREEN_WIDTH_F/2)
+#define SCREEN_CENTER_Y	(SCREEN_HEIGHT_F/2)
+#define TWOPI		6.283185307f
+#define PIOVER2		1.570796327f
+#define INVSQRT2	0.707106781f
+
+void fatal_sdl()
+{
+	fprintf(stderr, "%s\n", SDL_GetError());
+	SDL_ShowSimpleMessageBox(
+		SDL_MESSAGEBOX_ERROR,
+		"Fatal Error",
+		SDL_GetError(),
+		NULL
+	);
+	exit(1);
+}
+
+#define CHECK_SDL(f) do { if ((f) < 0) { fatal_sdl(); } } while (0)
+
+typedef struct vec2 {
+	float x, y;
+} vec2;
+
+#define vec2(x, y)	((vec2){(x), (y)})
+#define vadd(a, b)	vec2((a).x+(b).x, (a).y+(b).y)
+#define vscale(v, s)	vec2((v).x*(s), (v).y*(s))
+#define vcomplex(a, b)	vec2((a).x*(b).x-(a).y*(b).y, (a).x*(b).y+(a).y*(b).x)
+#define vdot(a, b)	((a).x*(b).x + (a).y*(b).y)
+#define vdotself(v)	vdot(v, v)
+#define viszero(v)	((v).x == 0.0f && (v).y == 0.0f)
+
+enum CollisionType {
+	COLLISION_TYPE_NONE		= 0x0,
+	COLLISION_TYPE_PLAYER		= 0x1,
+	COLLISION_TYPE_ASTEROID		= 0x2,
+	COLLISION_TYPE_UFO		= 0x4,
+	COLLISION_TYPE_PLAYER_BULLET	= 0x8,
+	COLLISION_TYPE_UFO_BULLET	= 0x10
+};
+
+struct Bullet {
+	vec2 position;
+	vec2 velocity;		// Zero velocity bullets are vacant
+};
+
+#define MAX_BULLETS	8
+
+/* Zero is initialization */
+struct BulletPool {
+	uint32_t used;		// Number of bullets currently in use
+	uint32_t index;		// Index of possibly vacant bullet
+	struct Bullet bullets[MAX_BULLETS];
+};
+
+struct BulletPool player_bullets;
+
+bool bullets_shoot(struct BulletPool *pool, const vec2 position, const vec2 velocity)
+{
+	if (pool->used >= MAX_BULLETS) {
+		return false;
+	}
+	uint32_t i;
+	for (i = pool->index; i < MAX_BULLETS; ++i) {
+		if (viszero(pool->bullets[i].velocity)) {
+			goto found;
+		}
+	}
+	for (i = 0; i < pool->index; ++i) {
+		if (viszero(pool->bullets[i].velocity)) {
+			goto found;
+		}
+	}
+	return false;
+found:
+	pool->bullets[i].position = position;
+	pool->bullets[i].velocity = velocity;
+	pool->index = (pool->index + 1) % MAX_BULLETS;
+	++pool->used;
+	return true;
+}
+
+static bool is_point_in_screen(const vec2 position)
+{
+	if (position.x > SCREEN_WIDTH_F || position.y > SCREEN_HEIGHT_F ||
+	    position.x < 0.0f || position.y < 0.0f) {
+		return false;
+	}
+	return true;
+}
+
+void bullets_integrate(struct BulletPool *pool)
+{
+	for (uint32_t i = 0; i < MAX_BULLETS; ++i) {
+		if (!viszero(pool->bullets[i].velocity)) {
+			pool->bullets[i].position = vadd(pool->bullets[i].position, pool->bullets[i].velocity);
+			if (!is_point_in_screen(pool->bullets[i].position)) {
+				pool->bullets[i].velocity = vec2(0.0f, 0.0f);
+				--pool->used;
+				pool->index = i;
+			}
+		}
+	}
+}
+
+void bullets_draw(const struct BulletPool *pool, SDL_Renderer *ren)
+{
+	uint32_t num_bullets = 0;
+	SDL_Point points[MAX_BULLETS];
+	for (uint32_t i = 0; i < MAX_BULLETS; ++i) {
+		if (!viszero(pool->bullets[i].velocity)) {
+			const vec2 v = vscale(pool->bullets[i].position, RENDER_SCALE);
+			points[num_bullets].x = lroundf(v.x);
+			points[num_bullets].y = lroundf(v.y);
+			++num_bullets;
+		}
+	}
+	SDL_RenderDrawPoints(ren, points, num_bullets);
+}
+
+struct KinematicBody {
+	vec2 position;
+	vec2 velocity;
+	vec2 acceleration;
+	float angle;
+	float angular_velocity;
+	float k_max_speed;
+	float collision_radius;
+	uint16_t collision_listen_mask;
+	uint16_t collision_create_mask;
+};
+
+struct Player {
+	struct KinematicBody body;
+	vec2 direction;
+	float k_acceleration;
+	float k_angular_speed;
+	bool can_shoot;
+	bool is_thrusting;
+	bool show_thrust;
+	uint8_t thrust_counter;
+};
+
+#define PLAYER_RENDER_RADIUS	INVSQRT2
+
+void player_create(struct Player *player, const vec2 position, const float update_rate)
+{
+	*player = (struct Player){
+		.body = {
+			.position = position,
+			.angle = -PIOVER2,
+			.collision_radius = PLAYER_RENDER_RADIUS,
+			.k_max_speed = 0.375f
+		},
+		.direction = vec2(0.0f, -1.0f),
+		.k_acceleration = 0.375f/update_rate,
+		.k_angular_speed = TWOPI/update_rate,		// 1 revolution per second
+		.can_shoot = true
+	};
+}
+
+void player_input(struct Player *player, const Uint8 *keys)
+{
+	struct KinematicBody *body = &player->body;
+	bool update_direction = false;
+	if (keys[SDL_SCANCODE_LEFT] && !keys[SDL_SCANCODE_RIGHT]) {
+		body->angular_velocity = -player->k_angular_speed;
+		update_direction = true;
+	} else if (keys[SDL_SCANCODE_RIGHT] && !keys[SDL_SCANCODE_LEFT]) {
+		body->angular_velocity = player->k_angular_speed;
+		update_direction = true;
+	} else {
+		body->angular_velocity = 0.0f;
+	}
+	if (keys[SDL_SCANCODE_UP]) {
+		body->acceleration = vscale(player->direction, player->k_acceleration);
+		player->is_thrusting = true;
+	} else {
+		body->acceleration = vec2(0.0f, 0.0f);
+		player->is_thrusting = false;
+	}
+	if (keys[SDL_SCANCODE_Z]) {
+		if (player->can_shoot) {
+			// TODO
+			const vec2 nose = vec2(INVSQRT2, 0.0f);	// Fire out the nose of the ship
+			const vec2 pos = vadd(vcomplex(nose, player->direction), body->position);
+			if (bullets_shoot(&player_bullets, pos, vadd(vscale(player->direction, 0.375f), body->velocity))) {
+				// Successful fire
+			}
+			player->can_shoot = false;
+		}
+	} else {
+		player->can_shoot = true;
+	}
+	if (update_direction) {
+		player->direction.x = cosf(body->angle);
+		player->direction.y = sinf(body->angle);
+	}
+}
+
+void kinematic_integrate(struct KinematicBody *body)
+{
+	body->angle += body->angular_velocity;
+	while (body->angle < 0.0f) body->angle += TWOPI;
+	while (body->angle >= TWOPI) body->angle -= TWOPI;
+
+	body->velocity = vadd(body->velocity, body->acceleration);
+	if (body->velocity.x > body->k_max_speed) {
+		body->velocity.x = body->k_max_speed;
+	} else if (-body->velocity.x > body->k_max_speed) {
+		body->velocity.x = -body->k_max_speed;
+	}
+	if (body->velocity.y > body->k_max_speed) {
+		body->velocity.y = body->k_max_speed;
+	} else if (-body->velocity.y > body->k_max_speed) {
+		body->velocity.y = -body->k_max_speed;
+	}
+	body->position = vadd(body->position, body->velocity);
+}
+
+void kinematic_wrap(struct KinematicBody *body)
+{
+	while (body->position.x > SCREEN_WIDTH_F + body->collision_radius) {
+		body->position.x -= SCREEN_WIDTH_F;
+	}
+	while (body->position.x < -body->collision_radius) {
+		body->position.x += SCREEN_WIDTH_F;
+	}
+	while (body->position.y > SCREEN_HEIGHT_F + body->collision_radius) {
+		body->position.y -= SCREEN_HEIGHT_F;
+	}
+	while (body->position.y < -body->collision_radius) {
+		body->position.y += SCREEN_HEIGHT_F;
+	}
+}
+
+/* Exact center of mass to set the origin of the player 1 - 1/sqrt(2) */
+#define PLAYER_ORIGIN		0.292893219f
+
+static const vec2 player_lines[] = {
+	vec2(1.0f - PLAYER_ORIGIN,  0.0f), vec2(-0.25f - PLAYER_ORIGIN, -0.5f),
+	vec2(1.0f - PLAYER_ORIGIN,  0.0f), vec2(-0.25f - PLAYER_ORIGIN,  0.5f),
+	vec2(0.0f - PLAYER_ORIGIN, -0.4f), vec2( 0.0f  - PLAYER_ORIGIN,  0.4f),
+	vec2(0.0f - PLAYER_ORIGIN, -0.2f), vec2(-0.75f, 0.0f),
+	vec2(0.0f - PLAYER_ORIGIN,  0.2f), vec2(-0.75f, 0.0f)
+};
+
+static void player_draw(struct Player *player, SDL_Renderer *const ren)
+{
+	struct KinematicBody *body = &player->body;
+	const int num_points = player->is_thrusting && player->show_thrust ? 10 : 6;
+	for (int i = 0; i < num_points; i += 2) {
+		const vec2 v1 = vscale(vadd(vcomplex(player_lines[i], player->direction), body->position), RENDER_SCALE);
+		const vec2 v2 = vscale(vadd(vcomplex(player_lines[i+1], player->direction), body->position), RENDER_SCALE);
+		SDL_RenderDrawLine(
+			ren,
+			lroundf(v1.x),
+			lroundf(v1.y),
+			lroundf(v2.x),
+			lroundf(v2.y)
+		);
+	}
+	if (++player->thrust_counter > 1) {
+		player->thrust_counter = 0;
+		player->show_thrust = !player->show_thrust;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	(void)argc;
+	(void)argv;
+	CHECK_SDL(SDL_Init(SDL_INIT_EVERYTHING));
+	SDL_Window *win = SDL_CreateWindow(
+		"Asteroids Clone",
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED,
+		SCREEN_WIDTH,
+		SCREEN_HEIGHT,
+		0
+	);
+	if (!win) fatal_sdl();
+	SDL_Renderer *ren = SDL_CreateRenderer(
+		win,
+		-1,
+		SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC
+	);
+	if (!ren) fatal_sdl();
+
+	struct Player player;
+	player_create(&player, vec2(SCREEN_CENTER_X, SCREEN_CENTER_Y), 60.0f);
+
+	SDL_Event e;
+	for (;;) {
+		while(SDL_PollEvent(&e)) {
+			if (e.type == SDL_QUIT) goto quit;
+			if (e.type == SDL_KEYDOWN &&
+			    e.key.keysym.sym == SDLK_ESCAPE) {
+				goto quit;
+			}
+		}
+		const Uint8 *keys = SDL_GetKeyboardState(NULL);
+		player_input(&player, keys);
+		kinematic_integrate(&player.body);
+		bullets_integrate(&player_bullets);
+		kinematic_wrap(&player.body);
+		SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+		SDL_RenderClear(ren);
+		SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
+		player_draw(&player, ren);
+		bullets_draw(&player_bullets, ren);
+		SDL_RenderPresent(ren);
+	}
+quit:
+	SDL_DestroyRenderer(ren);
+	SDL_DestroyWindow(win);
+	SDL_Quit();
+	return 0;
+}
diff --git a/readme.txt b/readme.txt
new file mode 100644
index 0000000..4efc9e5
--- /dev/null
+++ b/readme.txt
@@ -0,0 +1,5 @@
+Simple Asteroids clone in C as an exercise in game development.
+
+Requires SDL2 for input and drawing. Details for installation at libsdl.org.
+
+Compiles with gcc or clang. Can compile on Windows with clang or mingw.