int main(int argc, char **argv)
{
al_init();
al_init_image_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
ALLEGRO_BITMAP *tm = al_load_bitmap("tilemap.png");
int w = al_get_bitmap_width(tm);
int h = al_get_bitmap_height(tm);
int wt = w / 16;
int ht = h / 16;
ALLEGRO_BITMAP *b = al_create_bitmap(16, 16);
al_set_target_bitmap(b);
for (int y = 0; y < ht; y++) {
for (int x = 0; x < wt; x++) {
al_clear_to_color(al_map_rgba_f(0, 0, 0, 0));
al_draw_bitmap_region(tm, x*16, y*16, 16, 16, 0, 0, 0);
char name[200];
sprintf(name, "out/%d-%d.png", x, y);
al_save_bitmap(name, b);
}
}
}
void SpaceSim::LoadAllegro()
{
al_init(); //allegro-5.0.10-monolith-md-debug.lib
//Anti Aliasing
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
//Creating screen
screen_width = 1350;
screen_height = 690;
display = al_create_display(screen_width,screen_height);
al_set_window_position(display,0,0);
al_set_window_title(display, "Domitian Engine");
//Initializing Addons
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_install_keyboard();
al_install_audio();
al_init_acodec_addon();
al_reserve_samples(10);
};
void mw2_Application::Initialize()
{
al_init();
al_init_image_addon();
al_install_keyboard();
al_install_mouse();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_acodec_addon();
al_install_audio();
al_reserve_samples(20); // maximum 20 sounds at a time
al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA);
// this prevents random lag
al_set_new_display_option( ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST );
mWindow = al_create_display(Settings::width, Settings::height);
al_set_window_title(mWindow, Settings::title.c_str());
mw2_Input::Initialize(mWindow);
srand( (unsigned int) std::time(0) );
}
void
init_video (void)
{
if (! al_init_image_addon ())
error (-1, 0, "%s (void): failed to initialize image addon",
__func__);
al_set_new_display_flags (al_get_new_display_flags ()
| (display_mode < 0 ? ALLEGRO_WINDOWED : ALLEGRO_FULLSCREEN)
| ALLEGRO_RESIZABLE
| ALLEGRO_GENERATE_EXPOSE_EVENTS);
display_width = display_width ? display_width : DISPLAY_WIDTH;
display_height = display_height ? display_height : DISPLAY_HEIGHT;
if (display_mode >= 0) {
ALLEGRO_DISPLAY_MODE d;
get_display_mode (display_mode, &d);
display_width = d.width;
display_height = d.height;
al_set_new_display_refresh_rate (d.refresh_rate);
al_set_new_display_flags (al_get_new_display_flags ()
& ~ALLEGRO_FULLSCREEN_WINDOW);
}
al_set_new_display_option (ALLEGRO_SINGLE_BUFFER, 1, ALLEGRO_SUGGEST);
display = al_create_display (display_width, display_height);
if (! display) error (-1, 0, "%s (void): failed to initialize display", __func__);
set_target_backbuffer (display);
al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP);
al_set_window_title (display, WINDOW_TITLE);
icon = load_bitmap (ICON);
al_set_display_icon (display, icon);
cutscene = true;
if (mr.fit_w == 0 && mr.fit_h == 0) {
mr.fit_w = 2;
mr.fit_h = 2;
}
set_multi_room (1, 1);
effect_buffer = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
black_screen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
uscreen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
iscreen = create_bitmap (display_width, display_height);
clear_bitmap (uscreen, TRANSPARENT_COLOR);
video_timer = create_timer (1.0 / EFFECT_HZ);
al_init_font_addon ();
builtin_font = al_create_builtin_font ();
if (! builtin_font)
error (-1, 0, "%s (void): cannot create builtin font", __func__);
if (! al_init_primitives_addon ())
error (-1, 0, "%s (void): failed to initialize primitives addon",
__func__);
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *icons[NUM_ICONS];
ALLEGRO_EVENT_QUEUE *queue;
int u, v;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_keyboard();
al_init_image_addon();
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
}
al_clear_to_color(al_map_rgb_f(0, 0, 0));
al_flip_display();
/* First icon 16x16: Read from file. */
icons[0] = al_load_bitmap("data/cursor.tga");
if (!icons[0]) {
abort_example("icons.tga not found\n");
}
/* Second icon 32x32: Create it. */
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
icons[1] = al_create_bitmap(32, 32);
al_set_target_bitmap(icons[1]);
for (v = 0; v < 32; v++) {
for (u = 0; u < 32; u++) {
al_put_pixel(u, v, al_map_rgb_f(u / 31.0, v / 31.0, 1));
}
}
al_set_target_backbuffer(display);
al_set_display_icons(display, NUM_ICONS, icons);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
for (;;) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_KEY_DOWN &&
event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
}
al_uninstall_system();
return 0;
}
int main() {
ALLEGRO_DISPLAY *display = NULL;
if(!al_init() || !al_init_image_addon()) {
fprintf(stderr, "Não foi possível iniciar o Allegro.\n");
return -1;
}
display = al_create_display(640, 480);
if(!display) {
fprintf(stderr, "Não foi possível iniciar o display.\n");
return -1;
}
ALLEGRO_BITMAP *img1 = NULL, *img2 = NULL, *img3 = NULL, *img4 = NULL;
img1 = al_load_bitmap("A-P.png");
img2 = al_load_bitmap("A-E.png");
img3 = al_load_bitmap("A-C.png");
img4 = al_load_bitmap("A-O.png");
if(!img1 || !img2 || !img3 || !img4) {
fprintf(stderr, "Não foi possível criar a imagem.\n");
return -1;
}
al_clear_to_color(al_map_rgb(0, 150, 0));
al_draw_bitmap(img4, 559, 10, 0);
al_draw_bitmap(img3, 478, 10, 0);
al_draw_bitmap(img2, 397, 10, 0);
al_draw_bitmap(img1, 316, 10, 0);
al_flip_display();
al_rest(10.0);
al_destroy_display(display);
return 0;
}
int main(int argc, char **argv)
{
al_init();
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
al_get_display_mode(al_get_num_display_modes()-1, &disp_data);
//al_set_new_display_flags(ALLEGRO_FULLSCREEN);
al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
disp_data.width*=0.8;
disp_data.height*=0.8;
display=al_create_display(disp_data.width, disp_data.height);
if(!display)
{
return -1;
}
al_clear_to_color(al_map_rgb(0, 0, 0));
al_flip_display();
al_install_keyboard();
al_install_mouse();
al_install_audio();
al_init_acodec_addon();
al_reserve_samples(5);
al_rest(5.0);
al_destroy_display(display);
return 0;
}
GUI::GUI()
{
al_init();
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_install_keyboard();
al_set_new_display_flags(ALLEGRO_WINDOWED);
display = al_create_display(640, 480);
al_set_window_position(display,10,10);
al_set_window_title(display, "Rogue");
timer = al_create_timer(1.0 / TICK_PER_S);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
viewport.view = Rectangle(0,0,640,480);
tiles = al_load_bitmap("Images/Phoebus_tileset.png");
}
int main (void)
{
//cria a variavel para receber a tela
ALLEGRO_DISPLAY *display = NULL;
//inicializa o Allegro
al_init();
//cria a tela com tamanho 400 x 350 (teste: altere os valores)
display = al_create_display(400, 350);
//inicializa o modulo que permite carregar imagens no jogo
al_init_image_addon();
//carrega a imagem louco.jpg e a atribui aa variavel image
ALLEGRO_BITMAP *image = al_load_bitmap("louco.jpg");
//coloca na tela a imagem armazenada na variavel image nas posicoes x=50, y=100
al_draw_bitmap(image, 50, 100, NULL);
//atualiza a tela
al_flip_display();
//pausa a tela por 3.0 segundos
al_rest(3.0);
//destroi a variavel imagem = libera a memoria alocada para ela
al_destroy_bitmap(image);
//destroi a tela criada para o jogo
al_destroy_display(display);
return 0;
}
bool System::initSharedSystem()
{
if (!al_is_system_installed())
{
assert(al_init() && "Failed to initialize Allegro.");
assert(al_inhibit_screensaver(true) && "Failed to inhibit screensaver.");
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_GENERATE_EXPOSE_EVENTS | ALLEGRO_OPENGL_FORWARD_COMPATIBLE | ALLEGRO_OPENGL);
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
}
if (!al_init_image_addon())
{
std::cerr << "Failed to initialize image addon" << std::endl;
return false;
}
if (!al_install_keyboard())
{
std::cerr << "Failed to install keyboard" << std::endl;
return false;
}
if (!al_install_mouse())
{
std::cerr << "Failed to install mouse" << std::endl;
return false;
}
if (!al_install_joystick())
{
std::cerr << "Failed to install joystick" << std::endl;
return false;
}
return true;
}
int main ()
{
/* starting random seed */
srand ((unsigned int) time(NULL));
/* starting allegro 5 */
if (!al_init())
{
al_show_native_message_box(NULL, NULL, "Could not initialize Allegro 5", NULL, NULL, NULL);
return -1;
}
/* starting addons */
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_acodec_addon();
al_install_keyboard();
al_install_mouse();
al_install_audio();
/* calling start menu (windowed) */
start_game(0);
return 0;
}
int main()
{
al_init();
al_init_image_addon();
ALLEGRO_BITMAP *logo = al_load_bitmap("logo_no_alpha.png");
ALLEGRO_BITMAP *shine = al_load_bitmap("shine.png");
int w = al_get_bitmap_width(logo);
int h = al_get_bitmap_height(logo);
ALLEGRO_BITMAP *buf = al_create_bitmap(w, h);
for (int i = 0; i < 20; i++) {
char filename[100];
sprintf(filename, "frame%02d.png", i);
al_set_target_bitmap(buf);
al_clear_to_color(al_map_rgb(0x22, 0x22, 0x22));
float f = (rand() % 1000) / 1000.0 / 2.0;
if (rand() % 2) {
f = f + 0.5;
al_draw_tinted_bitmap(shine, al_map_rgba_f(f, f, f, f), 0, 0, 0);
}
else {
al_draw_bitmap(shine, 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
al_draw_tinted_bitmap(shine, al_map_rgba_f(f, f, f, f), 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
}
al_draw_bitmap(logo, 0, 0, 0);
al_save_bitmap(filename, buf);
}
}
void Engine::Init()
{
done = false;
al_init(); //Initialises the allegro library
al_init_image_addon();
al_init_primitives_addon();
display = al_create_display(WIDTH, HEIGHT);
al_set_window_title(display, "Double Pendulum Simulation");
al_install_keyboard(); //Installs keyboard driver
al_install_mouse(); //installs mouse driver
eventQueue = al_create_event_queue();
al_register_event_source(eventQueue, al_get_display_event_source(display));
al_register_event_source(eventQueue, al_get_keyboard_event_source());
al_register_event_source(eventQueue, al_get_mouse_event_source());
timer = al_create_timer(1.0f / FPS);
al_register_event_source(eventQueue, al_get_timer_event_source(timer));
al_start_timer(timer);
doublePendulum = new DoublePendulum();
doublePendulum->Init(150, 150, 4, 4, 0.5, 0.5, 400, 200);
}
ResourceCache::ResourceCache() {
PHYSFS_init(NULL);
PHYSFS_addToSearchPath("data/images.zip", 1);
PHYSFS_addToSearchPath("data/sounds.zip", 1);
al_init_image_addon();
al_init_acodec_addon();
al_set_physfs_file_interface();
}
Fixture()
: bitmap(NULL)
{
BOOST_REQUIRE_EQUAL(false, al_is_system_installed());
BOOST_REQUIRE_EQUAL(true, al_init());
BOOST_REQUIRE_EQUAL(true, al_init_image_addon());
bitmap = al_load_bitmap(TEST_FILENAME);
}
bool init()
{
if (!al_init())
return false;
if (!al_init_image_addon())
return false;
if (!al_install_keyboard())
return false;
if (!al_install_mouse())
return false;
_eventQueue = al_create_event_queue();
if (!_eventQueue)
return false;
_timer = al_create_timer(1.0f / 30.0f);
if (!_timer)
return (false);
al_register_event_source(_eventQueue, al_get_keyboard_event_source());
al_start_timer(_timer);
_cameraContext = new CameraCtx();
if (!_cameraContext)
return false;
_captureListener = new CaptureListener();
if (!_captureListener)
return false;
_captureDisplay = new CaptureDisplay();
if (!_captureDisplay)
return false;
_slideshowDisplay = new SlideshowDisplay();
if (!_slideshowDisplay)
return false;
_optionParser = new OptionParser();
if (!_optionParser)
return false;
if (!_cameraContext->init())
return false;
if (!_captureListener->init())
return false;
if (!_captureDisplay->init())
return false;
if (!_slideshowDisplay->init())
return false;
if (!_optionParser->init())
return false;
// init subscriptions
sub("stopRunning", [&](){
this->_running = false;
});
return true;
}
void InitAllegro()
{
al_init();
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
al_init_font_addon();
al_init_image_addon();
}
static int initialize(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
if (!al_install_keyboard()) {
printf("Could not init keyboard!\n");
return 0;
}
if (!al_install_mouse()) {
printf("Could not init mouse!\n");
return 0;
}
al_init_acodec_addon();
if (!al_install_audio()) {
printf("Could not init sound!\n");
return 0;
}
if (!al_reserve_samples(16)) {
printf("Could not set up voice and mixer.\n");
return 0;
}
display = al_create_display(640, 228);
if (!display) {
printf("Could not create display!\n");
return 0;
}
basic_font = al_load_font("data/font.tga", 0, 0);
if (!basic_font) {
printf("Could not load font!\n");
return 0;
}
timer = al_create_timer(1.000 / 30);
if (!timer) {
printf("Could not init timer!\n");
return 0;
}
queue = al_create_event_queue();
if (!queue) {
printf("Could not create event queue!\n");
return 0;
}
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
return 1;
}
bool init(int w, int h, bool fullscreen = false) {
// HWND hWndDisplay = NULL;
const char* err;
#define INIT(x, y) if(!(x)) { err = y; goto err; }
mt_seed();
// Allegro initialization
INIT( al_init() &&
al_install_mouse() &&
al_install_keyboard() &&
al_init_image_addon() &&
al_init_primitives_addon(),
"initialize allegro" );
if(fullscreen) al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
INIT(display = al_create_display(w, h), "create display")
al_set_window_title(display, "ŒwiteŸ");
// { auto icon = al_load_bitmap("img\\icon.gif");
// if(icon) al_set_display_icon(display, icon); }
// if(fullscreen) {
// hWndDisplay = al_get_win_window_handle(display);
// SetWindowLong(hWndDisplay, GWL_STYLE, 0);
// ShowWindow(hWndDisplay, SW_MAXIMIZE);
// }
INIT(timer = al_create_timer(1.0 / 60), "create timer")
INIT(event_queue = al_create_event_queue(), "create event queue")
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
// End of Allegro initialization
INIT(setup(display), "initialize renderer");
#undef INIT
return true;
err:
if(display) al_destroy_display(display);
{
char* buf = new char[strlen(err) + 13];
sprintf(buf, "Failed to %s!\n", err);
// MessageBoxA(NULL, buf, "Error", MB_ICONERROR);
delete buf;
}
return false;
}
bool initializeAllegro()
{
// Install Addons
if(!al_init())
{
fprintf(stderr, "failed to initialize allegro!\n");
return false;
}
if(!al_init_image_addon())
{
fprintf(stderr, "failed to initialize al_init_image_addon!\n");
return false;
}
if(!al_install_keyboard())
{
fprintf(stderr, "failed to initialize the keyboard!\n");
return false;
}
if(!al_install_audio())
{
fprintf(stderr, "failed to initialize audio!\n");
return false;
}
if(!al_init_acodec_addon())
{
fprintf(stderr, "failed to initialize audio codecs!\n");
return false;
}
if (!al_reserve_samples(NUM_SAMPLES))
{
fprintf(stderr, "failed to reserve samples!\n");
return false;
}
al_init_font_addon();
if( !al_init_ttf_addon())
{
fprintf(stderr, "failed to init ttf!\n");
return false;
}
//for testing
if (!al_init_primitives_addon())
{
fprintf(stderr, "failed to init primitives!\n");
return false;
}
// All Addons Successfully Installed!
return true;
}
bool GameManager::initialize()
{
if (!al_init())
{
al_show_native_message_box(0,0,"ERROR!!","failed to initalize allegro!!",0,0);
return false;
}
//Creating a display
display = al_create_display(WIDTH,HEIGHT);
if (!display)
{
al_show_native_message_box(0, 0, "ERROR!!", "failed to create display!!", 0, 0);
return false;
}
al_set_window_position(display,0,0);
//Initializing all the addons
al_install_keyboard();
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
//Loading different size fonts for our game
font[LARGE] = al_load_font("Resources/font.ttf", 60, 0);
assert(font[LARGE] != 0); //only one assert is needed
font[MEDIUM] = al_load_font("Resources/font.ttf", 48, 0);
font[SMALL] = al_load_font("Resources/font.ttf", 12, 0);
//Creating event queue
event_queue = al_create_event_queue();
//Setting timer to 60 frames per second
timer = al_create_timer(1.0/(float)FPS);
al_register_event_source(event_queue,al_get_keyboard_event_source());
al_register_event_source(event_queue,al_get_timer_event_source(timer));
gameDone = false;
actSwitched = false;
//Setting current activity to start menu
currentAct = ACT_STARTMENU;
for (int i = 0; i < 6; i++)
keys[i] = false;
draw = false;
return true;
}
bool Framework::initialize(std::string config_filename)
{
if (initialized) return initialized;
if (!al_init()) std::cerr << "al_init() failed" << std::endl;
ALLEGRO_PATH *resource_path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_change_directory(al_path_cstr(resource_path, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(resource_path);
if (!al_install_mouse()) std::cerr << "al_install_mouse() failed" << std::endl;
if (!al_install_keyboard()) std::cerr << "al_install_keyboard() failed" << std::endl;
if (!al_install_joystick()) std::cerr << "al_install_joystick() failed" << std::endl;
if (!al_install_audio()) std::cerr << "al_install_audio() failed" << std::endl;
if (!al_init_native_dialog_addon()) std::cerr << "al_init_native_dialog_addon() failed" << std::endl;
if (!al_init_primitives_addon()) std::cerr << "al_init_primitives_addon() failed" << std::endl;
if (!al_init_image_addon()) std::cerr << "al_init_image_addon() failed" << std::endl;
if (!al_init_font_addon()) std::cerr << "al_init_font_addon() failed" << std::endl;
if (!al_init_ttf_addon()) std::cerr << "al_init_ttf_addon() failed" << std::endl;
if (!al_init_acodec_addon()) std::cerr << "al_init_acodec_addon() failed" << std::endl;
if (!al_reserve_samples(32)) std::cerr << "al_reserve_samples() failed" << std::endl;
srand(time(NULL));
primary_timer = al_create_timer(ALLEGRO_BPS_TO_SECS(60));
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
// al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR | ALLEGRO_MIPMAP);
builtin_font = al_create_builtin_font();
event_queue = al_create_event_queue();
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(primary_timer));
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_default_menu_event_source());
if (al_get_num_joysticks()) joystick = al_get_joystick(0); // make this better eventually
else std::cerr << "no joystick(s) detected" << std::endl;
instance = new Framework(config_filename);
Attributes::create_datatype_definition(
AllegroColorAttributeDatatype::IDENTIFIER,
AllegroColorAttributeDatatype::to_val_func,
AllegroColorAttributeDatatype::to_str_func
);
initialized = true;
return true;
}
int initialize() {
// Initialize Subsystems
Error::initialize();
// Initialize Allegro
al_init();
al_init_image_addon();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA);
return 1;
}
// inicialização do complemento "primitives"
int ImageStart()
{
if (!al_init_image_addon())
{
fprintf(stderr, "Falha ao inicializar complemento image!\n");
return 0;
}
return 1;
}
bool init()
{
if (!al_init())
return false;
if (!al_init_image_addon())
return false;
ILogger::setLogger(new ConsoleLogger);
al_set_new_bitmap_flags(ALLEGRO_MIPMAP | ALLEGRO_MIN_LINEAR);
return true;
}
void init_allegro() {
al_init();
al_install_mouse();
al_install_keyboard();
al_install_audio();
al_install_joystick();
al_init_image_addon();
al_init_primitives_addon();
al_init_acodec_addon();
}
bool main_init_allegro_library() {
/* allegro main library */
if(!al_init()) {
error_message("fail to initialize allegro library");
return false;
}
/* inputs */
if(!al_install_mouse()) {
error_message("fail to install mouse for allegro");
return false;
}
if(!al_install_keyboard()) {
error_message("fail to install keyboard for allegro");
return false;
}
/* outputs */
if(!al_install_audio()) {
error_message("fail to install audio for allegro");
return false;
}
/* addon */
if(!al_init_acodec_addon()) {
error_message("fail to initialize audio codec addon for allegro");
return false;
}
al_init_font_addon();
if(!al_init_ttf_addon()) {
error_message("fail to initialize font addon for allegro");
return false;
}
if(!al_init_image_addon()) {
error_message("fail to initialize image addon for allegro");
return false;
}
if(!al_init_native_dialog_addon()) {
error_message("fail to initialize dialog addon for allegro");
return false;
}
if(!al_init_primitives_addon()) {
error_message("fail to initialize primitive addon for allegro");
return false;
}
/*
* reserve sample for audio output
* reserve amount of samples to 20
* there are 16 balls with different collision sound track
* and 1 background music
*/
if(!al_reserve_samples(20)) {
error_message("fail to reserve sample for audio output");
}
return true;
}
void inicializa_jogo( Jogo* jogo, int x, int y, int largura, int altura ) {
ALLEGRO_DISPLAY *display = NULL;
al_set_new_window_position( x, y );
if(!al_init()) {
fprintf(stderr, "Falha ao inicializar o Allegro!\n");
exit(-1);
}
if (!al_init_primitives_addon()) {
fprintf(stderr, "Falha ao inicializar add-on de primitivas.\n");
exit(-1);
}
if (!al_init_image_addon()) {
fprintf(stderr, "Falha ao inicializar add-on de imagens.\n");
exit(-1);
}
display = al_create_display( largura, altura );
if(!display) {
fprintf(stderr, "Falha ao criar o display!\n");
exit(-1);
}
if (!al_install_keyboard())
{
fprintf(stderr, "Falha ao inicializar o teclado.\n");
exit(-1);
}
jogo->fila_eventos = al_create_event_queue();
if (!jogo->fila_eventos)
{
fprintf(stderr, "Falha ao criar fila de eventos.\n");
exit(-1);
}
jogo->altura = altura;
jogo->largura = largura;
for( int i = 0, x = (jogo->largura / 4 - TAMANHO_BUNKER) / 2;
i < 4;
i++, x += jogo->largura / 4 ) {
inicializa_bunker( &jogo->bunker[i], x, 360 );
}
inicializa_tanque( &jogo->tanque, jogo->largura/2, 475, 0, jogo->largura );
inicializa_zbuffer( &jogo->zbuffer, display, jogo->altura, jogo->largura,
jogo->bunker, &jogo->tanque );
al_register_event_source(jogo->fila_eventos, al_get_keyboard_event_source());
}
void game_init()
{
if( ! al_init() )
EXIT_ON_FAILURE();
if( ! al_install_keyboard() )
EXIT_ON_FAILURE();
if( ! al_init_image_addon() )
EXIT_ON_FAILURE();
if( ! al_init_primitives_addon() )
EXIT_ON_FAILURE();
}
void initGameEngine()
{
if (!al_init()) {
FatalErrorDialog("Allegro 5 core library initialization failed.");
}
if (!al_init_image_addon()){
FatalErrorDialog("Allegro image add-on initialization failed.");
}
if (!al_init_primitives_addon()){
FatalErrorDialog("Allegro primitives add-on initialization failed.");
}
}
