bool Message::Init()
{
ALLEGRO_PATH * pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Avatar");
for (int i=0;i<7;i++)
{
char szFileName[255];
sprintf(szFileName,"av%03d.png",i);
al_set_path_filename(pPath,szFileName);
ALLEGRO_BITMAP * pBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (pBitmap!=NULL)
{
g_lstAvatar.push_back(pBitmap);
}
else
{
al_destroy_path(pPath);
return false;
}
}
al_destroy_path(pPath);
return true;
}
/* _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;
}
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
}
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, '/');
}
bool TKlingonBC::Init()
{
ALLEGRO_PATH * pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Ships");
al_set_path_filename(pPath,"KlingonCruiser.png");
g_pKlingonBCBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(pPath);
if (g_pKlingonBCBitmap==NULL)
{
return false;
}
else
{
return true;
}
}
static int allua_Path_append_component(lua_State * L)
{
ALLUA_path path = allua_check_path(L, 1);
const char *s = luaL_checkstring(L, 2);
al_append_path_component(path, s);
return 0;
}
/* 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;
}
Tileset::Tileset(const char* filename)
{
ALLEGRO_PATH *path;
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(path, RESOURCES_DIR);
al_set_path_filename(path, filename);
spritesheet_ = al_load_bitmap(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(path);
}
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;
}
BolsaDinero * BolsaDinero::crear_bolsa_dinero(ActorManager *actmgr,int mov_to_dead)
{
ALLEGRO_BITMAP *bmp;
MapaDeBits *bitm;
BolsaDinero *bolsa_dinero_tmp;
ALLEGRO_PATH *path;
/*
* para crear path relativos y poder distribuir el programa y ejecutarlo
* fuera del IDE
*/
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_remove_path_component(path,-1);
al_append_path_component(path, "resources");
al_set_path_filename(path, "bolsa-dinero.png");
bolsa_dinero_tmp = new BolsaDinero(actmgr,mov_to_dead);
bmp = al_load_bitmap(al_path_cstr(path, '/'));
if(bmp == NULL)
{
al_show_native_message_box(al_get_current_display(), "Ventana de error",
"error fatal", "Error al cargar resource bitmap",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
exit(-1);
}
// Hacemos que no se vea el color negro en el bitmap de rana
al_convert_mask_to_alpha(bmp, al_map_rgb(0,0,0));
bitm=new MapaDeBits(bolsa_dinero_tmp, bmp);
bolsa_dinero_tmp->set_actor_graphic(bitm);
bolsa_dinero_tmp->set_x(Game::rnd(0,Game::gfx_w-bolsa_dinero_tmp->get_w()));
bolsa_dinero_tmp->set_y(Game::rnd(50,Game::gfx_h-bolsa_dinero_tmp->get_h()));
bolsa_dinero_tmp->set_is_detected(true);
bolsa_dinero_tmp->set_team(TEAM_BOLSA_DINERO);
bolsa_dinero_tmp->set_collision_method(CollisionManager::PP_COLLISION);
actmgr->add(bolsa_dinero_tmp);
al_destroy_path(path);
return bolsa_dinero_tmp;
}
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;
}
std::shared_ptr<ALLEGRO_BITMAP> Tile::getFlameFrame(size_t num)
{
if(flames == NULL)
{
ALLEGRO_PATH *path;
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(path, RESOURCES_DIR);
al_set_path_filename(path, "flames.png");
flames = al_load_bitmap(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(path);
}
if(num < 3)
{
return std::shared_ptr<ALLEGRO_BITMAP>(al_create_sub_bitmap(flames, num * 32, 0, 32, 32), al_destroy_bitmap);
}
return NULL;
}
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_join_paths
*/
bool al_join_paths(ALLEGRO_PATH *path, const ALLEGRO_PATH *tail)
{
unsigned i;
ASSERT(path);
ASSERT(tail);
/* Don't bother concating if the tail is an absolute path. */
if (path_is_absolute(tail)) {
return false;
}
/* We ignore tail->drive. The other option is to do nothing if tail
* contains a drive letter.
*/
al_ustr_assign(path->filename, tail->filename);
for (i = 0; i < _al_vector_size(&tail->segments); i++) {
al_append_path_component(path, get_segment_cstr(tail, i));
}
return true;
}
static char* test_find_path_non_empty_level_end_in_unwalkable_cell()
{
char* level_name = "test-unreachable-cell.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[1][22];
Path* path = find_path(level, start_cell, target_cell);
mu_assert(path == NULL);
al_destroy_path(file_path);
level_free(level);
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
// Loads and processes the skin description file which is in fact a regular
// Allegro configuration file
MAS::Error MAS::Skin::Load(const char *file) {
int i = 0;
lastError = MAS::Error(MAS::Error::NONE);
ALLEGRO_CONFIG *config;
const char *str;
ALLEGRO_PATH *sdp;
if (!file) {
lastError = MAS::Error(MAS::Error::SKIN_INI);
return lastError;
}
// Try to open the skin description file
sdp = al_create_path(file);
if (!al_is_path_present(sdp)) {
al_destroy_path(sdp);
lastError = MAS::Error(MAS::Error::SKIN_INI);
return lastError;
}
config = al_load_config_file(file);
if (skinFilePath != file) {
delete [] skinFilePath;
skinFilePath = new char[1+strlen(file)];
strcpy(skinFilePath, file);
}
Reset();
// Get the path to the skin configuration file (drop the filename)
al_set_path_filename(sdp, "");
////////////////////////////////////////////////////////////////////////////////
// Read the name of the dir and load the bitmap data
bool default_bitmaps = false;
str = al_get_config_value(config, "Skin", "main_data");
if (str) {
al_append_path_component(sdp, str);
lastError = LoadData(sdp, config);
al_drop_path_tail(sdp);
if (lastError) {
al_destroy_config(config);
al_destroy_path(sdp);
delete [] skinFilePath;
skinFilePath = NULL;
return lastError;
}
}
else {
default_bitmaps = true;
}
////////////////////////////////////////////////////////////////////////////////
// Read the default colors
#define GET_COLOR_STR(val, def) ((str = al_get_config_value(config, "COLORS", val)) ? str : def)
c_face = MAS::Color(GET_COLOR_STR("face", "210,210,210"));
c_font = MAS::Color(GET_COLOR_STR("fontface", " 16, 16, 16"));
c_shad1 = MAS::Color(GET_COLOR_STR("shad1", "255,255,255"));
c_shad2 = MAS::Color(GET_COLOR_STR("shad2", " 80, 80, 80"));
c_disable = MAS::Color(GET_COLOR_STR("disable", "128,128,128"));
c_select = MAS::Color(GET_COLOR_STR("select", "128,192,128"));
c_deselect = MAS::Color(GET_COLOR_STR("deselect", "224,224,224"));
c_focus = MAS::Color(GET_COLOR_STR("focus", "128,192,128"));
c_sunken = MAS::Color(GET_COLOR_STR("sunken", "232,232,232"));
c_back = MAS::Color(GET_COLOR_STR("back", "180,180,180"));
#undef GET_COLOR_STR
if (default_bitmaps) {
GenerateDefaultBitmaps();
}
////////////////////////////////////////////////////////////////////////////////
// Read the cursors from another datafile
str = al_get_config_value(config, "Skin", "cursors");
if (str) {
al_append_path_component(sdp, str);
lastError = LoadCursors(sdp, config);
al_drop_path_tail(sdp);
if (lastError) {
al_destroy_config(config);
al_destroy_path(sdp);
delete [] skinFilePath;
skinFilePath = NULL;
return lastError;
}
}
////////////////////////////////////////////////////////////////////////////////
// Read the samples from another datafile
str = al_get_config_value(config, "Skin", "sounds");
if (str) {
al_append_path_component(sdp, str);
lastError = LoadSamples(sdp);
al_drop_path_tail(sdp);
if (lastError) {
al_destroy_config(config);
al_destroy_path(sdp);
delete [] skinFilePath;
skinFilePath = NULL;
return lastError;
}
}
#define GET_CONFIG_STR(section, key, def) \
(str = al_get_config_value(config, section, key)) ? strtol(str, NULL, 10) : def
////////////////////////////////////////////////////////////////////////////////
// Now load the fonts
const char *fonts[] = { "FONT0", "FONT1", "FONT2", "FONT3",
"FONT4", "FONT5", "FONT6", "FONT7" };
const char *ttfont;
int size;
for (i=0; i<nFonts; i++) {
size = GET_CONFIG_STR(fonts[i], "size", 10);
ttfont = al_get_config_value(config, fonts[i], "file"); // the filename of the font
al_set_path_filename(sdp, ttfont);
const char *filename = al_path_cstr(sdp, ALLEGRO_NATIVE_PATH_SEP);
fntList[i]->Load(filename, size, false);
}
////////////////////////////////////////////////////////////////////////////////
// Read the object specific data:
//----------------------------------------------
const char *fnames[] = { "font1", "font2", "font3", "font4" };
const char *cnames[] = { "f_col1", "f_col2", "f_col3", "f_col4" };
const char *snames[] = { "s_col1", "s_col2", "s_col3", "s_col4" };
const char *def_col[] = { "0,0,0", "0,0,0", "128,128,128", "0,0,0" };
const char *def_shd[] = { "-1", "-1", "-1", "-1" };
// button, checkbox, radio button, etc.
const char *info_name[] = {
"BOX",
"BUTTON",
"CHECKBOX",
"RADIO",
"LIST",
"WINDOW",
"MENU",
"TEXT",
"EDITBOX",
"PROGRESS",
"HYPER",
"TAB",
"TOOLTIP"
};
for (int j=0; j<nInfoItems; j++) {
for (i=0; i<4; i++) {
fnt[j][i] = GET_CONFIG_STR(info_name[i], fnames[i], 10);
fcol[j][i] = Color((str = al_get_config_value(config, info_name[j], cnames[i])) ? str : def_col[i]);
scol[j][i] = Color((str = al_get_config_value(config, info_name[j], snames[i])) ? str : def_shd[i]);
}
}
// wallpaper style
wallpaperStyle = GET_CONFIG_STR("WALLPAPER", "style", 3);
// buttons animation
buttonDisplacement = GET_CONFIG_STR("BUTTON", "displacement", 1);
buttonAnimationType = GET_CONFIG_STR("BUTTON", "animationType", 0);
buttonAnimationLength = GET_CONFIG_STR("BUTTON", "animationLength", 0);
// group box info
boxX = GET_CONFIG_STR("BOX", "offX", 6);
boxY = GET_CONFIG_STR("BOX", "offY", 1);
boxAlign = GET_CONFIG_STR("BOX", "alignment", 0);
boxBack = (str = al_get_config_value(config, "BOX", "backColor")) ? str : "222,222,222";
// window
winTextPos.x( GET_CONFIG_STR("WINDOW", "textX", 10));
winTextPos.y( GET_CONFIG_STR("WINDOW", "textY", 18));
winTextAlign = GET_CONFIG_STR("WINDOW", "alignment", 0);
winTextBack = GET_CONFIG_STR("WINDOW", "textBack", 0);
winExitPos.x( GET_CONFIG_STR("WINDOW", "exitX", -22));
winExitPos.y( GET_CONFIG_STR("WINDOW", "exitY", 6));
winMaxPos.x( GET_CONFIG_STR("WINDOW", "manX", -40));
winMaxPos.y( GET_CONFIG_STR("WINDOW", "manY", 6));
winMinPos.x( GET_CONFIG_STR("WINDOW", "minX", -56));
winMinPos.y( GET_CONFIG_STR("WINDOW", "minY", 6));
winAnimationType = GET_CONFIG_STR("WINDOW", "animationType", 0);
winAnimationLength = GET_CONFIG_STR("WINDOW", "animationLength", 0);
// combo box
comboAnimationType = GET_CONFIG_STR("COMBOBOX", "animationType", 0);
comboAnimationLength = GET_CONFIG_STR("COMBOBOX", "animationLength", 0);
// menu
menuHeight = GET_CONFIG_STR("MENU", "height", 16);
menuDelay = GET_CONFIG_STR("MENU", "delay", 300);
menuAnimationType = GET_CONFIG_STR("MENU", "animationType", 0);
menuAnimationLength = GET_CONFIG_STR("MENU", "animationLength", 0);
// tooltip info
tooltipAnimationType = GET_CONFIG_STR("TOOLTIP", "animationType", 0);
tooltipAnimationLength = GET_CONFIG_STR("TOOLTIP", "animationLength", 0);
tooltipBack = Color((str = al_get_config_value(config, "TOOLTIP", "backColor")) ? str : "255,255,192");
tooltipBorder = Color((str = al_get_config_value(config, "TOOLTIP", "backColor")) ? str : "0,0,0");
// dialog popup animation
// ...
// should the GUI draw dotted rectangles?
drawDots = (str = al_get_config_value(config, "Skin", "dottedRect")) ? *str != '0' : false;
// how the focus follows the mouse
focus = GET_CONFIG_STR("Skin", "focus", 1);
#undef GET_CONFIG_STR
al_destroy_path(sdp);
return MAS::Error(MAS::Error::NONE);
}
ALLEGRO_PATH *_al_unix_get_path(int id)
{
switch (id) {
case ALLEGRO_TEMP_PATH: {
/* Check: TMP, TMPDIR, TEMP or TEMPDIR */
char *envs[] = { "TMP", "TMPDIR", "TEMP", "TEMPDIR", NULL};
uint32_t i = 0;
for (; envs[i] != NULL; ++i) {
char *tmp = getenv(envs[i]);
if (tmp) {
return al_create_path(tmp);
}
}
/* next try: /tmp /var/tmp /usr/tmp */
char *paths[] = { "/tmp/", "/var/tmp/", "/usr/tmp/", NULL };
for (i=0; paths[i] != NULL; ++i) {
ALLEGRO_FS_ENTRY *fse = al_create_fs_entry(paths[i]);
bool found = al_fs_entry_is_directory(fse);
al_destroy_fs_entry(fse);
if (found) {
return al_create_path(paths[i]);
}
}
/* Give up? */
return NULL;
} break;
case ALLEGRO_PROGRAM_PATH: {
ALLEGRO_PATH *exe = get_executable_name();
al_set_path_filename(exe, NULL);
return exe;
} break;
case ALLEGRO_SYSTEM_DATA_PATH: {
ALLEGRO_PATH *sys_data_path = NULL;
/* FIXME: make this a compile time define, or a allegro cfg option? or both */
sys_data_path = al_create_path("/usr/share/");
al_append_path_component(sys_data_path, al_get_orgname());
al_append_path_component(sys_data_path, al_get_appname());
return sys_data_path;
} break;
#if 0
case ALLEGRO_USER_DATA_PATH: {
int32_t ret = 0;
uint32_t path_len = 0, ptr_len = 0, prog_len = 0;
char path[PATH_MAX] = "", *ptr = NULL;
char prog[PATH_MAX] = "";
if (_unix_find_home(path, PATH_MAX) != 0) {
return NULL;
}
strncat(path, "/.", 2);
path_len = strlen(path);
/* get exe name */
/* FIXME:
This really aught to get the "Program" name from somewhere, say a config var? Or a function al_set_program_name()?
making a ~/.test_program dir for a exe named "test_program" might not be what people have in mind.
*/
get_executable_name(prog, PATH_MAX);
ptr = strrchr(prog, '/');
if (!ptr) {
al_set_errno(EINVAL);
return NULL;
}
*ptr = '\0';
ptr++;
ptr_len = strlen(ptr);
//
strncat(path, ptr, ptr_len+1);
//*(ptr-1) = '/';
do_uconvert(path, U_ASCII, dir, U_UTF8, strlen(path)+1);
} break;
#endif
case ALLEGRO_USER_SETTINGS_PATH:
case ALLEGRO_USER_DATA_PATH: {
ALLEGRO_PATH *local_path = NULL;
local_path = _unix_find_home();
if (!local_path)
return NULL;
al_append_path_component(local_path, ".config");
al_append_path_component(local_path, al_get_orgname());
al_append_path_component(local_path, al_get_appname());
return local_path;
} break;
case ALLEGRO_USER_HOME_PATH:
return _unix_find_home();
case ALLEGRO_SYSTEM_SETTINGS_PATH: {
ALLEGRO_PATH *sys_path;
/* FIXME: make this a compile time define, or something */
sys_path = al_create_path("/etc/");
al_append_path_component(sys_path, al_get_orgname());
al_append_path_component(sys_path, al_get_appname());
return sys_path;
} break;
case ALLEGRO_EXENAME_PATH:
return get_executable_name();
break;
default:
return NULL;
}
return NULL;
}
void Hormiga::hit(Actor *who, int damage)
{
ALLEGRO_PATH *path;
/*
* para crear path relativos y poder distribuir el programa y ejecutarlo
* fuera del IDE
*/
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_remove_path_component(path,-1);
al_append_path_component(path, "resources");
switch (who->get_team())
{
case TEAM_HORMIGAS_ROJAS:
break;
case TEAM_HORMIGAS_VERDES:
break;
case TEAM_OSO:
am->del(this);
break;
case TEAM_COMIDA:
if (state == kForage) state=kGoHome;
break;
case TEAM_AGUA:
if (state == kThirsty) state=kForage;
break;
case TEAM_VENENO:
if (tipo == kGreenAnt) {
//creo la hormiga en la misma posicion de la que acaba de chocar con el veneno
Hormiga::crear_hormiga(am,kRedAnt,Hm,x,y);
am->del(this);
}
break;
case TEAM_HORMIGUERO:
if ((who->get_y()==Hm->get_y()) && (who->get_x()==Hm->get_x()) && (state == kGoHome))
{
/*
* Si he llegado a mi hormiguero creo una nueva hormiga de mi tipo y me
* pongo a buscara agua
*/
state=kThirsty;
Hormiga::crear_hormiga(am,tipo,Hm);
}
break;
case TEAM_RANA:
if (tipo == kRedAnt)
{
am->del(this);
}
break;
case TEAM_SCORE:
/*
* La envio al hormiguero
*/
x = Hm->get_x();
y = Hm->get_y();
break;
case TEAM_BOLSA_DINERO:
break;
default:
break;
}
al_destroy_path(path);
}
void Hormiga::crear_hormiga(ActorManager *actmgr,int tipo,Hormiguero *hormiguero_tmp,
int pos_x,int pos_y)
{
ALLEGRO_BITMAP *bmp;
MapaDeBits *bitm;
Hormiga *hormiga_tmp;
ALLEGRO_PATH *path;
/*
* para crear path relativos y poder distribuir el programa y ejecutarlo
* fuera del IDE
*/
path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_remove_path_component(path,-1);
al_append_path_component(path, "resources");
if (tipo == kRedAnt)
{
al_set_path_filename(path, "HormigaRoja.png");
hormiga_tmp = new Hormiga(actmgr,hormiguero_tmp,kRedAnt);
}
else
{
al_set_path_filename(path, "HormigaVerde.png");
hormiga_tmp = new Hormiga(actmgr,hormiguero_tmp,kGreenAnt);
}
bmp = al_load_bitmap(al_path_cstr(path, '/'));
if(bmp == NULL)
{
al_show_native_message_box(al_get_current_display(), "Ventana de error",
"error fatal", "Error al cargar resource bitmap",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
exit(-1);
}
// Hacemos que no se vea el color negro en el bitmap de hormiga
al_convert_mask_to_alpha(bmp, al_map_rgb(0,0,0));
bitm=new MapaDeBits(hormiga_tmp, bmp);
hormiga_tmp->set_actor_graphic(bitm);
if (pos_x == 0) {
hormiga_tmp->set_x(Game::rnd(50,Game::gfx_w-hormiga_tmp->get_w()));
} else {
hormiga_tmp->set_x(pos_x);
}
if (pos_y == 0) {
hormiga_tmp->set_y(Game::rnd(0,Game::gfx_h-hormiga_tmp->get_h()));
} else {
hormiga_tmp->set_y(pos_y);
}
hormiga_tmp->set_is_detected(true);
if (tipo == kRedAnt)
{
hormiga_tmp->set_team(TEAM_HORMIGAS_ROJAS);
}
else
{
hormiga_tmp->set_team(TEAM_HORMIGAS_VERDES);
}
hormiga_tmp->set_collision_method(CollisionManager::PP_COLLISION);
actmgr->add(hormiga_tmp);
al_destroy_path(path);
}
bool
initialize ()
{
ALLEGRO_BITMAP *temp_color_bitmap;
ALLEGRO_BITMAP *temp_mask_bitmap;
global.quit = false;
al_set_app_name ("Super Battle Thor II");
if (!al_init ())
{
fputs ("Error: Could not start allegro.\n", stderr);
return false;
}
al_set_new_display_option (ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
al_set_new_display_flags (ALLEGRO_GENERATE_EXPOSE_EVENTS);
global.display = al_create_display (256, 192);
if (!global.display)
{
fputs ("Error: Allegro could not create a display of 256x192 pixels.\n",
stderr);
return false;
}
if (!al_install_keyboard ())
{
fputs ("Allegro could not initialize the keyboard system.\n", stderr);
return false;
}
global.timer = al_create_timer (ALLEGRO_BPS_TO_SECS (60));
if (!global.timer)
{
fputs ("Allegro could not create a 60hrz timer.\n", stderr);
return false;
}
global.queue = al_create_event_queue ();
if (!global.queue)
{
fputs ("Allegro could not create an event queue.\n", stderr);
return false;
}
al_register_event_source (global.queue, al_get_keyboard_event_source ());
al_register_event_source (global.queue,
al_get_display_event_source (global.display));
al_register_event_source (global.queue,
al_get_timer_event_source (global.timer));
if (!al_init_image_addon ())
{
fputs ("Allegro could not initialize the image loading system.\n",
stderr);
return false;
}
if (!al_install_audio ())
{
fputs ("Allegro could not initialize the audio system.\n", stderr);
return false;
}
al_reserve_samples (16);
if (!al_init_acodec_addon ())
{
fputs ("Allegro could not initialize the audio file loading system.\n",
stderr);
return false;
}
al_init_font_addon ();
/* load files */
global.path = al_get_standard_path (ALLEGRO_PROGRAM_PATH);
al_append_path_component (global.path, "media");
al_set_path_filename (global.path, "proggy_tiny.png");
global.programing_font =
al_load_bitmap_font (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.programing_font)
{
fputs ("Allegro could not load proggy_tiny.png.\n", stderr);
return false;
}
al_set_path_filename (global.path, "mjollnir.png");
global.sprite_bitmap[SPRITE_THOR] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sprite_bitmap[SPRITE_THOR])
{
fputs ("Allegro could not load mjollnir.png.\n", stderr);
return false;
}
al_set_path_filename (global.path, "arrows.png");
global.arrow_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.arrow_bitmap)
{
fputs ("Allegro could not load arrows.png.\n", stderr);
return false;
}
al_set_path_filename (global.path, "background_1_2_3_4.jpg");
global.backgrounds[BACKGROUND_1] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_1])
{
fputs ("Allegro could not load background_1_2_3_4.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "background_5.jpg");
global.backgrounds[BACKGROUND_5] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_5])
{
fputs ("Allegro could not load background_5.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "background_6.jpg");
global.backgrounds[BACKGROUND_6] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_6])
{
fputs ("Allegro could not load background_6.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "title_screen.jpg");
global.backgrounds[BACKGROUND_TITLE] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_TITLE])
{
fputs ("Allegro could not load title_screen.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "game_over.jpg");
global.backgrounds[BACKGROUND_GAME_OVER] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_GAME_OVER])
{
fputs ("Allegro could not load game_over.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "you_win.jpg");
global.backgrounds[BACKGROUND_YOU_WIN] =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.backgrounds[BACKGROUND_YOU_WIN])
{
fputs ("Allegro could not load you_win.jpg.\n", stderr);
return false;
}
global.backgrounds[BACKGROUND_BLACK] = al_create_bitmap (256, 192);
if (!global.backgrounds[BACKGROUND_BLACK])
{
fputs ("Allegro could not make a 256x192 bitmap :o", stderr);
return false;
}
al_set_target_bitmap (global.backgrounds[BACKGROUND_BLACK]);
al_clear_to_color (al_map_rgb (0, 0, 0));
al_set_target_backbuffer (global.display);
/* start copy paste code here becasue I'm lazy */
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "0-thor.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 0-thor.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "0-thor_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 0-thor_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_THOR] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "1-giant.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 1-giant.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "1-giant_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 1-giant_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_GIANT] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "2-nidhogg.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 2-nidhogg.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "2-nidhogg_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 2-nidhogg_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_NIDHOGG] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "3-ran.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 3-ran.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "3-ran_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 3-ran_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_RAN] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "4-grendel.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 4-grendel.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "4-grendel_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 4-grendel_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_GRENDEL] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "5-fafnir.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 5-fafnir.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "5-fafnir_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 5-fafnir_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_FAFNIR] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "6-loki.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 6-loki.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "6-loki_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 6-loki_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_LOKI] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "7-fenrir.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load 7-fenrir.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "7-fenrir_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load 7-fenrir_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_FENRIR] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
al_set_path_filename (global.path, "fight.jpg");
temp_color_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_color_bitmap)
{
fputs ("Allegro could not load fight.jpg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "fight_mask.jpg");
temp_mask_bitmap =
al_load_bitmap (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!temp_mask_bitmap)
{
fputs ("Allegro could not load fight_mask.jpg.\n", stderr);
return false;
}
global.sprite_bitmap[SPRITE_FIGHT] =
make_from_mask (temp_color_bitmap, temp_mask_bitmap);
al_destroy_bitmap (temp_color_bitmap);
al_destroy_bitmap (temp_mask_bitmap);
/*------------------------------------------------------------------------*/
/* loading sounds here (still copy paste) */
al_set_path_filename (global.path, "titlescreen_loop.ogg");
global.sounds[SOUND_TITLESCREEN_LOOP] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_TITLESCREEN_LOOP])
{
fputs ("Allegro could not load titlescreen_loop.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "begin_battle.ogg");
global.sounds[SOUND_BEGIN_BATTLE] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_BEGIN_BATTLE])
{
fputs ("Allegro could not load begin_battle.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "battle_loop.ogg");
global.sounds[SOUND_BATTLE_LOOP] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_BATTLE_LOOP])
{
fputs ("Allegro could not load battle_loop.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "dragon_loop.ogg");
global.sounds[SOUND_DRAGON_LOOP] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_DRAGON_LOOP])
{
fputs ("Allegro could not load dragon_loop.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "hit_1.ogg");
global.sounds[SOUND_HIT_1] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_HIT_1])
{
fputs ("Allegro could not load hit_1.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "hit_2.ogg");
global.sounds[SOUND_HIT_2] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_HIT_2])
{
fputs ("Allegro could not load hit_2.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_1.ogg");
global.sounds[SOUND_LAUGH_1] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_1])
{
fputs ("Allegro could not load laugh_1.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_2.ogg");
global.sounds[SOUND_LAUGH_2] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_2])
{
fputs ("Allegro could not load laugh_2.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_3.ogg");
global.sounds[SOUND_LAUGH_3] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_3])
{
fputs ("Allegro could not load laugh_3.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_4.ogg");
global.sounds[SOUND_LAUGH_4] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_4])
{
fputs ("Allegro could not load laugh_4.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_5.ogg");
global.sounds[SOUND_LAUGH_5] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_5])
{
fputs ("Allegro could not load laugh_5.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "laugh_6.ogg");
global.sounds[SOUND_LAUGH_6] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_LAUGH_6])
{
fputs ("Allegro could not load laugh_6.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "killed_baddie.ogg");
global.sounds[SOUND_KILLED_BADDIE] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_KILLED_BADDIE])
{
fputs ("Allegro could not load killed_baddie.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "got_hit.ogg");
global.sounds[SOUND_GOT_HIT] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_GOT_HIT])
{
fputs ("Allegro could not load got_hit.ogg.\n", stderr);
return false;
}
al_set_path_filename (global.path, "you_are_dead.ogg");
global.sounds[SOUND_YOU_ARE_DEAD] =
al_load_sample (al_path_cstr (global.path, ALLEGRO_NATIVE_PATH_SEP));
if (!global.sounds[SOUND_YOU_ARE_DEAD])
{
fputs ("Allegro could not you_are_dead.ogg.\n", stderr);
return false;
}
global.music = NULL;
al_destroy_path (global.path);
return true;
}
static char* test_level_alloc_read_from_file()
{
char* level_name = "test.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);
// test if level is correctly initialized & read from file
mu_assert(level != NULL);
mu_assert(level->width == 11);
mu_assert(level->height == 10);
// test if cells are correctly initialized
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);
}
}
// test if cells are correctly read from file
// row 1
mu_assert(level->cells[0][0].owner == OWNER_NONE);
mu_assert(level->cells[0][0].type == ROCK);
mu_assert(level->cells[0][1].owner == OWNER_NONE);
mu_assert(level->cells[0][1].type == WATER);
mu_assert(level->cells[0][2].owner == OWNER_NONE);
mu_assert(level->cells[0][2].type == BRIDGE);
mu_assert(level->cells[0][3].owner == OWNER_NONE);
mu_assert(level->cells[0][3].type == WATER);
mu_assert(level->cells[0][4].owner == OWNER_NONE);
mu_assert(level->cells[0][4].type == GROUND);
mu_assert(level->cells[0][5].owner == OWNER_NONE);
mu_assert(level->cells[0][5].type == GROUND);
mu_assert(level->cells[0][6].owner == OWNER_NONE);
mu_assert(level->cells[0][6].type == GROUND);
mu_assert(level->cells[0][7].owner == OWNER_NONE);
mu_assert(level->cells[0][7].type == GROUND);
mu_assert(level->cells[0][8].owner == OWNER_NONE);
mu_assert(level->cells[0][8].type == GROUND);
mu_assert(level->cells[0][9].owner == OWNER_NONE);
mu_assert(level->cells[0][9].type == GROUND);
mu_assert(level->cells[0][10].owner == OWNER_NONE);
mu_assert(level->cells[0][10].type == GROUND);
// row 2
mu_assert(level->cells[1][0].owner == OWNER_HUMAN);
mu_assert(level->cells[1][0].type == UNIT_1);
mu_assert(level->cells[1][1].owner == OWNER_HUMAN);
mu_assert(level->cells[1][1].type == UNIT_2);
mu_assert(level->cells[1][2].owner == OWNER_HUMAN);
mu_assert(level->cells[1][2].type == UNIT_3);
mu_assert(level->cells[1][3].owner == OWNER_HUMAN);
mu_assert(level->cells[1][3].type == HEADQUARTER);
mu_assert(level->cells[1][4].owner == OWNER_HUMAN);
mu_assert(level->cells[1][4].type == HEADQUARTER);
mu_assert(level->cells[1][5].owner == OWNER_NONE);
mu_assert(level->cells[1][5].type == GROUND);
mu_assert(level->cells[1][6].owner == OWNER_NONE);
mu_assert(level->cells[1][6].type == GROUND);
mu_assert(level->cells[1][7].owner == OWNER_NONE);
mu_assert(level->cells[1][7].type == GROUND);
mu_assert(level->cells[1][8].owner == OWNER_NONE);
mu_assert(level->cells[1][8].type == GROUND);
mu_assert(level->cells[1][9].owner == OWNER_NONE);
mu_assert(level->cells[1][9].type == GROUND);
mu_assert(level->cells[1][10].owner == OWNER_NONE);
mu_assert(level->cells[1][10].type == GROUND);
// row 3
mu_assert(level->cells[2][0].owner == OWNER_AI);
mu_assert(level->cells[2][0].type == HEADQUARTER);
mu_assert(level->cells[2][1].owner == OWNER_AI);
mu_assert(level->cells[2][1].type == HEADQUARTER);
mu_assert(level->cells[2][2].owner == OWNER_NONE);
mu_assert(level->cells[2][2].type == GROUND);
mu_assert(level->cells[2][3].owner == OWNER_HUMAN);
mu_assert(level->cells[2][3].type == HEADQUARTER);
mu_assert(level->cells[2][4].owner == OWNER_HUMAN);
mu_assert(level->cells[2][4].type == HEADQUARTER);
mu_assert(level->cells[2][5].owner == OWNER_NONE);
mu_assert(level->cells[2][5].type == GROUND);
mu_assert(level->cells[2][6].owner == OWNER_NONE);
mu_assert(level->cells[2][6].type == GROUND);
mu_assert(level->cells[2][7].owner == OWNER_NONE);
mu_assert(level->cells[2][7].type == GROUND);
mu_assert(level->cells[2][8].owner == OWNER_NONE);
mu_assert(level->cells[2][8].type == GROUND);
mu_assert(level->cells[2][9].owner == OWNER_NONE);
mu_assert(level->cells[2][9].type == GROUND);
mu_assert(level->cells[2][10].owner == OWNER_NONE);
mu_assert(level->cells[2][10].type == GROUND);
// row 4
mu_assert(level->cells[3][0].owner == OWNER_AI);
mu_assert(level->cells[3][0].type == HEADQUARTER);
mu_assert(level->cells[3][1].owner == OWNER_AI);
mu_assert(level->cells[3][1].type == HEADQUARTER);
mu_assert(level->cells[3][2].owner == OWNER_AI);
mu_assert(level->cells[3][2].type == UNIT_1);
mu_assert(level->cells[3][3].owner == OWNER_AI);
mu_assert(level->cells[3][3].type == UNIT_2);
mu_assert(level->cells[3][4].owner == OWNER_AI);
mu_assert(level->cells[3][4].type == UNIT_3);
mu_assert(level->cells[3][5].owner == OWNER_NONE);
mu_assert(level->cells[3][5].type == GROUND);
mu_assert(level->cells[3][6].owner == OWNER_NONE);
mu_assert(level->cells[3][6].type == GROUND);
mu_assert(level->cells[3][7].owner == OWNER_NONE);
mu_assert(level->cells[3][7].type == GROUND);
mu_assert(level->cells[3][8].owner == OWNER_NONE);
mu_assert(level->cells[3][8].type == GROUND);
mu_assert(level->cells[3][9].owner == OWNER_NONE);
mu_assert(level->cells[3][9].type == GROUND);
mu_assert(level->cells[3][10].owner == OWNER_NONE);
mu_assert(level->cells[3][10].type == GROUND);
// other rows
int k;
int l;
for (k = 4; k < level->height; k++) // rows
{
for (l = 0; l < level->width; l++) // cols
{
mu_assert(level->cells[k][l].owner == OWNER_NONE);
mu_assert(level->cells[k][l].type == GROUND);
}
}
al_destroy_path(path);
level_free(level);
return NULL;
}
bool TEnterprise::Init()
{
ALLEGRO_PATH * pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Ships");
al_set_path_filename(pPath,"ent01.png");
g_pEnterpriseBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pEnterpriseBitmap == NULL) return false;
pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Interface");
al_set_path_filename(pPath,"eng01.png");
g_pEngineeringBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pEngineeringBitmap == NULL) return false;
pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Interface");
al_set_path_filename(pPath,"Com_Trans.png");
g_pCommunicationBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pCommunicationBitmap == NULL) return false;
pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Interface");
al_set_path_filename(pPath,"Switch.png");
g_pSwitchBitmap = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pSwitchBitmap == NULL) return false;
pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "Photon");
al_set_path_filename(pPath,"casing.png");
g_pPhotonCasing = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pPhotonCasing == NULL) return false;
pPath = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_append_path_component(pPath, "graphics");
al_append_path_component(pPath, "probe");
al_set_path_filename(pPath,"casing.png");
g_pProbeCasing = al_load_bitmap(al_path_cstr(pPath,ALLEGRO_NATIVE_PATH_SEP));
if (g_pProbeCasing == NULL) return false;
al_destroy_path(pPath);
return true;
}
int MonopolyGame::loadResources() {
reset();
// Normalize the paths.
ALLEGRO_PATH *path = al_get_standard_path( ALLEGRO_RESOURCES_PATH );
al_append_path_component( path, "etc" );
al_change_directory( al_path_cstr( path, '/' ) ); // change the working directory
//
// Load the board's bitmap
//
al_set_path_filename(path, "board.png");
if( !fileExists( al_path_cstr(path, '/') ) ) {
fprintf( stderr, "[ERROR] Cannot find bitmap: %s\n", al_path_cstr(path, '/') );
return -1;
}
else {
m_alBoardImage = al_load_bitmap( al_path_cstr(path, '/') );
if( !m_alBoardImage ) {
fprintf( stderr, "[ERROR] Failed loading board bitmap: %s\n", al_path_cstr(path, '/') );
return -1;
}
}
//
// Load the font set.
//
al_set_path_filename(path, "Emblem.ttf");
// Start building the fonts from 24pt.
int initialSize = 24;
if( !fileExists( al_path_cstr(path, '/') ) ) {
fprintf( stderr, "[ERROR] Cannot find font file: %s\n", al_path_cstr(path, '/') );
return -1;
}
else
{
for( int fontCounter = 0; fontCounter < MAX_FONTS; fontCounter++ ) {
m_fontCollection[fontCounter] = al_load_font( al_path_cstr(path, '/'), initialSize, 0 );
initialSize += 10;
if( !m_fontCollection[fontCounter] ) {
fprintf( stderr, "[ERROR] Failed loading font: %s size: %i\n", al_path_cstr(path, '/'), initialSize );
return -1;
}
}
}
// Now load the possible player pieces into memory.
// The piece file locations are stored in the database.
for( int pieceCounter = 0; pieceCounter < PLAYER_PIECES_COUNT; pieceCounter++ ) {
std::string tempQuery = "";
std::string sFileName = "";
tempQuery = m_sqlConn.Format( "SELECT %s FROM %s WHERE %s = %i", "path", DB_PIECES_TABLE, "id", pieceCounter );
if( !m_sqlConn.SelectStr( sFileName, tempQuery.c_str() ) ) {
// Append the filename to the resource path.
al_set_path_filename( path, sFileName.c_str() );
if( !fileExists( al_path_cstr(path, '/') ) ) {
fprintf( stderr, "[ERROR] Cannot find bitmap: %s\n", al_path_cstr(path, '/') );
return -1;
}
else {
// Load the bitmap from the filename from above.
m_alpieceImages[pieceCounter] = al_load_bitmap( al_path_cstr(path, '/') );
}
if( !m_alpieceImages[pieceCounter] ) {
// TODO: CURRENTLY I HAVE NO PLACE HOLDER IMAGES, SO THE APPLICATION WILL FAIL HERE!
fprintf( stderr, "[ERROR] Failed loading bitmap: %s\n", al_path_cstr(path, '/') );
return -1;
}
}
else {
fprintf( stderr, "[ERROR] Error processing SQL statement: %s\n", tempQuery.c_str() );
return -1;
}
}
// Assign random pieces to each player.
for( int plCount = 0; plCount < NUM_PLAYERS; plCount++ ) {
int* randomPlayerSel = rollDice( 1, PLAYER_PIECES_COUNT );
m_playerList[plCount].set_image( m_alpieceImages[randomPlayerSel[0]] );
}
al_destroy_path( path );
//
// Finally we will pull the property list from the database.
//
if( buildPropertyList() )
{
fprintf( stderr, "Failure building Property List, Please ensure the database is available!\n" );
return -1;
}
return 0;
}
/* _al_win_get_path:
* Returns full path to various system and user diretories
*/
ALLEGRO_PATH *_al_win_get_path(int id)
{
char path[MAX_PATH];
wchar_t pathw[MAX_PATH];
ALLEGRO_USTR *pathu;
uint32_t csidl = 0;
HRESULT ret = 0;
ALLEGRO_PATH *cisdl_path = NULL;
switch (id) {
case ALLEGRO_TEMP_PATH: {
/* Check: TMP, TMPDIR, TEMP or TEMPDIR */
DWORD ret = GetTempPathW(MAX_PATH, pathw);
if (ret > MAX_PATH) {
/* should this ever happen, windows is more broken than I ever thought */
return NULL;
}
pathu = al_ustr_new_from_utf16(pathw);
al_ustr_to_buffer(pathu, path, sizeof path);
al_ustr_free(pathu);
return al_create_path_for_directory(path);
}
break;
case ALLEGRO_RESOURCES_PATH: { /* where the program is in */
HANDLE process = GetCurrentProcess();
char *ptr;
GetModuleFileNameExW(process, NULL, pathw, MAX_PATH);
pathu = al_ustr_new_from_utf16(pathw);
al_ustr_to_buffer(pathu, path, sizeof path);
al_ustr_free(pathu);
ptr = strrchr(path, '\\');
if (!ptr) { /* shouldn't happen */
return NULL;
}
/* chop off everything including and after the last slash */
/* should this not chop the slash? */
*ptr = '\0';
return al_create_path_for_directory(path);
}
break;
case ALLEGRO_USER_DATA_PATH: /* CSIDL_APPDATA */
case ALLEGRO_USER_SETTINGS_PATH:
csidl = CSIDL_APPDATA;
break;
case ALLEGRO_USER_HOME_PATH: /* CSIDL_PROFILE */
csidl = CSIDL_PROFILE;
break;
case ALLEGRO_USER_DOCUMENTS_PATH: /* CSIDL_PERSONAL */
csidl = CSIDL_PERSONAL;
break;
case ALLEGRO_EXENAME_PATH: { /* full path to the exe including its name */
HANDLE process = GetCurrentProcess();
GetModuleFileNameExW(process, NULL, pathw, MAX_PATH);
pathu = al_ustr_new_from_utf16(pathw);
al_ustr_to_buffer(pathu, path, sizeof path);
al_ustr_free(pathu);
return al_create_path(path);
}
break;
default:
return NULL;
}
ret = SHGetFolderPathW(NULL, csidl, NULL, SHGFP_TYPE_CURRENT, pathw);
if (ret != S_OK) {
return NULL;
}
pathu = al_ustr_new_from_utf16(pathw);
al_ustr_to_buffer(pathu, path, sizeof path);
al_ustr_free(pathu);
cisdl_path = al_create_path_for_directory(path);
if (!cisdl_path)
return NULL;
if (csidl == CSIDL_APPDATA) {
const char *org_name = al_get_org_name();
const char *app_name = al_get_app_name();
if (!app_name || !app_name[0]) {
/* this shouldn't ever happen. */
al_destroy_path(cisdl_path);
return NULL;
}
if (org_name && org_name[0]) {
al_append_path_component(cisdl_path, org_name);
}
al_append_path_component(cisdl_path, app_name);
}
return cisdl_path;
}
ALLEGRO_PATH *_al_unix_get_path(int id)
{
switch (id) {
case ALLEGRO_TEMP_PATH: {
/* Check: TMP, TMPDIR, TEMP or TEMPDIR */
char *envs[] = { "TMP", "TMPDIR", "TEMP", "TEMPDIR", NULL};
uint32_t i = 0;
for (; envs[i] != NULL; ++i) {
char *tmp = getenv(envs[i]);
if (tmp) {
return al_create_path_for_directory(tmp);
}
}
/* next try: /tmp /var/tmp /usr/tmp */
char *paths[] = { "/tmp/", "/var/tmp/", "/usr/tmp/", NULL };
for (i=0; paths[i] != NULL; ++i) {
ALLEGRO_FS_ENTRY *fse = al_create_fs_entry(paths[i]);
bool found = (al_get_fs_entry_mode(fse) & ALLEGRO_FILEMODE_ISDIR) != 0;
al_destroy_fs_entry(fse);
if (found) {
return al_create_path_for_directory(paths[i]);
}
}
/* Give up? */
return NULL;
} break;
case ALLEGRO_RESOURCES_PATH: {
ALLEGRO_PATH *exe = get_executable_name();
exe = follow_symlinks(exe);
al_set_path_filename(exe, NULL);
return exe;
} break;
case ALLEGRO_USER_DATA_PATH:
case ALLEGRO_USER_SETTINGS_PATH: {
ALLEGRO_PATH *local_path = NULL;
const char *org_name = al_get_org_name();
const char *app_name = al_get_app_name();
/* to avoid writing directly into the user's directory, require at least an app name */
if (!app_name)
return NULL;
/* find the appropriate path from the xdg environment variables, if possible */
if (id == ALLEGRO_USER_DATA_PATH) {
const char *xdg_data_home = getenv("XDG_DATA_HOME");
local_path = al_create_path_for_directory(xdg_data_home ? xdg_data_home : ".local/share");
}
else {
const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
local_path = al_create_path_for_directory(xdg_config_home ? xdg_config_home : ".config");
}
if (!local_path)
return NULL;
/* if the path is relative, prepend the user's home directory */
if (al_path_cstr(local_path, '/')[0] != '/') {
ALLEGRO_PATH *home_path = _unix_find_home();
if (!home_path)
return NULL;
al_rebase_path(home_path, local_path);
al_destroy_path(home_path);
}
/* only add org name if not blank */
if (org_name && org_name[0]) {
al_append_path_component(local_path, al_get_org_name());
}
al_append_path_component(local_path, al_get_app_name());
return local_path;
} break;
case ALLEGRO_USER_HOME_PATH:
return _unix_find_home();
case ALLEGRO_USER_DOCUMENTS_PATH: {
ALLEGRO_PATH *local_path = _get_xdg_path("DOCUMENTS");
return local_path ? local_path : _unix_find_home();
} break;
case ALLEGRO_EXENAME_PATH:
return get_executable_name();
break;
default:
return NULL;
}
return NULL;
}
/* parse_path_string:
*
* Parse a path string according to the following grammar. The last
* component, if it is not followed by a directory separator, is interpreted
* as the filename component, unless it is "." or "..".
*
* GRAMMAR
*
* path ::= "//" c+ "/" nonlast [Windows only]
* | c ":" nonlast [Windows only]
* | nonlast
*
* nonlast ::= c* "/" nonlast
* | last
*
* last ::= "."
* | ".."
* | filename
*
* filename ::= c* [but not "." and ".."]
*
* c ::= any character but '/'
*/
static bool parse_path_string(const ALLEGRO_USTR *str, ALLEGRO_PATH *path)
{
ALLEGRO_USTR_INFO dot_info;
ALLEGRO_USTR_INFO dotdot_info;
const ALLEGRO_USTR * dot = al_ref_cstr(&dot_info, ".");
const ALLEGRO_USTR * dotdot = al_ref_cstr(&dotdot_info, "..");
ALLEGRO_USTR *piece = al_ustr_new("");
int pos = 0;
bool on_windows;
/* We compile the drive handling code on non-Windows platforms to prevent
* it becoming broken.
*/
#ifdef ALLEGRO_WINDOWS
on_windows = true;
#else
on_windows = false;
#endif
if (on_windows) {
/* UNC \\server\share name */
if (al_ustr_has_prefix_cstr(str, "//")) {
int slash = al_ustr_find_chr(str, 2, '/');
if (slash == -1 || slash == 2) {
/* Missing slash or server component is empty. */
goto Error;
}
al_ustr_assign_substr(path->drive, str, pos, slash);
pos = slash + 1;
}
else {
/* Drive letter. */
int colon = al_ustr_offset(str, 1);
if (colon > -1 && al_ustr_get(str, colon) == ':') {
/* Include the colon in the drive string. */
al_ustr_assign_substr(path->drive, str, 0, colon + 1);
pos = colon + 1;
}
}
}
for (;;) {
int slash = al_ustr_find_chr(str, pos, '/');
if (slash == -1) {
/* Last component. */
al_ustr_assign_substr(piece, str, pos, al_ustr_size(str));
if (al_ustr_equal(piece, dot) || al_ustr_equal(piece, dotdot)) {
al_append_path_component(path, al_cstr(piece));
}
else {
/* This might be an empty string, but that's okay. */
al_ustr_assign(path->filename, piece);
}
break;
}
/* Non-last component. */
al_ustr_assign_substr(piece, str, pos, slash);
al_append_path_component(path, al_cstr(piece));
pos = slash + 1;
}
al_ustr_free(piece);
return true;
Error:
al_ustr_free(piece);
return false;
}
/* get_xdg_path - locate an XDG user dir
*/
static ALLEGRO_PATH *_get_xdg_path(const char *location)
{
ALLEGRO_PATH *location_path = NULL;
ALLEGRO_PATH *xdg_config_path = NULL;
ALLEGRO_FILE *xdg_config_file = NULL;
const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
int fd;
if (xdg_config_home) {
/* use $XDG_CONFIG_HOME since it exists */
xdg_config_path = al_create_path_for_directory(xdg_config_home);
}
else {
/* the default XDG location is ~/.config */
xdg_config_path = al_get_standard_path(ALLEGRO_USER_HOME_PATH);
if (!xdg_config_path) return NULL;
al_append_path_component(xdg_config_path, ".config");
}
al_set_path_filename(xdg_config_path, "user-dirs.dirs");
fd = open(al_path_cstr(xdg_config_path, '/'), O_RDONLY);
if (fd != -1) {
xdg_config_file = al_fopen_fd(fd, "r");
}
al_destroy_path(xdg_config_path);
if (!xdg_config_file) return NULL;
while (!al_feof(xdg_config_file)) {
char line[XDG_MAX_PATH_LEN]; /* one line of the config file */
const char *p = line; /* where we're at in the line */
char component[XDG_MAX_PATH_LEN]; /* the path component being parsed */
int i = 0; /* how long the current component is */
al_fgets(xdg_config_file, line, XDG_MAX_PATH_LEN);
/* skip leading white space */
while (*p == ' ' || *p == '\t') p++;
/* skip the line if it does not begin with XDG_location_DIR */
if (strncmp(p, "XDG_", 4)) continue;
p += 4;
if (strncmp(p, location, strlen(location))) continue;
p += strlen(location);
if (strncmp(p, "_DIR", 4)) continue;
p += 4;
/* skip past the =", allowing for white space */
while (*p == ' ' || *p == '\t') p++;
if (*p++ != '=') continue;
while (*p == ' ' || *p == '\t') p++;
if (*p++ != '"') continue;
/* We've found the right line. Now parse it, basically assuming
that it is in a sane format.
*/
if (!strncmp(p, "$HOME", 5)) {
/* $HOME is the only environment variable that the path is
allowed to use, and it must be first, by specification. */
location_path = al_get_standard_path(ALLEGRO_USER_HOME_PATH);
p += 5;
}
else {
location_path = al_create_path("/");
}
while (*p) {
if (*p == '"' || *p == '/') {
/* add the component (if non-empty) to the path */
if (i > 0) {
component[i] = 0;
al_append_path_component(location_path, component);
i = 0;
}
if (*p == '"') break;
}
else {
if (*p == '\\') {
/* treat any escaped character as a literal */
p++;
if (!*p) break;
}
component[i++] = *p;
}
p++;
}
/* Finished parsing the path. */
break;
}
al_fclose(xdg_config_file);
return location_path;
}
