1a6a8b52f7
Original revision: 5123b1bf68777ffa86e651f178046b26a87cf2d9 MIT Licensed. Some games still crash and others are unplayable due to issues with controls. Still need a "real" polygon filling algorithm. Currently builds one plugin per puzzle (about 40 in total, around 100K each on ARM), but can easily be made to build a single monolithic overlay (800K or so on ARM). The following games are at least partially broken for various reasons, and have been disabled on this commit: Cube: failed assertion with "Icosahedron" setting Keen: input issues Mines: weird stuff happens on target Palisade: input issues Solo: input issues, occasional crash on target Towers: input issues Undead: input issues Unequal: input and drawing issues (concave polys) Untangle: input issues Features left to do: - In-game help system - Figure out the weird bugs Change-Id: I7c69b6860ab115f973c8d76799502e9bb3d52368
88 lines
1.9 KiB
C
88 lines
1.9 KiB
C
/*
|
|
* tdq.c: implement a 'to-do queue', a simple de-duplicating to-do
|
|
* list mechanism.
|
|
*/
|
|
|
|
#include "rbassert.h"
|
|
|
|
#include "puzzles.h"
|
|
|
|
/*
|
|
* Implementation: a tdq consists of a circular buffer of size n
|
|
* storing the integers currently in the queue, plus an array of n
|
|
* booleans indicating whether each integer is already there.
|
|
*
|
|
* Using a circular buffer of size n to store between 0 and n items
|
|
* inclusive has an obvious failure mode: if the input and output
|
|
* pointers are the same, how do you know whether that means the
|
|
* buffer is full or empty?
|
|
*
|
|
* In this application we have a simple way to tell: in the former
|
|
* case, the flags array is all 1s, and in the latter case it's all
|
|
* 0s. So we could spot that case and check, say, flags[0].
|
|
*
|
|
* However, it's even easier to simply determine whether the queue is
|
|
* non-empty by testing flags[buffer[op]] - that way we don't even
|
|
* _have_ to compare ip against op.
|
|
*/
|
|
|
|
struct tdq {
|
|
int n;
|
|
int *queue;
|
|
int ip, op; /* in pointer, out pointer */
|
|
char *flags;
|
|
};
|
|
|
|
tdq *tdq_new(int n)
|
|
{
|
|
int i;
|
|
tdq *tdq = snew(struct tdq);
|
|
tdq->queue = snewn(n, int);
|
|
tdq->flags = snewn(n, char);
|
|
for (i = 0; i < n; i++) {
|
|
tdq->queue[i] = 0;
|
|
tdq->flags[i] = 0;
|
|
}
|
|
tdq->n = n;
|
|
tdq->ip = tdq->op = 0;
|
|
return tdq;
|
|
}
|
|
|
|
void tdq_free(tdq *tdq)
|
|
{
|
|
sfree(tdq->queue);
|
|
sfree(tdq->flags);
|
|
sfree(tdq);
|
|
}
|
|
|
|
void tdq_add(tdq *tdq, int k)
|
|
{
|
|
assert((unsigned)k < (unsigned)tdq->n);
|
|
if (!tdq->flags[k]) {
|
|
tdq->queue[tdq->ip] = k;
|
|
tdq->flags[k] = 1;
|
|
if (++tdq->ip == tdq->n)
|
|
tdq->ip = 0;
|
|
}
|
|
}
|
|
|
|
int tdq_remove(tdq *tdq)
|
|
{
|
|
int ret = tdq->queue[tdq->op];
|
|
|
|
if (!tdq->flags[ret])
|
|
return -1;
|
|
|
|
tdq->flags[ret] = 0;
|
|
if (++tdq->op == tdq->n)
|
|
tdq->op = 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
void tdq_fill(tdq *tdq)
|
|
{
|
|
int i;
|
|
for (i = 0; i < tdq->n; i++)
|
|
tdq_add(tdq, i);
|
|
}
|