session_state session_service_destroy_session(session_service *service,\
jnx_guid *g) {
JNXCHECK(service);
session_state e = SESSION_STATE_NOT_FOUND;
jnx_node *h = service->session_list->head,
*r = service->session_list->head;
jnx_list *cl = jnx_list_create();
session *retrieved_session = NULL;
while(h) {
session *s = h->_data;
if(jnx_guid_compare(g,&s->session_guid) == JNX_GUID_STATE_SUCCESS) {
retrieved_session = s;
e = SESSION_STATE_OKAY;
} else {
jnx_list_add_ts(cl,s);
}
h = h->next_node;
}
service->session_list->head = r;
jnx_list_destroy(&service->session_list);
if(cl) {
destroy_session(retrieved_session);
}
service->session_list = cl;
return e;
}
void session_service_destroy(session_service **service) {
if((*service)->session_list->counter) {
jnx_list *sessions_list;
JNXCHECK(session_service_fetch_all_sessions(*service,&sessions_list) ==
SESSION_STATE_OKAY);
jnx_node *h = sessions_list->head,
*r = sessions_list->head;
while(h) {
session *s = h->_data;
session_service_destroy_session(*service,&s->session_guid);
h = h->next_node;
}
h = r;
jnx_list_destroy(&sessions_list);
}
jnx_list *s = (*service)->session_list;
jnx_list_destroy(&s);
free(*service);
*service = NULL;
}
void cartographer_clear(void)
{
if(object_list == NULL) return;
jnx_node *head = object_list->head;
while(head)
{
game_object *currentobj = head->_data;
free(currentobj->sprite);
free(currentobj);
head = head->next_node;
}
jnx_list_destroy(&object_list);
object_list = NULL;
}
static void test_data_removal() {
JNXLOG(LDEBUG,"- test_data_removal");
char *test_string = "AABBCC";
jnx_list *list = jnx_list_create();
int count = 10;
int x;
for(x = 0; x < count; ++x) {
char *dynamic_string = malloc(strlen(test_string));
jnx_list_add(list,dynamic_string);
}
char *ret;
while((ret = jnx_list_remove(&list)) != NULL) {
free(ret);
}
jnx_list_destroy(&list);
JNXCHECK(list == NULL);
JNXLOG(LDEBUG,"OK");
}
static void test_list_index() {
JNXLOG(LDEBUG,"- test_list_sequence");
jnx_list *j = jnx_list_create();
int count = 6;
char *ar[] = { "A", "B", "C", "D", "E", "F" };
int y;
for(y = 0; y < count; ++y) {
jnx_list_add(j,ar[y]);
}
int x;
for(x = count - 1; x >= 0; x--) {
char *current = jnx_list_remove(&j);
JNXCHECK(strcmp(current,ar[x]) == 0);
}
JNXLOG(LDEBUG,"OK");
jnx_list_destroy(&j);
JNXCHECK(j == NULL);
}
static void test_list_tail() {
jnx_list *l = jnx_list_create();
int count = 3;
char *ar[] = { "A", "B", "C" };
int x;
for(x = 0; x < count; ++x) {
jnx_list_add(l,ar[x]);
}
int c=count;
while(l->tail != NULL) {
JNXCHECK(strcmp((char*)l->tail->_data,ar[c-1]) == 0);
--c;
l->tail = l->tail->prev_node;
}
jnx_list_destroy(&l);
}
static void test_list_creation() {
JNXLOG(LDEBUG,"- test_list_creation");
jnx_list *secondlist = jnx_list_create();
JNXCHECK(secondlist != NULL);
JNXLOG(LDEBUG,"OK");
struct foo *f = malloc(sizeof(foo));
f->number = 10;
JNXLOG(LDEBUG,"- test_list_insertion");
jnx_list_add(secondlist,(void*)f);
JNXLOG(LDEBUG,"OK");
JNXLOG(LDEBUG,"- test_list_removal");
struct foo *output = (struct foo*)jnx_list_remove(&secondlist);
JNXCHECK(output->number == 10);
free(output);
JNXLOG(LDEBUG,"OK");
JNXLOG(LDEBUG,"- test_list_deletion");
jnx_list_destroy(&secondlist);
JNXLOG(LDEBUG,"OK");
}
void *game_load(void *args)
{
char *configuration_path = GAMECONFIGURATION;
loading_flag = 0;
JNX_LOG(NULL,"Starting game_load\n");
/*-----------------------------------------------------------------------------
* Perform object loading
*-----------------------------------------------------------------------------*/
jnx_list *configuration_list = config_parser_load_configuration(configuration_path);
jnx_node *head = configuration_list->head;
while(head)
{
game_object *obj = (game_object*)head->_data;
/*-----------------------------------------------------------------------------
* Setup a pointer to player
*-----------------------------------------------------------------------------*/
if(strcmp(obj->object_type,"player") == 0)
{
player = obj;
}
cartographer_add(obj);
head = head->next_node;
}
jnx_list_destroy(&configuration_list);
head = NULL;
if(player == NULL)
{
JNX_LOG(NULL,"Could not find the player from the loaded configuration file!\n Cannot have a game without a player\n");
exit(0);
}
/*-----------------------------------------------------------------------------
* Start results
*-----------------------------------------------------------------------------*/
JNX_LOG(NULL,"Done\n");
loading_flag = 1;
}
void jnx_hash_destroy(jnx_hashmap** hash) {
jnx_hashmap *hashmap = *hash;
JNXCHECK(hashmap);
jnx_int32 len = hashmap->size;
jnx_int32 count;
for(count = 0; count < len; ++count) {
jnx_hash_element *current_element = &hashmap->data[count];
if(current_element->used) {
jnx_list *current_bucket = current_element->bucket;
while(current_bucket->head) {
jnx_hash_bucket_el *current_element = current_bucket->head->_data;
free(current_element->origin_key);
free(current_element);
current_bucket->head = current_bucket->head->next_node;
}
jnx_list_destroy(¤t_bucket);
}
}
jnx_thread_mutex_destroy(&hashmap->internal_lock);
free(hashmap);
*hash = NULL;
}
void game_run()
{
JNX_LOG(NULL,"Starting run loop\n");
sfEvent current_event;
sfTime time;
float current_time;
while(sfRenderWindow_isOpen(main_window))
{
switch(current_game_state)
{
case COMPLETE:
sfRenderWindow_clear(main_window,clear_color);
sfRenderWindow_pollEvent(main_window,¤t_event);
switch(current_event.key.code)
{
case sfKeyReturn:
sfRenderWindow_close(main_window);
}
sfVector2f completepos = sfView_getCenter(main_view);
int string_length = strlen(sfText_getString(game_finish_text));
int complete_offset = sfText_getCharacterSize(game_finish_text) * string_length;
completepos.x = completepos.x - (complete_offset / 2);
sfText_setPosition(game_finish_text,completepos);
sfRenderWindow_drawText(main_window,game_finish_text,NULL);
sfRenderWindow_display(main_window);
break;
case NEXT_LEVEL:
sfRenderWindow_clear(main_window,clear_color);
sfRenderWindow_pollEvent(main_window,¤t_event);
switch(current_event.key.code)
{
case sfKeyEscape:
sfRenderWindow_close(main_window);
break;
case sfKeyReturn:
game_setup_next_level();
break;
}
sfVector2f nlpos = sfView_getCenter(main_view);
int nltext_offset = strlen(sfText_getString(next_level_text));
nltext_offset = nltext_offset * sfText_getCharacterSize(next_level_text);
sfVector2f nlnewpos;
nlnewpos.x = nlpos.x - (nltext_offset / 2);
nlnewpos.y = nlpos.y;
sfText_setPosition(next_level_text,nlnewpos);
int nlbt_offset = strlen(sfText_getString(next_level_button_text));
nlbt_offset = nlbt_offset * sfText_getCharacterSize(next_level_button_text);
nlnewpos.x = nlpos.x - (nlbt_offset /2);
nlnewpos.y = nlnewpos.y + 50;
sfText_setPosition(next_level_button_text,nlnewpos);
switch(text_yellow)
{
case 0:
sfText_setColor(next_level_button_text,sfColor_fromRGB(255,255,0));
text_yellow = 1;
break;
case 1:
sfText_setColor(next_level_button_text,sfColor_fromRGB(255,0,0));
text_yellow = 0;
break;
}
sfRenderWindow_drawText(main_window,next_level_text,NULL);
sfRenderWindow_drawText(main_window,next_level_button_text,NULL);
sfRenderWindow_display(main_window);
break;
case RUNNING:
time = sfClock_getElapsedTime(_clock);
current_time = sfTime_asSeconds(time);
sfRenderWindow_pollEvent(main_window,¤t_event);
/*-----------------------------------------------------------------------------
* Slowly zoom in as we start the level
*-----------------------------------------------------------------------------*/
/* if(sfView_getSize(main_view).x > videomode.width)
{
sfView_zoom(main_view,0.99f);
}
*/
switch(current_event.key.code)
{
case sfKeyEscape:
sfRenderWindow_close(main_window);
break;
}
if(score_max_achieved() == 1)
{
if(current_level < max_levels)
{
current_game_state = NEXT_LEVEL;
}else if(current_level == max_levels)
{
current_game_state = COMPLETE;
}
score_reset();
}
sfRenderWindow_clear(main_window,clear_color);
/*-----------------------------------------------------------------------------
* Set the current view
*-----------------------------------------------------------------------------*/
if(player != NULL){
sfView_setCenter(main_view,sfSprite_getPosition(player->sprite));
sfRenderWindow_setView(main_window,main_view);
}
/*-----------------------------------------------------------------------------
* Draw starfield
*-----------------------------------------------------------------------------*/
if(player != NULL){
starfield_draw(main_view,main_window,sfSprite_getPosition(player->sprite));
}
/*-----------------------------------------------------------------------------
* Draw objects
*-----------------------------------------------------------------------------*/
jnx_list *draw_queue = cartographer_get_at(main_view);
if(draw_queue != NULL){
jnx_node *current_draw_pos = draw_queue->head;
/*-----------------------------------------------------------------------------
* Draw weapon fire
*-----------------------------------------------------------------------------*/
weapon_draw(main_window,main_view,&draw_queue);
while(current_draw_pos)
{
game_object *obj = (game_object*)current_draw_pos->_data;
if(strcmp(obj->object_type,"player") == 0)
{
game_object_update(obj,current_event,main_view);
}
else
{
/*-----------------------------------------------------------------------------
* Update AI objects
*-----------------------------------------------------------------------------*/
game_ai_update(obj,player);
}
#ifdef BOUNDING_BOX
sfRectangleShape *bounding = game_object_get_boundingRect(obj);
sfRenderWindow_drawRectangleShape(main_window,bounding,NULL);
sfRectangleShape_destroy(bounding);
#endif
sfRenderWindow_drawSprite(main_window,obj->sprite,NULL);
current_draw_pos = current_draw_pos->next_node;
}
cartographer_update();
}
/*-----------------------------------------------------------------------------
* Draw ingame ui
*-----------------------------------------------------------------------------*/
game_ui_update(main_window,main_view,player,draw_queue);
game_ui_draw(main_window,draw_queue);
sfRenderWindow_display(main_window);
jnx_list_destroy(&draw_queue);
break;
case GAMEOVER:
sfRenderWindow_clear(main_window,clear_color);
sfRenderWindow_pollEvent(main_window,¤t_event);
switch(current_event.key.code)
{
case sfKeyEscape:
sfRenderWindow_close(main_window);
break;
}
sfVector2f pos = sfView_getCenter(main_view);
int text_offset = strlen(sfText_getString(game_over_text));
text_offset = text_offset * sfText_getCharacterSize(game_over_text);
sfVector2f newpos;
newpos.x = pos.x - (text_offset / 2);
newpos.y = pos.y;
sfText_setPosition(game_over_text,newpos);
sfRenderWindow_drawText(main_window,game_over_text,NULL);
sfRenderWindow_display(main_window);
break;
case GAMESTART:
sfRenderWindow_clear(main_window,clear_color);
sfRenderWindow_pollEvent(main_window,¤t_event);
int game_bound = atoi(jnx_hash_get(config,"GAMEBOUNDS"));
switch(current_event.key.code)
{
case sfKeyEscape:
sfRenderWindow_close(main_window);
break;
case sfKeySpace:
play_music(INGAMEMUSIC);
current_game_state = LOADING;
break;
}
sfVector2f pos_start = sfView_getCenter(main_view);
int text_offset_start = strlen(sfText_getString(game_start_text));
text_offset_start = text_offset_start * sfText_getCharacterSize(game_start_text);
sfVector2f newpos_start;
newpos_start.x = pos_start.x + (text_offset_start /2 );
newpos_start.y = pos_start.y - (text_offset_start /2);
sfText_setPosition(game_start_text,newpos_start);
sfVector2f button_start;
button_start.x = newpos_start.x;
button_start.y = newpos_start.y + 50;
sfText_setPosition(game_start_button_text,button_start);
button_start.y = button_start.y + 50;
sfText_setPosition(game_author_text,button_start);
switch(text_yellow)
{
case 0:
sfText_setColor(game_start_button_text,sfColor_fromRGB(255,255,0));
sfText_setColor(game_start_text,sfColor_fromRGB(255,255,0));
text_yellow = 1;
break;
case 1:
sfText_setColor(game_start_button_text,sfColor_fromRGB(255,0,0));
sfText_setColor(game_start_text,sfColor_fromRGB(255,0,0));
text_yellow = 0;
break;
}
jnx_list *menu_starfield = starfield_menu_create(main_view);
jnx_node *head = menu_starfield->head;
while(menu_starfield->head)
{
sfSprite *sprite = menu_starfield->head->_data;
sfVector2f pos = sfSprite_getPosition(sprite);
pos.y = pos.y +5;
if(pos.y > sfView_getSize(main_view).y)
{
pos.y = 0;
}
sfSprite_setPosition(sprite,pos);
sfRenderWindow_drawSprite(main_window,sprite,NULL);
menu_starfield->head = menu_starfield->head->next_node;
}
menu_starfield->head = head;
sfRenderWindow_drawText(main_window,game_start_button_text,NULL);
sfRenderWindow_drawText(main_window,game_start_text,NULL);
sfRenderWindow_drawText(main_window,game_author_text,NULL);
sfRenderWindow_display(main_window);
break;
case LOADING:
sfRenderWindow_clear(main_window,clear_color);
sfRenderWindow_setView(main_window,main_view);
if(loading_started == 0)
{
//spawn thread
pthread_t load_worker;
pthread_create(&load_worker,NULL,game_load,NULL);
loading_started = 1;
}
if(loading_flag == 1)
{
//break and start game
loading_started = 0;
loading_flag = 0;
sfVector2f viewpos;
viewpos.x = game_bound /2;
viewpos.y = game_bound /2;
sfView_setCenter(main_view,viewpos);
sfVector2f size = sfView_getSize(main_view);
size.x = size.x *2;
size.y = size.y *2;
/*-----------------------------------------------------------------------------
* Set the zoom a bit further out so on level start we can zoom in
*-----------------------------------------------------------------------------*/
// sfView_setSize(main_view,size);
current_game_state = RUNNING;
printf("Loading done\n");
break;
}
sfVector2f loadingpos = sfView_getCenter(main_view);
int loading_offset = strlen(sfText_getString(game_loading_text));
loading_offset = loading_offset * sfText_getCharacterSize(game_loading_text);
loadingpos.x = loadingpos.x - (loading_offset /2);
loadingpos.y = loadingpos.y - (loading_offset /2);
switch(text_yellow)
{
case 0:
sfText_setColor(game_loading_text,sfColor_fromRGB(255,255,0));
text_yellow = 1;
break;
case 1:
sfText_setColor(game_loading_text,sfColor_fromRGB(255,0,0));
text_yellow = 0;
break;
}
sfText_setPosition(game_loading_text,loadingpos);
sfRenderWindow_drawText(main_window,game_loading_text,NULL);
sfRenderWindow_display(main_window);
break;
}
}
}
void* jnx_hash_delete_value(jnx_hashmap *hashmap,jnx_char *key) {
JNXCHECK(hashmap);
JNXCHECK(key);
jnx_int32 index = jnx_hash_string(key, hashmap->size);
jnx_node *head = hashmap->data[index].bucket->head;
jnx_node *rewind = head;
if(head == NULL) {
return NULL;
}
if(head->next_node == NULL) {
jnx_hash_bucket_el *element = head->_data;
void *data = (void*)element->origin_value;
free(element->origin_key);
free(element);
jnx_list_destroy(&hashmap->data[index].bucket);
hashmap->data[index].bucket = NULL;
hashmap->data[index].used = 0;
hashmap->data[index].bucket_len = 0;
return data;
}
jnx_node *previous_node = NULL;
while(head) {
jnx_hash_bucket_el *bucketel = head->_data;
if(strcmp(bucketel->origin_key,key) == 0) {
if(previous_node == NULL) {
//Start node in list
void *data = (void*)bucketel->origin_value;
free(bucketel->origin_key);
free(bucketel);
//lets set the hashmap to pojnx_int32 to the next element of this list
hashmap->data[index].bucket->head = head->next_node;
///free this node in the list
free(head);
hashmap->data[index].bucket_len--;
return data;
} else {
if(head->next_node == NULL) {
///Last node in list
///we have a previous node which will become the last node in the list now
void *data = (void*)bucketel->origin_value;
free(bucketel->origin_key);
free(bucketel);
free(head);
previous_node->next_node = NULL;
head = rewind;
hashmap->data[index].bucket_len--;
return data;
} else {
//Middle node in list
//set need to set the previous node, and the next node to link to each other
void *data = (void*)bucketel->origin_value;
free(bucketel->origin_key);
free(bucketel);
//set the previous node to jump to the next
jnx_node *next_node = head->next_node;
free(head);
previous_node->next_node = next_node;
hashmap->data[index].bucket_len--;
return data;
}
}
}
previous_node = head;
head = head->next_node;
}
return NULL;
}
