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);
};
int allegro_initialization(int widht, int height)
{
if(!al_init())
{
al_show_native_message_box(display, "Error", "Error", "Failed to initialize allegro!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
//else
// printf("Allegro initialized\n");
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
display = al_create_display(widht, height);
if(!display)
{
al_show_native_message_box(display, "Error", "Error", "failed to create display!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
//else
// printf("Display created\n");
event_queue = al_create_event_queue();
if(!event_queue)
{
al_show_native_message_box(display, "Error", "Error", "failed to create event_queue!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return -1;
}
//else
// printf("Event queue created\n");
al_flush_event_queue(event_queue);
al_init_font_addon();
al_init_ttf_addon();
font = al_load_ttf_font("C:\\Windows\\Fonts\\cour.ttf", TEXT_SIZE, 0);
font_scale = al_load_ttf_font("C:\\Windows\\Fonts\\cour.ttf", TEXT_SIZE, 0);
if(!font || !font_scale)
{
al_destroy_event_queue(event_queue);
al_show_native_message_box(display, "Error", "Error", "Failed to initialize font!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return -1;
}
//else
// printf("Fonts installed\n");
al_install_keyboard();
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
ALLEGRO_EVENT ev;
al_init_primitives_addon();
al_clear_to_color(al_map_rgb(0,0,20));
//al_flip_display();
return 0;
}
int
main (int argc, char **argv)
{
g_type_init ();
al_init ();
al_init_image_addon ();
al_set_new_display_option (ALLEGRO_RED_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_GREEN_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_BLUE_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_ALPHA_SIZE, 8, ALLEGRO_REQUIRE);
/* Nouveau = good */
/* al_set_new_display_option (ALLEGRO_AUX_BUFFERS, 4, ALLEGRO_REQUIRE); */
al_set_new_display_flags (ALLEGRO_WINDOWED | ALLEGRO_OPENGL);
ALLEGRO_DISPLAY *disp;
disp = al_create_display (640, 480);
xassert (disp);
g_xassert (al_get_opengl_extension_list ()->ALLEGRO_GL_ARB_depth_texture);
g_xassert (al_get_opengl_extension_list ()->ALLEGRO_GL_ARB_framebuffer_object);
al_set_target_backbuffer (disp);
printf ("OPENGL %x\n", al_get_opengl_version ());
blender_bmp = al_load_bitmap ("../data/n1img0.bmp");
g_xassert (640 == al_get_bitmap_width (blender_bmp) &&
480 == al_get_bitmap_height (blender_bmp));
blender_tex = al_get_opengl_texture (blender_bmp);
g_xassert (blender_tex);
GLint glvar;
/* Query GL_MAX_DRAW_BUFFERS, GL_MAX_COLOR_ATTACHMENTS */
glGetIntegerv (GL_MAX_DRAW_BUFFERS, &glvar);
xassert (4 <= glvar);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &glvar);
xassert (4 <= glvar);
derp ();
al_flip_display ();
al_rest (2);
return EXIT_SUCCESS;
}
Terminal::Terminal(std::string const& fontPath, int charWidth, int charHeight, int width, int height)
{
this->width = width;
this->height = height;
this->charWidth = charWidth;
this->charHeight = charHeight;
// init addons
if (!al_init_image_addon())
THROW() << "Failed to init image addon";
if (!al_init_primitives_addon())
THROW() << "Failed to init primitives addon";
// load the font
glyphSheet = al_load_bitmap(fontPath.c_str());
if (!glyphSheet)
THROW() << "Failed to load font: " << fontPath;
// create the glyphs
for (int y = 0; y < GLYPH_ROWS; ++y) {
for (int x = 0; x < GLYPH_COLUMNS; ++x) {
ALLEGRO_BITMAP* glyph = al_create_sub_bitmap(glyphSheet, x * charWidth, y * charHeight, charWidth, charHeight);
if (!glyph)
THROW() << "Failed to create glyphs";
al_convert_mask_to_alpha(glyph, al_map_rgb(0, 0, 0));
glyphs.push_back(glyph);
}
}
// create the window
al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
display = al_create_display(width * charWidth, height * charHeight);
if (!display)
THROW() << "Failed to create display";
al_clear_to_color(al_map_rgb(0, 0, 0));
// create the character arrays
for (int i = 0; i < width * height; i++) {
chars.push_back(CharData(' ', white, black));
oldChars.push_back(CharData('?', white, black));
// we make oldChars different to force a refresh
}
foregroundColor = white;
backgroundColor = black;
cursorX = cursorY = 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__);
}
void Framework::InitialiseDisplay()
{
#ifdef WRITE_LOG
printf( "Framework: Initialise Display\n" );
#endif
int scrW = 800;
int scrH = 480;
bool scrFS = false;
if( Settings->KeyExists( "Visual.ScreenWidth" ) )
{
Settings->GetIntegerValue( "Visual.ScreenWidth", &scrW );
}
if( Settings->KeyExists( "Visual.ScreenHeight" ) )
{
Settings->GetIntegerValue( "Visual.ScreenHeight", &scrH );
}
if( Settings->KeyExists( "Visual.FullScreen" ) )
{
Settings->GetBooleanValue( "Visual.FullScreen", &scrFS );
}
if( scrFS )
{
al_set_new_display_flags( ALLEGRO_FULLSCREEN_WINDOW );
}
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
displaySurface = al_create_display( scrW, scrH );
if( displaySurface == 0 )
{
return;
}
al_set_blender( ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA );
al_register_event_source( eventQueue, al_get_display_event_source( displaySurface ) );
}
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) );
}
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;
}
bool Window::create(int width, int height, Window::WindowMode windowMode) {
assert(mDisplay == 0 && mEventQueue == 0);
switch (windowMode) {
case Windowed:
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL); break;
case Resizable:
al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_OPENGL); break;
case FullScreen:
al_set_new_display_flags(ALLEGRO_FULLSCREEN | ALLEGRO_OPENGL); break;
}
mWindowMode = windowMode;
al_set_new_display_option(ALLEGRO_DEPTH_SIZE,0,ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SUPPORT_NPOT_BITMAP,1,ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_CAN_DRAW_INTO_BITMAP,1,ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_COMPATIBLE_DISPLAY,1,ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_VSYNC, 2, ALLEGRO_SUGGEST);
mDisplay = al_create_display(width, height);
if (mDisplay == 0) {
error(U"Creating a window failed");
//If fullscreen, try windowed
if (windowMode == FullScreen) {
return create(width, height);
}
else {
return false;
}
}
mEventQueue = al_create_event_queue();
al_register_event_source(mEventQueue, al_get_display_event_source(mDisplay));
mBackgroundColor = al_map_rgb(0,0,0);
activate();
return true;
}
void GameEngine::Init()
{
done = false;
input = new InputHandler();
collisionDetector = new CollisionDetector();
menuState = new State_Menu();
gameState = new State_Game();
states.push_back(menuState);
states.push_back(gameState);
al_init(); //Initialises the allegro library
al_install_keyboard();
al_install_mouse();
al_set_new_display_flags(ALLEGRO_RESIZABLE);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 6, ALLEGRO_SUGGEST);
display = al_create_display(WIDTH, HEIGHT);
al_set_window_title(display, "Vinctus Arce");
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);
PushState(menuState);
}
bool Init()
{
if (LoadConfigurationData(applicationConfig, styleConfig) == false)
return false;
al_init();
if (applicationConfig.bfullscreen == true)
{
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
}
al_set_app_name(applicationConfig.strAppName.c_str());
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_REQUIRE);
display = al_create_display(applicationConfig.iDispW, applicationConfig.iDispH);
al_install_keyboard();
al_install_mouse();
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
timer = al_create_timer(applicationConfig.dFps);
queue = al_create_event_queue();
textFont = al_load_ttf_font(styleConfig.strFontPath.c_str(), styleConfig.iFontSize, NULL);
if ((display == nullptr) || (timer == nullptr) || (queue == nullptr) || (textFont == nullptr))
{
std::cout << "ERROR: Either the display, timer, queue or font failed to initialize!" << std::endl
<< "0x" << display << " 0x" << timer << " 0x" << queue << " 0x" << textFont << std::endl;
return false;
}
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 true;
}
void
error_display(const char *text)
{
ALLEGRO_DISPLAY *disp;
ALLEGRO_EVENT_QUEUE *ev_queue;
ALLEGRO_FONT *font;
al_init();
al_install_keyboard();
al_install_mouse();
al_init_font_addon();
al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
disp = al_create_display(640, 480);
al_set_window_title(disp, "mruby-minigame");
ev_queue = al_create_event_queue();
al_register_event_source(ev_queue, al_get_display_event_source(disp));
al_register_event_source(ev_queue, al_get_keyboard_event_source());
al_register_event_source(ev_queue, al_get_mouse_event_source());
font = al_create_builtin_font();
for (;;) {
ALLEGRO_EVENT ev;
while (al_get_next_event(ev_queue, &ev)) {
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) goto done;
}
al_clear_to_color(al_map_rgb(200, 120, 120));
al_draw_multiline_text(font, al_map_rgb(255, 255, 255), 64, 64, 640-64, 10, ALLEGRO_ALIGN_LEFT, text);
al_flip_display();
}
done:
return;
}
bool DisplayResource::load(void)
{
#ifdef ALLEGRO_IPHONE
int flags = ALLEGRO_FULLSCREEN_WINDOW;
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS, ALLEGRO_DISPLAY_ORIENTATION_LANDSCAPE, ALLEGRO_REQUIRE);
#else
int flags = useFullScreenMode ? ALLEGRO_FULLSCREEN : ALLEGRO_WINDOWED;
#endif
al_set_new_display_flags(flags);
display = al_create_display(BB_W, BB_H);
if (!display)
return false;
#ifndef ALLEGRO_IPHONE
ALLEGRO_BITMAP *bmp = al_load_bitmap(getResource("gfx/icon48.png"));
al_set_display_icon(display, bmp);
al_destroy_bitmap(bmp);
#endif
BB_W = al_get_display_width(display);
BB_H = al_get_display_height(display);
#ifdef ALLEGRO_IPHONE
if (BB_W < 960) {
BB_W *= 2;
BB_H *= 2;
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_scale_transform(&t, 0.5, 0.5);
al_use_transform(&t);
}
#endif
events = al_create_event_queue();
al_register_event_source(events, al_get_display_event_source(display));
return true;
}
int init_allegro(Camera *cam)
{
if (!al_init())
return 1;
if (!al_install_mouse())
return 1;
if (!al_install_keyboard())
return 1;
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL | ALLEGRO_OPENGL_FORWARD_COMPATIBLE | ALLEGRO_RESIZABLE);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
dpy = al_create_display(cam->left + cam->width, cam->bottom + cam->height);
glViewport(cam->left, cam->bottom, cam->width, cam->height);
ev_queue = al_create_event_queue();
al_register_event_source(ev_queue, al_get_display_event_source(dpy));
al_register_event_source(ev_queue, al_get_mouse_event_source());
al_register_event_source(ev_queue, al_get_keyboard_event_source());
return 0;
}
static bool
init(void)
{
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro.\n");
return false;
}
if(!al_install_keyboard()) {
fprintf(stderr, "failed to initialize keyboard.\n");
return false;
}
if(!al_init_image_addon()) {
fprintf(stderr, "failed to initialize image system.\n");
return false;
}
al_init_font_addon();
if(!al_init_ttf_addon()) {
fprintf(stderr, "failed to initialize ttf system.\n");
return false;
}
/* sound */
if(!al_install_audio()) {
fprintf(stderr, "failed to initialize audio system.\n");
return false;
}
if(!al_init_acodec_addon()) {
fprintf(stderr, "failed to initialize audio codecs.\n");
return false;
}
if(!al_reserve_samples(10)) {
fprintf(stderr, "failed to reserve audio samples.\n");
return false;
}
/* fonts */
asteroids.small_font = al_load_ttf_font("data/vectorb.ttf", 12, 0);
asteroids.large_font = al_load_ttf_font("data/vectorb.ttf", 24, 0);
/* lives sprite */
asteroids.lives_sprite = al_load_bitmap("data/sprites/ship/ship.png");
if(!asteroids.lives_sprite) {
fprintf(stderr, "failed to load lives sprite.\n");
return false;
}
/* sprite preloading */
if(!level_init())
return false;
if(!ship_init())
return false;
if(!missile_init())
return false;
if(!saucer_init())
return false;
if(!asteroid_init())
return false;
if(!explosion_init())
return false;
asteroids.timer = al_create_timer(1.0 / FPS);
if(!asteroids.timer) {
fprintf(stderr, "failed to create timer.\n");
return false;
}
asteroids.event_queue = al_create_event_queue();
if(!asteroids.event_queue) {
fprintf(stderr, "failed to create event queue.\n");
return false;
}
if(FULLSCREEN)
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
asteroids.display = al_create_display(SCREEN_W, SCREEN_H);
if(!asteroids.display) {
fprintf(stderr, "failed to create display.\n");
return false;
}
/* TODO: show on mouse movement */
al_hide_mouse_cursor(asteroids.display);
al_register_event_source(asteroids.event_queue, al_get_display_event_source(asteroids.display));
al_register_event_source(asteroids.event_queue, al_get_timer_event_source(asteroids.timer));
al_register_event_source(asteroids.event_queue, al_get_keyboard_event_source());
return true;
}
int main(void)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_MONITOR_INFO info;
int w = 640, h = 480;
bool done = false;
bool need_redraw = true;
bool background = false;
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
return 1;
}
if (!al_init_image_addon()) {
abort_example("Failed to init IIO addon.\n");
return 1;
}
al_init_font_addon();
if (!al_init_ttf_addon()) {
abort_example("Failed to init TTF addon.\n");
return 1;
}
al_get_num_video_adapters();
al_get_monitor_info(0, &info);
#ifdef ALLEGRO_IPHONE
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
#endif
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS,
ALLEGRO_DISPLAY_ORIENTATION_ALL, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 8, ALLEGRO_SUGGEST);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
example.display = al_create_display(w, h);
if (!example.display) {
abort_example("Error creating display.\n");
return 1;
}
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
return 1;
}
example.font = al_load_font("data/DejaVuSans.ttf", 40, 0);
if (!example.font) {
abort_example("Error loading data/DejaVuSans.ttf\n");
return 1;
}
example.font2 = al_load_font("data/DejaVuSans.ttf", 12, 0);
if (!example.font2) {
abort_example("Error loading data/DejaVuSans.ttf\n");
return 1;
}
example.mysha = al_load_bitmap("data/mysha.pcx");
if (!example.mysha) {
abort_example("Error loading data/mysha.pcx\n");
return 1;
}
example.obp = al_load_bitmap("data/obp.jpg");
if (!example.obp) {
abort_example("Error loading data/obp.jpg\n");
return 1;
}
init();
timer = al_create_timer(1.0 / FPS);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_display_event_source(example.display));
al_start_timer(timer);
while (!done) {
ALLEGRO_EVENT event;
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!background && need_redraw && al_is_event_queue_empty(queue)) {
double t = -al_get_time();
redraw();
t += al_get_time();
example.direct_speed_measure = t;
al_flip_display();
need_redraw = false;
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_CHAR:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
background = true;
al_acknowledge_drawing_halt(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
background = false;
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
break;
case ALLEGRO_EVENT_TIMER:
update();
need_redraw = true;
break;
}
}
return 0;
}
bool Renderer::init(Minecraft *mc, const char *argv0)
{
NBT_Debug("begin");
al_set_org_name("mctools");
al_set_app_name("viewer");
if(!al_init())
{
NBT_Debug("al_init failed???");
return false;
}
ALLEGRO_TIMER *tmr = nullptr;
ALLEGRO_EVENT_QUEUE *queue = nullptr;
ALLEGRO_DISPLAY *dpy = nullptr;
ALLEGRO_BITMAP *bmp = nullptr;
ALLEGRO_TRANSFORM *def_trans = nullptr;
ALLEGRO_FONT *fnt = nullptr;
if(!al_install_keyboard())
goto init_failed;
if(!al_install_mouse())
goto init_failed;
if(!al_init_primitives_addon())
goto init_failed;
if(!al_init_image_addon())
goto init_failed;
if(!al_init_font_addon())
goto init_failed;
tmr = al_create_timer(1.0/60.0);
if(!tmr)
goto init_failed;
queue = al_create_event_queue();
if(!queue)
goto init_failed;
// do display creation last so a display isn't created and instantly destroyed if any of the
// preceeding initializations fail.
al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_PROGRAMMABLE_PIPELINE | ALLEGRO_OPENGL_3_0);
//al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
//al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 24, ALLEGRO_REQUIRE);
dpy = al_create_display(800, 600);
if(!dpy)
{
NBT_Debug("display creation failed");
goto init_failed;
}
if(!al_get_opengl_extension_list()->ALLEGRO_GL_EXT_framebuffer_object)
{
NBT_Debug("FBO GL extension is missing. bail");
goto init_failed;
}
glGenVertexArrays(1, &vao_);
glBindVertexArray(vao_);
NBT_Debug("load shaders");
if(!loadShaders("shaders/default.vtx", "shaders/default.pxl"))
{
NBT_Debug("shader init failed");
goto init_failed;
}
NBT_Debug("load allegro shaders");
if(!loadAllegroShaders())
{
NBT_Debug("allegro shader init failed");
goto init_failed;
}
glBindVertexArray(0);
NBT_Debug("create resource manager");
resManager_ = new ResourceManager(this);
if(!resManager_->init(mc, argv0))
{
NBT_Debug("failed to init resource manager");
goto init_failed;
}
fnt = al_create_builtin_font();
if(!fnt)
{
NBT_Debug("failed to create builtin font");
goto init_failed;
}
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(dpy));
al_register_event_source(queue, al_get_timer_event_source(tmr));
def_trans = al_get_projection_transform(dpy);
al_copy_transform(&al_proj_transform_, def_trans);
al_identity_transform(&camera_transform_);
rx_look = 0.0;
queue_ = queue;
tmr_ = tmr;
dpy_ = dpy;
bmp_ = bmp;
fnt_ = fnt;
grab_mouse_ = false;
// initial clear display
// make things look purdy
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
NBT_Debug("end");
return true;
init_failed:
delete resManager_;
resManager_ = nullptr;
if(fnt)
al_destroy_font(fnt);
if(dpy)
al_destroy_display(dpy);
if(queue)
al_destroy_event_queue(queue);
al_uninstall_system();
NBT_Debug("end");
return false;
}
int main()
{
al_init();
al_install_mouse();
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
ALLEGRO_DISPLAY *display;
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL);
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 24, ALLEGRO_REQUIRE);
display = al_create_display(800, 600);
if(!display)
{
std::cout<<"Failed to create display"<<std::endl;
return 0;
}
ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue();
al_register_event_source(event_queue, (ALLEGRO_EVENT_SOURCE *)display);
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
if(!Init())
return 0;
double last_time = al_current_time();
bool quit = false;
while(1)
{
ALLEGRO_EVENT event;
while (al_get_next_event(event_queue, &event))
{
if (ALLEGRO_EVENT_KEY_DOWN == event.type)
{
if (ALLEGRO_KEY_ESCAPE == event.keyboard.keycode)
{
quit = true;
}
}
if (ALLEGRO_EVENT_DISPLAY_CLOSE == event.type)
{
quit = true;
}
Event(event);
}
if (quit)
break;
double current_time = al_current_time();
double dt = current_time - last_time;
last_time = current_time;
Update(dt);
al_clear_to_color(al_map_rgb(0, 0, 0));
Render();
al_flip_display();
al_rest(0.001);
}
al_destroy_event_queue(event_queue);
al_destroy_display(display);
return 0;
}
/* 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;
}
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 main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display, *ms_display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
ALLEGRO_BITMAP *memory;
char title[1024];
bool quit = false;
bool redraw = true;
int wx, wy;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Couldn't initialise Allegro.\n");
}
al_init_primitives_addon();
al_install_keyboard();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
memory = create_bitmap();
/* Create the normal display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 0, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 0, ALLEGRO_SUGGEST);
display = al_create_display(300, 450);
if (!display) {
abort_example("Error creating display\n");
}
al_set_window_title(display, "Normal");
/* Create bitmaps for the normal display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal = al_clone_bitmap(memory);
font = al_create_builtin_font();
al_get_window_position(display, &wx, &wy);
if (wx < 160)
wx = 160;
/* Create the multi-sampling display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
ms_display = al_create_display(300, 450);
if (!ms_display) {
abort_example("Multisampling not available.\n");
}
sprintf(title, "Multisampling (%dx)", al_get_display_option(
ms_display, ALLEGRO_SAMPLES));
al_set_window_title(ms_display, title);
/* Create bitmaps for the multi-sampling display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter_ms = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal_ms = al_clone_bitmap(memory);
font_ms = al_create_builtin_font();
/* Move the windows next to each other, because some window manager
* would put them on top of each other otherwise.
*/
al_set_window_position(display, wx - 160, wy);
al_set_window_position(ms_display, wx + 160, wy);
timer = al_create_timer(1.0 / 30.0);
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_display_event_source(ms_display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (!quit) {
ALLEGRO_EVENT event;
/* Check for ESC key or close button event and quit in either case. */
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
quit = true;
break;
case ALLEGRO_EVENT_TIMER:
bitmap_move();
redraw = true;
break;
}
if (redraw && al_is_event_queue_empty(queue)) {
/* Draw the multi-sampled version into the first window. */
al_set_target_backbuffer(ms_display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter_ms, 0, "filtered, multi-sample");
draw(bitmap_normal_ms, 250, "no filter, multi-sample");
al_flip_display();
/* Draw the normal version into the second window. */
al_set_target_backbuffer(display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter, 0, "filtered");
draw(bitmap_normal, 250, "no filter");
al_flip_display();
redraw = false;
}
}
return 0;
}
int main(void)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_MONITOR_INFO info;
int w = 640, h = 480;
bool done = false;
bool need_redraw = true;
bool background = false;
example.show_help = true;
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
return 1;
}
if (!al_init_image_addon()) {
abort_example("Failed to init IIO addon.\n");
return 1;
}
al_init_font_addon();
al_get_num_video_adapters();
al_get_monitor_info(0, &info);
#ifdef ALLEGRO_IPHONE
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
#endif
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS,
ALLEGRO_DISPLAY_ORIENTATION_ALL, ALLEGRO_SUGGEST);
example.display = al_create_display(w, h);
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!example.display) {
abort_example("Error creating display.\n");
return 1;
}
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
return 1;
}
if (!al_install_mouse()) {
abort_example("Error installing mouse.\n");
return 1;
}
example.font = al_load_font("data/fixed_font.tga", 0, 0);
if (!example.font) {
abort_example("Error loading data/fixed_font.tga\n");
return 1;
}
example.mysha = al_load_bitmap("data/mysha256x256.png");
if (!example.mysha) {
abort_example("Error loading data/mysha256x256.png\n");
return 1;
}
example.white = al_map_rgb_f(1, 1, 1);
example.half_white = al_map_rgba_f(1, 1, 1, 0.5);
example.dark = al_map_rgb(15, 15, 15);
example.red = al_map_rgb_f(1, 0.2, 0.1);
change_size(256);
add_sprite();
add_sprite();
timer = al_create_timer(1.0 / FPS);
queue = al_create_event_queue();
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_timer_event_source(timer));
if (al_install_touch_input())
al_register_event_source(queue, al_get_touch_input_event_source());
al_register_event_source(queue, al_get_display_event_source(example.display));
al_start_timer(timer);
while (!done) {
float x, y;
ALLEGRO_EVENT event;
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!background && need_redraw && al_is_event_queue_empty(queue)) {
double t = -al_get_time();
add_time();
al_clear_to_color(al_map_rgb_f(0, 0, 0));
redraw();
t += al_get_time();
example.direct_speed_measure = t;
al_flip_display();
need_redraw = false;
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_CHAR: /* includes repeats */
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
else if (event.keyboard.keycode == ALLEGRO_KEY_UP) {
add_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_DOWN) {
remove_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_LEFT) {
change_size(example.bitmap_size - 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_RIGHT) {
change_size(example.bitmap_size + 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_F1) {
example.show_help ^= 1;
}
else if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_B) {
example.blending++;
if (example.blending == 4)
example.blending = 0;
}
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
background = true;
al_acknowledge_drawing_halt(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
background = false;
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
break;
case ALLEGRO_EVENT_TIMER:
update();
need_redraw = true;
break;
case ALLEGRO_EVENT_TOUCH_BEGIN:
x = event.touch.x;
y = event.touch.y;
goto click;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
x = event.mouse.x;
y = event.mouse.y;
goto click;
click:
{
int fh = al_get_font_line_height(example.font);
if (x < 80 && y >= h - fh * 10) {
int button = (y - (h - fh * 10)) / (fh * 2);
if (button == 0) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
if (button == 1) {
example.blending++;
if (example.blending == 4)
example.blending = 0;
}
if (button == 3) {
if (x < 40)
remove_sprites(example.sprite_count / 2);
else
add_sprites(example.sprite_count);
}
if (button == 2) {
int s = example.bitmap_size * 2;
if (x < 40)
s = example.bitmap_size / 2;
change_size(s);
}
if (button == 4) {
example.show_help ^= 1;
}
}
break;
}
}
}
al_destroy_bitmap(example.bitmap);
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_FONT *font;
ALLEGRO_CONFIG *config;
ALLEGRO_EVENT_QUEUE *queue;
bool write = false;
bool flip = false;
bool quit;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_font_addon();
al_init_image_addon();
al_install_keyboard();
al_install_mouse();
/* Read parameters from ex_vsync.ini. */
config = al_load_config_file("ex_vsync.ini");
if (!config) {
config = al_create_config();
write = true;
}
/* 0 -> Driver chooses.
* 1 -> Force vsync on.
* 2 -> Force vsync off.
*/
vsync = option(config, "vsync", 0);
fullscreen = option(config, "fullscreen", 0);
frequency = option(config, "frequency", 0);
/* Write the file back (so a template is generated on first run). */
if (write) {
al_save_config_file("ex_vsync.ini", config);
}
al_destroy_config(config);
/* Vsync 1 means force on, 2 means forced off. */
if (vsync)
al_set_new_display_option(ALLEGRO_VSYNC, vsync, ALLEGRO_SUGGEST);
/* Force fullscreen mode. */
if (fullscreen) {
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
/* Set a monitor frequency. */
if (frequency)
al_set_new_display_refresh_rate(frequency);
}
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display.\n");
}
font = al_load_font("data/a4_font.tga", 0, 0);
if (!font) {
abort_example("Failed to load a4_font.tga\n");
}
queue = al_create_event_queue();
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));
quit = display_warning(queue, font);
al_flush_event_queue(queue);
while (!quit) {
ALLEGRO_EVENT event;
/* With vsync, this will appear as a 50% gray screen (maybe
* flickering a bit depending on monitor frequency).
* Without vsync, there will be black/white shearing all over.
*/
if (flip)
al_clear_to_color(al_map_rgb_f(1, 1, 1));
else
al_clear_to_color(al_map_rgb_f(0, 0, 0));
al_flip_display();
flip = !flip;
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
quit = true;
}
}
/* Let's not go overboard and limit flipping at 1000 Hz. Without
* this my system locks up and requires a hard reboot :P
*/
al_rest(0.001);
}
al_destroy_font(font);
al_destroy_event_queue(queue);
return 0;
}
void GameEngine::initialise()
{
if (!al_init())
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_ENGINE_FAILED);
}
if (!al_init_font_addon())
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_FONT_FAILED);
}
if (!al_init_image_addon())
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_IMAGE_FAILED);
}
if (!al_install_keyboard())
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_KEYBOARD_FAILED);
}
if (!al_install_mouse())
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_MOUSE_FAILED);
}
//Temporary Display Options
al_set_new_display_flags(ALLEGRO_OPENGL);
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_option(ALLEGRO_RENDER_METHOD, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_VSYNC, 2, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_CAN_DRAW_INTO_BITMAP, 1, ALLEGRO_SUGGEST);
int originalDisplayFlags = al_get_new_display_flags();
int displayFlags = 0;
if (m_Config->getFullscreen())
{
displayFlags = displayFlags | ALLEGRO_FULLSCREEN_WINDOW | ALLEGRO_NOFRAME;
}
al_set_new_display_flags(displayFlags);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR | ALLEGRO_VIDEO_BITMAP);
if (m_Config->getResolutionWidth() < 0 || m_Config->getResolutionHeight() < 0)
{
ALLEGRO_DISPLAY_MODE largest_display_mode;
al_get_display_mode(al_get_num_display_modes() - 1, &largest_display_mode);
m_Config->setResolutionWidth(largest_display_mode.width);
m_Config->setResolutionHeight(largest_display_mode.height);
//std::cout << m_Config->getResolutionWidth() << " " << m_Config->getResolutionHeight() << endl;
}
m_Display = al_create_display(m_Config->getResolutionWidth(), m_Config->getResolutionHeight());
if (!m_Display)
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_DISPLAY_FAILED);
}
al_set_new_display_flags(originalDisplayFlags);
m_RedrawTimer = al_create_timer(ALLEGRO_BPS_TO_SECS(m_Config->getFrameSpeed()));
if (!m_RedrawTimer)
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_TIMER_FAILED);
}
m_EventQueue = al_create_event_queue();
if (!m_EventQueue)
{
THROW_GAME_EXCEPTION(EXCEP_ALLEG_EQUEUE_FAILED);
}
al_register_event_source(m_EventQueue, al_get_display_event_source(m_Display));
al_register_event_source(m_EventQueue, al_get_timer_event_source(m_RedrawTimer));
al_register_event_source(m_EventQueue, al_get_keyboard_event_source());
}
int main(int argc, char **argv)
{
// Initialize Allegro
if (!al_init())
{
fprintf(stderr, "Fatal Error: Allegro initialization failed!\n");
return -1;
}
// Initialize the Allegro Image addon, used to load sprites and maps
if (!al_init_image_addon())
{
fprintf(stderr, "Fatal Error: Allegro Image Addon initialization failed!\n");
return -1;
}
// Initialize primitives for drawing
if (!al_init_primitives_addon())
{
fprintf(stderr, "Fatal Error: Could not initialize primitives module!");
throw -1;
}
// Initialize keyboard modules
if (!al_install_keyboard())
{
fprintf(stderr, "Fatal Error: Could not initialize keyboard module!");
throw -1;
}
// Initialize mouse
if (!al_install_mouse())
{
fprintf(stderr, "Fatal Error: Could not initialize mouse module!");
throw -1;
}
// Initialize networking system
if (enet_initialize())
{
fprintf(stderr, "Fatal Error: Could not initialize enet!");
throw -1;
}
// Create a display
ALLEGRO_DISPLAY *display;
al_set_new_display_option(ALLEGRO_VSYNC, 2, ALLEGRO_REQUIRE);
al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_RESIZABLE);
display = al_create_display(1280, 720);
if(!display)
{
// FIXME: Make the error argument mean anything?
fprintf(stderr, "Fatal Error: Could not create display\n");
throw -1;
}
//load font
//gg2 font as placeholder for now i guess
al_init_font_addon();
al_init_ttf_addon();
ALLEGRO_FONT *font = al_load_font("Vanguard Main Font.ttf", 12, ALLEGRO_TTF_MONOCHROME);
if (!font)
{
fprintf(stderr, "Could not load 'gg2bold.ttf'.\n");
throw -1;
}
// MainMenu *mainmenu = new MainMenu(display);
bool isserver;
if (argc >= 2)
{
// If there are any arguments
isserver = false;
}
else
{
isserver = true;
}
// double lasttimeupdated = al_get_time();
// bool run = true;
// while (run)
// {
// if (al_get_time() - lasttimeupdated >= MENU_TIMESTEP)
// {
// run = mainmenu->run(display, &gametype);
// lasttimeupdated = al_get_time();
// }
// }
// delete mainmenu;
Engine engine(isserver);
Renderer renderer;
InputCatcher inputcatcher(display);
Gamestate renderingstate(&engine);
std::unique_ptr<Networker> networker;
if (isserver)
{
networker = std::unique_ptr<Networker>(new ServerNetworker());
}
else
{
networker = std::unique_ptr<Networker>(new ClientNetworker());
}
engine.loadmap("lijiang");
// FIXME: Hack to make sure the oldstate is properly initialized
engine.update(&(networker->sendbuffer), 0);
EntityPtr myself(0);
if (isserver)
{
myself = engine.currentstate->addplayer();
engine.currentstate->get<Player>(myself)->spawntimer.active = true;
}
else
{
ClientNetworker *n = reinterpret_cast<ClientNetworker*>(networker.get());
while (not n->isconnected())
{
n->receive(engine.currentstate.get());
}
myself = engine.currentstate->playerlist[engine.currentstate->playerlist.size()-1];
}
InputContainer held_keys;
double mouse_x;
double mouse_y;
double enginetime = al_get_time();
double networkertime = al_get_time();
while (true)
{
try
{
while (al_get_time() - enginetime >= ENGINE_TIMESTEP)
{
networker->receive(engine.currentstate.get());
inputcatcher.run(display, &held_keys, &mouse_x, &mouse_y);
if (not isserver)
{
Character *c = engine.currentstate->get<Player>(myself)->getcharacter(engine.currentstate.get());
if (c != 0)
{
ClientNetworker *n = reinterpret_cast<ClientNetworker*>(networker.get());
n->sendinput(held_keys, mouse_x/renderer.zoom+renderer.cam_x, mouse_y/renderer.zoom+renderer.cam_y);
}
}
engine.setinput(myself, held_keys, mouse_x/renderer.zoom+renderer.cam_x, mouse_y/renderer.zoom+renderer.cam_y);
engine.update(&(networker->sendbuffer), ENGINE_TIMESTEP);
networker->sendeventdata(engine.currentstate.get());
enginetime += ENGINE_TIMESTEP;
}
if (isserver)
{
if (al_get_time() - networkertime >= NETWORKING_TIMESTEP)
{
ServerNetworker *n = reinterpret_cast<ServerNetworker*>(networker.get());
n->sendframedata(engine.currentstate.get());
networkertime = al_get_time();
}
}
renderingstate.interpolate(engine.oldstate.get(), engine.currentstate.get(), (al_get_time()-enginetime)/ENGINE_TIMESTEP);
renderer.render(display, &renderingstate, myself, networker.get());
}
catch (int e)
{
if (e != 0)
{
fprintf(stderr, "\nError during regular loop.");
fprintf(stderr, "\nExiting..");
}
al_destroy_display(display);
return 0;
}
}
al_shutdown_font_addon();
al_shutdown_ttf_addon();
al_destroy_display(display);
enet_deinitialize();
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_TIMER *timer;
ALLEGRO_CONFIG *config;
char const *value;
char str[256];
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
init_platform_specific();
/* Read supersampling info from ex_draw.ini. */
ex.samples = 0;
config = al_load_config_file("ex_draw.ini");
if (!config)
config = al_create_config();
value = al_get_config_value(config, "settings", "samples");
if (value)
ex.samples = strtol(value, NULL, 0);
sprintf(str, "%d", ex.samples);
al_set_config_value(config, "settings", "samples", str);
al_save_config_file("ex_draw.ini", config);
al_destroy_config(config);
if (ex.samples) {
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, ex.samples, ALLEGRO_SUGGEST);
}
display = al_create_display(640, 640);
if (!display) {
abort_example("Unable to create display.\n");
}
init();
timer = al_create_timer(1.0 / ex.FPS);
ex.queue = al_create_event_queue();
al_register_event_source(ex.queue, al_get_keyboard_event_source());
al_register_event_source(ex.queue, al_get_mouse_event_source());
al_register_event_source(ex.queue, al_get_display_event_source(display));
al_register_event_source(ex.queue, al_get_timer_event_source(timer));
al_start_timer(timer);
run();
al_destroy_event_queue(ex.queue);
return 0;
}
int main( int argc, char* argv[] )
{
ALLEGRO_EVENT e;
ALLEGRO_TIMER* t;
int64_t framesToUpdate = 0;
if( !al_init() )
{
return -1;
}
al_init_font_addon();
if( !al_install_keyboard() || !al_install_mouse() || !al_init_primitives_addon() || !al_init_ttf_addon() || !al_init_image_addon() )
{
return -1;
}
#if NETWORK_SUPPORT != 0
if( !install_network() )
{
return -1;
}
#endif
#if HTTP_SUPPORT
if( !install_http() )
{
return -1;
}
#ifdef PANDORA
Downloads = new HttpManager(2);
#else
Downloads = new HttpManager(6);
#endif
#endif
#if EXIT_IF_NO_AUDIO != 0
if( !al_install_audio() || !al_init_acodec_addon() )
{
return -1;
}
voice = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_INT16, ALLEGRO_CHANNEL_CONF_2);
if (!voice)
return 1;
mixer = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
if (!mixer)
return 1;
if (!al_attach_mixer_to_voice(mixer, voice))
return 1;
#else
if( al_install_audio() )
{
if( al_init_acodec_addon() )
{
voice = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_INT16, ALLEGRO_CHANNEL_CONF_2);
if( voice != 0 )
{
mixer = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
if( mixer != 0 )
al_attach_mixer_to_voice(mixer, voice);
}
}
}
#endif // EXIT_IF_NO_AUDIO
// Random number is guarenteed to be random
srand( 5 );
GameStack = new StageStack();
CurrentConfiguration = new Configuration();
if( CurrentConfiguration->FullScreen )
al_set_new_display_flags( ALLEGRO_FULLSCREEN_WINDOW );
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
bool foundMode = false;
int fallbackW = 640;
int fallbackH = 480;
if( CurrentConfiguration->ForceResolution )
{
foundMode = true;
} else {
for( int modeIdx = 0; modeIdx < al_get_num_display_modes(); modeIdx++ )
{
if( al_get_display_mode( modeIdx, &ScreenMode ) != NULL )
{
if( ScreenMode.width == CurrentConfiguration->ScreenWidth && ScreenMode.height == CurrentConfiguration->ScreenHeight )
{
foundMode = true;
} else {
fallbackW = ScreenMode.width;
fallbackH = ScreenMode.height;
}
}
if( foundMode )
break;
}
}
if( foundMode )
{
Screen = al_create_display( CurrentConfiguration->ScreenWidth, CurrentConfiguration->ScreenHeight );
} else {
Screen = al_create_display( fallbackW, fallbackH );
CurrentConfiguration->ScreenWidth = fallbackW;
CurrentConfiguration->ScreenHeight = fallbackH;
}
al_hide_mouse_cursor( Screen );
t = al_create_timer( 1.0 / SCREEN_FPS );
if( t == NULL )
Quit = true;
al_start_timer( t );
EventQueue = al_create_event_queue();
al_register_event_source( EventQueue, al_get_display_event_source( Screen ) );
al_register_event_source( EventQueue, al_get_keyboard_event_source() );
al_register_event_source( EventQueue, al_get_mouse_event_source() );
al_register_event_source( EventQueue, al_get_timer_event_source( t ) );
#if NETWORK_SUPPORT != 0
al_register_event_source( EventQueue, get_network_event_source() );
#endif
#if HTTP_SUPPORT
Downloads->urlDownloads = CurrentConfiguration->MaxConcurrentDownloads;
al_register_event_source( EventQueue, get_http_event_source() );
#endif
Fonts = new FontManager();
Images = new ImageManager();
Audio = new SoundManager();
al_set_blender( ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA );
GameStack->Push( (Stage*)new BootUp() );
while( !Quit )
{
if( GameStack->IsEmpty() )
{
Quit = true;
} else {
while( al_get_next_event( EventQueue, &e ) )
{
#if HTTP_SUPPORT
Downloads->Event( &e );
#endif
switch( e.type )
{
case ALLEGRO_EVENT_DISPLAY_CLOSE:
Quit = true;
break;
case ALLEGRO_EVENT_JOYSTICK_CONFIGURATION:
al_reconfigure_joysticks();
break;
case ALLEGRO_EVENT_TIMER:
if( e.timer.source == t )
framesToUpdate++;
else if( !GameStack->IsEmpty() )
GameStack->Current()->Event( &e );
break;
default:
if( !GameStack->IsEmpty() )
GameStack->Current()->Event( &e );
switch( e.type )
{
#if HTTP_SUPPORT
case ALLEGRO_EVENT_HTTP:
#endif
#if NETWORK_SUPPORT
case ALLEGRO_EVENT_NETWORK_CONNECTION:
case ALLEGRO_EVENT_NETWORK_RECEIVEPACKET:
case ALLEGRO_EVENT_NETWORK_DISCONNECTION:
#endif
case ALLEGRO_EVENT_BUTTON_CLICK:
case ALLEGRO_EVENT_MOUSEEX_MOVE:
case ALLEGRO_EVENT_MOUSEEX_DOWN:
case ALLEGRO_EVENT_MOUSEEX_UP:
case ALLEGRO_EVENT_MOUSEEX_CLICK:
case ALLEGRO_EVENT_MOUSEEX_DOUBLECLICK:
case ALLEGRO_EVENT_MOUSEEX_BOXED:
case ALLEGRO_EVENT_MOUSEEX_WHEEL:
al_unref_user_event( &e.user );
break;
}
break;
}
}
if( framesToUpdate > 0 )
{
for( int frmUp = 0; frmUp < framesToUpdate; frmUp++ )
{
if( !GameStack->IsEmpty() )
GameStack->Current()->Update();
}
framesToUpdate = 0;
}
al_clear_to_color( al_map_rgb( 128, 128, 128 ) );
if( !GameStack->IsEmpty() )
GameStack->Current()->Render();
al_flip_display();
Images->Tidy();
Fonts->Tidy();
Audio->Tidy();
}
}
while( !GameStack->IsEmpty() )
{
GameStack->Pop();
}
delete Downloads;
delete Fonts;
delete Images;
delete Audio;
al_destroy_event_queue( EventQueue );
al_destroy_display( Screen );
#if HTTP_SUPPORT
uninstall_http();
#endif
#if NETWORK_SUPPORT != 0
uninstall_network();
#endif
al_uninstall_keyboard();
al_uninstall_mouse();
al_shutdown_primitives_addon();
al_shutdown_ttf_addon();
al_shutdown_image_addon();
al_uninstall_audio();
al_shutdown_font_addon();
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_AUDIO_RECORDER *r;
ALLEGRO_AUDIO_STREAM *s;
ALLEGRO_EVENT_QUEUE *q;
ALLEGRO_DISPLAY *d;
ALLEGRO_FILE *fp = NULL;
ALLEGRO_PATH *tmp_path = NULL;
int prev = 0;
bool is_recording = false;
int n = 0; /* number of samples written to disk */
(void) argc;
(void) argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
if (!al_init_primitives_addon()) {
abort_example("Unable to initialize primitives addon");
}
if (!al_install_keyboard()) {
abort_example("Unable to install keyboard");
}
if (!al_install_audio()) {
abort_example("Unable to initialize audio addon");
}
if (!al_init_acodec_addon()) {
abort_example("Unable to initialize acodec addon");
}
/* Note: increasing the number of channels will break this demo. Other
* settings can be changed by modifying the constants at the top of the
* file.
*/
r = al_create_audio_recorder(1000, samples_per_fragment, frequency,
audio_depth, ALLEGRO_CHANNEL_CONF_1);
if (!r) {
abort_example("Unable to create audio recorder");
}
s = al_create_audio_stream(playback_fragment_count,
playback_samples_per_fragment, frequency, audio_depth,
ALLEGRO_CHANNEL_CONF_1);
if (!s) {
abort_example("Unable to create audio stream");
}
al_reserve_samples(0);
al_set_audio_stream_playing(s, false);
al_attach_audio_stream_to_mixer(s, al_get_default_mixer());
q = al_create_event_queue();
/* Note: the following two options are referring to pixel samples, and have
* nothing to do with audio samples. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
d = al_create_display(320, 256);
if (!d) {
abort_example("Error creating display\n");
}
al_set_window_title(d, "SPACE to record. P to playback.");
al_register_event_source(q, al_get_audio_recorder_event_source(r));
al_register_event_source(q, al_get_audio_stream_event_source(s));
al_register_event_source(q, al_get_display_event_source(d));
al_register_event_source(q, al_get_keyboard_event_source());
al_start_audio_recorder(r);
while (true) {
ALLEGRO_EVENT e;
al_wait_for_event(q, &e);
if (e.type == ALLEGRO_EVENT_AUDIO_RECORDER_FRAGMENT) {
/* We received an incoming fragment from the microphone. In this
* example, the recorder is constantly recording even when we aren't
* saving to disk. The display is updated every time a new fragment
* comes in, because it makes things more simple. If the fragments
* are coming in faster than we can update the screen, then it will be
* a problem.
*/
ALLEGRO_AUDIO_RECORDER_EVENT *re = al_get_audio_recorder_event(&e);
audio_buffer_t input = (audio_buffer_t) re->buffer;
int sample_count = re->samples;
const int R = sample_count / 320;
int i, gain = 0;
/* Calculate the volume, and display it regardless if we are actively
* recording to disk. */
for (i = 0; i < sample_count; ++i) {
if (gain < abs(input[i] - sample_center))
gain = abs(input[i] - sample_center);
}
al_clear_to_color(al_map_rgb(0,0,0));
if (is_recording) {
/* Save raw bytes to disk. Assumes everything is written
* succesfully. */
if (fp && n < frequency / (float) samples_per_fragment *
max_seconds_to_record) {
al_fwrite(fp, input, sample_count * sample_size);
++n;
}
/* Draw a pathetic visualization. It draws exactly one fragment
* per frame. This means the visualization is dependent on the
* various parameters. A more thorough implementation would use this
* event to copy the new data into a circular buffer that holds a
* few seconds of audio. The graphics routine could then always
* draw that last second of audio, which would cause the
* visualization to appear constant across all different settings.
*/
for (i = 0; i < 320; ++i) {
int j, c = 0;
/* Take the average of R samples so it fits on the screen */
for (j = i * R; j < i * R + R && j < sample_count; ++j) {
c += input[j] - sample_center;
}
c /= R;
/* Draws a line from the previous sample point to the next */
al_draw_line(i - 1, 128 + ((prev - min_sample_val) /
(float) sample_range) * 256 - 128, i, 128 +
((c - min_sample_val) / (float) sample_range) * 256 - 128,
al_map_rgb(255,255,255), 1.2);
prev = c;
}
}
/* draw volume bar */
al_draw_filled_rectangle((gain / (float) max_sample_val) * 320, 251,
0, 256, al_map_rgba(0, 255, 0, 128));
al_flip_display();
}
else if (e.type == ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT) {
/* This event is received when we are playing back the audio clip.
* See ex_saw.c for an example dedicated to playing streams.
*/
if (fp) {
audio_buffer_t output = al_get_audio_stream_fragment(s);
if (output) {
/* Fill the buffer from the data we have recorded into the file.
* If an error occurs (or end of file) then silence out the
* remainder of the buffer and stop the playback.
*/
const size_t bytes_to_read =
playback_samples_per_fragment * sample_size;
size_t bytes_read = 0, i;
do {
bytes_read += al_fread(fp, (uint8_t *)output + bytes_read,
bytes_to_read - bytes_read);
} while (bytes_read < bytes_to_read && !al_feof(fp) &&
!al_ferror(fp));
/* silence out unused part of buffer (end of file) */
for (i = bytes_read / sample_size;
i < bytes_to_read / sample_size; ++i) {
output[i] = sample_center;
}
al_set_audio_stream_fragment(s, output);
if (al_ferror(fp) || al_feof(fp)) {
al_drain_audio_stream(s);
al_fclose(fp);
fp = NULL;
}
}
}
}
else if (e.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (e.type == ALLEGRO_EVENT_KEY_CHAR) {
if (e.keyboard.unichar == 27) {
/* pressed ESC */
break;
}
else if (e.keyboard.unichar == ' ') {
if (!is_recording) {
/* Start the recording */
is_recording = true;
if (al_get_audio_stream_playing(s)) {
al_drain_audio_stream(s);
}
/* Reuse the same temp file for all recordings */
if (!tmp_path) {
fp = al_make_temp_file("alrecXXX.raw", &tmp_path);
}
else {
if (fp) al_fclose(fp);
fp = al_fopen(al_path_cstr(tmp_path, '/'), "w");
}
n = 0;
}
else {
is_recording = false;
if (fp) {
al_fclose(fp);
fp = NULL;
}
}
}
else if (e.keyboard.unichar == 'p') {
/* Play the previously recorded wav file */
if (!is_recording) {
if (tmp_path) {
fp = al_fopen(al_path_cstr(tmp_path, '/'), "r");
if (fp) {
al_set_audio_stream_playing(s, true);
}
}
}
}
}
}
/* clean up */
al_destroy_audio_recorder(r);
al_destroy_audio_stream(s);
if (fp)
al_fclose(fp);
if (tmp_path) {
al_remove_filename(al_path_cstr(tmp_path, '/'));
al_destroy_path(tmp_path);
}
return 0;
}
int main(void)
{
GLuint pid;
ALLEGRO_DISPLAY *d;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
int frames = 0;
double start;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_set_new_display_flags(ALLEGRO_OPENGL);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
d = al_create_display(WINDOW_W, WINDOW_H);
if (!d) {
abort_example("Unable to open a OpenGL display.\n");
return -1;
}
if (al_get_display_option(ALLEGRO_SAMPLE_BUFFERS)) {
printf("With multisampling, level %i\n", al_get_display_option(ALLEGRO_SAMPLES));
}
else {
printf("Without multisampling.\n");
}
al_install_keyboard();
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(d));
if (al_get_opengl_extension_list()->ALLEGRO_GL_ARB_multisample) {
glEnable(GL_MULTISAMPLE_ARB);
}
if (!al_get_opengl_extension_list()->ALLEGRO_GL_ARB_vertex_program) {
abort_example("This example requires a video card that supports "
" the ARB_vertex_program extension.\n");
return -1;
}
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_CULL_FACE);
/* Setup projection and modelview matrices */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, WINDOW_W/(float)WINDOW_H, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Position the camera to look at our mesh from a distance */
gluLookAt(0.0f, 20.0f, -45.0f, 0.0f, 0.0f, 0.0f, 0, 1, 0);
create_mesh();
/* Define the vertex program */
glEnable(GL_VERTEX_PROGRAM_ARB);
glGenProgramsARB(1, &pid);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, pid);
glGetError();
if (al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option) {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program_nv), program_nv);
}
else {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program), program);
}
/* Check for errors */
if (glGetError()) {
const char *pgm = al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option
? program_nv : program;
GLint error_pos;
const GLubyte *error_str = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
abort_example("Error compiling the vertex program:\n%s\n\nat "
"character: %i\n%s\n", error_str, (int)error_pos,
pgm + error_pos);
return -1;
}
start = al_current_time();
while (1) {
if (!al_event_queue_is_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
goto done;
break;
}
}
}
draw_mesh();
al_flip_display();
frames++;
}
done:
printf("%.1f FPS\n", frames / (al_current_time() - start));
glDeleteProgramsARB(1, &pid);
al_destroy_event_queue(queue);
return 0;
}
int main(int argc, char **argv)
{
bool done = false;
bool render = false;
float gameTime = 0;
int frames = 0;
int gameFPS = 0;
float evTimer = 0;
tractor = new Tractor();
Xml = new xml();
int state = -1;
ALLEGRO_BITMAP *icon;
ALLEGRO_BITMAP *map = NULL;
ALLEGRO_BITMAP *panel = NULL;
ALLEGRO_BITMAP *tractorImage = NULL;
ALLEGRO_BITMAP *titleImage = NULL;
ALLEGRO_BITMAP *lostImage = NULL;
ALLEGRO_SAMPLE *titleSong = NULL;
ALLEGRO_SAMPLE *gameSong = NULL;
ALLEGRO_SAMPLE *lostSong = NULL;
ALLEGRO_SAMPLE *cash = NULL;
ALLEGRO_BITMAP *L1 = NULL;
ALLEGRO_BITMAP *L2 = NULL;
ALLEGRO_BITMAP *L3 = NULL;
ALLEGRO_BITMAP *L4 = NULL;
ALLEGRO_BITMAP *L5 = NULL;
ALLEGRO_BITMAP *L6 = NULL;
ALLEGRO_BITMAP *L7 = NULL;
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_DISPLAY_MODE disp_data;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer;
ALLEGRO_FONT *font;
ALLEGRO_FONT *score;
if (!al_init())
return -1;
al_install_keyboard();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_primitives_addon();
al_install_audio();
al_init_acodec_addon();
al_get_display_mode(al_get_num_display_modes() - 1, &disp_data);
//al_set_new_display_flags(ALLEGRO_FULLSCREEN);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_REQUIRE);
display = al_create_display(disp_data.width, disp_data.height);
icon = al_load_bitmap("icon.png");
al_set_display_icon(display, icon);
float sx = (float)disp_data.width / WIDTH;
float sy = (float)disp_data.height / HEIGHT;
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_scale_transform(&trans, sx, sy);
al_use_transform(&trans);
if (!display)
return -1;
font = al_load_font("arial.ttf", 20, 0);
score = al_load_font("score.ttf", 45, 0);
al_reserve_samples(15);
map = al_load_bitmap("map2.png");
panel = al_load_bitmap("panel.png");
L1 = al_load_bitmap("l1.png");
L2 = al_load_bitmap("l2.png");
L3 = al_load_bitmap("l3.png");
L4 = al_load_bitmap("l4.png");
L5 = al_load_bitmap("l5.png");
L6 = al_load_bitmap("l6.png");
L7 = al_load_bitmap("l7.png");
Background *Map = new Background(map);
objects.push_back(Map);
TextBox *Task = new TextBox;
Field *field1 = new Field(L1, L2, L3, L4, L5, L6, L7, 50, 50);
objects.push_back(field1);
Field *field2 = new Field(L1, L2, L3, L4, L5, L6, L7, 450, 50);
objects.push_back(field2);
Field *field3 = new Field(L1, L2, L3, L4, L5, L6, L7, 50, 450);
objects.push_back(field3);
Field *field4 = new Field(L1, L2, L3, L4, L5, L6, L7, 450, 450);
objects.push_back(field4);
tractorImage = al_load_bitmap("tractor.png");
cash = al_load_sample("cash.ogg");
tractor->Init(tractorImage, cash);
objects.push_back(tractor);
titleImage = al_load_bitmap("screen_Title.png");
lostImage = al_load_bitmap("screen_Lost.png");
titleScreen = new Background(titleImage);
lostScreen = new Background(lostImage);
titleSong = al_load_sample("title.ogg");
gameSong = al_load_sample("game.ogg");
lostSong = al_load_sample("lost.ogg");
songInstance = al_create_sample_instance(titleSong);
al_set_sample_instance_playmode(songInstance, ALLEGRO_PLAYMODE_LOOP);
songInstance2 = al_create_sample_instance(gameSong);
al_set_sample_instance_playmode(songInstance2, ALLEGRO_PLAYMODE_LOOP);
songInstance3 = al_create_sample_instance(lostSong);
al_set_sample_instance_playmode(songInstance3, ALLEGRO_PLAYMODE_LOOP);
al_attach_sample_instance_to_mixer(songInstance, al_get_default_mixer());
al_attach_sample_instance_to_mixer(songInstance2, al_get_default_mixer());
al_attach_sample_instance_to_mixer(songInstance3, al_get_default_mixer());
ChangeState(state, TITLE);
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_start_timer(timer);
gameTime = al_current_time();
while (!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = true;
break;
case ALLEGRO_KEY_UP:
keys[UP] = true;
break;
case ALLEGRO_KEY_DOWN:
keys[DOWN] = true;
break;
case ALLEGRO_KEY_ENTER:
keys[ENTER] = true;
if (state == TITLE)
ChangeState(state, PLAYING);
else if (state == PLAYING && Task->CheckText())
{
TextBox *text = new TextBox();
text->SetText(Task->Send());
history.push_back(text);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 400)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
Xml->interpreter(Task->GetLast(), tractor);
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
else if (state == LOST)
ChangeState(state, PLAYING);
break;
case ALLEGRO_KEY_TAB:
keys[TAB] = true;
if (state == PLAYING)
{
Task->SetStatus();
if (Task->GetStatus())
{
TextBox *text = new TextBox();
text->SetText("Konsola zostala wlaczona");
history.push_back(text);
}
else
{
TextBox *text = new TextBox();
text->SetText("Konsola zostala wylaczona");
history.push_back(text);
}
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
setTimer(evTimer);
}
tractor->Sell();
break;
case ALLEGRO_KEY_SPACE:
keys[SPC] = true;
if (state == PLAYING)
Task->Add(" ");
break;
case ALLEGRO_KEY_BACKSPACE:
if (state == PLAYING && Task->CheckText())
Task->Backspace();
break;
case ALLEGRO_KEY_COMMA:
keys[COM] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add(",");
break;
case ALLEGRO_KEY_0:
numb[N0] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("0");
break;
case ALLEGRO_KEY_1:
numb[N1] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("1");
break;
case ALLEGRO_KEY_2:
numb[N2] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("2");
break;
case ALLEGRO_KEY_3:
numb[N3] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("3");
break;
case ALLEGRO_KEY_4:
numb[N4] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("4");
break;
case ALLEGRO_KEY_5:
numb[N5] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("5");
break;
case ALLEGRO_KEY_6:
numb[N6] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("6");
break;
case ALLEGRO_KEY_7:
numb[N7] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("7");
break;
case ALLEGRO_KEY_8:
numb[N8] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("8");
break;
case ALLEGRO_KEY_9:
numb[N9] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("9");
break;
case ALLEGRO_KEY_A:
letters[A] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("a");
break;
case ALLEGRO_KEY_B:
letters[B] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("b");
break;
case ALLEGRO_KEY_C:
letters[C] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("c");
break;
case ALLEGRO_KEY_D:
letters[D] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("d");
break;
case ALLEGRO_KEY_E:
letters[E] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("e");
break;
case ALLEGRO_KEY_F:
letters[F] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("f");
break;
case ALLEGRO_KEY_G:
letters[G] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("g");
break;
case ALLEGRO_KEY_H:
letters[H] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("h");
break;
case ALLEGRO_KEY_I:
letters[I] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("i");
break;
case ALLEGRO_KEY_J:
letters[J] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("j");
break;
case ALLEGRO_KEY_K:
letters[K] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("k");
break;
case ALLEGRO_KEY_L:
letters[L] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("l");
break;
case ALLEGRO_KEY_M:
letters[M] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("m");
break;
case ALLEGRO_KEY_N:
letters[N] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("n");
break;
case ALLEGRO_KEY_O:
letters[O] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("o");
break;
case ALLEGRO_KEY_P:
letters[P] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("p");
break;
case ALLEGRO_KEY_Q:
letters[Q] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("q");
break;
case ALLEGRO_KEY_R:
letters[R] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("r");
break;
case ALLEGRO_KEY_S:
letters[S] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("s");
break;
case ALLEGRO_KEY_T:
letters[T] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("t");
break;
case ALLEGRO_KEY_U:
letters[U] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("u");
break;
case ALLEGRO_KEY_V:
letters[V] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("v");
break;
case ALLEGRO_KEY_W:
letters[W] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("w");
break;
case ALLEGRO_KEY_X:
letters[X] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("x");
break;
case ALLEGRO_KEY_Y:
letters[Y] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("y");
break;
case ALLEGRO_KEY_Z:
letters[Z] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("z");
break;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = false;
break;
case ALLEGRO_KEY_UP:
keys[UP] = false;
break;
case ALLEGRO_KEY_DOWN:
keys[DOWN] = false;
break;
case ALLEGRO_KEY_ENTER:
keys[ENTER] = false;
break;
case ALLEGRO_KEY_TAB:
keys[TAB] = false;
break;
case ALLEGRO_KEY_BACKSPACE:
keys[BSPC] = false;
break;
case ALLEGRO_KEY_COMMA:
keys[COM] = false;
break;
case ALLEGRO_KEY_0:
numb[N0] = false;
break;
case ALLEGRO_KEY_1:
numb[N1] = false;
break;
case ALLEGRO_KEY_2:
numb[N2] = false;
break;
case ALLEGRO_KEY_3:
numb[N3] = false;
break;
case ALLEGRO_KEY_4:
numb[N4] = false;
break;
case ALLEGRO_KEY_5:
numb[N5] = false;
break;
case ALLEGRO_KEY_6:
numb[N6] = false;
break;
case ALLEGRO_KEY_7:
numb[N7] = false;
break;
case ALLEGRO_KEY_8:
numb[N8] = false;
break;
case ALLEGRO_KEY_9:
numb[N9] = false;
break;
case ALLEGRO_KEY_A:
letters[A] = false;
break;
case ALLEGRO_KEY_B:
letters[B] = false;
break;
case ALLEGRO_KEY_C:
letters[C] = false;
break;
case ALLEGRO_KEY_D:
letters[D] = false;
break;
case ALLEGRO_KEY_E:
letters[E] = false;
break;
case ALLEGRO_KEY_F:
letters[F] = false;
break;
case ALLEGRO_KEY_G:
letters[G] = false;
break;
case ALLEGRO_KEY_H:
letters[H] = false;
break;
case ALLEGRO_KEY_I:
letters[I] = false;
break;
case ALLEGRO_KEY_J:
letters[J] = false;
break;
case ALLEGRO_KEY_K:
letters[K] = false;
break;
case ALLEGRO_KEY_L:
letters[L] = false;
break;
case ALLEGRO_KEY_M:
letters[M] = false;
break;
case ALLEGRO_KEY_N:
letters[N] = false;
break;
case ALLEGRO_KEY_O:
letters[O] = false;
break;
case ALLEGRO_KEY_P:
letters[P] = false;
break;
case ALLEGRO_KEY_Q:
letters[Q] = false;
break;
case ALLEGRO_KEY_R:
letters[R] = false;
break;
case ALLEGRO_KEY_S:
letters[S] = false;
break;
case ALLEGRO_KEY_T:
letters[T] = false;
break;
case ALLEGRO_KEY_U:
letters[U] = false;
break;
case ALLEGRO_KEY_V:
letters[V] = false;
break;
case ALLEGRO_KEY_W:
letters[W] = false;
break;
case ALLEGRO_KEY_X:
letters[X] = false;
break;
case ALLEGRO_KEY_Y:
letters[Y] = false;
break;
case ALLEGRO_KEY_Z:
letters[Z] = false;
break;
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
render = true;
frames++;
if (al_current_time() - gameTime >= 1)
{
gameTime = al_current_time();
gameFPS = frames;
frames = 0;
}
if (state == PLAYING)
{
if (keys[UP])
{
if (Map->GetY() + Map->frameHeight > disp_data.height)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetY((*iter)->GetY() - 10);
}
tractor->SetDistY((tractor->GetDistY() - 10));
}
}
else if (keys[DOWN])
{
if (Map->GetY() < 0)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetY((*iter)->GetY() + 10);
}
tractor->SetDistY(tractor->GetDistY() + 10);
}
}
if (keys[LEFT])
{
if (Map->GetWidth() > (disp_data.width - al_get_bitmap_width(panel)))
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetX((*iter)->GetX() - 10);
}
tractor->SetDistX(tractor->GetDistX() - 10);
}
}
else if (keys[RIGHT])
{
if (Map->GetX() < 0)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetX((*iter)->GetX() + 10);
}
tractor->SetDistX(tractor->GetDistX() + 10);
}
}
for (iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Update();
if (tractor->GetStatus())
tractor->Move();
field1->Change_Field();
field1->Grow_Field();
field2->Change_Field();
field2->Grow_Field();
field3->Change_Field();
field3->Grow_Field();
field4->Change_Field();
field4->Grow_Field();
field1->Action_On_Field(tractor);
field2->Action_On_Field(tractor);
field3->Action_On_Field(tractor);
field4->Action_On_Field(tractor);
if (!tractor->Get_Iminwork()){
Xml->ZKolejki(field1, field2, field3, field4, tractor);
if (Xml->wyslij() != ""){
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
}
if (evTimer < 60)
{
evTimer += 0.1;
}
else
{
if (tractor->GetPodpowiedz() == 0)
{
Xml->podpowiedz(field1, field2, field3, field4, tractor);
evTimer = 0;
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
}
}
if (tractor->GetMoney() <= 0)
ChangeState(state, LOST);
}
for (iter = objects.begin(); iter != objects.end();)
{
if (!(*iter)->GetAlive())
{
delete (*iter);
iter = objects.erase(iter);
}
else
iter++;
}
if (render && al_is_event_queue_empty(event_queue))
{
render = false;
if (state == TITLE)
{
titleScreen->Render();
}
else if (state == PLAYING)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Render();
al_draw_bitmap(panel, WIDTH - al_get_bitmap_width(panel), 0, 0);
al_draw_textf(font, al_map_rgb(255, 255, 255), Task->GetX(), Task->GetY(), 0, Task->ShowText());
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
al_draw_textf(font, al_map_rgb(255, 255, 255), (*iter2)->GetX(), (*iter2)->GetY(), 0, (*iter2)->ShowText());
}
if (tractor->GetHealth() < 20)
al_draw_textf(score, RED, WIDTH - 430, 15, 0, "%i", tractor->GetHealth());
else
al_draw_textf(score, BLACK, WIDTH - 430, 15, 0, "%i", tractor->GetHealth());
if (tractor->GetFuel() < 20)
al_draw_textf(score, RED, WIDTH - 260, 15, 0, "%i", tractor->GetFuel());
else
al_draw_textf(score, BLACK, WIDTH - 260, 15, 0, "%i", tractor->GetFuel());
if (tractor->GetMoney() < 200)
al_draw_textf(score, RED, WIDTH - 400, 100, 0, "%i", tractor->GetMoney());
else
al_draw_textf(score, BLACK, WIDTH - 400, 100, 0, "%i", tractor->GetMoney());
al_draw_textf(score, BLACK, WIDTH - 70, 15, 0, "%i", tractor->GetWater());
for (int j = 0; j < 5; j++)
{
al_draw_textf(font, BLACK, WIDTH - 170, 85 + j * 20, 0, "%i", tractor->GetSupply(0, j));
}
for (int j = 0; j < 5; j++)
{
al_draw_textf(font, BLACK, WIDTH - 150, 85 + j * 20, 0, "%i", tractor->GetSupply(1, j));
}
al_draw_textf(font, al_map_rgb(255, 0, 255), 5, 5, 0, "FPS: %i", WIDTH - al_get_bitmap_width(panel) /*gameFPS*/);
}
else if (state == LOST)
lostScreen->Render();
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
}
for (iter = objects.begin(); iter != objects.end();)
{
(*iter)->Destroy();
delete (*iter);
iter = objects.erase(iter);
}
for (iter2 = history.begin(); iter2 != history.end();)
{
(*iter2)->Destroy();
delete (*iter2);
iter2 = history.erase(iter2);
}
//tractor->Destroy();
Task->Destroy();
titleScreen->Destroy();
lostScreen->Destroy();
delete titleScreen;
delete lostScreen;
al_destroy_sample(cash);
al_destroy_sample_instance(songInstance);
al_destroy_sample_instance(songInstance2);
al_destroy_sample_instance(songInstance3);
al_destroy_font(score);
al_destroy_font(font);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_display(display);
return 0;
}
