randomwalk/main.cpp

#include <SDL2/SDL.h>

#include <algorithm>
#include <chrono>
#include <functional>
#include <memory>
#include <print>
#include <random>
#include <vector>

template <typename SDLT, auto deletef>
struct sdl_wrapper_t : std::unique_ptr<SDLT, decltype(deletef)> {
	explicit sdl_wrapper_t(SDLT* p)
		: std::unique_ptr<SDLT, decltype(deletef)>{p, deletef} {}

	operator SDLT*() { return std::unique_ptr<SDLT, decltype(deletef)>::get(); }
};

using window_t = sdl_wrapper_t<SDL_Window, SDL_DestroyWindow>;
using surface_t = sdl_wrapper_t<SDL_Surface, SDL_FreeSurface>;
using renderer_t = sdl_wrapper_t<SDL_Renderer, SDL_DestroyRenderer>;

auto operator+(SDL_Point a, SDL_Point b) {
	return SDL_Point{.x = a.x + b.x, .y = a.y + b.y};
}

auto operator<=>(const SDL_Point& a, const SDL_Point& b) {
	auto y_comp = a.x <=> b.x;
	if (y_comp != std::strong_ordering::equal) { return y_comp; }
	return a.y <=> b.y;
}

auto operator==(const SDL_Point& a, const SDL_Point& b) {
	return a.x == b.x && a.y == b.y;
}

constexpr int width = 1000;
constexpr int height = 1000;

template <auto EF>
struct [[nodiscard("give this a name so SDL_Quit is called at the end"
)]] Defer {
	Defer() = default;
	Defer(const Defer&) = delete;
	Defer(Defer&&) = delete;
	auto operator=(Defer&&) = delete;
	auto operator=(const Defer&) = delete;

	~Defer() { EF(); }
};

int main() {
	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
		std::println("fuck");
		return EXIT_FAILURE;
	}
	Defer<SDL_Quit> defer_SDL_Quit;

	window_t window{SDL_CreateWindow(
		"random walk", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width,
		height, 0
	)};
	if (!window) {
		std::println(
			"Window could not be created! SDL_Error: {}", SDL_GetError()
		);
		return EXIT_FAILURE;
	}

	// owned by window
	auto* window_surface = SDL_GetWindowSurface(window);
	if (!window_surface) { return EXIT_FAILURE; }
	if (window_surface->format->palette) { return EXIT_FAILURE; }

	SDL_Point pos{.x = width / 2, .y = height / 2};
	const SDL_Point directions[] = {
		{.x = -1, .y = 0}, {.x = 1, .y = 0}, {.x = 0, .y = -1}, {.x = 0, .y = 1}
	};

	std::mt19937_64 rne(std::random_device{}());
	std::uniform_int_distribution dist(0, 3);

	for (bool continu = true; continu;) {

		{
			SDL_Point newpoint;
			do {
				newpoint = pos + directions[dist(rne)];
			} while (newpoint.x < 0 or newpoint.x >= width or newpoint.y < 0 or
			         newpoint.y >= height);
			pos = newpoint;
		}

		for (SDL_Event e; SDL_PollEvent(&e);) {
			if (e.type == SDL_QUIT) { continu = false; }
		}

		SDL_UpdateWindowSurface(window);
	}

	// leaking memory, nothing I can do
}