Example #1
0
StructRecord structrecord_init(StructRecord sr, char *typeName, char *name, StructRecord parent) {
  sr->type=strdup(typeName);
  sr->name = name ? strdup(name) : NULL;
  if(parent) {
    structrecord_add_child(parent, sr);
  }
  sr->flags=TCOD_list_new();
  sr->props=TCOD_list_new();
  sr->children=TCOD_list_new();
  return sr;
}
Example #2
0
static TCOD_path_data_t *TCOD_path_new_intern(int w, int h) {
	TCOD_path_data_t *path=(TCOD_path_data_t *)calloc(sizeof(TCOD_path_data_t),1);
	path->w=w;
	path->h=h;
	path->grid=(float *)calloc(sizeof(float),w*h);
	path->heur=(float *)calloc(sizeof(float),w*h);
	path->prev=(dir_t *)calloc(sizeof(dir_t),w*h);
	if (! path->grid || ! path->heur || ! path->prev ) {
		TCOD_fatal("Fatal error : path finding module cannot allocate djikstra grids (size %dx%d)\n",w,h);
		exit(1);
	}
	path->path=TCOD_list_new();
	path->heap=TCOD_list_new();
	return path;
}
Example #3
0
static void check_quadrant(map_t *m,int startX,int startY,int dx, int dy, int extentX,int extentY, bool light_walls) {
    TCOD_list_t active_views=TCOD_list_new();
    line_t shallow_line= {offset,limit,extentX*STEP_SIZE,0};
    line_t steep_line= {limit,offset,0,extentY*STEP_SIZE};
    int maxI=extentX+extentY,i=1;
    view_t *view= &views[startX+startY*m->width];

    view->shallow_line=shallow_line;
    view->steep_line=steep_line;
    view->shallow_bump=NULL;
    view->steep_bump=NULL;
    TCOD_list_push(active_views,view);
    current_view=(view_t **)TCOD_list_begin(active_views);
    while ( i  != maxI+1 && ! TCOD_list_is_empty(active_views) ) {
        int startJ=MAX(i-extentX,0);
        int maxJ=MIN(i,extentY);
        int j=startJ;
        while ( j != maxJ+1 && ! TCOD_list_is_empty(active_views) && current_view != (view_t **)TCOD_list_end(active_views) ) {
            int x=(i - j)*STEP_SIZE;
            int y=j*STEP_SIZE;
            visit_coords(m,startX,startY,x,y,dx,dy,active_views, light_walls);
            j++;
        }
        i++;
        current_view=(view_t **)TCOD_list_begin(active_views);
    }
    TCOD_list_delete(active_views);
}
Example #4
0
/* retrieve the list of all available syllable set names */
TCOD_list_t TCOD_namegen_get_sets (void) {
    TCOD_list_t l = TCOD_list_new();
    namegen_t ** it;
    for (it = (namegen_t**)TCOD_list_begin(namegen_generators_list); it < (namegen_t**)TCOD_list_end(namegen_generators_list); it++)
        TCOD_list_push(l,(const void*)((*it)->name));
    return l;
}
Example #5
0
Sensor sensor_init(Sensor s, char *id, Volume volume, void *context) {
  s->id = strdup(id);
  s->volume = volume;
  volume_swept_bounds(s->volume, &(s->borig), &(s->bsz));
  
  s->vistiles = calloc(s->bsz.x*s->bsz.y*s->bsz.z, sizeof(perception));
      
  s->visObjects = TCOD_list_new();
  s->oldVisObjects = TCOD_list_new();

  s->stimuli = TCOD_list_new();
  
  s->context = context;
  
  return s;
}
Example #6
0
TCOD_list_t TCOD_list_duplicate(TCOD_list_t l) {
	int i=0;
	void **t;
	TCOD_list_int_t *ret=(TCOD_list_int_t *)TCOD_list_new();
	while ( ret->allocSize < LIST(l)->allocSize ) TCOD_list_allocate_int((TCOD_list_t)ret);
	ret->fillSize=LIST(l)->fillSize;
	for (t=TCOD_list_begin(l); t != TCOD_list_end(l); t++) {
		ret->array[i++]=*t;
	}
	return (TCOD_list_t)ret;
}
/* create a new generator */
namegen_t * namegen_generator_new (void) {
    namegen_t * data = malloc(sizeof(namegen_t));
    data->name = NULL;
    /* assign the rng */
	data->random = TCOD_random_get_instance();
	/* create the lists */
    data->vocals = TCOD_list_new();
    data->consonants = TCOD_list_new();
    data->syllables_pre = TCOD_list_new();
    data->syllables_start = TCOD_list_new();
    data->syllables_middle = TCOD_list_new();
    data->syllables_end = TCOD_list_new();
    data->syllables_post = TCOD_list_new();
    data->illegal_strings = TCOD_list_new();
    data->rules = TCOD_list_new();
    return (TCOD_namegen_t)data;
}
bool namegen_parser_end_struct(TCOD_parser_struct_t str, const char *name) {
    /* if there's no syllable set by this name, add it to the list */
    if (namegen_generator_check(name) == false) {
        parser_data->name = TCOD_strdup(name);
        parser_output = namegen_generator_new();
        namegen_populate(parser_output,parser_data);
        parser_output->random = namegen_random;
        if (namegen_generators_list == NULL) namegen_generators_list = TCOD_list_new();
        TCOD_list_push(namegen_generators_list, (const void*)parser_output);
    }
    /* free the allocated memory to prevent a memory leak */
    namegen_syllables_delete(parser_data);
    return true;
}
Example #9
0
bool TCOD_bsp_traverse_inverted_level_order(TCOD_bsp_t *node, TCOD_bsp_callback_t listener, void *userData) {
	TCOD_list_t stack1=TCOD_list_new();
	TCOD_list_t stack2=TCOD_list_new();
	TCOD_list_push(stack1,node);
	while ( ! TCOD_list_is_empty(stack1) ) {
		TCOD_bsp_t *node=(TCOD_bsp_t *)TCOD_list_get(stack1,0);
		TCOD_list_push(stack2,node);
		TCOD_list_remove(stack1,node);
		if ( TCOD_bsp_left(node) ) TCOD_list_push(stack1,TCOD_bsp_left(node));
		if ( TCOD_bsp_right(node) ) TCOD_list_push(stack1,TCOD_bsp_right(node));
	}
	while ( ! TCOD_list_is_empty(stack2) ) {
		TCOD_bsp_t *node=(TCOD_bsp_t *)TCOD_list_pop(stack2);
		if (!listener(node,userData)) {
			TCOD_list_delete(stack1);
			TCOD_list_delete(stack2);
			return false;
		}
	}
	TCOD_list_delete(stack1);
	TCOD_list_delete(stack2);
	return true;
}
/* run the parser */
void namegen_parser_run (const char * filename) {
    char ** it;
    /* prepare the parser --- this will be executed only once */
    namegen_parser_prepare();
    if (parsed_files == NULL) parsed_files = TCOD_list_new();
    if (TCOD_list_size(parsed_files) > 0) {
        for (it = (char **)TCOD_list_begin(parsed_files); it != (char **)TCOD_list_end(parsed_files); it++)
            if (strcmp(*it,filename) == 0) return;
    }
    /* if the file hasn't been parsed yet, add its name to the list so that it's never parsed twice */
    TCOD_list_push(parsed_files,(const void *)TCOD_strdup(filename));
    /* run the parser */
    TCOD_parser_run(namegen_parser,filename,&namegen_listener);
}
/* check whether a given generator already exists */
bool namegen_generator_check (const char * name) {
    /* if the list is not created yet, create it */
    if (namegen_generators_list == NULL) {
        namegen_generators_list = TCOD_list_new();
        return false;
    }
    /* otherwise, scan it for the name */
    else {
        namegen_t ** it;
        for (it = (namegen_t**)TCOD_list_begin(namegen_generators_list); it < (namegen_t**)TCOD_list_end(namegen_generators_list); it++) {
            if (strcmp((*it)->name,name) == 0) return true;
        }
        return false;
    }
}
Example #12
0
TCOD_dijkstra_t TCOD_dijkstra_new_using_function(int map_width, int map_height, TCOD_path_func_t func, void *user_data, float diagonalCost) {
	dijkstra_t * data;
	TCOD_IFNOT(func != NULL && map_width > 0 && map_height > 0) return NULL;
	data = malloc(sizeof(dijkstra_t));
	data->map = NULL;
	data->func = func;
	data->user_data=user_data;
	data->distances = malloc(map_width*map_height*sizeof(int)*4);
	data->nodes = malloc(map_width*map_height*sizeof(int)*4);
	data->diagonal_cost = (int)((diagonalCost * 100.0f)+0.1f); /* because (int)(1.41f*100.0f) == 140!!! */
	data->width = map_width;
	data->height = map_height;
	data->nodes_max = map_width*map_height;
	data->path = TCOD_list_new();
	return (TCOD_dijkstra_t)data;
}
Example #13
0
/* create a Dijkstra object */
TCOD_dijkstra_t TCOD_dijkstra_new (TCOD_map_t map, float diagonalCost) {
	dijkstra_t * data ;
	TCOD_IFNOT(map != NULL) return NULL;
	data = malloc(sizeof(dijkstra_t));
	data->map = map;
	data->func = NULL;
	data->user_data=NULL;
	data->distances = malloc(TCOD_map_get_nb_cells(data->map)*sizeof(int));
	data->nodes = malloc(TCOD_map_get_nb_cells(data->map)*sizeof(int));
	data->diagonal_cost = (int)((diagonalCost * 100.0f)+0.1f); /* because (int)(1.41f*100.0f) == 140!!! */
	data->width = TCOD_map_get_width(data->map);
	data->height = TCOD_map_get_height(data->map);
	data->nodes_max = TCOD_map_get_nb_cells(data->map);
	data->path = TCOD_list_new();
	return (TCOD_dijkstra_t)data;
}
Example #14
0
File: gui.c Project: pasoev/innfin
struct gui *mkgui(int w, int h)
{
    struct gui *gui = malloc(sizeof *gui);
    if (gui) {
        gui->con = TCOD_console_new(w, h);
        gui->inventory_con =
                   TCOD_console_new(INVENTORY_WIDTH, INVENTORY_HEIGHT);
        gui->render_bar = render_bar;
        gui->render_log = render_log;
        gui->render_mouse_look = render_mouse_look;
        gui->render = gui_render;
        gui->message = message;
        gui->log = TCOD_list_new();
    }

