////////////////////////////////////////////////////////////////////////////////
// A helper function for loading an Allegro dat file where bitmaps are
// supposed to be stored.
MAS::Error MAS::Skin::LoadData(ALLEGRO_PATH *dir, ALLEGRO_CONFIG *config) {
if (!dir || !al_is_path_present(dir) || !al_get_path_filename(dir)) {
return Error(Error::SKIN_DAT);
}
// load the datafile
int i;
char tmp[256];
const char *str;
// Look for each bitmap inside and load it if it exists
for (i=0; i<nBitmaps; i++) {
al_set_path_filename(dir, bitmapName[i]);
al_set_path_extension(dir, ".png");
const char *fullPath = al_path_cstr(dir, ALLEGRO_NATIVE_PATH_SEP);
Bitmap bmp;
if (bmp.Load(fullPath, Bitmap::MEMORY) == Error::NONE) {
bmpList[i]->Set(bmp, true, MAS::Settings::useVideoMemory ? Bitmap::VIDEO : Bitmap::MEMORY);
snprintf(tmp, 256, "%s_TCKX", bitmapName[i]);
bmpList[i]->ThickX((str = al_get_config_value(config, "TILING", tmp)) ? strtol(str, NULL, 10) : -1);
snprintf(tmp, 256, "%s_TCKY", bitmapName[i]);
bmpList[i]->ThickY((str = al_get_config_value(config, "TILING", tmp)) ? strtol(str, NULL, 10) : -1);
}
}
al_set_path_filename(dir, "");
return Error(Error::NONE);
}
////////////////////////////////////////////////////////////////////////////////
// A helper function for loading an Allegro dat file where samples are
// supposed to be stored.
MAS::Error MAS::Skin::LoadSamples(ALLEGRO_PATH *dir) {
if (!dir || !al_is_path_present(dir))
return Error(Error::NO_FILE);
int i;
const char *sampleName[] = {
"SAMPLE_ACTIVATE",
"SAMPLE_CLOSE",
"SAMPLE_GOTFOCUS",
"SAMPLE_KEY",
"SAMPLE_LOSTFOCUS",
"SAMPLE_OPEN",
"SAMPLE_SCROLL"
};
// Look for each sample inside the dat file and load it if it exists
for (i=0; i<nSamples; i++) {
al_set_path_filename(dir, sampleName[i]);
al_set_path_extension(dir, ".wav");
const char *fullPath = al_path_cstr(dir, ALLEGRO_NATIVE_PATH_SEP);
Sample spl;
if (spl.Load(fullPath) == Error::NONE) {
smpList[i]->Set(spl, true);
}
}
al_set_path_filename(dir, "");
return Error(Error::NONE);
}
////////////////////////////////////////////////////////////////////////////////
// A helper function for loading an Allegro dat file where cursors are
// supposed to be stored.
MAS::Error MAS::Skin::LoadCursors(ALLEGRO_PATH *dir, ALLEGRO_CONFIG *config) {
if (!dir || !al_is_path_present(dir)) {
return Error(Error::NO_FILE);
}
MAS::Cursor::ReadSkinData(config);
al_set_path_filename(dir, al_get_path_component(dir, -1));
al_set_path_extension(dir, ".ini");
const char *config_path_t = al_path_cstr(dir, ALLEGRO_NATIVE_PATH_SEP);
ALLEGRO_CONFIG *mouse_config = al_load_config_file(config_path_t);
int i;
char tmp[256];
char *config_path = strdup(config_path_t);
int x, y, frames, interval;
const char *str;
// Look for each bitmap inside the dat file and load it if it exists
for (i=0; i<nCursors; i++) {
al_set_path_filename(dir, cursorName[i]);
al_set_path_extension(dir, ".png");
const char *fullPath = al_path_cstr(dir, ALLEGRO_NATIVE_PATH_SEP);
Bitmap bmp;
if (bmp.Load(fullPath, Bitmap::MEMORY) == Error::NONE) {
snprintf(tmp, 256, "%s_FCSX", cursorName[i]);
x = (str = al_get_config_value(mouse_config, "HOTSPOTS", tmp)) ? strtol(str, NULL, 10) : 0;
snprintf(tmp, 256, "%s_FCSY", cursorName[i]);
y = (str = al_get_config_value(mouse_config, "HOTSPOTS", tmp)) ? strtol(str, NULL, 10) : 0;
snprintf(tmp, 256, "%s_FRMS", cursorName[i]);
frames = (str = al_get_config_value(mouse_config, "HOTSPOTS", tmp)) ? strtol(str, NULL, 10) : 1;
snprintf(tmp, 256, "%s_FDUR", cursorName[i]);
interval = (str = al_get_config_value(mouse_config, "HOTSPOTS", tmp)) ? strtol(str, NULL, 10) : 20;
curList[i]->Create(bmp, frames);
curList[i]->SetFocus(x, y);
curList[i]->SetAnimationInterval(interval);
}
}
al_set_path_filename(dir, "");
free(config_path);
al_destroy_config(mouse_config);
return Error(Error::NONE);
}
static void read_allegro_cfg(void)
{
/* We assume that the stdio file interface is in effect. */
ALLEGRO_PATH *path;
ALLEGRO_CONFIG *temp;
if (!sys_config)
sys_config = al_create_config();
#if defined(ALLEGRO_UNIX) && !defined(ALLEGRO_IPHONE)
temp = al_load_config_file("/etc/allegro5rc");
if (temp) {
al_merge_config_into(sys_config, temp);
al_destroy_config(temp);
}
path = _al_unix_get_path(ALLEGRO_USER_HOME_PATH);
if (path) {
al_set_path_filename(path, "allegro5rc");
temp = al_load_config_file(al_path_cstr(path, '/'));
if (temp) {
al_merge_config_into(sys_config, temp);
al_destroy_config(temp);
}
al_set_path_filename(path, ".allegro5rc");
temp = al_load_config_file(al_path_cstr(path, '/'));
if (temp) {
al_merge_config_into(sys_config, temp);
al_destroy_config(temp);
}
al_destroy_path(path);
}
#endif
path = early_get_exename_path();
if (path) {
al_set_path_filename(path, "allegro5.cfg");
temp = al_load_config_file(al_path_cstr(path, ALLEGRO_NATIVE_PATH_SEP));
if (temp) {
al_merge_config_into(sys_config, temp);
al_destroy_config(temp);
}
al_destroy_path(path);
}
/* Reconfigure logging in case something changed. */
_al_configure_logging();
}
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;
}
static void read_scores(void)
{
ALLEGRO_PATH *fn = userResourcePath();
if (al_make_directory(al_path_cstr(fn, ALLEGRO_NATIVE_PATH_SEP))) {
al_set_path_filename(fn, "scores.cfg");
ALLEGRO_CONFIG *cfg = al_load_config_file(al_path_cstr(fn, ALLEGRO_NATIVE_PATH_SEP));
if (cfg) {
for (int i = 0; i < NUM_SCORES; i++) {
char name[] = {'n', (char)('0'+i), '\0'};
char score[] = {'s', (char)('0'+i), '\0'};
const char *v;
v = al_get_config_value(cfg, "scores", name);
if (v && strlen(v) <= 3) {
strcpy(highScores[i].name, v);
}
v = al_get_config_value(cfg, "scores", score);
if (v) {
highScores[i].score = atoi(v);
}
}
al_destroy_config(cfg);
}
}
al_destroy_path(fn);
}
static int allua_Path_set_filename(lua_State * L)
{
ALLUA_path path = allua_check_path(L, 1);
const char *s = luaL_checkstring(L, 2);
al_set_path_filename(path, s);
return 0;
}
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 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 ALLEGRO_PATH *maybe_parent_dir(const ALLEGRO_PATH *path)
{
ALLEGRO_PATH *path2;
if (!path)
return NULL;
if (!is_build_config_name(al_get_path_tail(path)))
return NULL;
path2 = al_clone_path(path);
if (path2) {
al_drop_path_tail(path2);
al_set_path_filename(path2, NULL);
ALLEGRO_DEBUG("Also searching %s\n", al_path_cstr(path2, '\\'));
}
return path2;
}
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 void write_scores(void)
{
ALLEGRO_CONFIG *cfg = al_create_config();
for (int i = 0; i < NUM_SCORES; i++) {
char name[] = {'n', (char)('0'+i), '\0'};
char score[] = {'s', (char)('0'+i), '\0'};
char sc[32];
al_set_config_value(cfg, "scores", name, highScores[i].name);
snprintf(sc, sizeof(sc), "%d", highScores[i].score);
al_set_config_value(cfg, "scores", score, sc);
}
ALLEGRO_PATH *fn = userResourcePath();
al_set_path_filename(fn, "scores.cfg");
al_save_config_file(al_path_cstr(fn, ALLEGRO_NATIVE_PATH_SEP), cfg);
al_destroy_path(fn);
al_destroy_config(cfg);
}
/* Function: al_get_standard_path
*/
ALLEGRO_PATH *al_get_standard_path(int id)
{
ASSERT(active_sysdrv);
ASSERT(active_sysdrv->vt);
ASSERT(active_sysdrv->vt->get_path);
if (id == ALLEGRO_EXENAME_PATH && active_sysdrv->user_exe_path)
return al_clone_path(active_sysdrv->user_exe_path);
if (id == ALLEGRO_RESOURCES_PATH && active_sysdrv->user_exe_path) {
ALLEGRO_PATH *exe_dir = al_clone_path(active_sysdrv->user_exe_path);
al_set_path_filename(exe_dir, NULL);
return exe_dir;
}
if (active_sysdrv->vt->get_path)
return active_sysdrv->vt->get_path(id);
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;
}
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;
}
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;
}
GAME * game_init ()
{
if (!al_init ()) {
fprintf (stderr, "Failed to initialize Allegro.\n");
return NULL;
}
if (!al_init_image_addon ()) {
fprintf (stderr, "Failed to initialize image addon.\n");
return NULL;
}
if (!al_install_keyboard ()) {
fprintf (stderr, "Failed to install keyboard.\n");
return NULL;
}
al_init_font_addon ();
if (!al_init_ttf_addon ()) {
fprintf (stderr, "Failed to initialize ttf addon.\n");
return NULL;
}
if (!al_init_primitives_addon ()) {
fprintf (stderr, "Failed to initialize primitives addon.\n");
return NULL;
}
GAME *game = al_malloc (sizeof (GAME));
if (!game)
return NULL;
srand (time (NULL));
game->running = true;
game->paused = false;
game->fullscreen = 1;
game->windowed = 1;
game->rrate = 60;
game->suggest_vsync = 1;
game->force_vsync = 0;
game->current_npc = NULL;
game->screen = screen_new ();
char *filename;
const char *str;
filename = get_resource_path_str ("data/game.ini");
ALLEGRO_CONFIG *game_config = al_load_config_file (filename);
al_free (filename);
str = al_get_config_value (game_config, "", "org");
al_set_org_name (str);
str = al_get_config_value (game_config, "", "app");
al_set_app_name (str);
ALLEGRO_PATH *settpath = al_get_standard_path (ALLEGRO_USER_SETTINGS_PATH);
ALLEGRO_PATH *gcpath = al_clone_path (settpath);
al_set_path_filename (gcpath, "general.ini");
const char * gcpath_str = al_path_cstr (gcpath, ALLEGRO_NATIVE_PATH_SEP);
ALLEGRO_CONFIG *gconfig = al_load_config_file (gcpath_str);
if (!gconfig) {
gconfig = al_create_config ();
al_make_directory (al_path_cstr (settpath, ALLEGRO_NATIVE_PATH_SEP));
set_config_i (gconfig, "display", "width", game->screen.width);
set_config_i (gconfig, "display", "height", game->screen.height);
set_config_i (gconfig, "display", "fullscreen", game->fullscreen);
set_config_i (gconfig, "display", "windowed", game->windowed);
set_config_i (gconfig, "display", "refreshrate", game->rrate);
set_config_i (gconfig, "display", "suggest_vsync", game->suggest_vsync);
set_config_i (gconfig, "display", "force_vsync", game->force_vsync);
} else {
get_config_i (gconfig, "display", "width", &game->screen.width);
get_config_i (gconfig, "display", "height", &game->screen.height);
get_config_i (gconfig, "display", "fullscreen", &game->fullscreen);
get_config_i (gconfig, "display", "windowed", &game->windowed);
get_config_i (gconfig, "display", "refreshrate", &game->rrate);
get_config_i (gconfig, "display", "suggest_vsync", &game->suggest_vsync);
get_config_i (gconfig, "display", "force_vsync", &game->force_vsync);
}
al_save_config_file (gcpath_str, gconfig);
al_destroy_path (settpath);
al_destroy_path (gcpath);
al_destroy_config (gconfig);
int flags = 0;
if (game->fullscreen == game->windowed)
flags |= ALLEGRO_FULLSCREEN_WINDOW;
else if (game->fullscreen)
flags |= ALLEGRO_FULLSCREEN;
else
flags |= ALLEGRO_WINDOWED;
al_set_new_display_option (ALLEGRO_VSYNC, game->suggest_vsync, ALLEGRO_SUGGEST);
al_set_new_display_option (ALLEGRO_DEPTH_SIZE, 8, ALLEGRO_SUGGEST);
al_set_new_display_flags (flags);
al_set_new_display_refresh_rate (game->rrate);
game->display = al_create_display (game->screen.width, game->screen.height);
if (!game->display) {
fprintf (stderr, "Failed to create display.\n");
al_free (game);
return NULL;
}
al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP);
game->timer = al_create_timer (1.0 / FPS);
if (!game->timer) {
fprintf (stderr, "Failed to create timer.\n");
al_free (game);
return NULL;
}
game->screen.width = al_get_display_width (game->display);
game->screen.height = al_get_display_height (game->display);
screen_update_size (&game->screen, game->screen.width, game->screen.height);
game->rrate = al_get_display_refresh_rate (game->display);
game->event_queue = al_create_event_queue ();
if (!game->event_queue) {
fprintf (stderr, "Failed to create event queue.\n");
al_free (game);
return NULL;
}
al_register_event_source (game->event_queue, al_get_display_event_source (game->display));
al_register_event_source (game->event_queue, al_get_timer_event_source (game->timer));
al_set_render_state (ALLEGRO_ALPHA_FUNCTION, ALLEGRO_RENDER_EQUAL);
al_set_render_state (ALLEGRO_ALPHA_TEST_VALUE, 1);
filename = get_resource_path_str ("data/sprites.ini");
game->sprites = sprite_load_sprites (filename);
al_free (filename);
filename = get_resource_path_str ("data/scenes.ini");
game->scenes = scene_load_file (filename);
scene_load_scenes (game->scenes, game->sprites);
al_free (filename);
str = al_get_config_value (game_config, "", "scene");
game->current_scene = scene_get (game->scenes, str);
str = al_get_config_value (game_config, "", "actor");
game->current_actor = sprite_new_actor (game->sprites, str);
str = al_get_config_value (game_config, "", "portal");
SCENE_PORTAL *portal = scene_get_portal (game->scenes, str);
al_destroy_config (game_config);
filename = get_resource_path_str ("data/ui.ini");
game->ui = ui_load_file (filename);
al_free (filename);
sprite_center (game->current_actor, &portal->position);
screen_center (&game->screen, portal->position, game->current_scene->map);
return game;
}
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;
}
/* _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 *cwd;
/* Prepend current directory */
cwd = al_get_current_directory();
if (cwd) {
ALLEGRO_PATH *path = al_create_path_for_directory(cwd);
al_free(cwd);
al_set_path_filename(path, filename);
if (stat(al_path_cstr(path, '/'), &finfo) == 0
&& !S_ISDIR(finfo.st_mode)) {
return path;
}
al_destroy_path(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;
const ALLEGRO_USTR *sub = al_ref_ustr(&info, us, start_pos, end_pos);
ALLEGRO_PATH *path = al_create_path_for_directory(al_cstr(sub));
al_set_path_filename(path, filename);
if (stat(al_path_cstr(path, '/'), &finfo) == 0 &&
!S_ISDIR (finfo.st_mode)) {
return path;
}
al_destroy_path(path);
start_pos = next_start_pos;
}
}
return NULL;
}
/* the main program body */
int main(int argc, char *argv[])
{
ALLEGRO_PATH *font_path;
int w = 0, h = 0;
int www = FALSE;
int i, n;
int display_flags = ALLEGRO_GENERATE_EXPOSE_EVENTS;
srand(time(NULL));
al_set_org_name("liballeg.org");
al_set_app_name("SPEED");
if (!al_init()) {
fprintf(stderr, "Could not initialise Allegro.\n");
return 1;
}
al_init_primitives_addon();
/* parse the commandline */
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-cheat") == 0) {
cheat = TRUE;
}
else if (strcmp(argv[i], "-simple") == 0) {
low_detail = TRUE;
}
else if (strcmp(argv[i], "-nogrid") == 0) {
no_grid = TRUE;
}
else if (strcmp(argv[i], "-nomusic") == 0) {
no_music = TRUE;
}
else if (strcmp(argv[i], "-www") == 0) {
www = TRUE;
}
else if (strcmp(argv[i], "-fullscreen") == 0) {
/* if no width is specified, assume fullscreen_window */
display_flags |= w ? ALLEGRO_FULLSCREEN : ALLEGRO_FULLSCREEN_WINDOW;
}
else {
n = atoi(argv[i]);
if (!n) {
usage();
return 1;
}
if (!w) {
w = n;
if (display_flags & ALLEGRO_FULLSCREEN_WINDOW) {
/* toggle from fullscreen_window to fullscreen */
display_flags &= ~ALLEGRO_FULLSCREEN_WINDOW;
display_flags |= ALLEGRO_FULLSCREEN;
}
}
else if (!h) {
h = n;
}
else {
usage();
return 1;
}
}
}
/* it's a real shame that I had to take this out! */
if (www) {
printf(
"\n"
"Unfortunately the built-in web browser feature had to be removed.\n"
"\n"
"I did get it more or less working as of Saturday evening (forms and\n"
"Java were unsupported, but tables and images were mostly rendering ok),\n"
"but the US Department of Justice felt that this was an unacceptable\n"
"monopolistic attempt to tie in web browsing functionality to an\n"
"unrelated product, so they threatened me with being sniped at from\n"
"the top of tall buildings by guys with high powered rifles unless I\n"
"agreed to disable this code.\n"
"\n"
"We apologise for any inconvenience that this may cause you.\n"
);
return 1;
}
if (!w || !h) {
if (argc == 1 || (display_flags & ALLEGRO_FULLSCREEN_WINDOW)) {
w = 640;
h = 480;
}
else {
usage();
return 1;
}
}
/* set the screen mode */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
al_set_new_display_flags(display_flags);
screen = al_create_display(w, h);
if (!screen) {
fprintf(stderr, "Error setting %dx%d display mode\n", w, h);
return 1;
}
al_init_image_addon();
/* The Allegro 5 port introduced an external data dependency, sorry.
* To avoid performance problems on graphics drivers that don't support
* drawing to textures, we build up transition screens on memory bitmaps.
* We need a font loaded into a memory bitmap for those, then a font
* loaded into a video bitmap for the game view. Blech!
*/
font_path = get_resources_path();
al_set_path_filename(font_path, "a4_font.tga");
al_init_font_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
font = al_load_bitmap_font(al_path_cstr(font_path, '/'));
if (!font) {
fprintf(stderr, "Error loading %s\n", al_path_cstr(font_path, '/'));
return 1;
}
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP);
font_video = al_load_bitmap_font(al_path_cstr(font_path, '/'));
if (!font_video) {
fprintf(stderr, "Error loading %s\n", al_path_cstr(font_path, '/'));
return 1;
}
al_destroy_path(font_path);
/* set up everything else */
al_install_keyboard();
al_install_joystick();
if (al_install_audio()) {
if (!al_reserve_samples(8))
al_uninstall_audio();
}
init_input();
init_sound();
init_hiscore();
/* the main program body */
while (title_screen()) {
if (play_game()) {
show_results();
score_table();
}
}
/* time to go away now */
shutdown_hiscore();
shutdown_sound();
goodbye();
shutdown_input();
al_destroy_font(font);
al_destroy_font(font_video);
return 0;
}
TILED_MAP* tiled_load_tmx_file (const char *filename)
{
TILED_MAP *map;
xmlDoc *doc;
xmlNode *root;
char *str;
if (!filename)
return NULL;
LIBXML_TEST_VERSION
doc = xmlReadFile (filename, NULL, 0);
if (!doc)
return NULL;
ALLEGRO_PATH *mapdir = al_create_path (filename);
al_set_path_filename (mapdir, NULL);
if (!al_change_directory (al_path_cstr (mapdir, ALLEGRO_NATIVE_PATH_SEP))) {
printf ("Failed to change directory.");
}
al_destroy_path (mapdir);
root = xmlDocGetRootElement (doc);
map = al_malloc (sizeof (TILED_MAP));
map->width = get_int (root, "width", 0);
map->height = get_int (root, "height", 0);
map->tile_width = get_int (root, "tilewidth", 0);
map->tile_height = get_int (root, "tileheight", 0);
map->strings = _al_list_create ();
map->properties = get_properties (root, map);
map->tiles = NULL;
str = get_xml_attribute (root, "orientation");
if (!strcmp (str, "orthogonal"))
map->orientation = ORIENTATION_ORTHOGONAL;
else if (!strcmp (str, "isometric"))
map->orientation = ORIENTATION_ISOMETRIC;
else if (!strcmp (str, "staggered"))
map->orientation = ORIENTATION_STAGGERED;
else
map->orientation = ORIENTATION_UNKNOWN;
// Tilesets
LIST *tileset_nodes = get_children_for_name (root, 1, "tileset");
map->tilesets = create_list (_al_list_size (tileset_nodes));
LIST_ITEM *tileset_item = _al_list_front (tileset_nodes);
while (tileset_item) {
xmlNode *tileset_node = _al_list_item_data (tileset_item);
TILED_TILESET *tileset = al_malloc (sizeof (TILED_TILESET));
tileset->first_gid = get_int (tileset_node, "firstgid", 1);
tileset->tile_width = get_int (tileset_node, "tilewidth", 0);
tileset->tile_height = get_int (tileset_node, "tileheight", 0);
tileset->name = get_str (tileset_node, "name");
tileset->properties = get_properties (tileset_node, map);
xmlNode *image_node = get_first_child_for_name (tileset_node, "image");
tileset->image_width = get_int (image_node, "width", 0);
tileset->image_height = get_int (image_node, "height", 0);
tileset->image_source = get_str (image_node, "source");
tileset->bitmap = al_load_bitmap (tileset->image_source);
LIST *tile_nodes = get_children_for_name (tileset_node, 1, "tile");
int tiles_per_row = tileset->image_width / tileset->tile_width;
tileset->num_tiles = (tileset->image_width * tileset->image_height) /
(tileset->tile_width * tileset->tile_height);
TILED_TILE *tile;
tileset->tiles = al_malloc (tileset->num_tiles * sizeof (TILED_TILE));
for (int i = 0; i < tileset->num_tiles; i++) {
tile = &tileset->tiles[i];
tile->id = i;
tile->gid = i + tileset->first_gid;
tile->tileset = tileset;
tile->properties = NULL;
int x = (i % tiles_per_row) * tileset->tile_width;
int y = (i / tiles_per_row) * tileset->tile_height;
tile->bitmap = al_create_sub_bitmap(tileset->bitmap, x, y,
tileset->tile_width,
tileset->tile_height);
map->tiles = aa_insert (map->tiles, &tile->gid, tile, intcmp);
}
LIST_ITEM *tile_item = _al_list_front (tile_nodes);
while (tile_item) {
xmlNode *tile_node = (xmlNode*)_al_list_item_data (tile_item);
int id = get_int (tile_node, "id", 0);
tile = &tileset->tiles[id];
tile->properties = get_properties (tile_node, map);
tile_item = _al_list_next (tile_nodes, tile_item);
}
_al_list_destroy (tile_nodes);
_al_list_push_back_ex (map->tilesets, tileset, dtor_tileset);
tileset_item = _al_list_next (tileset_nodes, tileset_item);
}
_al_list_destroy (tileset_nodes);
// Layers
LIST *layer_nodes = get_children_for_name (root, 2, "layer", "objectgroup");
map->layers = create_list (_al_list_size (layer_nodes));
map->layers_fore = _al_list_create ();
map->layers_back = _al_list_create ();
LIST_ITEM *layer_item = _al_list_front (layer_nodes);
while (layer_item) {
xmlNode *layer_node = _al_list_item_data (layer_item);
TILED_LAYER *layer = NULL;
const char* type_str = (const char *)layer_node->name;
if (!strcmp (type_str, "layer")) {
layer = al_malloc (sizeof (TILED_LAYER_TILE));
layer->type = LAYER_TYPE_TILE;
}
else if (!strcmp (type_str, "objectgroup")) {
layer = al_malloc (sizeof (TILED_LAYER_OBJECT));
layer->type = LAYER_TYPE_OBJECT;
}
layer->name = get_str (layer_node, "name");
layer->width = get_int (layer_node, "width", 0);
layer->height = get_int (layer_node, "height", 0);
layer->opacity = get_float (layer_node, "opacity", 1.0);
layer->map = map;
layer->properties = get_properties (layer_node, map);
char *order = aa_search (layer->properties, "order", charcmp);
if (layer->type == LAYER_TYPE_TILE) {
TILED_LAYER_TILE *tile_layer = (TILED_LAYER_TILE *)layer;
tile_layer->tiles = al_malloc (layer->height * sizeof (TILED_TILE*));
xmlNode *data_node = get_first_child_for_name (layer_node, "data");
LIST *tile_nodes = get_children_for_name (data_node, 1, "tile");
LIST_ITEM *tile_item = _al_list_front (tile_nodes);
for (int j = 0; j < layer->height; j++) {
tile_layer->tiles[j] = al_malloc (layer->width * sizeof (TILED_TILE*));
for (int k = 0; k < layer->width; k++) {
xmlNode *tile_node = (xmlNode*)_al_list_item_data (tile_item);
int id = get_int (tile_node, "gid", 0);
if (id == 0) {
tile_layer->tiles[j][k] = NULL;
} else {
TILED_TILE *tile = aa_search (map->tiles, &id, intcmp);
tile_layer->tiles[j][k] = tile;
}
tile_item = _al_list_next (tile_nodes, tile_item);
}
}
_al_list_destroy (tile_nodes);
} else if (layer->type == LAYER_TYPE_OBJECT) {
TILED_LAYER_OBJECT *object_layer = (TILED_LAYER_OBJECT *)layer;
object_layer->objects = _al_list_create ();
LIST *object_nodes = get_children_for_name (layer_node, 1, "object");
LIST_ITEM *object_item = _al_list_front (object_nodes);
while (object_item) {
xmlNode *object_node = (xmlNode*)_al_list_item_data (object_item);
TILED_OBJECT *cobj = NULL;
int width = get_int (object_node, "width", 0);
int gid = get_int (object_node, "gid", 0);
int px = get_int (object_node, "x", 0);
int py = get_int (object_node, "y", 0);
if (width > 0) {
TILED_OBJECT_RECT *obj = al_malloc (sizeof (TILED_OBJECT_RECT));
obj->object.type = OBJECT_TYPE_RECT;
obj->width = width;
obj->height = get_int (object_node, "height", 0);
cobj = (TILED_OBJECT *) obj;
} else if (gid > 0) {
TILED_OBJECT_TILE *obj = al_malloc (sizeof (TILED_OBJECT_TILE));
obj->object.type = OBJECT_TYPE_TILE;
obj->tile = aa_search (map->tiles, &gid, intcmp);
cobj = (TILED_OBJECT *) obj;
} else {
TILED_OBJECT_GEOM *obj = al_malloc (sizeof (TILED_OBJECT_GEOM));
obj->object.type = OBJECT_TYPE_GEOM;
xmlNode *poly_node = get_first_child_for_name (object_node, "polyline");
if (poly_node) {
obj->points = get_float_points (poly_node, "points", &obj->num_points);
offset_points (px, py, obj->points, obj->num_points);
} else {
poly_node = get_first_child_for_name (object_node, "polygon");
if (poly_node)
obj->points = get_float_points (poly_node, "points", &obj->num_points);
offset_points (px, py, obj->points, obj->num_points);
}
cobj = (TILED_OBJECT *) obj;
}
cobj->x = px;
cobj->y = py;
cobj->name = get_str (object_node, "name");
cobj->type_str = get_str (object_node, "type");
cobj->properties = get_properties (object_node, map);
_al_list_push_back_ex (object_layer->objects, cobj, dtor_object);
object_item = _al_list_next (object_nodes, object_item);
}
_al_list_destroy (object_nodes);
}
layer_item = _al_list_next (layer_nodes, layer_item);
_al_list_push_back_ex (map->layers, layer, dtor_layer);
if (order && !strcmp (order, "fore"))
_al_list_push_back (map->layers_fore, layer);
else
_al_list_push_back (map->layers_back, layer);
}
_al_list_destroy (layer_nodes);
xmlFreeDoc (doc);
xmlCleanupParser ();
ALLEGRO_PATH *respath = al_get_standard_path (ALLEGRO_RESOURCES_PATH);
al_change_directory (al_path_cstr (respath, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path (respath);
return map;
}
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::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);
}
////////////////////////////////////////////////////////////////////////////////
// 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);
}
bool _al_show_native_file_dialog(ALLEGRO_DISPLAY *display,
ALLEGRO_NATIVE_DIALOG *fd)
{
OPENFILENAME ofn;
ALLEGRO_DISPLAY_WIN *win_display;
int flags = 0;
bool ret;
char buf[4096] = "";
ALLEGRO_USTR *filter_string = NULL;
win_display = (ALLEGRO_DISPLAY_WIN *)display;
if (fd->flags & ALLEGRO_FILECHOOSER_FOLDER) {
return select_folder(win_display, fd);
}
/* Selecting a file. */
memset(&ofn, 0, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = (win_display) ? win_display->window : NULL;
/* Create filter string. */
if (fd->fc_patterns) {
filter_string = create_filter_string(fd->fc_patterns);
ofn.lpstrFilter = al_cstr(filter_string);
}
else {
/* List all files by default. */
ofn.lpstrFilter = "All Files\0*.*\0\0";
}
ofn.lpstrFile = buf;
ofn.nMaxFile = sizeof(buf);
if (fd->fc_initial_path) {
ofn.lpstrInitialDir =
al_path_cstr(fd->fc_initial_path, ALLEGRO_NATIVE_PATH_SEP);
}
if (fd->title)
ofn.lpstrTitle = al_cstr(fd->title);
flags |= OFN_NOCHANGEDIR | OFN_EXPLORER;
if (fd->flags & ALLEGRO_FILECHOOSER_SAVE) {
flags |= OFN_OVERWRITEPROMPT;
}
else {
flags |= (fd->flags & ALLEGRO_FILECHOOSER_FILE_MUST_EXIST) ? OFN_FILEMUSTEXIST : 0;
}
flags |= (fd->flags & ALLEGRO_FILECHOOSER_MULTIPLE) ? OFN_ALLOWMULTISELECT : 0;
flags |= (fd->flags & ALLEGRO_FILECHOOSER_SHOW_HIDDEN) ? 0x10000000 : 0; // NOTE: 0x10000000 is FORCESHOWHIDDEN
ofn.Flags = flags;
if (flags & OFN_OVERWRITEPROMPT) {
ret = GetSaveFileName(&ofn);
}
else {
ret = GetOpenFileName(&ofn);
}
al_ustr_free(filter_string);
if (!ret) {
DWORD err = GetLastError();
if (err != ERROR_SUCCESS) {
char buf[1000];
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, sizeof(buf), NULL);
ALLEGRO_ERROR("al_show_native_file_dialog failed: %s\n", buf);
}
return false;
}
if (flags & OFN_ALLOWMULTISELECT) {
int i;
/* Count number of file names in buf. */
fd->fc_path_count = 0;
i = skip_nul_terminated_string(buf);
while (1) {
if (buf[i] == '\0') {
fd->fc_path_count++;
if (buf[i+1] == '\0')
break;
}
i++;
}
}
else {
fd->fc_path_count = 1;
}
if (fd->fc_path_count == 1) {
fd->fc_paths = al_malloc(sizeof(void *));
fd->fc_paths[0] = al_create_path(buf);
}
else {
int i, p;
/* If multiple files were selected, the first string in buf is the
* directory name, followed by each of the file names terminated by NUL.
*/
fd->fc_paths = al_malloc(fd->fc_path_count * sizeof(void *));
i = skip_nul_terminated_string(buf);
for (p = 0; p < (int)fd->fc_path_count; p++) {
fd->fc_paths[p] = al_create_path_for_directory(buf);
al_set_path_filename(fd->fc_paths[p], buf+i);
i += skip_nul_terminated_string(buf+i);
}
}
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
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;
}