void sprite_load_meta_file(char* filename, DArray *meta_info) {
FILE *file = fopen ( filename, "r" );
char line[LINE_BUFF_SIZE];
char* pch;
memset(line, '\0', LINE_BUFF_SIZE);
darray_init(meta_info);
if ( file != NULL ) {
while(fgets(line, sizeof line, file) != NULL) {
int val = 0;
fputs (line, stdout);
pch = strtok (line," ,.-");
val = atoi(pch);
darray_add(meta_info, val);
while(pch != NULL) {
//printf ("%i\n",val);
pch = strtok (NULL, " ,.-");
if(pch != NULL) {
val = atoi(pch);
darray_add(meta_info, val);
}
}
}
fclose(file);
}
else {
perror(filename);
}
}
void problem_02_test_basic(){
/* declare and initialize a new array */
DArray array;
int majority = 0;
darray_init(&array);
/* initialize array */
darray_append(&array, 3);
darray_append(&array, 3);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 4);
majority = find_majority_basic(&array);
if(majority == FAILURE){
printf("No majority value found!\n");
}else{
printf("Majority value: %d\n", majority);
}
/* free up the underlying array */
darray_free(&array);
}
DArray * darray_radix_sort(DArray *array) {
DArray *buckets, *bucket;
int *val, i, j, cur, mask, sortval, sorted;
buckets = darray_init();
mask = 1;
do {
sorted = 1;
// reset the buckets
for (i = 0; i < 10; i++) {
darray_set(buckets, i, darray_init());
}
// sort the values into buckets
for (i = 0; i <= (array->last); i++) {
val = (int*)darray_get(array, i);
sortval = (*val / mask) % 10;
if (sortval > 0) { sorted = 0; }
darray_push((PDArray)darray_get(buckets, sortval), val);
}
// rebuild array
cur = 0;
for (i = 0; i < 10; i++) {
bucket = (PDArray)darray_get(buckets, i);
for (j = 0; j <= (bucket->last); j++) {
darray_set(array,
cur++,
darray_get(bucket, j));
}
}
mask *= 10;
} while (!sorted);
return array;
}
void
rsynth_phones(rsynth_t * rsynth, char *phone, int len)
{
darray_t elm;
darray_t f0;
unsigned frames;
darray_init(&elm, sizeof(char), len);
darray_init(&f0, sizeof(float), len);
if ((frames = phone_to_elm(rsynth, len, phone, &elm, &f0))) {
if (rsynth_verbose(rsynth))
fprintf(stderr, "[%.*s]\n", len, phone);
rsynth_flush(rsynth,
rsynth_interpolate(rsynth,
(unsigned char *) darray_find(&elm, 0),elm.items,
(float *) darray_find(&f0,0),
f0.items));
}
darray_free(&f0);
darray_free(&elm);
}
// Flushes the queue, blocks until all queries are processed and then performs
// a little cleanup.
void db_close() {
// Send a END message to the database thread
GByteArray *a = g_byte_array_new();
darray_init(a);
darray_add_int32(a, DBF_END);
g_async_queue_push(db_queue, g_byte_array_free(a, FALSE));
// And wait for it to quit
g_thread_join(db_thread);
g_async_queue_unref(db_queue);
db_queue = NULL;
}
int
master_init(vr_conf *conf)
{
rstatus_t status;
uint32_t j;
sds *host, listen_str;
vr_listen **vlisten;
int threads_num;
int filelimit;
master.cbsul = NULL;
pthread_mutex_init(&master.cbsullock, NULL);
conf_server_get(CONFIG_SOPN_THREADS,&threads_num);
filelimit = threads_num*2+CONFIG_MIN_RESERVED_FDS;
vr_eventloop_init(&master.vel,filelimit);
master.vel.thread.fun_run = master_thread_run;
darray_init(&master.listens,darray_n(&cserver->binds),sizeof(vr_listen*));
for (j = 0; j < darray_n(&cserver->binds); j ++) {
host = darray_get(&cserver->binds,j);
listen_str = sdsdup(*host);
listen_str = sdscatfmt(listen_str, ":%i", cserver->port);
vlisten = darray_push(&master.listens);
*vlisten = vr_listen_create(listen_str);
if (*vlisten == NULL) {
darray_pop(&master.listens);
log_error("Create listen %s failed", listen_str);
sdsfree(listen_str);
return VR_ERROR;
}
sdsfree(listen_str);
}
for (j = 0; j < darray_n(&master.listens); j ++) {
vlisten = darray_get(&master.listens, j);
status = vr_listen_begin(*vlisten);
if (status != VR_OK) {
log_error("Begin listen to %s failed", (*vlisten)->name);
return VR_ERROR;
}
}
master.cbsul = dlistCreate();
if (master.cbsul == NULL) {
log_error("Create list failed: out of memory");
return VR_ENOMEM;
}
setup_master();
return VR_OK;
}
state_t* new_state(int in_cnt, int out_cnt)
{
state_t *st = (state_t*)calloc(1, sizeof(state_t));
if (!st)
goto err;
if ((st->in = darray_init(in_cnt, sizeof(edge_t*))) == NULL)
goto err;
if ((st->out = darray_init(out_cnt, sizeof(edge_t*))) == NULL)
goto err;
return st;
err:
if (st)
free(st->in);
free(st);
return NULL;
}
// Give back a final response and unref the queue.
static void db_queue_item_final(GAsyncQueue *res, int code, gint64 lastid) {
if(!res)
return;
GByteArray *r = g_byte_array_new();
darray_init(r);
darray_add_int32(r, code);
if(code == SQLITE_DONE)
darray_add_int64(r, lastid);
g_async_queue_push(res, g_byte_array_free(r, FALSE));
g_async_queue_unref(res);
}
// The query is assumed to be a static string that is not freed or modified.
static void *db_queue_item_create(int flags, const char *q, ...) {
GByteArray *a = g_byte_array_new();
darray_init(a);
darray_add_int32(a, flags);
darray_add_ptr(a, q);
int t;
char *p;
va_list va;
va_start(va, q);
while((t = va_arg(va, int)) != DBQ_END && t != DBQ_RES) {
switch(t) {
case DBQ_NULL:
darray_add_int32(a, DBQ_NULL);
break;
case DBQ_INT:
darray_add_int32(a, DBQ_INT);
darray_add_int32(a, va_arg(va, int));
break;
case DBQ_INT64:
darray_add_int32(a, DBQ_INT64);
darray_add_int64(a, va_arg(va, gint64));
break;
case DBQ_TEXT:
p = va_arg(va, char *);
if(p) {
darray_add_int32(a, DBQ_TEXT);
darray_add_string(a, p);
} else
darray_add_int32(a, DBQ_NULL);
break;
case DBQ_BLOB:
t = va_arg(va, int);
p = va_arg(va, char *);
if(p) {
darray_add_int32(a, DBQ_BLOB);
darray_add_dat(a, p, t);
} else
darray_add_int32(a, DBQ_NULL);
break;
default:
g_return_val_if_reached(NULL);
}
}
if(t == DBQ_RES) {
darray_add_int32(a, DBQ_RES);
GAsyncQueue *queue = va_arg(va, GAsyncQueue *);
g_async_queue_ref(queue);
darray_add_ptr(a, queue);
while((t = va_arg(va, int)) != DBQ_END)
darray_add_int32(a, t);
}
int hash_init(struct hash *hash, unsigned siz)
{
unsigned i;
hash->buckets = calloc(siz, sizeof *hash->buckets);
if (!hash->buckets)
return -1;
hash->max_size = siz;
for (i = 0; i < siz; ++i)
darray_init(&hash->buckets[i], 3);
return 0;
}
/*--------------------------------------------------------------------
* newmethod, freemethod
*/
static void *number2text_new(t_symbol *sel)
{
t_number2text *x;
x = (t_number2text *)pd_new(number2text_class);
/* initialize darray */
darray_init(&x->text, sizeof(char), NUMBER2TEXT_DA_GSIZE);
/* outlet(s) */
x->txt_out = outlet_new(&x->x_obj, &s_symbol);
return (void *)x;
}
void problem_01_test_hash(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
array_has_sum_of_hash(&array, array.size, search);
/* free up the underlying array */
darray_free(&array);
}
void problem_05_test_sum(){
/* declare and initialize a new array */
DArray array;
int missing;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 2);
darray_append(&array, 4);
darray_append(&array, 5);
darray_append(&array, 6);
missing = get_missing_number_sum_formula(&array, 5);
printf("The missing number is: %d\n", missing);
/* free up the underlying array */
darray_free(&array);
}
/* Creates the real pixel format for the target window */
static int gl_choose_pixel_format(HDC hdc, struct gs_init_data *info)
{
struct darray attribs;
int color_bits = get_color_format_bits(info->format);
int depth_bits = get_depth_format_bits(info->zsformat);
int stencil_bits = get_stencil_format_bits(info->zsformat);
UINT num_formats;
BOOL success;
int format;
if (!color_bits) {
blog(LOG_ERROR, "gl_init_pixel_format: color format not "
"supported");
return false;
}
darray_init(&attribs);
add_attrib(&attribs, WGL_DRAW_TO_WINDOW_ARB, GL_TRUE);
add_attrib(&attribs, WGL_SUPPORT_OPENGL_ARB, GL_TRUE);
add_attrib(&attribs, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB);
add_attrib(&attribs, WGL_DOUBLE_BUFFER_ARB, GL_TRUE);
add_attrib(&attribs, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB);
add_attrib(&attribs, WGL_COLOR_BITS_ARB, color_bits);
add_attrib(&attribs, WGL_DEPTH_BITS_ARB, depth_bits);
add_attrib(&attribs, WGL_STENCIL_BITS_ARB, stencil_bits);
add_attrib(&attribs, 0, 0);
success = wglChoosePixelFormatARB(hdc, attribs.array, NULL, 1, &format,
&num_formats);
if (!success || !num_formats) {
blog(LOG_ERROR, "wglChoosePixelFormatARB failed, %u",
GetLastError());
format = 0;
}
darray_free(&attribs);
return format;
}
void problem_01_test_sort(){
/* declare and initialize a new array */
DArray array;
int search = 16;
darray_init(&array);
/* initialize array */
darray_append(&array, 1);
darray_append(&array, 4);
darray_append(&array, 45);
darray_append(&array, 6);
darray_append(&array, 10);
darray_append(&array, -8);
if(!array_has_sum_of(&array, array.capacity, search)){
printf("Array has two elements with sum %d\n", search);
}else{
printf("Array doesn't have two elements with sum %d\n", search);
}
/* free up the underlying array */
darray_free(&array);
}
void
rsynth_pho(rsynth_t * rsynth, const char *path, int dodur, char *trans)
{
int verbose = rsynth_verbose(rsynth);
FILE *f = fopen(path, "r");
trie_ptr table;
if (!phtoelm)
enter_phonemes();
if (trans && *trans && strcmp(trans, "sampa"))
table = enter_trans(trans, verbose);
else
table = phtoelm;
if (f) {
char buffer[1024];
char *s;
darray_t elm;
unsigned t = 0;
float f0a[1024] = { rsynth->speaker->F0Hz };
unsigned nf0 = 0; /* index of last f0 value */
unsigned f0t = 0; /* time of last f0 value */
darray_init(&elm, sizeof(char), 1024);
if (verbose) {
fprintf(stderr, "Frame is %.3gms\n",
rsynth->samples_frame * 1000.0 / rsynth->sr);
}
while ((s = fgets(buffer, sizeof(buffer), f))) {
/* skip leading space - should not be any but ... */
while (isspace((unsigned) *s))
s++;
if (*s && *s != ';') {
/* Not a comment */
char *ps = s;
char *e = (char *) trie_lookup(&table, &s);
if (*s == ':')
s++;
if (e && isspace((unsigned) *s)) {
char *pe = s;
unsigned pt = 0;
int n = *e++;
int i;
double ms = strtod(s, &s);
float frames =
ms * (rsynth->sr / rsynth->samples_frame) / 1000;
float edur = 0;
float estp = 0;
int nstp = 0;
float delta = 0;
for (i = 0; i < n; i++) {
int x = e[i];
Elm_ptr p = &Elements[x];
if (!p->du || p->feat & stp)
estp += p->ud;
else {
edur += p->ud;
nstp++;
}
}
/* Stops don't change length */
frames -= estp;
delta = frames - edur;
#if 0
/* FIXME - revisit the rounding process */
if (verbose)
fprintf(stderr,
"'%.*s' %gms %d elem %g frames vs %g nat d=%g) %d stops\n",
(pe - ps), ps, ms, n, frames, edur, delta,
n - nstp);
#endif
for (i = 0; i < n; i++) {
int x = e[i];
Elm_ptr p = &Elements[x];
darray_append(&elm, x);
if (!p->du || p->feat & stp)
pt += darray_append(&elm, p->ud);
else {
if (dodur) {
float share =
(nstp >
1) ? rint(delta * (p->ud -
1) / (edur -
nstp)) :
delta;
#if 0
fprintf(stderr,
"%s d=%d vs nstp=%g delta=%g take=%g\n",
p->name, p->ud, edur, delta,
share);
#endif
edur -= p->ud;
delta -= share;
nstp--;
pt +=
darray_append(&elm,
(int) (p->ud + share));
}
else
pt += darray_append(&elm, p->du);
}
}
/* Now have elements entered and duration of phone computed */
if (verbose && dodur) {
float got =
1.0 * pt * rsynth->samples_frame / rsynth->sr *
1000;
if (fabs(got - ms) > 0.5) {
fprintf(stderr,
"'%.*s' want=%gms got=%.3g (%+3.0f%%)\n",
(pe - ps), ps, ms, got,
100 * (got - ms) / ms);
}
}
while (isspace((unsigned) *s))
s++;
while (*s) {
float percent = strtod(s, &s);
float f0 = strtod(s, &s);
unsigned nt =
(unsigned) (t + (percent * pt / 100));
if (nt > f0t) {
/* time has advanced */
f0a[++nf0] = (nt - f0t);
f0a[++nf0] = f0;
f0t = nt;
}
else {
/* same time - change target inplace */
f0a[nf0] = f0;
}
while (isspace((unsigned) *s))
s++;
}
t += pt;
}
else {
fputs(buffer, stderr);
fprintf(stderr, "Unknown phone:%s", ps);
}
}
}
fclose(f);
if (t) {
float f0 = f0a[nf0++];
if (f0t < t) {
f0a[nf0++] = t - f0t;
f0a[nf0++] = f0;
}
rsynth_flush(rsynth,
rsynth_interpolate(rsynth,
(unsigned char *) darray_find(&elm, 0),
elm.items, f0a, nf0));
}
}
else {
perror(path);
}
}
void symtab_init(symtab_t t) {
darray_init(t->list);
}
int main(int argc, char **argv)
{
char *out = 0;
int i;
unsigned boot_addr = 0x07; // Standard boot address: $800
int boot_file = 0; // Next file is boot file
int exact_size = 0; // Use image of exact size
int min_size = 0; // Minimum image size
prog_name = argv[0];
file_list flist;
darray_init(flist, 1);
flist_add_main_dir(&flist);
for(i=1; i<argc; i++)
{
char *arg = argv[i];
if( arg[0] == '-' )
{
char op;
while( 0 != (op = *++arg) )
{
if( op == 'h' || op == '?' )
show_usage();
else if( op == 'b' )
{
if( boot_file )
show_error("can specify only one boot file\n");
boot_file = 1;
}
else if( op == 'x' )
exact_size = 1;
else if( op == 'B' )
{
char *ep;
if( i+1 >= argc )
show_error("option '-B' needs an argument\n");
i++;
boot_addr = strtol(argv[i], &ep, 0);
if( boot_addr <= 3 || boot_addr >= 0xF0 || !ep || *ep )
show_error("argument for option '-B' must be from 3 to 240\n");
}
else if( op == 's' )
{
char *ep;
if( i+1 >= argc )
show_error("option '-s' needs an argument\n");
i++;
min_size = strtol(argv[i], &ep, 0);
if( min_size <= 0 || !ep || *ep )
show_error("argument for option '-s' must be a positive integer\n");
if( min_size > 65535 * 256 )
show_error("maximum image size is 16776960 bytes\n");
}
else if( op == 'v' )
show_version();
else
show_error("invalid command line option '-%c'. Try '%s -h' for help.\n",
op, prog_name);
}
}
else if( !out && boot_file != 1 )
out = arg;
else
{
flist_add_file(&flist, arg, boot_file == 1);
if( boot_file )
boot_file = -1;
}
}
if( !out )
show_error("missing output file name. Try '%s -h' for help.\n", prog_name);
struct sfs *sfs = 0;
if( exact_size )
{
// Try biggest size and the try reducing:
if( min_size < 128*65535 )
sfs = build_spartafs(128, 65535, boot_addr, &flist);
if( !sfs )
sfs = build_spartafs(256, 65535, boot_addr, &flist);
if( sfs )
{
int nsec = 65535 - sfs_get_free_sectors(sfs);
int ssec = sfs_get_sector_size(sfs);
if( nsec*ssec < min_size )
nsec = (min_size + ssec - 1) / ssec;
for(; nsec>5 && (nsec*ssec)>=min_size; nsec--)
{
struct sfs *n = build_spartafs(ssec, nsec, boot_addr, &flist);
if( !n )
break;
sfs_free(sfs);
sfs = n;
if( sfs_get_free_sectors(sfs) > 0 && (nsec-1)*ssec > min_size )
{
nsec = nsec - sfs_get_free_sectors(sfs) + 1;
if( nsec*ssec < min_size )
nsec = 1 + (min_size + ssec - 1) / ssec;
}
}
}
}
else
{
for(i=0; !sfs && sectors[i].size; i++)
{
if( sectors[i].size * sectors[i].num < min_size )
continue;
sfs = build_spartafs(sectors[i].size, sectors[i].num, boot_addr, &flist);
}
}
if( sfs )
write_atr(out, sfs_get_data(sfs), sfs_get_sector_size(sfs), sfs_get_num_sectors(sfs));
else
show_error("can't create an image big enough\n");
return 0;
}
DArray* MemoryAllocation_New() { return darray_init(); }
int main(int argc, char** argv){
printf("hello world\n");
behaviors_init();
log_file_open("log.txt");
if (SDL_Init(SDL_INIT_EVERYTHING) == -1){
printf("%s\n", SDL_GetError());
return 1;
}
printf("sdl init success\n");
SDL_Renderer *renderer = NULL;
SDL_Window *window = NULL;
//Setup our window and renderer
window = SDL_CreateWindow("Stick Fighter", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL){
printf("%s\n", SDL_GetError());
return 2;
}
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (renderer == NULL){
printf("%s\n", SDL_GetError());
return 3;
}
SDL_Texture *background1 = NULL;
SDL_Texture *background2 = NULL;
SDL_Texture *image = NULL;
//background = sprite_load_image(renderer, "res/background_rcr.png");
background1 = sprite_load_image(renderer, "res/background_rcr.png");
background2 = sprite_load_image(renderer, "res/background_new.png");
SDL_Texture* backgrounds[2];
backgrounds[0] = background1;
backgrounds[1] = background2;
SDL_Rect bg;
//Query the texture to get its width and height to use
SDL_QueryTexture(background1, NULL, NULL, &bg.w, &bg.h);
float bg_width = bg.w;
float bg_height = bg.h;
float world_width = bg_width / 10;
float world_height = bg_height / 10;
printf("bg_width: %f bg_height: %f world_width: %f world_height: %f\n", bg_width, bg_height, world_width, world_height);
//printf("bg 1: [%p]\n", backgrounds[0]);
//printf("bg 2: [%p]\n", backgrounds[1]);
image = sprite_load_image(renderer, "res/output.png");
//printf("after sprite load image\n");
//load the meta info
char* filename = "res/animation_meta_info.txt";
DArray meta_info;
darray_init(&meta_info);
sprite_load_meta_file(filename, &meta_info);
darray_print(&meta_info);
float interval = 0.0f;
float start = 0.0f;
int quit = 0;
float delay = 1000.0f / FPS;
Sprite* player = sprite_create(PLAYER, WALK, 200, 300, delay, image);
player->x_speed = 0;
player->y_speed = 0;
Sprite* enemy = sprite_create(ENEMY, WALK, 0, 300, delay, image);
enemy->x_speed = 2;
enemy->y_speed = 2;
enemy->advance_frame = 1;
//set white background
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
pixel_to_world(bg_width, bg_height, world_width, world_height,
enemy->x, enemy->y, &enemy->location->coords->x, &enemy->location->coords->y);
int dest_x = 0;
int dest_y = 0;
//TODO:
//animations for punch and basic kick
//animation for getting hit
//animations for walk left and run left
//2 more ai behaviors
//health bars above units and health stats
//dying animation
//dying logic
//generate enemies off screen and have them walk on to screen
//redo tornado kick and spinning back kick so stick figure is same size
//figure out how to color stick figure without having to make new sprites on sheet...need to make figures white to set modulation
//add rolling punch move
//add game state which keeps track of game state
//add buy moves screen in between levels
//add a generator which generates guys for 100 levels
int i = 0;
while (!quit){
printf("iteration: %i\n", i);
start = SDL_GetTicks();
quit = player_input(player, &meta_info);
//printf("quit: %i\n", quit);
//log_msg(LOG_DEBUG, "after player input: current frame: %i\n", player->current_frame[HIT]);
//pixel location to world location
pixel_to_world(bg_width, bg_height, world_width, world_height,
player->x, player->y, &player->location->coords->x, &player->location->coords->y);
//world location to pixel location
world_to_pixel(bg_width, bg_height, world_width, world_height,
enemy->location->coords->x, enemy->location->coords->y, &dest_x, &dest_y);
//boundry check
boundry_check(SCREEN_WIDTH, SCREEN_HEIGHT, enemy, &meta_info, &dest_x, &dest_y);
//printf("2nd before moveto = enemy x:%i enemy y:%i dest_x:%i dest_y:%i\n", enemy->x, enemy->y, dest_x, dest_y);
//update enemy sprite by sprite's speed
moveto_coordinates(enemy, dest_x, dest_y);
//are we at the original world location in pixel coordinates?
int arrived = within_coordinates(enemy, dest_x, dest_y);
printf("arrived: %i\n", arrived);
if(arrived == 1) {
//wander(enemy);
// we reached last behavior's destination so do new AI behavior
wander_stall_attack(player, enemy, &meta_info, 3);
}
sprite_update_bounding_box(player, &meta_info);
sprite_update_bounding_box(enemy, &meta_info);
//check collision
int collision = sprite_check_collision(player, enemy);
//printf("collision: %i\n", collision);
if(collision) {
sprite_handle_collision(player, enemy, &meta_info);
}
//handle collision
//if animation is an attack then check frame range that triggers a hit
//check if attack animation triggers a hi or low hit
//if sequence of attacks is within delta time then 4th hit triggers a knockdown
//if attack would make health below 0 then it triggers a knockdown
//handle opposite attack from opposing sprite
//if is in attack animation then check frame range for a hit
//update animation frame
sprite_update(player, &meta_info, renderer);
sprite_update(enemy, &meta_info, renderer);
//Rendering
SDL_RenderClear(renderer);
//printf("player->x: %i\n", player->x);
//printf("moving right: %i\n", player->moving_right);
//printf("moving left: %i\n", player->moving_left);
int current_background = 0;
sprite_draw_background(renderer, backgrounds, 2, ¤t_background, player->x, player->moving_right, player->moving_left, &player->scroll);
sprite_draw_health_bar(renderer, player, &meta_info, 100);
sprite_draw_health_bar(renderer, enemy, &meta_info, 100);
//draw sprite
sprite_render_frame(SCREEN_WIDTH, SCREEN_HEIGHT, player, &meta_info, renderer, 0);
sprite_render_frame(bg_width, bg_height, enemy, &meta_info, renderer, 0);
//Update the screen
SDL_RenderPresent(renderer);
interval = SDL_GetTicks() - start;
if(interval > 0) {
//float fps = 1.0f / (interval / 1000.0f);
//printf("%f fps\n", fps);
}
i++;
}
//SDL_Delay(4000);
//Destroy the various items
sprite_destroy(player);
sprite_destroy(enemy);
darray_destroy(&meta_info);
SDL_DestroyTexture(backgrounds[0]);
SDL_DestroyTexture(backgrounds[1]);
SDL_DestroyTexture(image);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
printf("after destory text rend win\n");
SDL_Quit();
log_file_close();
return 0;
}
int main(void) {
field_t fp, fx;
mpz_t prime;
darray_t list;
int p = 7;
// Exercise poly_is_irred() with a sieve of Erastosthenes for polynomials.
darray_init(list);
mpz_init(prime);
mpz_set_ui(prime, p);
field_init_fp(fp, prime);
field_init_poly(fx, fp);
element_t e;
element_init(e, fp);
// Enumerate polynomials in F_p[x] up to degree 2.
int a[3], d;
a[0] = a[1] = a[2] = 0;
for(;;) {
element_ptr f = pbc_malloc(sizeof(*f));
element_init(f, fx);
int j;
for(j = 0; j < 3; j++) {
element_set_si(e, a[j]);
poly_set_coeff(f, e, j);
}
// Test poly_degree().
for(j = 2; !a[j] && j >= 0; j--);
EXPECT(poly_degree(f) == j);
// Add monic polynomials to the list.
if (j >= 0 && a[j] == 1) darray_append(list, f);
else {
element_clear(f);
free(f);
}
// Next!
d = 0;
for(;;) {
a[d]++;
if (a[d] >= p) {
a[d] = 0;
d++;
if (d > 2) goto break2;
} else break;
}
}
break2: ;
// Find all composite monic polynomials of degree 3 or less.
darray_t prodlist;
darray_init(prodlist);
void outer(void *data) {
element_ptr f = data;
void inner(void *data2) {
element_ptr g = data2;
if (!poly_degree(f) || !poly_degree(g)) return;
if (poly_degree(f) + poly_degree(g) > 3) return;
element_ptr h = pbc_malloc(sizeof(*h));
element_init(h, fx);
element_mul(h, f, g);
darray_append(prodlist, h);
EXPECT(!poly_is_irred(h));
}
// See Cohen; my D is -D in his notation.
size_t pbc_hilbert(mpz_t **arr, int D) {
int a, b;
int t;
int B = (int)floor(sqrt((double) D / 3.0));
mpc_t alpha;
mpc_t j;
mpf_t sqrtD;
mpf_t f0;
darray_t Pz;
mpc_t z0, z1, z2;
double d = 1.0;
int h = 1;
int jcount = 1;
// Compute required precision.
b = D % 2;
for (;;) {
t = (b*b + D) / 4;
a = b;
if (a <= 1) {
a = 1;
goto step535_4;
}
step535_3:
if (!(t % a)) {
jcount++;
if ((a == b) || (a*a == t) || !b) {
d += 1.0 / ((double) a);
h++;
} else {
d += 2.0 / ((double) a);
h+=2;
}
}
step535_4:
a++;
if (a * a <= t) {
goto step535_3;
} else {
b += 2;
if (b > B) break;
}
}
//printf("modulus: %f\n", exp(3.14159265358979 * sqrt(D)) * d * 0.5);
d *= sqrt(D) * 3.14159265358979 / log(2);
precision_init((int)(d + 34));
pbc_info("class number %d, %d bit precision", h, (int) d + 34);
darray_init(Pz);
mpc_init(alpha);
mpc_init(j);
mpc_init(z0);
mpc_init(z1);
mpc_init(z2);
mpf_init(sqrtD);
mpf_init(f0);
mpf_sqrt_ui(sqrtD, D);
b = D % 2;
h = 0;
for (;;) {
t = (b*b + D) / 4;
if (b > 1) {
a = b;
} else {
a = 1;
}
step3:
if (t % a) {
step4:
a++;
if (a * a <= t) goto step3;
} else {
// a, b, t/a are coeffs of an appropriate primitive reduced positive
// definite form.
// Compute j((-b + sqrt{-D})/(2a)).
h++;
pbc_info("[%d/%d] a b c = %d %d %d", h, jcount, a, b, t/a);
mpf_set_ui(f0, 1);
mpf_div_ui(f0, f0, 2 * a);
mpf_mul(mpc_im(alpha), sqrtD, f0);
mpf_mul_ui(f0, f0, b);
mpf_neg(mpc_re(alpha), f0);
compute_j(j, alpha);
if (0) {
int i;
for (i=Pz->count - 1; i>=0; i--) {
printf("P %d = ", i);
mpc_out_str(stdout, 10, 4, Pz->item[i]);
printf("\n");
}
}
if (a == b || a * a == t || !b) {
// P *= X - j
int i, n;
mpc_ptr p0;
p0 = (mpc_ptr) pbc_malloc(sizeof(mpc_t));
mpc_init(p0);
mpc_neg(p0, j);
n = Pz->count;
if (n) {
mpc_set(z1, Pz->item[0]);
mpc_add(Pz->item[0], z1, p0);
for (i=1; i<n; i++) {
mpc_mul(z0, z1, p0);
mpc_set(z1, Pz->item[i]);
mpc_add(Pz->item[i], z1, z0);
}
mpc_mul(p0, p0, z1);
}
darray_append(Pz, p0);
} else {
// P *= X^2 - 2 Re(j) X + |j|^2
int i, n;
mpc_ptr p0, p1;
p0 = (mpc_ptr) pbc_malloc(sizeof(mpc_t));
p1 = (mpc_ptr) pbc_malloc(sizeof(mpc_t));
mpc_init(p0);
mpc_init(p1);
// p1 = - 2 Re(j)
mpf_mul_ui(f0, mpc_re(j), 2);
mpf_neg(f0, f0);
mpf_set(mpc_re(p1), f0);
// p0 = |j|^2
mpf_mul(f0, mpc_re(j), mpc_re(j));
mpf_mul(mpc_re(p0), mpc_im(j), mpc_im(j));
mpf_add(mpc_re(p0), mpc_re(p0), f0);
n = Pz->count;
if (!n) {
} else if (n == 1) {
mpc_set(z1, Pz->item[0]);
mpc_add(Pz->item[0], z1, p1);
mpc_mul(p1, z1, p1);
mpc_add(p1, p1, p0);
mpc_mul(p0, p0, z1);
} else {
mpc_set(z2, Pz->item[0]);
mpc_set(z1, Pz->item[1]);
mpc_add(Pz->item[0], z2, p1);
mpc_mul(z0, z2, p1);
mpc_add(Pz->item[1], z1, z0);
mpc_add(Pz->item[1], Pz->item[1], p0);
for (i=2; i<n; i++) {
mpc_mul(z0, z1, p1);
mpc_mul(alpha, z2, p0);
mpc_set(z2, z1);
mpc_set(z1, Pz->item[i]);
mpc_add(alpha, alpha, z0);
mpc_add(Pz->item[i], z1, alpha);
}
mpc_mul(z0, z2, p0);
mpc_mul(p1, p1, z1);
mpc_add(p1, p1, z0);
mpc_mul(p0, p0, z1);
}
darray_append(Pz, p1);
darray_append(Pz, p0);
}
goto step4;
}
b+=2;
if (b > B) break;
}
// Round polynomial and assign.
int k = 0;
{
*arr = pbc_malloc(sizeof(mpz_t) * (Pz->count + 1));
int i;
for (i=Pz->count - 1; i>=0; i--) {
if (mpf_sgn(mpc_re(Pz->item[i])) < 0) {
mpf_set_d(f0, -0.5);
} else {
mpf_set_d(f0, 0.5);
}
mpf_add(f0, f0, mpc_re(Pz->item[i]));
mpz_init((*arr)[k]);
mpz_set_f((*arr)[k], f0);
k++;
mpc_clear(Pz->item[i]);
pbc_free(Pz->item[i]);
}
mpz_init((*arr)[k]);
mpz_set_ui((*arr)[k], 1);
k++;
}
darray_clear(Pz);
mpc_clear(z0);
mpc_clear(z1);
mpc_clear(z2);
mpf_clear(f0);
mpf_clear(sqrtD);
mpc_clear(alpha);
mpc_clear(j);
precision_clear();
return k;
}
/*
@description:
Releases memory from a previously initialized darray
pointed to by p, and resets to empty status. The item_size
value of the darray is preserved.
*/
extern void darray_reset(darray *p)
{
free(p->data);
darray_init(p, p->item_size, 0);
}
darray_ptr darray_new(void)
{
darray_ptr res = pbc_malloc(sizeof(darray_t));
darray_init(res);
return res;
}
static inline bool ep_compile_pass_shader(struct effect_parser *ep,
struct gs_effect_technique *tech,
struct gs_effect_pass *pass, struct ep_pass *pass_in,
size_t pass_idx, enum gs_shader_type type)
{
struct dstr shader_str;
struct dstr location;
struct darray used_params; /* struct dstr */
struct darray *pass_params = NULL; /* struct pass_shaderparam */
gs_shader_t *shader = NULL;
bool success = true;
dstr_init(&shader_str);
darray_init(&used_params);
dstr_init(&location);
dstr_copy(&location, ep->cfp.lex.file);
if (type == GS_SHADER_VERTEX)
dstr_cat(&location, " (Vertex ");
else if (type == GS_SHADER_PIXEL)
dstr_cat(&location, " (Pixel ");
/*else if (type == SHADER_GEOMETRY)
dstr_cat(&location, " (Geometry ");*/
assert(pass_idx <= UINT_MAX);
dstr_catf(&location, "shader, technique %s, pass %u)", tech->name,
(unsigned)pass_idx);
if (type == GS_SHADER_VERTEX) {
ep_makeshaderstring(ep, &shader_str,
&pass_in->vertex_program.da, &used_params);
pass->vertshader = gs_vertexshader_create(shader_str.array,
location.array, NULL);
shader = pass->vertshader;
pass_params = &pass->vertshader_params.da;
} else if (type == GS_SHADER_PIXEL) {
ep_makeshaderstring(ep, &shader_str,
&pass_in->fragment_program.da, &used_params);
pass->pixelshader = gs_pixelshader_create(shader_str.array,
location.array, NULL);
shader = pass->pixelshader;
pass_params = &pass->pixelshader_params.da;
}
#if 0
blog(LOG_DEBUG, "+++++++++++++++++++++++++++++++++++");
blog(LOG_DEBUG, " %s", location.array);
blog(LOG_DEBUG, "-----------------------------------");
blog(LOG_DEBUG, "%s", shader_str.array);
blog(LOG_DEBUG, "+++++++++++++++++++++++++++++++++++");
#endif
if (shader)
success = ep_compile_pass_shaderparams(ep, pass_params,
&used_params, shader);
else
success = false;
dstr_free(&location);
dstr_array_free(used_params.array, used_params.num);
darray_free(&used_params);
dstr_free(&shader_str);
return success;
}
// x in Z_r, g, h in some group of order r
// finds x such that g^x = h
void element_dlog_pollard_rho(element_t x, element_t g, element_t h) {
// see Blake, Seroussi and Smart
// only one snark for this implementation
int i, s = 20;
field_ptr Zr = x->field, G = g->field;
element_t asum;
element_t bsum;
element_t a[s];
element_t b[s];
element_t m[s];
element_t g0, snark;
darray_t hole;
int interval = 5;
mpz_t counter;
int found = 0;
mpz_init(counter);
element_init(g0, G);
element_init(snark, G);
element_init(asum, Zr);
element_init(bsum, Zr);
darray_init(hole);
//set up multipliers
for (i = 0; i < s; i++) {
element_init(a[i], Zr);
element_init(b[i], Zr);
element_init(m[i], G);
element_random(a[i]);
element_random(b[i]);
element_pow_zn(g0, g, a[i]);
element_pow_zn(m[i], h, b[i]);
element_mul(m[i], m[i], g0);
}
element_random(asum);
element_random(bsum);
element_pow_zn(g0, g, asum);
element_pow_zn(snark, h, bsum);
element_mul(snark, snark, g0);
record(asum, bsum, snark, hole, counter);
for (;;) {
int len = element_length_in_bytes(snark);
unsigned char *buf = pbc_malloc(len);
unsigned char hash = 0;
element_to_bytes(buf, snark);
for (i = 0; i < len; i++) {
hash += buf[i];
}
i = hash % s;
pbc_free(buf);
element_mul(snark, snark, m[i]);
element_add(asum, asum, a[i]);
element_add(bsum, bsum, b[i]);
for (i = 0; i < hole->count; i++) {
snapshot_ptr ss = hole->item[i];
if (!element_cmp(snark, ss->snark)) {
element_sub(bsum, bsum, ss->b);
element_sub(asum, ss->a, asum);
//answer is x such that x * bsum = asum
//complications arise if gcd(bsum, r) > 1
//which can happen if r is not prime
if (!mpz_probab_prime_p(Zr->order, 10)) {
mpz_t za, zb, zd, zm;
mpz_init(za);
mpz_init(zb);
mpz_init(zd);
mpz_init(zm);
element_to_mpz(za, asum);
element_to_mpz(zb, bsum);
mpz_gcd(zd, zb, Zr->order);
mpz_divexact(zm, Zr->order, zd);
mpz_divexact(zb, zb, zd);
//if zd does not divide za there is no solution
mpz_divexact(za, za, zd);
mpz_invert(zb, zb, zm);
mpz_mul(zb, za, zb);
mpz_mod(zb, zb, zm);
do {
element_pow_mpz(g0, g, zb);
if (!element_cmp(g0, h)) {
element_set_mpz(x, zb);
break;
}
mpz_add(zb, zb, zm);
mpz_sub_ui(zd, zd, 1);
} while (mpz_sgn(zd));
mpz_clear(zm);
mpz_clear(za);
mpz_clear(zb);
mpz_clear(zd);
} else {
element_div(x, asum, bsum);
}
found = 1;
break;
}
}
if (found) break;
mpz_add_ui(counter, counter, 1);
if (mpz_tstbit(counter, interval)) {
record(asum, bsum, snark, hole, counter);
interval++;
}
}
for (i = 0; i < s; i++) {
element_clear(a[i]);
element_clear(b[i]);
element_clear(m[i]);
}
element_clear(g0);
element_clear(snark);
for (i = 0; i < hole->count; i++) {
snapshot_ptr ss = hole->item[i];
element_clear(ss->a);
element_clear(ss->b);
element_clear(ss->snark);
pbc_free(ss);
}
darray_clear(hole);
element_clear(asum);
element_clear(bsum);
mpz_clear(counter);
}
// Executes a single query.
// If transaction = TRUE, the query is assumed to be executed in a transaction
// (which has already been initiated)
// The return path (if any) and lastid (0 if not requested) are stored in *res
// and *lastid. The caller of this function is responsible for sending back the
// final response. If this function returns anything other than SQLITE_DONE,
// the query has failed.
// It is assumed that the first `flags' part of the queue item has already been
// fetched.
static int db_queue_process_one(sqlite3 *db, char *q, gboolean nocache, gboolean transaction, GAsyncQueue **res, gint64 *lastid) {
char *query = darray_get_ptr(q);
*res = NULL;
*lastid = 0;
// Would be nice to have the parameters logged
g_debug("db: Executing \"%s\"", query);
// Get statement handler
int r = SQLITE_ROW;
sqlite3_stmt *s;
if(nocache ? sqlite3_prepare_v2(db, query, -1, &s, NULL) : db_queue_process_prepare(db, query, &s)) {
g_critical("SQLite3 error preparing `%s': %s", query, sqlite3_errmsg(db));
r = SQLITE_ERROR;
}
// Bind parameters
int t, n;
int i = 1;
char *a;
while((t = darray_get_int32(q)) != DBQ_END && t != DBQ_RES) {
if(r == SQLITE_ERROR)
continue;
switch(t) {
case DBQ_NULL:
sqlite3_bind_null(s, i);
break;
case DBQ_INT:
sqlite3_bind_int(s, i, darray_get_int32(q));
break;
case DBQ_INT64:
sqlite3_bind_int64(s, i, darray_get_int64(q));
break;
case DBQ_TEXT:
sqlite3_bind_text(s, i, darray_get_string(q), -1, SQLITE_STATIC);
break;
case DBQ_BLOB:
a = darray_get_dat(q, &n);
sqlite3_bind_blob(s, i, a, n, SQLITE_STATIC);
break;
}
i++;
}
// Fetch information about what results we need to send back
gboolean wantlastid = FALSE;
char columns[20]; // 20 should be enough for everyone
n = 0;
if(t == DBQ_RES) {
*res = darray_get_ptr(q);
while((t = darray_get_int32(q)) != DBQ_END) {
if(t == DBQ_LASTID)
wantlastid = TRUE;
else
columns[n++] = t;
}
}
// Execute query
while(r == SQLITE_ROW) {
// do the step()
if(transaction)
r = sqlite3_step(s);
else
while((r = sqlite3_step(s)) == SQLITE_BUSY)
;
if(r != SQLITE_DONE && r != SQLITE_ROW)
g_critical("SQLite3 error on step() of `%s': %s", query, sqlite3_errmsg(db));
// continue with the next step() if we're not going to do anything with the results
if(r != SQLITE_ROW || !*res || !n)
continue;
// send back a response
GByteArray *rc = g_byte_array_new();
darray_init(rc);
darray_add_int32(rc, r);
for(i=0; i<n; i++) {
switch(columns[i]) {
case DBQ_INT: darray_add_int32( rc, sqlite3_column_int( s, i)); break;
case DBQ_INT64: darray_add_int64( rc, sqlite3_column_int64(s, i)); break;
case DBQ_TEXT: darray_add_string(rc, (char *)sqlite3_column_text( s, i)); break;
case DBQ_BLOB: darray_add_dat( rc, sqlite3_column_blob( s, i), sqlite3_column_bytes(s, i)); break;
default: g_warn_if_reached();
}
}
g_async_queue_push(*res, g_byte_array_free(rc, FALSE));
}
// Fetch last id, if requested
if(r == SQLITE_DONE && wantlastid)
*lastid = sqlite3_last_insert_rowid(db);
sqlite3_reset(s);
if(nocache)
sqlite3_finalize(s);
return r;
}
