//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); }