//Returns 0 for no currentpolled event,
// -1, 'nothing to say' (for _some_ reason)
int poll_event()
{
SDL_Event event;
if( SDL_PollEvent(&event) )
{
switch(event.type)
{
case SDL_MOUSEMOTION:
mouse_pos.x = event.button.x;
mouse_pos.y = event.button.y;
return _MOUSE_MOTION;
case SDL_MOUSEBUTTONDOWN:
return +mouse_index(event.button.button);
case SDL_MOUSEBUTTONUP:
return -mouse_index(event.button.button);
case SDL_KEYDOWN:
return +key_index(event.key.keysym.sym);
case SDL_KEYUP:
return -key_index(event.key.keysym.sym);
break;
case SDL_QUIT:
return 1100;
case SDL_VIDEORESIZE:
return 1101;
case SDL_VIDEOEXPOSE:
return 1102;
case SDL_SYSWMEVENT:
return 1103;
default: //NOTE: just mousedown atm.
return _ID_FAILED;
}
}
return 0;
}
void endstate(
dict *d, lin_dict *ko_ld,
node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes,
state *s, node_value parent_v, int turn, int low_player
) {
if (s->passes == 2) {
if (turn) {
stones_t temp = s->player;
s->player = s->opponent;
s->opponent = temp;
}
return;
}
state child_;
state *child = &child_;
for (int j = -1; j < STATE_SIZE; j++) {
*child = *s;
stones_t move;
if (j == -1){
move = 0;
}
else {
move = 1UL << j;
}
node_value child_v;
if (make_move(child, move)) {
canonize(child);
size_t child_key = to_key(child);
if (child->passes == 2){
value_t score = liberty_score(child);
child_v = (node_value) {score, score, 0, 0};
}
else if (child->passes == 1) {
child_v = pass_nodes[key_index(d, child_key)];
}
else if (child->ko) {
child_key = child_key * STATE_SIZE + bitscan(child->ko);
child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
}
else {
child_v = base_nodes[key_index(d, child_key)];
}
int is_best_child = (-child_v.high == parent_v.low && child_v.high_distance + 1 == parent_v.low_distance);
is_best_child = low_player ? is_best_child : (-child_v.low == parent_v.high && child_v.low_distance + 1 == parent_v.high_distance);
if (is_best_child) {
*s = *child;
endstate(
d, ko_ld,
base_nodes, pass_nodes, ko_nodes,
s, child_v, !turn, !low_player
);
}
}
}
}
/** sort_hosts:
** Sorts #hosts# based on common prefix match and key distance from #Key#
*/
void sort_hosts (void *logs, ChimeraHost ** hosts, Key key, int size)
{
int i, j;
ChimeraHost *tmp;
Key dif1;
Key dif2;
int pmatch1 = 0;
int pmatch2 = 0;
for (i = 0; i < size; i++)
{
for (j = i + 1; j < size; j++)
{
if (hosts[i] != NULL && hosts[j] != NULL)
{
pmatch1 = key_index (logs, key, hosts[i]->key);
pmatch2 = key_index (logs, key, hosts[j]->key);
if (pmatch2 > pmatch1)
{
tmp = hosts[i];
hosts[i] = hosts[j];
hosts[j] = tmp;
}
else if (pmatch1 == pmatch2)
{
key_distance (logs, &dif1, &hosts[i]->key,
&key);
key_distance (logs, &dif2, &hosts[j]->key,
&key);
if (key_comp (&dif2, &dif1) < 0)
{
tmp = hosts[i];
hosts[i] = hosts[j];
hosts[j] = tmp;
}
}
}
}
}
}
int keydiv_dtable::remove(const dtype & key, ATX_DEF)
{
size_t index = key_index(key);
assert(index < sub.size());
if(atx != NO_ABORTABLE_TX)
{
int r = map_atx(&atx, index);
if(r < 0)
return r;
}
return sub[index]->remove(key, atx);
}
int keydiv_dtable::insert(const dtype & key, const blob & blob, bool append, ATX_DEF)
{
size_t index = key_index(key);
assert(index < sub.size());
if(atx != NO_ABORTABLE_TX)
{
int r = map_atx(&atx, index);
if(r < 0)
return r;
}
return sub[index]->insert(key, blob, append, atx);
}
blob keydiv_dtable::lookup(const dtype & key, bool * found, ATX_DEF) const
{
size_t index = key_index(key);
assert(index < sub.size());
if(atx != NO_ABORTABLE_TX)
if(map_atx(&atx, index) < 0)
{
*found = false;
return blob();
}
return sub[index]->lookup(key, found, atx);
}
void find_keys(struct onak_dbctx *dbctx,
char *search, uint64_t keyid,
struct openpgp_fingerprint *fingerprint,
bool ishex, bool isfp, bool dispfp, bool skshash,
bool exact, bool verbose, bool mrhkp)
{
struct openpgp_publickey *publickey = NULL;
int count = 0;
if (ishex) {
count = dbctx->fetch_key_id(dbctx, keyid, &publickey,
false);
} else if (isfp) {
count = dbctx->fetch_key_fp(dbctx, fingerprint, &publickey,
false);
} else {
count = dbctx->fetch_key_text(dbctx, search, &publickey);
}
if (publickey != NULL) {
if (mrhkp) {
printf("info:1:%d\n", count);
mrkey_index(publickey);
} else {
key_index(dbctx, publickey, verbose, dispfp,
skshash, true);
}
free_publickey(publickey);
} else if (count == 0) {
if (mrhkp) {
puts("info:1:0");
} else {
puts("Key not found.");
}
} else {
if (mrhkp) {
puts("info:1:0");
} else {
printf("Found %d keys, but maximum number to return"
" is %d.\n",
count,
config.maxkeys);
puts("Try again with a more specific search.");
}
}
}
/**
* hash_table_set - adds an element to the hash table
* @ht: the table
* @key: index where to add
* @value: value to be added
* Return: 1 for success, 0 for failure
*/
int hash_table_set(hash_table_t *ht, const char *key, const char *value)
{
hash_node_t *array_ptr, *new_node;
unsigned long int index;
if (!ht || !key || !value)
return (0);
index = key_index((const unsigned char *)key, ht->size);
array_ptr = ht->array[index];
while (array_ptr)
{
if (strcmp(key, array_ptr->key) == 0)
{
free(array_ptr->value);
array_ptr->value = strdup(value);
return (1);
}
array_ptr = array_ptr->next;
}
new_node = malloc(sizeof(hash_node_t));
if (!new_node)
return (0);
new_node->key = strdup(key);
if (!(new_node->key))
{
free(new_node);
return (0);
}
new_node->value = strdup(value);
if (!(new_node->value))
{
free(new_node->key);
free(new_node);
return (0);
}
new_node->next = (ht->array[index]);
ht->array[index] = new_node;
return (1);
}
void scan_matrix(void) {
pressed_count = 0;
for (int row=0; row<row_count; row++) {
// activate row
digitalWrite(row_pins[row], LOW);
_delay_us(50);
for (int col=0; col<col_count; col++) {
int index = key_index(row, col);
raw_presses[index] <<= 1;
if (!digitalRead(col_pins[col])) {
raw_presses[index] += 1;
if ((raw_presses[index] & 255) == 255) {
presses[pressed_count++] = index;
}
}
}
// deactivate row
digitalWrite(row_pins[row], HIGH);
}
}
void route_update (ChimeraState * state, ChimeraHost * host, int joined)
{
int i, j, k, found, pick;
ChimeraHost *tmp, *deleted = NULL, *added = NULL;
RouteGlobal *routeglob = (RouteGlobal *) state->route;
pthread_mutex_lock (&routeglob->lock);
if (key_equal (routeglob->me->key, host->key))
{
pthread_mutex_unlock (&routeglob->lock);
return;
}
i = key_index (state->log, routeglob->me->key, host->key);
j = hexalpha_to_int (get_key_string (&host->key)[i]);
/*join */
if (joined)
{
found = 0;
for (k = 0; k < MAX_ENTRY; k++)
{
if (routeglob->table[i][j][k] == NULL)
{
routeglob->table[i][j][k] =
host_get (state, host->name, host->port);
leafset_update (state, host, joined, &deleted,
&added);
found = 1;
break;
}
else if (routeglob->table[i][j][k] != NULL
&& key_equal (routeglob->table[i][j][k]->key,
host->key))
{
pthread_mutex_unlock (&routeglob->lock);
return;
}
}
/* the entry array is full we have to get rid of one */
/* replace the new node with the node with the highest latncy in the entry array */
if (!found)
{
pick = 0;
for (k = 1; k < MAX_ENTRY; k++)
{
if (routeglob->table[i][j][pick]->success_avg >
routeglob->table[i][j][k]->success_avg)
pick = k;
}
host_release (state, routeglob->table[i][j][pick]);
routeglob->table[i][j][pick] =
host_get (state, host->name, host->port);
leafset_update (state, host, joined, &deleted, &added);
}
}
/*delete */
else
{
for (k = 0; k < MAX_ENTRY; k++)
if (routeglob->table[i][j][k] != NULL
&& key_equal (routeglob->table[i][j][k]->key, host->key))
{
host_release (state, routeglob->table[i][j][k]);
routeglob->table[i][j][k] = NULL;
break;
}
leafset_update (state, host, joined, &deleted, &added);
}
if (deleted != NULL)
{
leafset_range_update (routeglob, &(routeglob->Rrange),
&(routeglob->Lrange));
chimera_update_upcall (state, &(deleted->key), deleted, 0);
}
if (added != NULL)
{
leafset_range_update (routeglob, &(routeglob->Rrange),
&(routeglob->Lrange));
chimera_update_upcall (state, &(added->key), added, 1);
}
pthread_mutex_unlock (&routeglob->lock);
fflush (stderr);
}
void iterate(
dict *d, lin_dict *ko_ld,
node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes, value_t *leaf_nodes,
state *s, size_t key_min, int japanese_rules
) {
state child_;
state *child = &child_;
size_t num_states = num_keys(d);
int changed = 1;
while (changed) {
changed = 0;
size_t key = key_min;
for (size_t i = 0; i < 2 * num_states + ko_ld->num_keys; i++) {
if (i < 2 * num_states) {
assert(from_key(s, key));
if (i % 2 == 1) {
s->passes = 1;
}
}
else {
key = ko_ld->keys[i - 2 * num_states];
size_t ko_pos = key % STATE_SIZE;
key /= STATE_SIZE;
assert(from_key(s, key));
s->ko = 1UL << ko_pos;
}
node_value new_v = (node_value) {VALUE_MIN, VALUE_MIN, DISTANCE_MAX, 0};
for (int j = -1; j < STATE_SIZE; j++) {
size_t child_key;
node_value child_v;
*child = *s;
stones_t move;
if (j == -1){
move = 0;
}
else {
move = 1UL << j;
}
if (make_move(child, move)) {
canonize(child);
child_key = to_key(child);
if (child->passes == 2){
value_t score = leaf_nodes[key_index(d, child_key)];
child_v = (node_value) {score, score, 0, 0};
}
else if (child->passes == 1) {
child_v = pass_nodes[key_index(d, child_key)];
}
else if (child->ko) {
child_key = child_key * STATE_SIZE + bitscan(child->ko);
child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
}
else {
child_v = base_nodes[key_index(d, child_key)];
}
if (japanese_rules) {
int prisoners = (popcount(s->opponent) - popcount(child->player)) * PRISONER_VALUE;
if (child_v.low > VALUE_MIN) {
child_v.low = child_v.low - prisoners;
}
if (child_v.high < VALUE_MAX) {
child_v.high = child_v.high - prisoners;
}
}
new_v = negamax(new_v, child_v);
}
}
assert(new_v.high_distance > 0);
if (i < 2 * num_states) {
if (i % 2 == 0) {
assert(new_v.low_distance > 1);
assert(new_v.high_distance > 1);
assert(new_v.low >= base_nodes[i / 2].low);
assert(new_v.high <= base_nodes[i / 2].high);
changed = changed || !equal(base_nodes[i / 2], new_v);
base_nodes[i / 2] = new_v;
}
else {
changed = changed || !equal(pass_nodes[i / 2], new_v);
pass_nodes[i / 2] = new_v;
key = next_key(d, key);
}
}
else {
changed = changed || !equal(ko_nodes[i - 2 * num_states], new_v);
ko_nodes[i - 2 * num_states] = new_v;
}
}
print_node(base_nodes[0]);
}
for (size_t i = 0; i < ko_ld->num_keys; i++) {
assert(ko_nodes[i].low_distance > 2);
assert(ko_nodes[i].high_distance > 2);
}
for (size_t i = 0; i < num_states; i++) {
assert(base_nodes[i].low_distance > 1);
assert(base_nodes[i].high_distance > 1);
assert(pass_nodes[i].low_distance > 0);
assert(pass_nodes[i].high_distance > 0);
}
}
int main(int argc, char *argv[]) {
if (argc != 3 && argc != 4) {
printf("Usage: %s width height high_path\n", argv[0]);
return 0;
}
int width = atoi(argv[1]);
int height = atoi(argv[2]);
if (width <= 0) {
printf("Width must be larger than 0.\n");
return 0;
}
if (width >= 7) {
printf("Width must be less than 7.\n");
return 0;
}
if (height <= 0) {
printf("Height must be larger than 0.\n");
return 0;
}
if (height >= 6) {
printf("Height must be less than 6.\n");
return 0;
}
int player_low = 1;
if (argc == 4) {
player_low = 0;
}
state s_ = (state) {rectangle(width, height), 0, 0, 0, 0};
state *s = &s_;
char dir_name[16];
sprintf(dir_name, "%dx%d", width, height);
assert(chdir(dir_name) == 0);
dict d_;
dict *d = &d_;
d->num_slots = load_dat("d_slots.dat", (void**) &(d->slots), sizeof(slot_t));
load_dat("d_checkpoints.dat", (void**) &(d->checkpoints), sizeof(size_t));
lin_dict ko_ld_;
lin_dict *ko_ld = &ko_ld_;
ko_ld->num_keys = load_dat("ko_ld_keys.dat", (void**) &(ko_ld->keys), sizeof(size_t));
node_value *base_nodes;
load_dat("base_nodes_j.dat", (void**) &base_nodes, sizeof(node_value));
node_value *pass_nodes;
load_dat("pass_nodes_j.dat", (void**) &pass_nodes, sizeof(node_value));
node_value *ko_nodes;
load_dat("ko_nodes_j.dat", (void**) &ko_nodes, sizeof(node_value));
value_t *leaf_nodes;
load_dat("leaf_nodes_j.dat", (void**) &leaf_nodes, sizeof(value_t));
canonize(s);
inspect(
d, ko_ld,
base_nodes, pass_nodes, ko_nodes, leaf_nodes,
s, base_nodes[key_index(d, to_key(s))], player_low, 1
);
/*
FILE *f;
f = fopen("d_slots.dat", "wb");
fwrite((void*) d->slots, sizeof(slot_t), d->num_slots, f);
fclose(f);
f = fopen("d_checkpoints.dat", "wb");
fwrite((void*) d->checkpoints, sizeof(size_t), (d->num_slots >> 4) + 1, f);
fclose(f);
f = fopen("ko_ld_keys.dat", "wb");
fwrite((void*) ko_ld->keys, sizeof(size_t), ko_ld->num_keys, f);
fclose(f);
*/
}
void inspect(
dict *d, lin_dict *ko_ld,
node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes, value_t *leaf_nodes,
state *s, node_value parent_v, int low_player, int japanese_rules
) {
print_state(s);
print_node(parent_v);
if (s->passes == 2){
return;
}
state child_;
state *child = &child_;
for (int j = -1; j < STATE_SIZE; j++) {
*child = *s;
stones_t move;
if (j == -1){
move = 0;
}
else {
move = 1UL << j;
}
node_value child_v;
if (make_move(child, move)) {
canonize(child);
size_t child_key = to_key(child);
if (child->passes == 2){
value_t score = leaf_nodes[key_index(d, child_key)];
child_v = (node_value) {score, score, 0, 0};
}
else if (child->passes == 1) {
child_v = pass_nodes[key_index(d, child_key)];
}
else if (child->ko) {
child_key = child_key * STATE_SIZE + bitscan(child->ko);
child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
}
else {
child_v = base_nodes[key_index(d, child_key)];
}
node_value child_tree_v = child_v;
if (japanese_rules) {
int prisoners = (popcount(s->opponent) - popcount(child->player)) * PRISONER_VALUE;
if (child_v.low > VALUE_MIN) {
child_v.low = child_v.low - prisoners;
}
if (child_v.high < VALUE_MAX) {
child_v.high = child_v.high - prisoners;
}
}
int is_best_child = (-child_v.high == parent_v.low && child_v.high_distance + 1 == parent_v.low_distance);
is_best_child = low_player ? is_best_child : (-child_v.low == parent_v.high && child_v.low_distance + 1 == parent_v.high_distance);
if (is_best_child) {
*s = *child;
inspect(
d, ko_ld,
base_nodes, pass_nodes, ko_nodes, leaf_nodes,
s, child_tree_v, !low_player, japanese_rules
);
return;
}
}
}
assert(0);
}
