char* GetDataFilePath(char* filename) {
char *result = 0;
if (al_filename_exists(filename)) {
return strdup(filename);
}
char origfn[255] = "data/";
strcat(origfn, filename);
if (al_filename_exists(origfn)) {
return strdup(origfn);
}
void TestPath(char* subpath) {
ALLEGRO_PATH *tail = al_create_path(filename);
ALLEGRO_PATH *path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
ALLEGRO_PATH *data = al_create_path(subpath);
al_join_paths(path, data);
al_join_paths(path, tail);
//printf("Testing for %s\n", al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
if (al_filename_exists(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP))) {
result = strdup(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
}
al_destroy_path(tail);
al_destroy_path(data);
al_destroy_path(path);
}
bool Windows::LoadProfile()
{
#ifdef WIN32
char szPath[MAX_PATH];
ALLEGRO_PATH* alPath;
bool res;
if( al_filename_exists( "c4a-prof" ) )
return ParseProfileFile( "c4a-prof" );
if( SHGetFolderPathA( 0, CSIDL_PERSONAL, 0, 0, (char*)&szPath ) == S_OK )
{
alPath = al_create_path( (char*)&szPath );
al_append_path_component( alPath, "c4a-prof" );
if( al_filename_exists( al_path_cstr( alPath, '/' ) ) )
res = ParseProfileFile( (char*)al_path_cstr( alPath, '/' ) );
al_destroy_path( alPath );
return res;
}
return false;
#else
return false;
#endif
}
/* Function: al_open_video
*/
ALLEGRO_VIDEO *al_open_video(char const *filename)
{
ALLEGRO_VIDEO *video;
const char *extension = filename + strlen(filename) - 1;
while ((extension >= filename) && (*extension != '.'))
extension--;
video = al_calloc(1, sizeof *video);
video->vtable = find_handler(extension);
if (video->vtable == NULL) {
ALLEGRO_ERROR("No handler for video extension %s - "
"therefore not trying to load %s.\n", extension, filename);
al_free(video);
return NULL;
}
video->filename = al_create_path(filename);
video->playing = true;
if (!video->vtable->open_video(video)) {
ALLEGRO_ERROR("Could not open %s.\n", filename);
al_destroy_path(video->filename);
al_free(video);
return NULL;
}
al_init_user_event_source(&video->es);
video->es_inited = true;
return video;
}
const char* getResource(const char* fmt, ...)
{
va_list ap;
static char res[512];
static ALLEGRO_PATH *dir;
static ALLEGRO_PATH *path;
va_start(ap, fmt);
memset(res, 0, 512);
snprintf(res, 511, fmt, ap);
if (!dir) {
dir = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
#ifdef ALLEGRO_MSVC
{
/* Hack to cope automatically with MSVC workspaces. */
const char *last = al_get_path_component(dir, -1);
if (0 == strcmp(last, "Debug")
|| 0 == strcmp(last, "RelWithDebInfo")
|| 0 == strcmp(last, "Release")
|| 0 == strcmp(last, "Profile")) {
al_remove_path_component(dir, -1);
}
}
#endif
al_append_path_component(dir, "data");
}
if (path)
al_destroy_path(path);
path = al_create_path(res);
al_rebase_path(dir, path);
return al_path_cstr(path, '/');
}
SlotManager::SlotManager(bool a_blLoading, ALLEGRO_PATH * a_pSearchpath,void (* a_pCallBack)(string))
{
m_ColorInner = al_map_rgb(0,0,0);
m_ColorOuter = al_map_rgb(100,100,255);
m_ColorHighlight = al_map_rgb(0,0,255);
m_pActiveSlot = NULL;
m_blLoading = a_blLoading;
m_pCallBack = a_pCallBack;
m_nIndex = 1;
if (a_pSearchpath!=NULL)
{
ALLEGRO_FS_ENTRY * pDir = al_create_fs_entry(al_path_cstr(a_pSearchpath,ALLEGRO_NATIVE_PATH_SEP));
if (al_open_directory(pDir))
{
ALLEGRO_FS_ENTRY * pFile;
while (pFile = al_read_directory(pDir))
{
ALLEGRO_PATH * pPath = al_create_path(al_get_fs_entry_name(pFile));
AddSlot(al_get_path_basename(pPath));
al_destroy_path(pPath);
al_destroy_fs_entry(pFile);
}
}
al_destroy_fs_entry(pDir);
}
if (!a_blLoading)
{
AddSlot("NEW SAVE...");
}
}
static ALLEGRO_PATH *follow_symlinks(ALLEGRO_PATH *path)
{
for (;;) {
const char *path_str = al_path_cstr(path, '/');
char buf[PATH_MAX];
int len;
len = readlink(path_str, buf, sizeof(buf) - 1);
if (len <= 0)
break;
buf[len] = '\0';
al_destroy_path(path);
path = al_create_path(buf);
}
/* Make absolute path. */
{
const char *cwd = al_get_current_directory();
ALLEGRO_PATH *cwd_path = al_create_path_for_directory(cwd);
if (al_rebase_path(cwd_path, path))
al_make_path_canonical(path);
al_destroy_path(cwd_path);
al_free((void *) cwd);
}
return path;
}
static bool select_folder(ALLEGRO_DISPLAY_WIN *win_display,
ALLEGRO_NATIVE_DIALOG *fd)
{
BROWSEINFO folderinfo;
LPCITEMIDLIST pidl;
char buf[MAX_PATH] = "";
char dbuf[MAX_PATH] = "";
folderinfo.hwndOwner = win_display->window;
folderinfo.pidlRoot = NULL;
folderinfo.pszDisplayName = dbuf;
folderinfo.lpszTitle = al_cstr(fd->title);
folderinfo.ulFlags = 0;
folderinfo.lpfn = NULL;
pidl = SHBrowseForFolder(&folderinfo);
if (pidl) {
SHGetPathFromIDList(pidl, buf);
fd->fc_path_count = 1;
fd->fc_paths = al_malloc(sizeof(void *));
fd->fc_paths[0] = al_create_path(buf);
return true;
}
return false;
}
s_sprite c_tile::get_from_ini(ALLEGRO_CONFIG *config, const char * section, ALLEGRO_PATH * base_path)
{
s_sprite temp;
const char * buffer_file = al_get_config_value(config, section, "image_file");
if(!buffer_file)
{
temp.index = -1;
return temp;
}
ALLEGRO_PATH * imagepath = al_create_path(buffer_file);
al_rebase_path(base_path, imagepath);
temp.index = imagelist.load_image(al_path_cstr(imagepath, ALLEGRO_NATIVE_PATH_SEP));
temp.x = get_config_int(config, section, "x");
temp.y = get_config_int(config, section, "y");
temp.width = get_config_int(config, section, "width");
temp.height = get_config_int(config, section, "height");
temp.origin_x = get_config_int(config, section, "origin_x");
temp.origin_y = get_config_int(config, section, "origin_y");
temp.origin_x = 0 - temp.origin_x;
temp.origin_y = 0 - temp.origin_y;
temp.palette_number = get_config_int(config, section, "palette_index");
temp.column_height = get_config_int(config, section, "column_height");
const char * color_selection = al_get_config_value(config, section, "color_source");
if(color_selection)
temp.color_by = get_color_selector(color_selection);
const char * pal_source = al_get_config_value(config, section, "palette_source");
if(pal_source)
temp.color_source = get_color_source(pal_source);
const char * color = al_get_config_value(config, section, "color_html");
if(color)
temp.color = color_html(color);
const char * off = al_get_config_value(config, section, "offset_type");
if(off)
temp.offset_type = get_offset_type(off);
const char * neigh = al_get_config_value(config, section, "border_terrain");
if(neigh)
temp.border_terrain = get_terrain_type(neigh);
const char * neighbobj = al_get_config_value(config, section, "border_structure");
if(neighbobj)
temp.border_structure = get_structure_type(neighbobj);
temp.offset_amount = get_config_int(config, section, "offset_amount");
al_destroy_path(imagepath);
return temp;
}
/* Function: al_set_exe_name
*/
void al_set_exe_name(char const *path)
{
ASSERT(active_sysdrv);
if (active_sysdrv->user_exe_path) {
al_destroy_path(active_sysdrv->user_exe_path);
}
active_sysdrv->user_exe_path = al_create_path(path);
}
void InitConfig(void) {
ALLEGRO_PATH *path = al_get_standard_path(ALLEGRO_USER_SETTINGS_PATH);
ALLEGRO_PATH *data = al_create_path("SuperDerpy.ini");
al_join_paths(path, data);
config = al_load_config_file(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
if (!config) config=al_create_config();
al_destroy_path(path);
al_destroy_path(data);
}
static int allua_Path_create(lua_State * L)
{
const char *str = luaL_checkstring(L, 1);
ALLUA_path path = al_create_path(str);
allua_pushPath(L, path, true);
return 1;
}
void DeinitConfig(void) {
ALLEGRO_PATH *path = al_get_standard_path(ALLEGRO_USER_SETTINGS_PATH);
ALLEGRO_PATH *data = al_create_path("SuperDerpy.ini");
al_make_directory(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
al_join_paths(path, data);
al_save_config_file(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP), config);
al_destroy_path(path);
al_destroy_path(data);
al_destroy_config(config);
}
void mapEditor::saveMap() {
ALLEGRO_FILECHOOSER* fC = al_create_native_file_dialog(al_create_path(""),"Select Location..","*.map",ALLEGRO_FILECHOOSER_SAVE);
al_show_native_file_dialog(this->display,fC);
const ALLEGRO_PATH* savePath = al_get_native_file_dialog_path(fC,0);
const char* pathName = al_path_cstr(savePath, ALLEGRO_NATIVE_PATH_SEP);
ALLEGRO_FILE* fHandle = al_fopen(pathName,"wb");
mapSaver* newSaver = new mapSaver(*this->mHandler->mData);
newSaver->writeData(fHandle);
al_fclose(fHandle);
}
/* Function: al_create_path_for_directory
*/
ALLEGRO_PATH *al_create_path_for_directory(const char *str)
{
ALLEGRO_PATH *path = al_create_path(str);
if (al_ustr_length(path->filename)) {
ALLEGRO_USTR *last = path->filename;
path->filename = al_ustr_new("");
al_append_path_component(path, al_cstr(last));
al_ustr_free(last);
}
return path;
}
/* _find_executable_file:
* Helper function: searches path and current directory for executable.
* Returns 1 on succes, 0 on failure.
*/
static ALLEGRO_PATH *_find_executable_file(const char *filename)
{
char *env;
/* If filename has an explicit path, search current directory */
if (strchr(filename, '/')) {
if (filename[0] == '/') {
/* Full path; done */
return al_create_path(filename);
}
else {
struct stat finfo;
char pathname[1024];
/* Prepend current directory */
ALLEGRO_PATH *path = al_get_current_directory();
al_append_path_component(path, filename);
if ((stat(pathname, &finfo)==0) &&
(!S_ISDIR (finfo.st_mode))) {
return path;
}
}
}
/* If filename has no explicit path, but we do have $PATH, search
* there
*/
else if ((env = getenv("PATH"))) {
struct stat finfo;
ALLEGRO_USTR *us = al_ustr_new(env);
int start_pos = 0;
while (start_pos >= 0) {
int next_start_pos = al_ustr_find_chr(us, start_pos + 1, ':');
int end_pos = next_start_pos;
if (next_start_pos < 0)
end_pos = al_ustr_size(us);
ALLEGRO_USTR_INFO info;
ALLEGRO_USTR *sub = al_ref_ustr(&info, us, start_pos, end_pos);
ALLEGRO_PATH *path = al_create_path_for_directory(al_cstr(sub));
al_append_path_component(path, filename);
if (stat(al_path_cstr(path, '/'), &finfo) == 0 &&
!S_ISDIR (finfo.st_mode)) {
return path;
}
start_pos = next_start_pos;
}
}
return NULL;
}
SYMBOL_EXPORT void DeinitConfig(struct Game* game) {
const ALLEGRO_FILE_INTERFACE* iface = al_get_new_file_interface();
al_set_standard_file_interface();
ALLEGRO_PATH* path = al_get_standard_path(ALLEGRO_USER_SETTINGS_PATH);
ALLEGRO_PATH* data = al_create_path("SuperDerpy.ini");
al_make_directory(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
al_join_paths(path, data);
al_save_config_file(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP), game->_priv.config);
al_destroy_path(path);
al_destroy_path(data);
al_destroy_config(game->_priv.config);
al_set_new_file_interface(iface);
}
void Map::SaveMapDialog()
{
ALLEGRO_FILECHOOSER *saveDialog;
saveDialog = al_create_native_file_dialog("..\\Maps\\", "Save Map", "*.*", ALLEGRO_FILECHOOSER_SAVE);
al_show_native_file_dialog(display_, saveDialog);
mapPath_ = al_create_path(al_get_native_file_dialog_path(saveDialog,0));
if(strcmp(al_get_path_extension(mapPath_),"") == 0)
{
al_set_path_extension(mapPath_, ".mapa");
}
SaveMap();
al_destroy_native_file_dialog(saveDialog);
}
/*
* Calling LoadLibrary with a relative file name is a security risk:
* see e.g. Microsoft Security Advisory (2269637)
* "Insecure Library Loading Could Allow Remote Code Execution"
*/
HMODULE _al_win_safe_load_library(const char *filename)
{
ALLEGRO_PATH *path1 = NULL;
ALLEGRO_PATH *path2 = NULL;
char buf[MAX_PATH];
const char *other_dirs[3];
HMODULE lib = NULL;
bool msvc_only = false;
/* MSVC only: if the executable is in the build configuration directory,
* which is also just under the current directory, then also try to load the
* library from the current directory. This leads to less surprises when
* running example programs.
*/
#if defined(ALLEGRO_MSVC)
msvc_only = true;
#endif
/* Try to load the library from the directory containing the running
* executable, the Windows system directories, or directories on the PATH.
* Do NOT try to load the library from the current directory.
*/
if (al_is_system_installed()) {
path1 = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
}
else if (GetModuleFileName(NULL, buf, sizeof(buf)) < sizeof(buf)) {
path1 = al_create_path(buf);
}
if (msvc_only) {
path2 = maybe_parent_dir(path1);
}
other_dirs[0] = path1 ? al_path_cstr(path1, '\\') : NULL;
other_dirs[1] = path2 ? al_path_cstr(path2, '\\') : NULL;
other_dirs[2] = NULL; /* sentinel */
_al_sane_strncpy(buf, filename, sizeof(buf));
if (PathFindOnPath(buf, other_dirs)) {
ALLEGRO_DEBUG("PathFindOnPath found: %s\n", buf);
lib = load_library_at_path(buf);
}
else {
ALLEGRO_WARN("PathFindOnPath failed to find %s\n", filename);
}
al_destroy_path(path1);
al_destroy_path(path2);
return lib;
}
static char* test_level_write_to_file()
{
char* level_name = "test-write.world";
ALLEGRO_PATH* path = al_create_path(FILES_ASSETS_PATH);
al_append_path_component(path, FILES_LEVELS_SUBDIRNAME);
al_set_path_filename(path, level_name);
const char* filename = al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP);
// create new test level
Level* level_new = level_alloc_empty(LEVEL_TEST_WIDTH, LEVEL_TEST_HEIGHT);
level_new->cells[3][4] = cell_init(UNIT_1, OWNER_HUMAN, 3, 4);
// write level to file
level_write_to_file(level_new, filename);
level_free(level_new);
// read level from file
// (this function is assumed to work correctly
// because it has been tested earlier)
Level* level = level_alloc_read_from_file(filename);
// test if level was correctly written
mu_assert(level != NULL);
mu_assert(level->width == LEVEL_TEST_WIDTH);
mu_assert(level->height == LEVEL_TEST_HEIGHT);
// test if cells were correctly written
int i;
int j;
for (i = 0; i < level->height; i++) // rows
{
for (j = 0; j < level->width; j++) // cols
{
mu_assert(level->cells[i][j].row == i);
mu_assert(level->cells[i][j].col == j);
}
}
mu_assert(level->cells[0][0].type == GROUND);
mu_assert(level->cells[0][0].owner == OWNER_NONE);
mu_assert(level->cells[3][4].type == UNIT_1);
mu_assert(level->cells[3][4].owner == OWNER_HUMAN);
al_destroy_path(path);
level_free(level);
return NULL;
}
static void filesel_ok(GtkWidget *w, GtkFileSelection *fs)
{
ALLEGRO_NATIVE_DIALOG *fc;
fc = g_object_get_data(G_OBJECT(w), "ALLEGRO_NATIVE_DIALOG");
gchar **paths = gtk_file_selection_get_selections(fs);
int n = 0, i;
while (paths[n]) {
n++;
}
fc->fc_path_count = n;
fc->fc_paths = al_malloc(n * sizeof(void *));
for (i = 0; i < n; i++)
fc->fc_paths[i] = al_create_path(paths[i]);
g_strfreev(paths);
}
static int allua_Filechooser_create(lua_State * L)
{
const char *ipath = luaL_checkstring(L, 1);
const char *title = luaL_checkstring(L, 2);
const char *patterns = luaL_checkstring(L, 3);
int mode = luaL_checkint(L, 4);
ALLEGRO_PATH *initial_path = al_create_path(ipath);
ALLUA_filechooser d =
al_create_native_file_dialog(al_path_cstr
(initial_path, ALLEGRO_NATIVE_PATH_SEP),
title, patterns, mode);
al_destroy_path(initial_path);
if (d)
allua_pushFilechooser(L, d);
else
lua_pushnil(L);
return 1;
}
static char* test_level_alloc_read_from_file_read_invalid_level_size_for_dimensions()
{
char* level_name = "test-invalid-level-size-for-dimensions.world";
ALLEGRO_PATH* path = al_create_path(FILES_ASSETS_PATH);
al_append_path_component(path, FILES_LEVELS_SUBDIRNAME);
al_set_path_filename(path, level_name);
const char* filename = al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP);
Level* level = level_alloc_read_from_file(filename);
mu_assert(level == NULL);
al_destroy_path(path);
level_free(level);
return NULL;
}
bool includeFile(SpriteNode* node, TiXmlElement* includeNode, SpriteBlock* &oldSibling)
{
// get path... ugly
char configfilepath[FILENAME_BUFFERSIZE] = {0};
const char* documentRef = getDocument(includeNode);
if (!getLocalFilename(configfilepath,includeNode->Attribute("file"),documentRef))
{
return false;
}
ALLEGRO_PATH * incpath = al_create_path(configfilepath);
al_append_path_component(incpath, "include");
TiXmlDocument doc( al_path_cstr(incpath, ALLEGRO_NATIVE_PATH_SEP) );
al_destroy_path(incpath);
bool loadOkay = doc.LoadFile();
TiXmlHandle hDoc(&doc);
TiXmlElement* elemParent;
if(!loadOkay)
{
contentError("Include failed",includeNode);
WriteErr("File load failed: %s\n",configfilepath);
WriteErr("Line %d: %s\n",doc.ErrorRow(),doc.ErrorDesc());
return false;
}
elemParent = hDoc.FirstChildElement("include").Element();
if( elemParent == NULL)
{
contentError("Main <include> node not present",&doc);
return false;
}
TiXmlElement* elemNode = elemParent->FirstChildElement();
if (elemNode == NULL)
{
contentError("Empty include",elemParent);
return false;
}
while (elemNode)
{
if (!readNode(node, elemNode, elemParent, oldSibling))
return false;
elemNode = elemNode->NextSiblingElement();
}
return true;
}
void Map::LoadMapDialog()
{
ALLEGRO_FILECHOOSER *loadDialog = NULL;
loadDialog = al_create_native_file_dialog("..\\Maps\\", "Load Mapx file","*.*",0);
al_show_native_file_dialog(display_, loadDialog);
mapPath_ = al_create_path(al_get_native_file_dialog_path(loadDialog, 0));
LoadMap();
//ADJUST offset if a player has been placed but since player placed is false somteimes set it to top left corner as players pos will be created at this point
mapXoffset_ = width_*Constants::TileSize <= settings_->GetScreenWidth() ? settings_->GetScreenWidth()/2-width_*Constants::TileSize/2 : 0;
mapYoffset_ = height_*Constants::TileSize <= settings_->GetScreenHeight() ? settings_->GetScreenHeight()/2-height_*Constants::TileSize/2 : 0;
PreCalc();
al_destroy_native_file_dialog(loadDialog);
}
static char* test_find_path_non_empty_level_around_obstacles()
{
char* level_name = "test-around-obstacles.world";
ALLEGRO_PATH* file_path = al_create_path(FILES_ASSETS_PATH);
al_append_path_component(file_path, FILES_LEVELS_SUBDIRNAME);
al_set_path_filename(file_path, level_name);
const char* filename = al_path_cstr(file_path, ALLEGRO_NATIVE_PATH_SEP);
Level* level = level_alloc_read_from_file(filename);
mu_assert(level != NULL);
Cell* start_cell = &level->cells[0][0];
Cell* target_cell = &level->cells[11][24];
Path* path = find_path(level, start_cell, target_cell);
mu_assert(path != NULL);
mu_assert(path->distance == 12 * 95 + 17 * 26);
mu_assert(path->step_count == 122);
mu_assert(path->steps != NULL);
mu_assert(test_is_path_start_and_end_step_correct(path, start_cell, target_cell));
mu_assert(test_is_path_walkable(path, level) == 1);
// test a few steps
mu_assert(path->steps[5].row == 5);
mu_assert(path->steps[5].col == 1);
mu_assert(path->steps[11].row == 11);
mu_assert(path->steps[11].col == 2);
mu_assert(path->steps[65].row == 1);
mu_assert(path->steps[65].col == 12);
mu_assert(path->steps[119].row == 11);
mu_assert(path->steps[119].col == 22);
path_free(path);
al_destroy_path(file_path);
level_free(level);
return NULL;
}
/* Function: al_open_video
*/
ALLEGRO_VIDEO *al_open_video(char const *filename)
{
ALLEGRO_VIDEO *video;
video = al_calloc(1, sizeof *video);
video->vtable = _al_video_vtable;
video->filename = al_create_path(filename);
if (!video->vtable->open_video(video)) {
al_destroy_path(video->filename);
al_free(video);
return NULL;
}
al_init_user_event_source(&video->es);
video->es_inited = true;
return video;
}
/* Function: al_create_native_file_dialog
*/
ALLEGRO_FILECHOOSER *al_create_native_file_dialog(
char const *initial_path,
char const *title,
char const *patterns,
int mode)
{
ALLEGRO_NATIVE_DIALOG *fc;
fc = al_calloc(1, sizeof *fc);
if (initial_path) {
fc->fc_initial_path = al_create_path(initial_path);
}
fc->title = al_ustr_new(title);
fc->fc_patterns = al_ustr_new(patterns);
fc->flags = mode;
_al_register_destructor(_al_dtor_list, fc,
(void (*)(void *))al_destroy_native_file_dialog);
return (ALLEGRO_FILECHOOSER *)fc;
}
static ALLEGRO_FS_ENTRY *fs_apk_create_entry(const char *path)
{
ALLEGRO_FS_ENTRY_APK *e;
ALLEGRO_USTR *us;
e = al_calloc(1, sizeof *e);
if (!e)
return NULL;
e->fs_entry.vtable = &fs_apk_vtable;
us = apply_cwd(path);
e->path = al_create_path(al_cstr(us));
al_ustr_free(us);
if (!e->path) {
al_free(e);
return NULL;
}
e->path_cstr = al_path_cstr(e->path, '/');
return &e->fs_entry;
}
/* Function: al_clone_path
*/
ALLEGRO_PATH *al_clone_path(const ALLEGRO_PATH *path)
{
ALLEGRO_PATH *clone;
unsigned int i;
ASSERT(path);
clone = al_create_path(NULL);
if (!clone) {
return NULL;
}
al_ustr_assign(clone->drive, path->drive);
al_ustr_assign(clone->filename, path->filename);
for (i = 0; i < _al_vector_size(&path->segments); i++) {
ALLEGRO_USTR **slot = _al_vector_alloc_back(&clone->segments);
(*slot) = al_ustr_dup(get_segment(path, i));
}
return clone;
}
/* drop build configuration directory tail */
static ALLEGRO_PATH *get_resources_path(void)
{
ALLEGRO_PATH *path;
const char *last;
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
if (!path)
return al_create_path("");
/* If the last directory component is the name of an MSVC build
* configuration, then drop it.
*/
last = al_get_path_tail(path);
if (last &&
(0 == strcmp(last, "Debug") ||
0 == strcmp(last, "Release") ||
0 == strcmp(last, "RelWithDebInfo") ||
0 == strcmp(last, "Profile"))) {
al_drop_path_tail(path);
}
return path;
}