FuzzyChess * fuzzy_chess_add(FuzzyGame * game, FuzzyPlayer * pg, FuzzyFooes foo, ulong x, ulong y)
{
char * grp = GID_LINK;
FuzzyArea * atkarea;
FuzzyChess * chess;
// Select foo asset
switch (foo) {
case FUZZY_FOO_LINK:
grp = GID_LINK;
atkarea = &FuzzyMeleeMan;
break;
}
chess = fuzzy_new(FuzzyChess);
chess->x = x;
chess->y = y;
chess->atkarea = atkarea;
chess->owner = pg;
fuzzy_list_null(chess);
fuzzy_sprite_create(game->map, FUZZY_LAYER_SPRITES, grp, x, y);
fuzzy_list_append(FuzzyChess, pg->chess_l, chess);
return chess;
}
Fuzzy *
fuzzy_new_with_free_func (gboolean case_sensitive,
GDestroyNotify free_func)
{
Fuzzy *fuzzy;
fuzzy = fuzzy_new(case_sensitive);
fuzzy_set_free_func(fuzzy, free_func);
return fuzzy;
}
static PyObject *
_cffi_f_fuzzy_new(PyObject *self, PyObject *no_arg)
{
struct fuzzy_state * result;
Py_BEGIN_ALLOW_THREADS
_cffi_restore_errno();
{ result = fuzzy_new(); }
_cffi_save_errno();
Py_END_ALLOW_THREADS
return _cffi_from_c_pointer((char *)result, _cffi_type(3));
}
FuzzyGame * fuzzy_game_new(char * mapname)
{
FuzzyGame * game;
fuzzy_areadb_init();
fuzzy_map_setup();
game = fuzzy_new(FuzzyGame);
game->players = NULL;
game->_pctr = 0;
game->map = fuzzy_map_load(mapname);
fuzzy_map_update(game->map, 0);
return game;
}
/* player related */
FuzzyPlayer * fuzzy_player_new(FuzzyGame * game, FuzzyFuzzyPlayerType type, char * name)
{
FuzzyPlayer * player;
player = fuzzy_new(FuzzyPlayer);
player->id = (game->_pctr)++;
player->chess_l = NULL;
player->type = type;
player->soul_time = 0;
player->soul_points = SOUL_POINTS_INITIAL;
fuzzy_list_null(player);
strncpy(player->name, name, sizeof(player->name));
fuzzy_list_append(FuzzyPlayer, game->players, player);
return player;
}
std::string fuzzy::calc_digest ()
{
fuzzy_state * ctx = fuzzy_new () ;
auto_fuzzy_state afs (ctx) ;
if (ctx == 0)
THROW_XDELTA_EXCEPTION_NO_ERRNO ("Out of memory") ;
char_buffer<uchar_t> buff (BUFLEN);
reader_.open_file () ;
while (true ) {
int bytes = reader_.read_file (buff.begin (), (uint32_t)buff.size ());
if (bytes == 0 )
break ;
if (0 != fuzzy_update (afs.ctx, buff.begin (), bytes))
THROW_XDELTA_EXCEPTION ("fuzzy update failed.") ;
}
char result [FUZZY_MAX_RESULT];
if (0 != fuzzy_digest (afs.ctx, result, FUZZY_FLAG_ELIMSEQ))
THROW_XDELTA_EXCEPTION ("fuzzy digest failed.");
reader_.close_file () ;
return std::string(result) ;
}
int
main (int argc,
char *argv[])
{
IdeLineReader reader;
const gchar *param;
Fuzzy *fuzzy;
GArray *ar;
gchar *contents;
gchar *line;
gsize len;
gsize line_len;
if (argc < 3)
{
g_printerr ("usage: %s FILENAME QUERY\n", argv[0]);
return 1;
}
fuzzy = fuzzy_new (FALSE);
g_print ("Loading contents\n");
g_file_get_contents (argv [1], &contents, &len, NULL);
g_print ("Loaded\n");
ide_line_reader_init (&reader, contents, len);
fuzzy_begin_bulk_insert (fuzzy);
g_print ("Building index.\n");
while ((line = ide_line_reader_next (&reader, &line_len)))
{
line [line_len] = '\0';
fuzzy_insert (fuzzy, line, NULL);
}
fuzzy_end_bulk_insert (fuzzy);
g_print ("Built.\n");
g_free (contents);
if (!g_utf8_validate (argv[2], -1, NULL))
{
g_critical ("Invalid UTF-8 discovered, aborting.");
return EXIT_FAILURE;
}
if (strlen (argv[2]) > 256)
{
g_critical ("Only supports searching of up to 256 characters.");
return EXIT_FAILURE;
}
param = (const gchar *)argv[2];
ar = fuzzy_match (fuzzy, param, 0);
for (guint i = 0; i < ar->len; i++)
{
FuzzyMatch *m = &g_array_index (ar, FuzzyMatch, i);
g_print ("%0.3lf: %s\n", m->score, m->key);
}
g_print ("%d matches\n", ar->len);
g_array_unref (ar);
fuzzy_unref (fuzzy);
return 0;
}
