minesweeper-bot/main.c

/*
 * Copyright (c) Camden Dixie O'Brien
 * SPDX-License-Identifier: AGPL-3.0-only
 */

#include "puzz.h"

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>

#define NRUNS 10000
#define MAX_ADJ 8

typedef enum {
	FOUND_MINE,
	FOUND_SAFE,
	FOUND_NOTHING,
	FOUND_CONTRADICTION,
} update_res_t;

typedef struct {
	int mines, unknown;
	puzz_t field;
} state_t;

static void setadj(puzz_t field, int x, int y, uint8_t from, uint8_t to)
{
	FORADJ(x, y, xi, yi)
		field[xi][yi] = field[xi][yi] == from ? to : field[xi][yi];
}

static void getadj(puzz_t field, int *x, int *y, uint8_t val)
{
	FORADJ(*x, *y, xi, yi)
	{
		if (field[xi][yi] == val) {
			*x = xi;
			*y = yi;
			return;
		}
	}
	assert(false);
}

static update_res_t update(state_t *state, int *x_out, int *y_out)
{
	state->mines = state->unknown = 0;

	for (int y = 0; y < HEIGHT; ++y) {
		for (int x = 0; x < WIDTH; ++x) {
			state->mines += state->field[x][y] == MINE ? 1 : 0;
			state->unknown += state->field[x][y] == UNKNOWN ? 1 : 0;
		}
	}

	if (state->mines > NMINES || state->mines + state->unknown < NMINES)
		return FOUND_CONTRADICTION;

	for (int y = 0; y < HEIGHT; ++y) {
		for (int x = 0; x < WIDTH; ++x) {
			if (state->field[x][y] == UNKNOWN || state->field[x][y] == MINE
			    || state->field[x][y] == SAFE)
				continue;

			const int mines = countadj(state->field, x, y, MINE);
			if (mines > state->field[x][y])
				return FOUND_CONTRADICTION;

			const int unknowns = countadj(state->field, x, y, UNKNOWN);
			if (unknowns == 0)
				continue;

			if (mines + unknowns < state->field[x][y])
				return FOUND_CONTRADICTION;

			if (mines + unknowns == state->field[x][y]) {
				setadj(state->field, x, y, UNKNOWN, MINE);
				return FOUND_MINE;
			}

			if (mines == state->field[x][y]) {
				getadj(state->field, &x, &y, UNKNOWN);
				*x_out = x;
				*y_out = y;
				return FOUND_SAFE;
			}
		}
	}

	return FOUND_NOTHING;
}

static update_res_t
search_at(state_t *state, int x, int y, int *x_out, int *y_out)
{
	update_res_t res;

	state_t with_mine;
	memcpy(&with_mine, state, sizeof(state_t));
	with_mine.field[x][y] = MINE;
	do {
		int res_x, res_y;
		switch (res = update(&with_mine, &res_x, &res_y)) {
		case FOUND_MINE:
			break;
		case FOUND_SAFE:
			with_mine.field[res_x][res_y] = SAFE;
			break;
		case FOUND_NOTHING:
			break;
		case FOUND_CONTRADICTION:
			*x_out = x;
			*y_out = y;
			return FOUND_SAFE;
		}
	} while (res == FOUND_MINE);

	state_t with_safe;
	memcpy(&with_safe, state, sizeof(state_t));
	with_safe.field[x][y] = SAFE;
	do {
		int res_x, res_y;
		switch (res = update(&with_safe, &res_x, &res_y)) {
		case FOUND_MINE:
			break;
		case FOUND_SAFE:
			with_safe.field[res_x][res_y] = SAFE;
			break;
		case FOUND_NOTHING:
			break;
		case FOUND_CONTRADICTION:
			state->field[x][y] = MINE;
			return FOUND_MINE;
		}
	} while (res == FOUND_MINE);

	return FOUND_NOTHING;
}

static update_res_t search(state_t *state, int *x_out, int *y_out)
{
	for (int y = 0; y < HEIGHT; ++y) {
		for (int x = 0; x < WIDTH; ++x) {
			if (state->field[x][y] != UNKNOWN)
				continue;

			if (countadj(state->field, x, y, UNKNOWN) != MAX_ADJ) {
				update_res_t res = search_at(state, x, y, x_out, y_out);
				if (res == FOUND_MINE || res == FOUND_SAFE)
					return res;
			}
		}
	}
	return FOUND_NOTHING;
}

static status_t solve(int *turns_out)
{
	state_t state = { .mines = 0, .unknown = WIDTH * HEIGHT };
	memset(state.field, UNKNOWN, sizeof(puzz_t));

	int x = rand() % WIDTH;
	int y = rand() % HEIGHT;

	status_t status;
	int turns = 0;
	do {
		++turns;
		if (state.field[x][y] != MINE
		    && (status = probe(x, y, state.field)) == DEAD)
			break;

		update_res_t res;
		do {
			res = update(&state, &x, &y);
			if (res == FOUND_NOTHING)
				res = search(&state, &x, &y);
		} while (res == FOUND_MINE);

		if (check(state.field) != OK) {
			printf("Incorrect inference! State:\n");
			print(state.field);
			printsoln();
			return INCORRECT;
		}

		if (res == FOUND_NOTHING) {
			x = rand() % WIDTH;
			y = rand() % HEIGHT;
		}
	} while (state.mines < NMINES || state.unknown > 0);

	*turns_out = turns;
	return status;
}

int main(void)
{
	struct timeval tv;
	if (gettimeofday(&tv, NULL) != 0) {
		perror("Failed to get time");
		exit(1);
	}
	srand(tv.tv_usec);

	int nsolved = 0, nfirst = 0, nincorrect = 0, turns;
	for (int i = 0; i < NRUNS; ++i) {
		gen();
		switch (solve(&turns)) {
		case DEAD:
			if (turns == 1)
				++nfirst;
			break;
		case OK:
			++nsolved;
			break;
		case INCORRECT:
			++nincorrect;
			break;
		}
	}

	if (nincorrect > 0) {
		printf(
		    "Fail: %d incorrect! (%0.1f%%)\n", nincorrect,
		    (double)nincorrect / NRUNS);
		return 1;
	}

	const double solved_prop = (double)nsolved / NRUNS;
	const double first_prop = (double)nfirst / NRUNS;
	const double solved_safe_start_prop = (double)nsolved / (NRUNS - nfirst);
	printf("Solved %d (%0.1f%%)\n", nsolved, 100 * solved_prop);
	printf("%d died on first turn (%0.1f%%)\n", nfirst, 100 * first_prop);
	printf("%0.1f%% solved on safe start\n", 100 * solved_safe_start_prop);

	return 0;
}