examples

gl-asteroids.cpp (14817B)

---

 #include <GLFW/glfw3.h>
 #include <alsa/asoundlib.h>
 #include <cmath>
 #include <vector>
 #include <span>
 #include <random>
 #include <array>
 #include <iostream>
 #include <algorithm>
 #include <thread>
 #include <chrono>
 #include <optional>
 #include <functional>
 
 extern "C" char const* __asan_default_options() { return "detect_leaks=0"; }
 
 /// SOUNDS
 
 using sample = std::span<short>;
 
 std::mutex queued_sounds_mutex;
 std::vector<sample> queued_sounds;
 
 void play_sample(sample s)
 {
 	std::lock_guard lock(queued_sounds_mutex);
 	queued_sounds.push_back(s);
 }
 
 void sound_routine(std::stop_token token)
 {
 	snd_pcm_t* handle;
 
 	snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);
 	snd_pcm_set_params(handle, SND_PCM_FORMAT_S16, SND_PCM_ACCESS_RW_INTERLEAVED, 1, 48000, 1, 10000);
 
 	std::vector<sample> playing_sounds;
 
 	while (not token.stop_requested())
 	{
 		{
 			std::lock_guard lock(queued_sounds_mutex);
 			std::ranges::move(queued_sounds, back_inserter(playing_sounds));
 			queued_sounds.clear();
 		}
 
 		std::array<short, 2048> buf;
 		for (auto& b : buf)
 		{
 			b = 0;
 			std::erase_if(playing_sounds, [](auto s){ return s.empty(); });
 			for (auto& s : playing_sounds)
 			{
 				b += s[0];
 				s = sample{s.data()+1, s.size()-1};
 			}
 		}
 
 		snd_pcm_writei(handle, buf.data(), buf.size());
 	}
 	snd_pcm_drain(handle);
 	snd_pcm_close(handle);
 }
 
 std::jthread sound(sound_routine);
 
 /// GRAPHICS
 
 constexpr int window_size = 700;
 
 struct coord
 {
 	coord() = default;
 	coord(float s)
 	:	x(s)
 	,	y(s)
 	{}
 	coord(float _x, float _y)
 	:	x(_x)
 	,	y(_y)
 	{}
 	float x = 0, y = 0;
 };
 
 struct color
 {
 	float r, g, b;
 };
 
 struct visual
 {
 	GLint mode;
 	std::span<coord const> verts;
 	std::span<color const> cols;
 };
 
 coord const shipv[] = {{0, 2}, {1, -1}, {-1, -1}};
 color const shipc[] = {{1,1,1}, {.5,.5,.5}};
 
 coord const flamev[3] = {{0, -2.5}, {.6, -.25}, {-.6, -.25}};
 color const flamec[] = {{1,0,0}, {1,1,0}};
 
 coord const rockv1[] = {{0, 0}, {1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 0}};
 coord const rockv2[] = {{0, 0}, {1, 0}, {.7,.7}, {0, 1}, {-1, 0}, {-.9,-.9}, {0, -1}, {1, 0}};
 coord const rockv3[] = {{0, 0}, {1, 0}, {.7,.4}, {0, 1}, {-.8,.6}, {-1, 0}, {-.6,-.5}, {0, -1}, {1, 0}};
 coord const rockv4[] = {{0, 0}, {1, 0}, {.6,.4}, {0, .5}, {-.3,.6}, {-1, 0}, {-.6,-.5}, {0, -1}, {1, 0}};
 
 color const rockc[] = {{.5,.5,.5}, {.2,.2,.2}};
 color const powerupcb[] = {{.8,.4,.2}, {.4,.2,.1}};
 color const powerupcf[] = {{.2,.4,.8}, {.1,.2,.4}};
 color const powerupca[] = {{.8,.8,.2}, {.4,.4,.1}};
 
 coord const bulletv[] = {{0, 1}, {.25, .25}, {-.25, .25}, {.25, -1}, {-.25, -1}};
 color const bulletc[] = {{.0,.8,.0}, {.0,.4,.0}, {.0,.4,.0}, {.0,.0,.0}};
 
 coord starsv[64];
 
 visual ship{GL_TRIANGLES, shipv, shipc};
 visual flame{GL_TRIANGLES, flamev, flamec};
 visual bullet(GL_TRIANGLE_STRIP, bulletv, bulletc);
 visual rock1{GL_TRIANGLE_FAN, rockv1, rockc};
 visual rock2{GL_TRIANGLE_FAN, rockv2, rockc};
 visual rock3{GL_TRIANGLE_FAN, rockv3, rockc};
 visual rock4{GL_TRIANGLE_FAN, rockv4, rockc};
 visual powerup_firerate{GL_TRIANGLE_FAN, rockv1, powerupcf};
 visual powerup_bulletspeed{GL_TRIANGLE_FAN, rockv1, powerupcb};
 visual powerup_acceleration{GL_TRIANGLE_FAN, rockv1, powerupca};
 std::array<visual const*, 4> rock_types = {&rock1, &rock2, &rock3, &rock4};
 
 float wrap(float n, float min, float max)
 {
 	if (n >= max)
 		return n - max + min;
 	else if (n < min)
 		return n + max - min;
 	else
 		return n;
 }
 
 void glCoord(coord c)
 {
 	glVertex2f(c.x, c.y);
 }
 void glColor(color c)
 {
 	glColor3f(c.r, c.g, c.b);
 }
 
 coord operator +(coord lhs, coord rhs)
 {
 	return {lhs.x + rhs.x, lhs.y + rhs.y};
 }
 
 coord& operator +=(coord& lhs, coord rhs)
 {
 	return lhs = lhs + rhs;
 }
 
 coord operator -(coord rhs)
 {
 	return {-rhs.x, -rhs.y};
 }
 
 coord operator - (coord lhs, coord rhs)
 {
 	return lhs + -rhs;
 }
 
 coord& operator -=(coord& lhs, coord rhs)
 {
 	return lhs = lhs - rhs;
 }
 
 coord operator *(coord lhs, coord rhs)
 {
 	return {lhs.x * rhs.x, lhs.y * rhs.y};
 }
 
 coord& operator *=(coord& lhs, coord rhs)
 {
 	lhs = lhs * rhs;
 	return lhs;
 }
 
 /// PHYSICS
 
 coord rotate(coord o, float a)
 {
 	float s = sin(a), c = cos(a);
 	return {o.x*c + o.y*s, o.y*c - o.x*s};
 }
 
 coord coord_from_rotation(float a)
 {
 	return {(float)sin(a), (float)cos(a)};
 }
 
 struct physics
 {
 	coord pos, vel;
 	float rot, ang_mom, scale;
 	void move(float dt)
 	{
 		pos += vel * dt;
 		rot += ang_mom * dt;
 	}
 	static void wrap_pos(float& pos, float vel)
 	{
 		if (pos > 1 && vel > 0)
 			pos -= 2;
 		else if (pos < -1 && vel < 0)
 			pos += 2;
 	}
 	void wrap_pos(void)
 	{
 		wrap_pos(pos.x, vel.x);
 		wrap_pos(pos.y, vel.y);
 	}
 	static bool left_axis(float pos, float vel, float scale)
 	{
 		if (vel < 0)
 			pos = -pos;
 
 		return pos > 1 + scale;
 	}
 	bool left_arena() const
 	{
 		return left_axis(pos.x, vel.x, scale) or left_axis(pos.y, vel.y, scale);
 	}
 };
 
 bool is_colliding(physics const& a, physics const& b)
 {
 	float len = a.scale + b.scale;
 	auto d = a.pos - b.pos;
 
 	return d.x * d.x + d.y * d.y < len * len;
 }
 
 void draw(visual const& v, physics const& p)
 {
 	glBegin(v.mode);
 
 	for (unsigned i = 0; i < v.verts.size(); ++i)
 	{
 		if (i < v.cols.size())
 			glColor(v.cols[i]);
 		glCoord(rotate(v.verts[i] * p.scale, p.rot) + p.pos);
 	}
 
 	glEnd();
 }
 
 void draw_wrapped(visual const& v, physics p)
 {
 	static coord const offsets[] = {{0,0}, {2,0}, {-2,2}, {-2,-2}, {2,-2}};
 
 	for (auto o : offsets)
 	{
 		p.pos += o;
 		draw(v, p);
 	}
 }
 
 struct entity
 {
 	visual const* vis;
 	physics phys;
 
 	entity() = delete;
 	entity(visual const& _v, physics _p)
 	:	vis(&_v)
 	,	phys(_p)
 	{}
 
 	void draw()
 	{
 		::draw(*vis, phys);
 	}
 };
 
 static bool left_arena(entity const& e)
 {
 	return e.phys.left_arena();
 }
 
 std::random_device rd;
 std::default_random_engine gen(rd());
 
 struct particle : entity
 {
 	float ttl;
 
 	static particle& make_particle(entity e, float ttl)
 	{
 		static std::uniform_real_distribution<float> d(.5, 1);
 		return particles.emplace_back(e, ttl * d(gen));
 	}
 	static void move_all(float dt)
 	{
 		for (auto& p : particles)
 		{
 			p.ttl -= dt;
 			p.phys.move(dt);
 		}
 		std::erase_if(particles, [](auto& p) { return p.ttl <= 0; });
 		std::erase_if(particles, left_arena);
 	}
 	static void draw_all()
 	{
 		for (auto& p : particles)
 			p.draw();
 	}
 private:
 	static std::vector<particle> particles;
 };
 
 std::vector<particle> particle::particles;
 
 static GLFWwindow* w;
 
 bool is_pressed(int key)
 {
 	return glfwGetKey(w, key) != GLFW_RELEASE;
 }
 
 struct powerup : entity
 {
 	std::function<void(void)> cb;
 
 	powerup(entity e, std::function<void(void)> c)
 	:	entity(e)
 	,	cb(c)
 	{}
 };
 
 std::vector<entity> rocks;
 std::vector<entity> bullets;
 std::optional<powerup> powerups;
 
 physics ship_phys{{}, {}, 0.f, 0.f, .06f};
 bool up = false;
 
 int lives = 3;
 unsigned ammo = 10;
 
 void draw_scene(float t)
 {
 	glClearColor(0,0,0,1);
 	glClear(GL_COLOR_BUFFER_BIT);
 
 	glColor({1,1,1});
 	glBegin(GL_POINTS);
 	for (auto v : starsv)
 		glCoord(v);
 	glEnd();
 
 	particle::draw_all();
 	for (auto& r : rocks)
 		r.draw();
 	for (auto& b : bullets)
 		b.draw();
 	if (powerups)
 		powerups->draw();
 
 	if (up)
 	{
 		auto f = ship_phys;
 		f.scale *= 1 + 0.1 * sin(t * 49) * sin(t * 9);
 		draw_wrapped(flame, f);
 	}
 	draw_wrapped(ship, ship_phys);
 
 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
 	for (int i = 0; i < lives-1; ++i)
 		draw(ship, {{.9f, -.9f + i * .15f}, {}, 0.f, 0.f, .04f});
 
 	glBegin(GL_LINES);
 	glColor({.0,.4,.0});
 	glCoord({-.95f, -.9f});
 	glCoord({-.95f, ammo * .09f - .9f});
 	glEnd();
 
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
 	glfwSwapBuffers(w);
 	glfwPollEvents();
 }
 
 visual const& random_rock_visual(void)
 {
 	static unsigned rtype;
 
 	++rtype;
 	rtype %= rock_types.size();
 
 	return *rock_types[rtype];
 }
 
 void joy_cb(int jid, int event)
 {
 	switch (event)
 	{
 	case GLFW_CONNECTED:
 		std::cout << 'J' << jid << ": CONNECTED\n";
 		return;
 	case GLFW_DISCONNECTED:
 		std::cout << 'J' << jid << ": DISCONNECTED\n";
 		return;
 	default:
 		std::cout << 'J' << jid << ": " << event << '\n';
 	}
 }
 
 int main(int, char* argv[])
 {
 	signed score = 0;
 	float firerate = 2, bullet_speed = 1, acceleration = 0.8;
 
 	std::uniform_real_distribution<float> dis_p(-1,1);
 	std::uniform_real_distribution<float> dis_s(0.05,0.25);
 	std::uniform_real_distribution<float> dis_v(0.02,0.05);
 	std::uniform_int_distribution<int> dis_d(0,7);
 
 	std::array<short, 2 * 512> tone;
 	for (unsigned i = 0; i < tone.size(); ++i)
 		tone[i] = sin(i * 6.283 * 440 / 48000) * 50 * 128;
 
 	std::array<short, 2 * 512> square;
 	for (unsigned i = 0; i < square.size(); ++i)
 		square[i] = ((i & 0x80) - 0x40) * 50;
 
 	std::array<short, 3 * 512> saw;
 	for (unsigned i = 0; i < saw.size(); ++i)
 		saw[i] = (i % 0x80 - 0x40) * 30;
 
 	std::array<short, 8 * 512> blip;
 	for (unsigned i = 0; i < blip.size(); ++i)
 		blip[i] = sin(i * (i + 440) * 6.283 / 10 / 48000) * 50 * 128;
 
 	std::array<short, 16 * 1024> bang;
 	for (unsigned i = 0; i < bang.size(); ++i)
 		bang[i] = 2048 * dis_p(gen) / exp(i * .00005) * (2 + cos(i * 6.283 * 15 / 48000));
 
 	glfwInit();
 
 	w = glfwCreateWindow(window_size, window_size, argv[0], NULL, NULL);
 	glfwSetJoystickCallback(joy_cb);
 	int wx, wy;
 	glfwGetFramebufferSize(w, &wx, &wy);
 	std::cout << "x: " << wx << "    y: " << wy << '\n';
 
 	glfwMakeContextCurrent(w);
 
 	float last_t = glfwGetTime();
 
 	float rock_time = 1, bullet_time = 0, ammo_refill_time = .3, powerup_time = 10;
 
 	for (auto& c : starsv)
 		c.x = dis_p(gen), c.y = dis_p(gen);
 
 	while (!glfwWindowShouldClose(w) && not is_pressed(GLFW_KEY_ESCAPE))
 	{
 		float t = glfwGetTime();
 		float dt = t - last_t;
 
 		if (rock_time < t)
 		{
 			rock_time += (rocks.size() < 3 ? 2 : 6) / log(2*t+1);
 
 			int dir = dis_d(gen);
 
 			auto scale = dis_s(gen);
 			coord p = {dis_p(gen) / 2 - .5f, -1 - scale};
 			coord v(dis_v(gen), dis_v(gen));
 
 			v *= 1+log(t+1);
 
 			if (dir & 1)
 				v.x = -v.x, p.x = -p.x;
 			if (dir & 2)
 				p.y = -p.y, v.y = -v.y;
 			if (dir & 4)
 			{
 				std::swap(p.x, p.y);
 				std::swap(v.x, v.y);
 			}
 
 			static std::uniform_real_distribution<float> ang(-3,3);
 			rocks.emplace_back(random_rock_visual(), physics{p, v, 0, ang(gen), scale});
 		}
 
 		if (powerup_time < t)
 		{
 			powerup_time += 15;
 			int dir = dis_d(gen);
 			auto scale = .03f;
 			static std::uniform_real_distribution<float> pos(-.9,.9);
 			coord p = {pos(gen) / 2 - .5f, -1 - scale};
 			coord v = {0, .3f};
 			if (dir & 1)
 				v.x = -v.x, p.x = -p.x;
 			if (dir & 2)
 				p.y = -p.y, v.y = -v.y;
 			if (dir & 4)
 			{
 				std::swap(p.x, p.y);
 				std::swap(v.x, v.y);
 			}
 
 			visual const* vis;
 			std::function<void(void)> cb;
 
 			static int type;
 			switch (type++ % 3)
 			{
 			case 0:
 				vis = &powerup_bulletspeed;
 				cb = [&firerate](){ firerate += .5f; };
 				break;
 			case 1:
 				vis = &powerup_firerate;
 				cb = [&bullet_speed](){ bullet_speed += .2f; };
 				break;
 			case 2:
 				vis = &powerup_acceleration;
 				cb = [&acceleration](){ acceleration += .2f; };
 				break;
 			}
 
 			powerups.emplace(entity{*vis, physics{p, v, 0, 0, scale}}, cb);
 		}
 
 		if (ammo < 20 && ammo_refill_time < t)
 		{
 			++ammo;
 			ammo_refill_time += .4;
 		}
 
 		if (is_pressed(GLFW_KEY_SPACE) && bullet_time < t && ammo)
 		{
 			play_sample(tone);
 			--ammo;
 			bullet_time = t + 1/firerate;
 
 			bullets.emplace_back(bullet, ship_phys);
 			auto& b = bullets.back().phys;
 
 			b.ang_mom = 0;
 			b.scale /= 1.25;
 			auto vel = coord_from_rotation(b.rot) * bullet_speed;
 			b.vel += vel;
 			ship_phys.vel -= vel * .05f;
 		}
 
 		last_t = t;
 
 		int kl = is_pressed(GLFW_KEY_LEFT);
 		int kr = is_pressed(GLFW_KEY_RIGHT);
 
 		if (kl ^ kr)
 			ship_phys.ang_mom = (kr ? 1 : -1) * (up ? 3 : 2);
 		else
 			ship_phys.ang_mom = 0;
 
 		up = is_pressed(GLFW_KEY_UP);
 
 		if (up)
 			ship_phys.vel += coord_from_rotation(ship_phys.rot) * dt * acceleration;
 
 		// resolve motion
 
 		for (auto& r : rocks)
 			r.phys.move(dt);
 		for (auto& b : bullets)
 			b.phys.move(dt);
 		if (powerups)
 			powerups->phys.move(dt);
 
 		ship_phys.move(dt);
 		ship_phys.wrap_pos();
 		particle::move_all(dt);
 
 		// handle collisions
 
 		for (unsigned i = 0; i < rocks.size();)
 		{
 			auto r = rocks.begin() + i;
 			for (auto b = bullets.begin(); b < bullets.end();)
 			{
 				if (is_colliding(r->phys, b->phys))
 				{
 					play_sample(square);
 					for (unsigned j = 0; j < 7; ++j)
 					{
 						static std::uniform_real_distribution<float> scale(0.005,0.025);
 						entity debris = *r;
 						debris.vis = &random_rock_visual();
 						debris.phys.vel.x += .3 * dis_p(gen);
 						debris.phys.vel.y += .3 * dis_p(gen);
 						debris.phys.scale = scale(gen);
 						particle::make_particle(debris, 1);
 					}
 
 					if (r->phys.scale > .13f)
 					{
 						coord split{dis_v(gen), dis_v(gen)};
 
 						auto nr = *r;
 
 						static std::uniform_real_distribution<float> dis_z(.3,.6);
 						float sf = dis_z(gen);
 
 						r->phys.scale *= sf;
 						nr.phys.scale *= .9 - sf;
 
 						r->vis = &random_rock_visual();
 						nr.vis = &random_rock_visual();
 
 						r->phys.vel += 2*split;
 						nr.phys.vel -= split;
 
 						nr.phys.ang_mom *= -1.5f;
 
 						rocks.push_back(nr);
 						++i;
 					}
 					else
 						rocks.erase(r);
 
 					b = bullets.erase(b);
 					score += 3;
 					goto bang;
 				}
 				++b;
 			}
 			++i;
 		bang:	continue;
 		}
 
 		if (powerups)
 		{
 			for (auto b = bullets.begin(); b < bullets.end(); ++b)
 			{
 				if (not is_colliding(b->phys, powerups->phys))
 					continue;
 
 				play_sample(saw);
 
 				for (unsigned j = 0; j < 4; ++j)
 				{
 					entity debris = *powerups;
 					debris.phys.vel.x += .3 * dis_p(gen);
 					debris.phys.vel.y += .3 * dis_p(gen);
 					debris.phys.scale *= 1.5 * dis_s(gen);
 					particle::make_particle(debris, 2);
 				}
 				powerups.reset();
 				score -= 10;
 				bullets.erase(b);
 				break;
 			}
 			if (is_colliding(ship_phys, powerups->phys))
 			{
 				play_sample(blip);
 				powerups->cb();
 				powerups.reset();
 				score += 10;
 			}
 		}
 
 		for (auto r = rocks.begin(); r != rocks.end(); /**/)
 		{
 			if (!is_colliding(ship_phys, r->phys))
 			{
 				++r;
 				continue;
 			}
 
 			play_sample(bang);
 			lives--;
 
 			for (unsigned j = 0; j < 7; ++j)
 			{
 				static std::uniform_real_distribution<float> scale(0.005,0.025);
 				entity debris = *r;
 				debris.vis = &random_rock_visual();
 				debris.phys.vel.x += .3 * dis_p(gen);
 				debris.phys.vel.y += .3 * dis_p(gen);
 				debris.phys.scale = scale(gen);
 				particle::make_particle(debris, 1);
 			}
 			r = rocks.erase(r);
 		}
 
 		if (!lives)
 		{
 			using namespace std::chrono_literals;
 			auto timeout = std::chrono::steady_clock::now() + 1s;
 			score += t;
 			std::cout << "Score: " << score << '\n';
 			while (std::chrono::steady_clock::now() < timeout)
 				draw_scene(t);
 			break;
 		}
 
 		score -= std::erase_if(bullets, left_arena);
 		score -= std::erase_if(rocks, left_arena);
 
 		if (powerups && left_arena(*powerups))
 		{
 			powerups.reset();
 			--score;
 		}
 
 		draw_scene(t);
 	}
 
 	glfwDestroyWindow(w);
 	glfwTerminate();
 
 	return 0;
 }