    return gui;
}
Example #15
0
TCOD_list_t TCOD_sys_get_directory_content(const char *path, const char *pattern) {
    TCOD_list_t list=TCOD_list_new();
#ifdef TCOD_WINDOWS
    WIN32_FIND_DATA FileData;
    HANDLE          hList;
	char dname[ 512 ];
	sprintf(dname, "%s\\*",path);
    hList = FindFirstFile(dname, &FileData);
    if (hList == INVALID_HANDLE_VALUE)
    {
        return list;
    }
	do
	{
		if ( ! (strcmp(FileData.cFileName,".") == 0 || strcmp(FileData.cFileName,"..") == 0 ) )
		{
			if ( filename_match(FileData.cFileName,pattern) )
				TCOD_list_push(list,TCOD_strdup(FileData.cFileName));
		}

	} while ( FindNextFile(hList, &FileData) );
    FindClose(hList);
#else
    DIR *dir = opendir(path);
    struct dirent *dirent = NULL;
    if ( ! dir ) return list;
    while ( ( dirent = readdir(dir) ) )
    {
		if ( ! (strcmp(dirent->d_name,".") == 0 || strcmp(dirent->d_name,"..") == 0 ) )
		{
			if ( filename_match(dirent->d_name,pattern) )
				TCOD_list_push(list,strdup(dirent->d_name));
		}
	}
	closedir(dir);
#endif
	return list;
}
Example #16
0
TCOD_list_t TCOD_list_allocate(int nb_elements) {
	TCOD_list_t l=TCOD_list_new();
	LIST(l)->array = (void **)calloc(sizeof(void *),nb_elements);
	LIST(l)->allocSize = nb_elements;
	return l;
}
Example #17
0
Loader loader_init(Loader l, char *basePath) {
  l->path = strdup(basePath);
  
  //first, install the basic trigger schema. this happens before any config files are loaded.
  l->triggerSchema = flagschema_init(flagschema_new());
  #define ADD_TRIGGER(_trigName) flagschema_insert(l->triggerSchema, "on_" #_trigName , 1)
  ADD_TRIGGER(enter);
  ADD_TRIGGER(exit);
  ADD_TRIGGER(inside);
  ADD_TRIGGER(bump);
  ADD_TRIGGER(atop);
  ADD_TRIGGER(walk_up);
  ADD_TRIGGER(walk_down);
  ADD_TRIGGER(fall_onto);
  ADD_TRIGGER(fall_through);
  ADD_TRIGGER(chomp);
  ADD_TRIGGER(unchomp);
  ADD_TRIGGER(attach);
  ADD_TRIGGER(release);
  ADD_TRIGGER(eat);
  ADD_TRIGGER(digesting);
  ADD_TRIGGER(digested);
  ADD_TRIGGER(carry);
  ADD_TRIGGER(carry_left);
  ADD_TRIGGER(carry_right);
  ADD_TRIGGER(carry_back);
  ADD_TRIGGER(carry_forward);
  ADD_TRIGGER(carry_up);
  ADD_TRIGGER(carry_down);
  ADD_TRIGGER(latch);
  ADD_TRIGGER(tug_left);
  ADD_TRIGGER(tug_right);
  ADD_TRIGGER(tug_back);
  ADD_TRIGGER(tug_forward);
  #undef ADD_TRIGGER
  
  l->configParser = configlistener_init_parser(TCOD_parser_new(), l);
  l->configListener = configlistener_init(configlistener_new(), l);
  
  l->moveFlags = TCOD_list_new();
  loader_add_move_flag(l, "normal");
  
  loader_load_config(l, "init");
  
  l->statusParser = statuslistener_init_parser(TCOD_parser_new(), l);
  l->statusListener = statuslistener_init(statuslistener_new(), l);
  
  TCOD_list_t statusFiles = configlistener_status_files(l->configListener);
  TS_LIST_FOREACH(statusFiles, loader_load_status(l, each));

  l->objectParser = objectlistener_init_parser(TCOD_parser_new(), l);  
  l->objectListener = objectlistener_init(objectlistener_new(), l);

  l->mapParser = maplistener_init_parser(TCOD_parser_new(), l);  
  l->mapListener = maplistener_init(maplistener_new(), l);

  l->saveParser = savelistener_init_parser(TCOD_parser_new(), l);
  l->saveListener = savelistener_init(savelistener_new(), l);

  return l;
}
Example #18
0
TCOD_list_t sensor_consume_stimuli(Sensor s) {
  TCOD_list_t ret = s->stimuli;
  s->stimuli = TCOD_list_new();
  return ret;
}