int main(int argc, char **argv)
{
int i;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log_monospace();
log_printf("%-36s %-6s %8s %8s %8s %8s\n",
"name", "flags", "ctime", "mtime", "atime", "size");
log_printf(
"------------------------------------ "
"------ "
"-------- "
"-------- "
"-------- "
"--------\n");
if (argc == 1) {
ALLEGRO_FS_ENTRY *entry = al_create_fs_entry("data");
print_entry(entry);
al_destroy_fs_entry(entry);
}
for (i = 1; i < argc; i++) {
ALLEGRO_FS_ENTRY *entry = al_create_fs_entry(argv[i]);
print_entry(entry);
al_destroy_fs_entry(entry);
}
close_log(true);
return 0;
}
bool t3f_scan_files(const char * path, bool (*process_file)(const char * fn, bool isfolder, void * data), bool subdir, void * data)
{
ALLEGRO_FS_ENTRY * dir;
ALLEGRO_FS_ENTRY * fp;
char cname[1024] = {0};
/* ignore ./ and ../ path entries */
strcpy(cname, path);
if(strlen(cname) > 0)
{
if(cname[strlen(cname) - 1] == '/')
{
if(subdir)
{
if(cname[strlen(cname) - 2] == '.')
{
return false;
}
}
cname[strlen(cname) - 1] = 0;
}
}
// printf("!Looking in %s\n", cname);
dir = al_create_fs_entry(cname);
if(!dir)
{
return false;
}
if(!al_open_directory(dir))
{
return false;
}
// printf("Looking in %s\n", cname);
while(1)
{
fp = al_read_directory(dir);
if(!fp)
{
break;
}
// name = al_path_to_string(al_get_entry_name(fp), '/');
if(al_get_fs_entry_mode(fp) & ALLEGRO_FILEMODE_ISDIR)
{
if(process_file(al_get_fs_entry_name(fp), true, data))
{
}
t3f_scan_files(al_get_fs_entry_name(fp), process_file, true, data);
}
else
{
if(process_file(al_get_fs_entry_name(fp), false, data))
{
}
}
al_destroy_fs_entry(fp);
}
al_destroy_fs_entry(dir);
return true;
}
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...");
}
}
bool ScreenPlay::scan_save_files()
{
//reduntant finction?
if(gms == nullptr)
gms = new GameSave();
savefiles.clear();
std::string dum;
int a = 0;
ALLEGRO_FS_ENTRY* dir = al_create_fs_entry("saves/");
if(al_open_directory(dir) == false)
{
al_make_directory("saves/");
}
if(al_open_directory(dir))
{
ALLEGRO_FS_ENTRY* file;
while(file = al_read_directory(dir))
{
dum = al_get_fs_entry_name(file);
if( al_get_fs_entry_mode(file) == ALLEGRO_FILEMODE_ISDIR || dum.substr(dum.size()-4,4) != ".sav")
{
continue;
}
gms->Load(dum);
savefiles.push_back(dum);
scba->AddText(5, a * 100 +10, gms->Get_player_name(), al_map_rgb(255,215,0), &n_font);
scba->AddButton("resources/fonts/Calibri.ttf", 400, a * 100 + 60, 75, 30, "Load", al_map_rgb(0,0,139));
scba->AddRectangle(1,a * 100 , 500, 100, 2, al_map_rgb(10,10,10));
scba->AddText(10, a * 100 + 60, "Mission: " + std::to_string(gms->Get_mission_number()), al_map_rgb(255,255,250), &m_font);
a++;
gms->Save();
}
al_destroy_fs_entry(file);
}
al_destroy_fs_entry(dir);
return true;
}
static void print_entry(ALLEGRO_FS_ENTRY *entry)
{
print_file(entry);
if (al_get_fs_entry_mode(entry) & ALLEGRO_FILEMODE_ISDIR) {
ALLEGRO_FS_ENTRY *next;
al_open_directory(entry);
while (1) {
next = al_read_directory(entry);
if (!next)
break;
print_entry(next);
al_destroy_fs_entry(next);
}
al_close_directory(entry);
}
}
ScreenPlay::ScreenPlay(Button *ext_b) : but(ext_b)
{
n_font = al_load_font("resources/fonts/Asimov.otf",40,0);
m_font = al_load_font("resources/fonts/Calibri.ttf",30,0);
std::string bnames[SCREENPLAY_NMB] = {"Back", "New game", "OK"};
int bpoz[SCREENPLAY_NMB][4] = { {1300, global::dHeight -70, 120, 50},
{(global::dWidth-120)/2, global::dHeight -70, 120, 50},
{(global::dWidth-120)/2, (global::dHeight-50)/2 +45, 120, 50} };
for(int a = 0;a < SCREENPLAY_NMB;a++)
{
buttons.push_back(new Button("resources/fonts/Calibri.ttf", bpoz[a][0], bpoz[a][1], bpoz[a][0] + bpoz[a][2],bpoz[a][1] + bpoz[a][3], bnames[a], al_map_rgb(0,0,128)));
}
buttons[OK]->Active(false);
buttons[OK]->Print_active(false);
scba = new ScrollableArea(((float)global::dWidth - 500.0f)/2.0f ,100, 500 ,global::dHeight-200);
scba->background_col = al_map_rgba(50,50,50,120);
//graphic background trash
zemak_bitmpa = al_load_bitmap("resources/graphics/zemiacik.png");
if(zemak_bitmpa == nullptr)
{
error_message("Could not load image : resources/graphics/zemiacik.png");
}
std::mt19937 generator(std::chrono::system_clock::now().time_since_epoch().count());
std::uniform_int_distribution<int> distribution(1,5);
std::uniform_real_distribution<float> change(-10, 10);
std::uniform_int_distribution<int> width(0,global::dWidth - ZEMIAK_SIZE);
std::uniform_int_distribution<int> height(0,global::dHeight-ZEMIAK_SIZE);
number_of_zemaky = distribution(generator);
zemaky = new float[number_of_zemaky*4];
for(int a = 0;a < number_of_zemaky*4;a+=4)
{
zemaky[a] = width(generator);
zemaky[a+1] = height(generator);
zemaky[a+2] = round(change(generator));
zemaky[a+3] = round(change(generator));
}
//------------------------------------------
//Saves loading
gms = new GameSave();
std::string dum;
int a = 0;
ALLEGRO_FS_ENTRY* dir = al_create_fs_entry("saves/");
if(al_open_directory(dir) == false)
{
al_make_directory("saves/");
}
if(al_open_directory(dir))
{
ALLEGRO_FS_ENTRY* file;
while(file = al_read_directory(dir))
{
dum = al_get_fs_entry_name(file);
if( al_get_fs_entry_mode(file) == ALLEGRO_FILEMODE_ISDIR || dum.substr(dum.size()-4,4) != ".sav")
{
continue;
}
gms->Load(dum);
savefiles.push_back(dum);
scba->AddText(5, a * 100 +10, gms->Get_player_name(), al_map_rgb(255,215,0), &n_font);
scba->AddButton("resources/fonts/Calibri.ttf", 400, a * 100 + 60, 75, 30, "Load", al_map_rgb(0,0,139));
scba->AddRectangle(1,a * 100 , 500, 100, 2, al_map_rgb(10,10,10));
scba->AddText(10, a * 100 + 60, "Mission: " + std::to_string(gms->Get_mission_number()), al_map_rgb(255,255,250), &m_font);
a++;
gms->Save();
}
al_destroy_fs_entry(file);
}
al_destroy_fs_entry(dir);
}
virtual Skybox *load(const File &file, bool force = false)
{
//
// A terminer
// http://raptor.developpez.com/tutorial/opengl/skybox/
ALLEGRO_FS_ENTRY *fs;
ALLEGRO_FS_ENTRY *content;
ALLEGRO_BITMAP **bmps = new ALLEGRO_BITMAP*[6];
int fileCnt = 0;
GLuint cube_map_texture_ID;
GLenum cube_map_target[6] = {
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z
};
std::map<std::string, ALLEGRO_LOCKED_REGION*> texture_image;
fs = al_create_fs_entry(file.getFullName().c_str());
if (!fs)
{
throw LoadingFailed(file.getFullName(), "SkyboxLoader failed to find or open skybox folder.");
}
if (!al_open_directory(fs))
{
throw LoadingFailed(file.getFullName(), "SkyboxLoader failed to open skybox folder.");
}
if (!al_fs_entry_exists(fs))
{
throw LoadingFailed(file.getFullName(), "SkyboxLoader can't find folder.");
}
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
while ((content = al_read_directory(fs)))
{
const char *name = al_get_fs_entry_name(content);
ALLEGRO_LOCKED_REGION *r;
std::cout << name << std::endl;
bmps[fileCnt] = al_load_bitmap(name);
if (!bmps[fileCnt])
throw LoadingFailed(name, "SkyboxLoader can't load image.");
r = al_lock_bitmap(bmps[fileCnt], ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE);
if (!r)
throw LoadingFailed(name, "SkyboxLoader can't lock bitmap.");
texture_image.insert(std::pair<std::string, ALLEGRO_LOCKED_REGION*>(std::string(name), r));
al_destroy_fs_entry(content);
++fileCnt;
}
al_destroy_fs_entry(fs);
al_set_new_bitmap_flags(~ALLEGRO_MEMORY_BITMAP);
// Génération d'une texture CubeMap
glGenTextures(1, &cube_map_texture_ID);
if (cube_map_texture_ID == 0)
throw LoadingFailed(file.getFullName(), "SkyboxLoader error generating a texture.");
// Configuration de la texture
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_map_texture_ID);
std::map<std::string, ALLEGRO_LOCKED_REGION*>::iterator it = texture_image.begin();
int i = 0;
while (it != texture_image.end())
{
glTexImage2D(cube_map_target[i], 0, it->second->pixel_size,
al_get_bitmap_width(bmps[i]),
al_get_bitmap_height(bmps[i]),
0, GL_BGRA, GL_UNSIGNED_BYTE,
it->second->data);
al_unlock_bitmap(bmps[i]);
++i;
++it;
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP);
return new Skybox(cube_map_texture_ID, bmps, file.getFileName(), force);
}
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;
}
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;
}