static void linear_container_darray_destroy(LinearContainer* thiz)
{
PrivInfo* priv = (PrivInfo*)thiz->priv;
darray_destroy(priv->darray);
free(thiz);
return;
}
static inline void Server_destroy_handlers(Server *srv)
{
int i = 0;
for(i = 0; i < darray_end(srv->handlers); i++) {
Handler *handler = darray_get(srv->handlers, i);
Handler_destroy(handler);
}
darray_destroy(srv->handlers);
}
void vrt_dispatch_data_deinit(void)
{
if (dispatch_data_threads) {
while (darray_n(dispatch_data_threads) > 0) {
dispatch_data_thread *ddt = darray_pop(dispatch_data_threads);
dispatch_data_thread_deinit(ddt);
}
darray_destroy(dispatch_data_threads);
dispatch_data_threads = NULL;
}
}
void hashmap_destroy(Hashmap *map) {
int i = 0;
int j = 0;
if (map) {
if (map->buckets) {
for (i = 0; i < darray_count(map->buckets); i += 1) {
DArray *bucket = darray_get(map->buckets, i);
if (bucket) {
for (j = 0; j < darray_count(bucket); j += 1) {
free(darray_get(bucket, j));
}
darray_destroy(bucket);
}
}
darray_destroy(map->buckets);
}
free(map);
}
}
int Server_queue_destroy()
{
int i = 0;
Server *srv = NULL;
for(i = 0; i < darray_end(SERVER_QUEUE); i++) {
srv = darray_get(SERVER_QUEUE, i);
check(srv != NULL, "Got a NULL value from the server queue.");
Server_destroy(srv);
}
darray_destroy(SERVER_QUEUE);
return 0;
error:
return -1;
}
int main(int argc, char* argv[])
{
int i = 0;
int n = 100;
int data = 0;
DArray* darray = darray_create(NULL, NULL);
for (i = 0; i < n; i++) {
darray_append(darray, (void*)(rand() % n));
}
darray_sort(darray, quick_sort, cmp_int);
darray_foreach(darray, print_int, NULL);
printf("\n");
darray_get_by_index(darray, 0, (void*)&data);
data = !data;
darray_foreach(darray, unique_print_int, &data);
printf("\n");
darray_destroy(darray);
return 0;
}
/*
* Bucket sort algorithm.
*/
void integer_sort(int *array, int n)
{
int max, _max; /* Max number in array. */
int range; /* Bucket range. */
int i, j, k; /* Loop indexes. */
int *indexes; /* Index for buckets. */
struct darray **buckets; /* Buckets. */
indexes = smalloc(NUM_BUCKETS*sizeof(int));
/* Create buckets. */
buckets = smalloc(NUM_BUCKETS*sizeof(struct darray *));
for (i = 0; i < NUM_BUCKETS; i++)
buckets[i] = darray_create(n/NUM_BUCKETS);
max = INT_MIN;
#pragma omp parallel private(i, j, k, _max)
{
_max = INT_MIN;
/* Find max number in the array. */
#pragma omp for schedule(static)
for (i = 0; i < n; i++)
{
/* Found. */
if (array[i] > _max)
_max = array[i];
}
#pragma omp critical
{
if (_max > max) {
max = _max;
}
}
#pragma omp master
range = max/NUM_BUCKETS;
#pragma omp barrier
/* Distribute numbers into buckets. */
#pragma omp master
for (i = 0; i < n; i++)
{
j = array[i]/range;
if (j >= NUM_BUCKETS)
j = NUM_BUCKETS - 1;
darray_append(buckets[j], array[i]);
}
/* Sort Each bucket. */
#pragma omp for schedule(dynamic)
for (i = 0; i < NUM_BUCKETS; i++)
{
if (darray_size(buckets[i]) > 0)
sort(buckets[i]);
}
#pragma omp master
{
/* Build indexes. */
indexes[0] = 0;
for (i = 1; i < NUM_BUCKETS; i++)
indexes[i] = indexes[i - 1] + darray_size(buckets[i]);
/* Rebuild array. */
for (i = 0; i < NUM_BUCKETS; i++)
{
k = indexes[i];
for (j = 0; j < darray_size(buckets[i]); j++)
array[k + j] = darray_get(buckets[i], j);
}
}
}
/* House keeping. */
for (i = 0; i < NUM_BUCKETS; i++)
darray_destroy(buckets[i]);
free(buckets);
free(indexes);
}
char *test_darray_operations()
{
darray_t *array = darray_create(sizeof(int), 100);
mu_assert(array != NULL, "darray_create failed.");
mu_assert(array->contents != NULL, "contents are wrong in darray");
mu_assert(array->end == 0, "end isn't at the right spot");
mu_assert(array->element_size == sizeof(int), "element size is wrong.");
mu_assert(array->max == 100, "wrong max length on initial size");
int *val1 = darray_new(array);
mu_assert(val1 != NULL, "failed to make a new element");
int *val2 = darray_new(array);
mu_assert(val2 != NULL, "failed to make a new element");
darray_set(array, 0, val1);
darray_set(array, 1, val2);
mu_assert(darray_get(array, 0) == val1, "Wrong first value.");
mu_assert(darray_get(array, 1) == val2, "Wrong second value.");
int *val_check = darray_remove(array, 0);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val1, "Should get the first value.");
mu_assert(darray_get(array, 0) == NULL, "Should be gone.");
darray_free(val_check);
val_check = darray_remove(array, 1);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val2, "Should get the first value.");
mu_assert(darray_get(array, 1) == NULL, "Should be gone.");
darray_free(val_check);
int old_max = array->max;
darray_expand(array);
mu_assert(array->max == old_max + array->expand_rate, "Wrong size after expand.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
int i = 0;
for(i = 0; i < 1000; i++) {
int *val = darray_new(array);
darray_attach(array, val);
*val = i * 333;
darray_push(array, val);
}
mu_assert(array->max == 1201, "Wrong max size.");
for(i = 999; i > 0; i--) {
int *val = darray_pop(array);
mu_assert(val != NULL, "Shouldn't get a NULL.");
mu_assert(*val == i * 333, "Wrong value.");
darray_free(val);
}
darray_destroy(array);
return NULL;
}
/**
* Mostly used in testing, reloading filters won't be supported.
*/
void Filter_destroy()
{
darray_destroy(REGISTERED_FILTERS);
REGISTERED_FILTERS = NULL;
}
char *test_destroy()
{
darray_destroy(array);
return NULL;
}
void darray_clear_destroy(darray_t *array)
{
darray_clear(array);
darray_destroy(array);
}
void Register_destroy()
{
darray_destroy(REGISTRATIONS);
RadixMap_destroy(REG_ID_TO_FD);
}
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;
}
