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__);
}
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;
}
void init_misc_graphics() {
// Graphics.
bmp_red_onion = load_bmp("Red_onion.png");
bmp_yellow_onion = load_bmp("Yellow_onion.png");
bmp_blue_onion = load_bmp("Blue_onion.png");
bmp_ship = load_bmp("Ship.png");
bmp_bubble = load_bmp( "Bubble.png");
bmp_cursor = load_bmp( "Cursor.png");
bmp_day_bubble = load_bmp( "Day_bubble.png");
bmp_enemy_spirit = load_bmp( "Enemy_spirit.png");
bmp_hard_bubble = load_bmp( "Hard_bubble.png");
bmp_icon = load_bmp( "Icon.png");
bmp_idle_glow = load_bmp( "Idle_glow.png");
bmp_info_spot = load_bmp( "Info_spot.png");
bmp_message_box = load_bmp( "Message_box.png");
bmp_mouse_cursor = load_bmp( "Mouse_cursor.png");
bmp_group_move_arrow = load_bmp("Group_move_arrow.png");
bmp_nectar = load_bmp( "Nectar.png");
bmp_no_pikmin = load_bmp( "No_Pikmin.png");
bmp_number_bubble = load_bmp( "Number_bubble.png");
bmp_pikmin_spirit = load_bmp( "Pikmin_spirit.png");
bmp_shadow = load_bmp( "Shadow.png");
bmp_smack = load_bmp( "Smack.png");
bmp_smoke = load_bmp( "Smoke.png");
bmp_sparkle = load_bmp( "Sparkle.png");
bmp_sun = load_bmp( "Sun.png");
bmp_sun_bubble = load_bmp( "Sun_bubble.png");
bmp_tp = load_bmp( "TP.png");
bmp_ub_spray = load_bmp( "Ultra-bitter_spray.png");
bmp_us_spray = load_bmp( "Ultra-spicy_spray.png");
bmp_test = load_bmp("Test.png");
al_set_display_icon(display, bmp_icon);
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *icon1;
ALLEGRO_BITMAP *icon2;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
int i;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
al_init_image_addon();
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
/* First icon: Read from file. */
icon1 = al_load_bitmap("data/icon.tga");
if (!icon1) {
abort_example("icon.tga not found\n");
return 1;
}
/* Second icon: Create it. */
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
icon2 = al_create_bitmap(16, 16);
al_set_target_bitmap(icon2);
for (i = 0; i < 256; i++) {
int u = i % 16;
int v = i / 16;
al_put_pixel(u, v, al_map_rgb_f(u / 15.0, v / 15.0, 1));
}
al_set_target_backbuffer(display);
al_set_window_title(display, "Changing icon example");
timer = al_create_timer(0.5);
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);
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;
}
if (event.type == ALLEGRO_EVENT_TIMER) {
al_set_display_icon(display, (event.timer.count & 1) ? icon2 : icon1);
}
}
al_uninstall_system();
return 0;
}
int main(int argc, char *argv[])
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *evqueue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_KEYBOARD_STATE keyboard_state;
ALLEGRO_EVENT event;
ALLEGRO_FONT *font;
ALLEGRO_BITMAP *clock_hand, *clock_quadrant, *bow, *sword;
float clock_ray = 0, clock_angle = 0;
int clock_ray_alpha;
float soul_interval = SOUL_TIME_INTERVAL;
FuzzyPlayer *player, *cpu;
FuzzyGame * game;
bool running = true;
bool redraw = true;
int map_x = 13*16, map_y = 5*16;
int screen_width = WINDOW_WIDTH;
int screen_height = WINDOW_HEIGHT;
double curtime;
/* Initialization */
fuzzy_iz_error(al_init(), "Failed to initialize allegro");
fuzzy_load_addon("image", al_init_image_addon());
fuzzy_load_addon("primitives", al_init_primitives_addon());
fuzzy_load_addon("keyboard", al_install_keyboard());
fuzzy_load_addon("mouse", al_install_mouse());
al_init_font_addon();
fuzzy_iz_error(timer = al_create_timer(1.0 / FPS), "Cannot create FPS timer");
fuzzy_iz_error(evqueue = al_create_event_queue(), "Cannot create event queue");
fuzzy_iz_error(display = al_create_display(screen_width, screen_height),
"Cannot initialize display");
al_set_window_title(display, WINDOW_TITLE);
fuzzy_iz_error(font = al_load_font(fuzzy_res(FONT_FOLDER, "fixed_font.tga"), 0, 0), "Cannot load 'fixed_font.tga'");
clock_hand = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "clock_hand.png"));
fuzzy_iz_error(clock_hand, "Cannot load clock handle");
clock_quadrant = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "clock_quadrant.png"));
fuzzy_iz_error(clock_hand, "Cannot load clock quadrant");
bow = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "bow.png"));
fuzzy_iz_error(clock_hand, "Cannot load bow image");
sword = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "sword.png"));
fuzzy_iz_error(clock_hand, "Cannot load sword image");
/* Queue setup */
al_register_event_source(evqueue, al_get_display_event_source(display));
al_register_event_source(evqueue, al_get_timer_event_source(timer));
al_register_event_source(evqueue, al_get_keyboard_event_source());
al_register_event_source(evqueue, al_get_mouse_event_source());
/* Game setup */
game = fuzzy_game_new("level000.tmx");
player = fuzzy_player_new(game, FUZZY_PLAYER_LOCAL, "Dolly");
cpu = fuzzy_player_new(game, FUZZY_PLAYER_CPU, "CPU_0");
fuzzy_chess_add(game, player, FUZZY_FOO_LINK, 34, 30);
fuzzy_chess_add(game, player, FUZZY_FOO_LINK, 33, 30);
fuzzy_chess_add(game, cpu, FUZZY_FOO_LINK, 40, 30);
bool showing_area = false;
FuzzyChess *chess, *focus = NULL;
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_bitmap(game->map->bitmap, -map_x, -map_y, 0);
al_flip_display();
#if DEBUG
ALLEGRO_BITMAP *icon;
int fps, fps_accum;
double fps_time;
icon = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "icon.tga"));
if (icon)
al_set_display_icon(display, icon);
fps_accum = fps_time = 0;
fps = FPS;
#endif
/* Server connection */
int svsock;
//~ FuzzyMessage * sendmsg = fuzzy_message_new();
svsock = fuzzy_server_connect(FUZZY_DEFAULT_SERVER_ADDRESS, FUZZY_DEFAULT_SERVER_PORT);
_aaa_menu(game, svsock);
/* MAIN loop */
player->soul_time = al_get_time();
al_start_timer(timer);
while (running) {
/* wait until an event happens */
al_wait_for_event(evqueue, &event);
switch (event.type) {
case ALLEGRO_EVENT_TIMER:
/* check soul ticks */
curtime = al_get_time();
while (curtime - player->soul_time >= soul_interval) {
//~ fuzzy_debug("Soul tick!");
player->soul_time += soul_interval;
player->soul_points += SOUL_POINTS_BOOST;
clock_ray = 1;
}
clock_angle = (curtime - player->soul_time)/soul_interval * FUZZY_2PI;
if (clock_ray) {
clock_ray = (curtime - player->soul_time)/RAY_TIME_INTERVAL * 50 + 40;
clock_ray_alpha = (curtime - player->soul_time)/RAY_TIME_INTERVAL*(55) + 200;
if (clock_ray >= 90)
clock_ray = 0;
}
al_get_keyboard_state(&keyboard_state);
if (al_key_down(&keyboard_state, ALLEGRO_KEY_RIGHT)) {
map_x += 5;
if (map_x > (game->map->tot_width - screen_width))
map_x = game->map->tot_width - screen_width;
}
else if (al_key_down(&keyboard_state, ALLEGRO_KEY_LEFT)) {
map_x -= 5;
if (map_x < 0)
map_x = 0;
}
else if (al_key_down(&keyboard_state, ALLEGRO_KEY_UP)) {
map_y -= 5;
if (map_y < 0)
map_y = 0;
}
else if (al_key_down(&keyboard_state, ALLEGRO_KEY_DOWN)) {
map_y += 5;
if (map_y > (game->map->tot_height - screen_height))
map_y = game->map->tot_height - screen_height;
} else if (al_key_down(&keyboard_state, ALLEGRO_KEY_O)) {
soul_interval = fuzzy_max(0.1, soul_interval - 0.05);
} else if (al_key_down(&keyboard_state, ALLEGRO_KEY_P)) {
soul_interval += 0.05;
}
redraw = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if(! focus)
break;
_attack_area_off();
switch(event.keyboard.keycode) {
case ALLEGRO_KEY_W:
_chess_move(game, player, focus, focus->x, focus->y-1);
break;
case ALLEGRO_KEY_A:
_chess_move(game, player, focus, focus->x-1, focus->y);
break;
case ALLEGRO_KEY_S:
_chess_move(game, player, focus, focus->x, focus->y+1);
break;
case ALLEGRO_KEY_D:
_chess_move(game, player, focus, focus->x+1, focus->y);
break;
case ALLEGRO_KEY_K:
_attack_area_on();
break;
case ALLEGRO_KEY_SPACE:
/* switch attack type */
if (! focus)
break;
if (focus->atkarea == &FuzzyMeleeMan)
focus->atkarea = &FuzzyRangedMan;
else
focus->atkarea = &FuzzyMeleeMan;
break;
}
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
running = false;
break;
case ALLEGRO_EVENT_KEY_UP:
break;
case ALLEGRO_EVENT_KEY_CHAR:
break;
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
if(event.mouse.button == RIGHT_BUTTON) {
_attack_area_on();
} else if(event.mouse.button == LEFT_BUTTON) {
/* world to tile coords */
int tx = (event.mouse.x+map_x) / game->map->tile_width;
int ty = (event.mouse.y+map_y) / game->map->tile_height;
#ifdef DEBUG
printf("SELECT %d %d\n", tx, ty);
#endif
if(showing_area && fuzzy_chess_inside_target_area(game, focus, tx, ty)) {
/* select attack target */
if (fuzzy_map_spy(game->map, FUZZY_LAYER_SPRITES, tx, ty) == FUZZY_CELL_SPRITE) {
if (fuzzy_chess_local_attack(game, player, focus, tx, ty))
_attack_area_off();
}
} else {
/* select chess */
chess = fuzzy_chess_at(game, player, tx, ty);
if (chess && focus != chess) {
_attack_area_off();
if (focus != NULL) {
// already has a focus effect, just move it
fuzzy_sprite_move(game->map, FUZZY_LAYER_BELOW, focus->x, focus->y, tx, ty);
} else {
fuzzy_sprite_create(game->map, FUZZY_LAYER_BELOW, GID_TARGET, tx, ty);
}
focus = chess;
} else if (! chess) {
if (showing_area) {
// just hide the attack area
_attack_area_off();
} else if(focus) {
// remove the focus
fuzzy_sprite_destroy(game->map, FUZZY_LAYER_BELOW, focus->x, focus->y);
focus = NULL;
}
}
}
}
break;
default:
#ifdef DEBUG
//~ fprintf(stderr, "Unknown event received: %d\n", event.type);
#endif
break;
}
if (redraw && al_is_event_queue_empty(evqueue)) {
curtime = al_get_time();
fuzzy_map_update(game->map, curtime);
// Clear the screen
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_bitmap(game->map->bitmap, -map_x, -map_y, 0);
#ifdef GRID_ON
/* Draw the grid */
int tw = game->map->tile_width;
int ty = game->map->tile_height;
int x, y;
for (x=(tw-map_x)%tw; x<screen_width; x+=tw)
al_draw_line(x, 0, x, screen_height, al_map_rgba(7,7,7,100), 1);
for (y=(ty-map_y)%ty; y<screen_height; y+=ty)
al_draw_line(0, y, screen_width, y, al_map_rgba(7,7,7,100), 1);
#endif
#if DEBUG
al_draw_filled_rounded_rectangle(screen_width-100, 4, screen_width, 30,
8, 8, al_map_rgba(0, 0, 0, 200));
al_draw_textf(font, al_map_rgb(255, 255, 255),
screen_width-50, 8, ALLEGRO_ALIGN_CENTRE, "FPS: %d", fps);
#endif
/* draw SP count */
al_draw_filled_rounded_rectangle(4, screen_height-170, 175, screen_height-4,
8, 8, al_map_rgba(0, 0, 0, 200));
al_draw_textf(font, al_map_rgb(255, 255, 255),
15, screen_height-163, ALLEGRO_ALIGN_LEFT, "SP: %d", player->soul_points);
/* draw Soul Clock */
al_draw_scaled_bitmap(clock_quadrant, 0, 0, 301, 301, 20, screen_height-80-139/2, 139, 139, 0);
al_draw_scaled_rotated_bitmap(clock_hand, 160, 607, 90, screen_height-80, 0.11, 0.11, clock_angle, 0);
al_draw_circle(90, screen_height-80, clock_ray, al_map_rgb(80, clock_ray_alpha, 80), 2.0);
/* draw weapon */
if (focus) {
ALLEGRO_BITMAP * weapon;
if (focus->atkarea == &FuzzyMeleeMan)
weapon = sword;
else
weapon = bow;
al_draw_scaled_bitmap(weapon, 0, 0, 90, 90, 20, 20, 60, 60, 0);
}
al_flip_display();
#if DEBUG
fps_accum++;
if (curtime - fps_time >= 1) {
fps = fps_accum;
fps_accum = 0;
fps_time = curtime;
}
#endif
redraw = false;
}
}
/* Cleanup */
//~ void * retval;
//~ char srvkey[FUZZY_SERVERKEY_LEN];
//~ fuzzy_protocol_server_shutdown(svsock, sendmsg, srvkey);
//~ fuzzy_message_del(sendmsg);
fuzzy_game_free(game);
al_destroy_event_queue(evqueue);
al_destroy_display(display);
al_destroy_timer(timer);
return 0;
}
// Initializes the the GDATA struct
_Bool data_init(void)
{
// Create a window to display things on: 800x600 pixels
al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_OPENGL);
al_set_new_display_refresh_rate(60);
data->display = al_create_display(res_width, res_height);
if(data->display == NULL)
{
al_show_native_message_box(data->display, "Error!", "Display Error:", "Failed to create window!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
// Sets the physfs file interface to be used for loading files
al_set_physfs_file_interface();
PHYSFS_mount("images", NULL, 1);
PHYSFS_mount("fonts", NULL, 1);
PHYSFS_mount("buttons", NULL, 1);
// Well, looks like we're gonna have to draw our own mouse *SIGH*
al_hide_mouse_cursor(data->display);
data->cursor = al_load_bitmap("cursor_darkgrey.png");
if(data->cursor == NULL)
{
al_show_native_message_box(data->display, "Error!", "Cursor Error:", "Failed to locate cursor!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
// Set the title of the window
al_set_window_title(data->display, "SpeedRun!");
// Sets the window's icon
data->icon = al_load_bitmap("speedrundisplayicon.png");
if(data->icon == NULL)
{
al_show_native_message_box(data->display, "Error!", "Icon Error:", "Failed to locate icon!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
al_set_display_icon(data->display, data->icon);
// Load a font
data->font = al_load_ttf_font("times.ttf", 25, 0);
data->b_font = al_load_ttf_font("impact.ttf", 25, 0);
if(data->font == NULL || data->b_font == NULL)
{
al_show_native_message_box(data->display, "Error!", "Font Error:", "Failed to load font!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
// Make and set a color to draw with
data->text_color = al_map_rgba(80, 112, 255, 255);
// Set background color
data->background_color = al_map_rgba(0, 0, 0, 0);
// Install the keyboard handler
if(!al_install_keyboard())
{
al_show_native_message_box(data->display, "Error!", "Keyboard Error:", "Failed to install keyboard handler!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
// Install the mouse handler
if(!al_install_mouse())
{
al_show_native_message_box(data->display, "Error!", "Mouse Error:", "Failed to install mouse handler!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return false;
}
// Detect and set refresh rate
int refresh_rate = al_get_display_refresh_rate(data->display);
if(refresh_rate == 0)
{
refresh_rate = 60;
}
// Install timer with refresh rate
data->timer = al_create_timer(1.0/refresh_rate);
if(data->timer == NULL)
{
al_show_native_message_box(data->display, "Error!", "Timer Error:", "Failed to initialize timer!", NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 1;
}
al_start_timer(data->timer);
// Start the event queues to handle keyboard input, mouse input, display input and timer input
data->queue = al_create_event_queue();
al_register_event_source(data->queue, (ALLEGRO_EVENT_SOURCE*)data->timer);
data->queue2 = al_create_event_queue();
al_register_event_source(data->queue2, al_get_keyboard_event_source());
al_register_event_source(data->queue2, (ALLEGRO_EVENT_SOURCE*)data->display);
al_register_event_source(data->queue2, al_get_mouse_event_source());
// Set the quit and gamestarted flags to false initially
data->exit = false;
data->gamestarted = false;
data->options = false;
data->highscores = false;
data->howtoplay = false;
al_start_timer(data->timer);
return true;
}
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;
}
int main(int argc, char *argv[])
{
bool windowed = false;
float rescale = 1.0f;
std::string arg;
if(argc > 1)
{
arg = argv[1];
if(arg == "--help")
{
std::cout << "-s {scale} for running in windowed mode and scaled (standart size is 1440*810)" << std::endl;
return 0;
}
else if(arg == "-s")
{
if( argc > 2)
{
arg = argv[2];
rescale = atof(argv[2]);
}
windowed = true;
}
}
/**initialize allegro*/
if(!al_init()){error_message("al_init()");return 33;}
if(!al_init_primitives_addon()){error_message("al_init_primitives_addon()");return 33;}
//if(!al_install_keyboard()){error_message("al_install_keyboard()");return 33;} //no use for keyboard in this game
if(!al_install_mouse()){error_message("al_install_mouse()");return 33;}
if(!al_init_image_addon()){error_message("al_init_image_addon()");return 33;}
al_init_font_addon(); // returns void
if(!al_init_ttf_addon()){error_message("al_init_ttf_addon()");return 33;}
//audio
if(al_install_audio() == true)
{
if(al_init_acodec_addon() == true){}
else
{
error_message("al_init_acodec_addon() - cant initialize audio codec");
global::audio = false;
global::sound_card = false;
}
}
else
{
error_message("al_install_audio() - cant found sound device");
global::audio = false;
global::sound_card = false;
}
/**Some allegro variables*/
ALLEGRO_DISPLAY *display = nullptr;
ALLEGRO_EVENT_QUEUE *event_queue = nullptr;
ALLEGRO_TIMER *timer = nullptr;
ALLEGRO_BITMAP *logo = nullptr;
/**Display preparation*/
bool supported_ratio = true;
ALLEGRO_MONITOR_INFO mon_info;
al_get_monitor_info(0, &mon_info);
global::sHeight = mon_info.y2 - mon_info.y1; //gets monitor size in pixels
global::sWidth = mon_info.x2 - mon_info.x1;
global::aspectratio = round( ((float)global::sWidth / (float)global::sHeight) * 100.0f) / 100.0f; //gets aspectratio
if(global::aspectratio == 1.78f){global::xratio = 16; global::yratio = 9;} // 16:9 screen ration
else if(global::aspectratio == 1.6f){global::xratio = 16; global::yratio = 10;} // 16:10
else if(global::aspectratio == 1.33f){global::xratio = 4; global::yratio = 3;} // 4:3
else{supported_ratio = false;}
global::dHeight = global::dWidth / global::xratio * global::yratio;
global::xscale = (float)global::sWidth / (float)global::dWidth;
global::yscale = (float)global::sHeight / (float)global::dHeight;
/**display creation*/
al_set_new_bitmap_flags(ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR); // Thanks to this, magnified fonts dont look retarted, and game is fast (hopefully) :D
if(windowed == true || supported_ratio == false)
{
supported_ratio = true;
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL);
global::xscale = rescale;
global::yscale = rescale;
global::dWidth = 1440;
global::dHeight = 810;
display = al_create_display(global::dWidth*rescale, global::dHeight*rescale);
}
else
{
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW | ALLEGRO_OPENGL);
display = al_create_display(global::dWidth, global::dHeight);
}
if(display == nullptr){error_message("al_create_display()"); return 1;}
al_set_window_title(display, "Este neviem meno, ale asi neco so zemiakom");
/**logo*/
logo = al_load_bitmap("resources/graphics/logo.png");
if(logo == nullptr){error_message("resources/graphics/logo.png not found");}
else{ al_set_display_icon(display, logo);}
/**Transformation*/
al_identity_transform(&global::trans);
if(supported_ratio == true)
{
al_scale_transform(&global::trans, global::xscale, global::yscale);
}
else
{
error_message("Unsupported monitor type - upgrade you monitor pls");
float scale_backup_plan = (global::xscale > global::yscale ? global::yscale : global::xscale);
global::xscale = scale_backup_plan;
global::yscale = scale_backup_plan;
al_scale_transform(&global::trans, global::xscale, global::yscale);
}
al_use_transform(&global::trans);
/**timer*/
timer = al_create_timer(1.0f/global::FPS);
if(timer == nullptr){error_message("al_create_timer()"); return 44;}
bool redraw = true;
/**even que*/
event_queue = al_create_event_queue();
if(event_queue == nullptr){error_message("al_create_event_queue()"); return 44;}
/**registering event sources*/
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_register_event_source(event_queue, al_get_mouse_event_source());
al_start_timer(timer);
rguil::mouse_state = &global::mouse_state;
global::audio_player = new AudioHandler(10);
#ifdef _SOUND_TEST
ALLEGRO_SAMPLE *s = al_load_sample("resources/music/Fuck_This_Shit_Im_Out.wav");
ALLEGRO_SAMPLE_INSTANCE *si = al_create_sample_instance(s);
global::audio_player->global_sounds.push_back(si);
global::audio_player->Play_sample_instance(&si, ALLEGRO_PLAYMODE_LOOP);
#endif // _SOUND_TEST
#ifdef _FPS
ALLEGRO_FONT *fps_font = nullptr;
fps_font = al_load_font("resources/fonts/Asimov.otf", 12,0);
int counter = 0;
time_t tsttme2 = time(nullptr), tsttme = time(nullptr);
int fps = 0;
#endif // FPS
global::save = new GameSave();
ScreenMain *SCMain = new ScreenMain();
global::audio_b = new Button("resources/fonts/Calibri.ttf", 1240, global::dHeight -65, 1240 + 40, global::dHeight - 25,
"", al_map_rgba(0,0,0,0),
( global::audio == true ? MusicON : MusicOFF));
/**Main loop*/ //forced 30 FPS, drawing and computing in same thread
while(global::loop == true)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
al_get_mouse_state(&global::mouse_state);
if(ev.type == ALLEGRO_EVENT_TIMER)
{
redraw = true;
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
break;
}
/**Take event input here*/
if(global::audio_b->Input(ev, global::xscale, global::yscale) == 2)
{
global::audio_b->unclick();
global::audio = (global::audio == true ? false : true);
if(global::audio == true)
{
al_destroy_bitmap(global::audio_b->bmp);
global::audio_b->bmp = al_load_bitmap(MusicON);
global::audio_player->Mute_sample_instances(false);
}
else
{
al_destroy_bitmap(global::audio_b->bmp);
global::audio_b->bmp = al_load_bitmap(MusicOFF);
global::audio_player->Mute_sample_instances(true);
}
}
SCMain->Input(ev, global::xscale, global::yscale);
/**---------------------*/
#ifdef _FPS
tsttme2 = time(&tsttme2);
if(difftime(tsttme2,tsttme) >= 1.0f)
{
tsttme = time(&tsttme);
fps = counter;
counter = 0;
}
#endif // FPS
if(redraw == true && al_is_event_queue_empty(event_queue))
{
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
/**Draw and compute here*/
SCMain->Print();
global::audio_b->Print();
/**---------------------*/
#ifdef _FPS
counter++;
al_draw_text(fps_font, al_map_rgb(255,0,0), 0.0f,0.0f, 0, std::to_string(fps).c_str());
#endif // FPS
al_flip_display();
}
}
#ifdef _SOUND_TEST
global::audio_player->Stop_sample_instances();
global::audio_player->global_sounds.erase(global::audio_player->global_sounds.begin());
al_destroy_sample_instance(si);
al_destroy_sample(s);
#endif // _SOUND_TEST
delete global::audio_b;
delete SCMain;
delete global::save;
delete global::audio_player;
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
if(logo != nullptr)
al_destroy_bitmap(logo);
#ifdef _FPS
al_destroy_font(fps_font);
#endif // FPS
return 0;
}
int main(int argc, char **argv){
signal(SIGSEGV, derp);
srand(time(NULL));
al_set_org_name("Super Derpy");
al_set_app_name("Back to the Browser Wars");
#ifdef ALLEGRO_MACOSX
char exe_path[MAXPATHLEN];
char link_path[MAXPATHLEN];
uint32_t size = sizeof(exe_path);
_NSGetExecutablePath(exe_path, &size);
realpath(exe_path, link_path);
chdir(link_path);
#endif
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
struct Game game;
InitConfig(&game);
game._priv.fps_count.frames_done = 0;
game._priv.fps_count.fps = 0;
game._priv.fps_count.old_time = 0;
game._priv.font_bsod = NULL;
game._priv.console = NULL;
game.config.fullscreen = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "fullscreen", "0"));
game.config.music = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "music", "10"));
game.config.voice = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "voice", "10"));
game.config.fx = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "fx", "10"));
game.config.debug = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "debug", "0"));
game.config.width = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "width", "1280"));
if (game.config.width<320) game.config.width=320;
game.config.height = atoi(GetConfigOptionDefault(&game, "SuperDerpy", "height", "720"));
if (game.config.height<180) game.config.height=180;
if(!al_init_image_addon()) {
fprintf(stderr, "failed to initialize image addon!\n");
/*al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);*/
return -1;
}
if(!al_init_acodec_addon()){
fprintf(stderr, "failed to initialize audio codecs!\n");
return -1;
}
if(!al_install_audio()){
fprintf(stderr, "failed to initialize audio!\n");
return -1;
}
if(!al_install_keyboard()){
fprintf(stderr, "failed to initialize keyboard!\n");
return -1;
}
if(!al_init_primitives_addon()){
fprintf(stderr, "failed to initialize primitives!\n");
return -1;
}
if(!al_install_mouse()) {
fprintf(stderr, "failed to initialize the mouse!\n");
return -1;
}
al_init_font_addon();
if(!al_init_ttf_addon()){
fprintf(stderr, "failed to initialize fonts!\n");
return -1;
}
if (game.config.fullscreen) al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
else al_set_new_display_flags(ALLEGRO_WINDOWED);
al_set_new_display_option(ALLEGRO_VSYNC, 2-atoi(GetConfigOptionDefault(&game, "SuperDerpy", "vsync", "1")), ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_OPENGL, atoi(GetConfigOptionDefault(&game, "SuperDerpy", "opengl", "1")), ALLEGRO_SUGGEST);
#ifdef ALLEGRO_WINDOWS
al_set_new_window_position(20, 40); // workaround nasty Windows bug with window being created off-screen
#endif
game.display = al_create_display(game.config.width, game.config.height);
if(!game.display) {
fprintf(stderr, "failed to create display!\n");
return -1;
}
SetupViewport(&game);
PrintConsole(&game, "Viewport %dx%d", game.viewport.width, game.viewport.height);
ALLEGRO_BITMAP *icon = al_load_bitmap(GetDataFilePath(&game, "icons/bttbw.png"));
al_set_window_title(game.display, "Back to the Browser Wars");
al_set_display_icon(game.display, icon);
al_destroy_bitmap(icon);
if (game.config.fullscreen) al_hide_mouse_cursor(game.display);
al_inhibit_screensaver(true);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR);
game._priv.gamestates = NULL;
game._priv.event_queue = al_create_event_queue();
if(!game._priv.event_queue) {
FatalError(&game, true, "Failed to create event queue.");
al_destroy_display(game.display);
return -1;
}
game.audio.v = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_INT16, ALLEGRO_CHANNEL_CONF_2);
game.audio.mixer = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
game.audio.fx = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
game.audio.music = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
game.audio.voice = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
al_attach_mixer_to_voice(game.audio.mixer, game.audio.v);
al_attach_mixer_to_mixer(game.audio.fx, game.audio.mixer);
al_attach_mixer_to_mixer(game.audio.music, game.audio.mixer);
al_attach_mixer_to_mixer(game.audio.voice, game.audio.mixer);
al_set_mixer_gain(game.audio.fx, game.config.fx/10.0);
al_set_mixer_gain(game.audio.music, game.config.music/10.0);
al_set_mixer_gain(game.audio.voice, game.config.voice/10.0);
al_register_event_source(game._priv.event_queue, al_get_display_event_source(game.display));
al_register_event_source(game._priv.event_queue, al_get_mouse_event_source());
al_register_event_source(game._priv.event_queue, al_get_keyboard_event_source());
game._priv.showconsole = game.config.debug;
al_clear_to_color(al_map_rgb(0,0,0));
game._priv.timer = al_create_timer(ALLEGRO_BPS_TO_SECS(60)); // logic timer
if(!game._priv.timer) {
FatalError(&game, true, "Failed to create logic timer.");
return -1;
}
al_register_event_source(game._priv.event_queue, al_get_timer_event_source(game._priv.timer));
al_flip_display();
al_start_timer(game._priv.timer);
setlocale(LC_NUMERIC, "C");
game.shuttingdown = false;
game.restart = false;
game.mediator.lives = 3;
game.mediator.score = 0;
game.mediator.modificator = 1;
game.mediator.heart = CreateCharacter(&game, "heart");
RegisterSpritesheet(&game, game.mediator.heart, "heart");
RegisterSpritesheet(&game, game.mediator.heart, "blank");
LoadSpritesheets(&game, game.mediator.heart);
SelectSpritesheet(&game, game.mediator.heart, "heart");
char* gamestate = strdup("dosowisko"); // FIXME: don't hardcore gamestate
int c;
while ((c = getopt (argc, argv, "l:s:")) != -1)
switch (c) {
case 'l':
free(gamestate);
gamestate = strdup("levelX");
gamestate[5] = optarg[0];
break;
case 's':
free(gamestate);
gamestate = strdup(optarg);
break;
}
LoadGamestate(&game, gamestate);
game._priv.gamestates->showLoading = false; // we have only one gamestate right now
StartGamestate(&game, gamestate);
free(gamestate);
char libname[1024] = {};
snprintf(libname, 1024, "libsuperderpy-%s-loading" LIBRARY_EXTENTION, "bttbw");
void *handle = dlopen(libname, RTLD_NOW);
if (!handle) {
FatalError(&game, true, "Error while initializing loading screen %s", dlerror());
exit(1);
} else {
#define GS_LOADINGERROR FatalError(&game, true, "Error on resolving loading symbol: %s", dlerror()); exit(1);
if (!(game._priv.loading.Draw = dlsym(handle, "Draw"))) { GS_LOADINGERROR; }
if (!(game._priv.loading.Load = dlsym(handle, "Load"))) { GS_LOADINGERROR; }
if (!(game._priv.loading.Start = dlsym(handle, "Start"))) { GS_LOADINGERROR; }
if (!(game._priv.loading.Stop = dlsym(handle, "Stop"))) { GS_LOADINGERROR; }
if (!(game._priv.loading.Unload = dlsym(handle, "Unload"))) { GS_LOADINGERROR; }
}
game._priv.loading.data = (*game._priv.loading.Load)(&game);
bool redraw = false;
while(1) {
ALLEGRO_EVENT ev;
if (redraw && al_is_event_queue_empty(game._priv.event_queue)) {
struct Gamestate *tmp = game._priv.gamestates;
int toLoad = 0, loaded = 0;
// FIXME: move to function
// TODO: support dependences
while (tmp) {
if ((tmp->pending_start) && (tmp->started)) {
PrintConsole(&game, "Stopping gamestate \"%s\"...", tmp->name);
(*tmp->api.Gamestate_Stop)(&game, tmp->data);
tmp->started = false;
tmp->pending_start = false;
}
if ((tmp->pending_load) && (!tmp->loaded)) toLoad++;
tmp=tmp->next;
}
tmp = game._priv.gamestates;
// FIXME: move to function
// TODO: support dependences
double t = -1;
while (tmp) {
if ((tmp->pending_load) && (tmp->loaded)) {
PrintConsole(&game, "Unloading gamestate \"%s\"...", tmp->name);
al_stop_timer(game._priv.timer);
tmp->loaded = false;
tmp->pending_load = false;
(*tmp->api.Gamestate_Unload)(&game, tmp->data);
dlclose(tmp->handle);
tmp->handle = NULL;
al_start_timer(game._priv.timer);
} else if ((tmp->pending_load) && (!tmp->loaded)) {
PrintConsole(&game, "Loading gamestate \"%s\"...", tmp->name);
al_stop_timer(game._priv.timer);
// TODO: take proper game name
char libname[1024];
snprintf(libname, 1024, "libsuperderpy-%s-%s" LIBRARY_EXTENTION, "bttbw", tmp->name);
tmp->handle = dlopen(libname,RTLD_NOW);
if (!tmp->handle) {
//PrintConsole(&game, "Error while loading gamestate \"%s\": %s", tmp->name, dlerror());
FatalError(&game, false, "Error while loading gamestate \"%s\": %s", tmp->name, dlerror());
tmp->pending_load = false;
tmp->pending_start = false;
} else {
#define GS_ERROR FatalError(&game, false, "Error on resolving gamestate symbol: %s", dlerror()); tmp->pending_load = false; tmp->pending_start = false; tmp=tmp->next; continue;
if (!(tmp->api.Gamestate_Draw = dlsym(tmp->handle, "Gamestate_Draw"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Logic = dlsym(tmp->handle, "Gamestate_Logic"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Load = dlsym(tmp->handle, "Gamestate_Load"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Start = dlsym(tmp->handle, "Gamestate_Start"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Pause = dlsym(tmp->handle, "Gamestate_Pause"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Resume = dlsym(tmp->handle, "Gamestate_Resume"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Stop = dlsym(tmp->handle, "Gamestate_Stop"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Unload = dlsym(tmp->handle, "Gamestate_Unload"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_ProcessEvent = dlsym(tmp->handle, "Gamestate_ProcessEvent"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_Reload = dlsym(tmp->handle, "Gamestate_Reload"))) { GS_ERROR; }
if (!(tmp->api.Gamestate_ProgressCount = dlsym(tmp->handle, "Gamestate_ProgressCount"))) { GS_ERROR; }
int p = 0;
void progress(struct Game *game) {
p++;
DrawGamestates(game);
float progress = ((p / (*(tmp->api.Gamestate_ProgressCount) ? (float)*(tmp->api.Gamestate_ProgressCount) : 1))/(float)toLoad)+(loaded/(float)toLoad);
if (game->config.debug) PrintConsole(game, "[%s] Progress: %d% (%d/%d)", tmp->name, (int)(progress*100), p, *(tmp->api.Gamestate_ProgressCount));
if (tmp->showLoading) (*game->_priv.loading.Draw)(game, game->_priv.loading.data, progress);
DrawConsole(game);
if (al_get_time() - t >= 1/60.0) {
al_flip_display();
}
t = al_get_time();
}
t = al_get_time();
// initially draw loading screen with empty bar
DrawGamestates(&game);
if (tmp->showLoading) {
(*game._priv.loading.Draw)(&game, game._priv.loading.data, loaded/(float)toLoad);
}
DrawConsole(&game);
if (al_get_time() - t >= 1/60.0) {
al_flip_display();
}
t = al_get_time();
tmp->data = (*tmp->api.Gamestate_Load)(&game, &progress); // feel free to replace "progress" with empty function if you want to compile with clang
loaded++;
tmp->loaded = true;
tmp->pending_load = false;
}
al_start_timer(game._priv.timer);
}
tmp=tmp->next;
}
bool gameActive = false;
tmp=game._priv.gamestates;
while (tmp) {
if ((tmp->pending_start) && (!tmp->started) && (tmp->loaded)) {
PrintConsole(&game, "Starting gamestate \"%s\"...", tmp->name);
al_stop_timer(game._priv.timer);
(*tmp->api.Gamestate_Start)(&game, tmp->data);
al_start_timer(game._priv.timer);
tmp->started = true;
tmp->pending_start = false;
}
if ((tmp->started) || (tmp->pending_start) || (tmp->pending_load)) gameActive = true;
tmp=tmp->next;
}
if (!gameActive) {
PrintConsole(&game, "No gamestates left, exiting...");
break;
}
DrawGamestates(&game);
DrawConsole(&game);
al_flip_display();
redraw = false;
} else {
