void Engine::Init()
{
done = false;
al_init(); //Initialises the allegro library
al_init_image_addon();
al_init_primitives_addon();
display = al_create_display(WIDTH, HEIGHT);
al_set_window_title(display, "Double Pendulum Simulation");
al_install_keyboard(); //Installs keyboard driver
al_install_mouse(); //installs mouse driver
eventQueue = al_create_event_queue();
al_register_event_source(eventQueue, al_get_display_event_source(display));
al_register_event_source(eventQueue, al_get_keyboard_event_source());
al_register_event_source(eventQueue, al_get_mouse_event_source());
timer = al_create_timer(1.0f / FPS);
al_register_event_source(eventQueue, al_get_timer_event_source(timer));
al_start_timer(timer);
doublePendulum = new DoublePendulum();
doublePendulum->Init(150, 150, 4, 4, 0.5, 0.5, 400, 200);
}
bool AllegroEngine::Init(int winwidth,int winheight)
{
map<int,bool> errormap;
//
if (!al_init()) errormap.insert(pair<int,bool>(E_ALLEGRO,true)); //Did Allegro fail to open?
//
root = al_create_display(winwidth, winheight);
if (!root) errormap.insert(pair<int,bool>(E_DISPLAY,true)); //Did the root display fail to be created?
//
al_init_font_addon(); // initialize the font addon
al_init_ttf_addon();// initialize the ttf (True Type Font) addon
font = al_load_ttf_font("malgun.ttf",72,0 );
if (!font) errormap.insert(pair<int,bool>(E_FONT,true)); //Did the font fail to load?
//
setFPS(errormap, 10);
//
if (!al_install_mouse())
errormap.insert(pair<int,bool>(E_MOUSE,true)); //No mouse?
if (!al_install_keyboard())
errormap.insert(pair<int,bool>(E_KEYBOARD,true)); //No mouse?
//
event_queue = al_create_event_queue();
if (!event_queue) errormap.insert(pair<int,bool>(E_EVENTQUEUE,true)); //Did the event queue not appear?
//
al_register_event_source(event_queue, al_get_display_event_source(root)); //register display as event source
al_register_event_source(event_queue, al_get_timer_event_source(timer_fps)); //register timer as event source
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
//
bool errors = EngineInit(errormap);
return errors || errormap.size()==0?true:false;
}
void equipAligner::initialize(){
this->display = al_create_display(800,600);
eventQueue = al_create_event_queue();
al_register_event_source(eventQueue,al_get_mouse_event_source());
al_register_event_source(eventQueue,al_get_keyboard_event_source());
font = al_load_ttf_font("arial.ttf",-20,0);
bodyPart newBodyPart;
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_BODY);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_FACINGFOOT);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_HEAD);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_LEFTHAND);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_RIGHTHAND);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_CLOSEDHAND);
availableBodyParts.push_back(newBodyPart);
newBodyPart.bodyPartImage = character::characterImageManager::getSkinImage(1, 0, character::BODY_STRAIGHTFOOT);
availableBodyParts.push_back(newBodyPart);
cache_head_eyes = character::characterImageManager::getEyesImage(1);
cache_head_mouth = character::characterImageManager::getMouthImage(1);
selectedBodyPart = 0;
aligningImage = NULL;
imageAlignAlpha = 1;
}
// |----------------------------------------------------------------------------|
// | init() |
// |----------------------------------------------------------------------------|
int Input::init(Screen* first_screen) {
// Mouse installation
if(!al_install_mouse()) {
debug("Input: failed to initialise the mouse.");
return -1;
}
debug("Input: mouse initialised.");
// Keyboard installation
if(!al_install_keyboard()) {
debug("Input: failed to initialise the keyboard.");
return -1;
}
debug("Input: keyboard initialised.");
// Event Queue Setup
keyboard_queue = al_create_event_queue();
if(!keyboard_queue) {
debug("Input: failed to create keyboard event queue.");
error = -1;
}
mouse_queue = al_create_event_queue();
if(!mouse_queue) {
debug("Input: failed to create mouse event queue.");
error = -1;
}
al_register_event_source(mouse_queue, al_get_mouse_event_source());
// Initiallise current screen
current_screen = first_screen;
if (!error) debug("Input: object initialised.");
return error;
}
Dialog::Dialog(const Theme & theme, ALLEGRO_DISPLAY *display,
int grid_m, int grid_n):
theme(theme),
display(display),
grid_m(grid_m),
grid_n(grid_n),
x_padding(1),
y_padding(1),
draw_requested(true),
quit_requested(false),
mouse_over_widget(NULL),
mouse_down_widget(NULL),
key_widget(NULL),
event_handler(NULL)
{
this->event_queue = al_create_event_queue();
al_register_event_source(this->event_queue, al_get_keyboard_event_source());
al_register_event_source(this->event_queue, al_get_mouse_event_source());
al_register_event_source(this->event_queue, al_get_display_event_source(display));
if (al_is_touch_input_installed()) {
al_register_event_source(this->event_queue,
al_get_touch_input_mouse_emulation_event_source());
}
}
// Constructor - initialises member variables
Level::Level(GamestateManager *_stateManager)
{
m_mapWidth = 1000;
m_mapHeight = 1000;
m_map = new Map(m_mapWidth, m_mapHeight);
m_player = new Player(m_map);
m_enemies.push_back(new Enemy(glm::vec2(150.0f,850.0f), 300.0f, m_map, m_player));
m_enemies.push_back(new Enemy(glm::vec2(450.0f,350.0f), 350.0f, m_map, m_player));
m_enemies.push_back(new Enemy(glm::vec2(800.0f,250.0f), 400.0f, m_map, m_player));
m_enemies.push_back(new Enemy(glm::vec2(100.0f,750.0f), 500.0f, m_map, m_player));
m_enemies.push_back(new Enemy(glm::vec2(750.0f,850.0f), 200.0f, m_map, m_player));
m_stateManager = _stateManager;
m_currTileType = -1;
m_mouseDown = false;
m_paused = true;
m_enemiesActive = false;
m_activeTileType = "";
m_algoMessage = "";
m_font = al_load_font("Arial.ttf", 14, 0);
// Creates the event queue used for getting keyboard input and registers the keyboard
m_eventQueue = al_create_event_queue();
al_register_event_source(m_eventQueue, al_get_keyboard_event_source());
al_register_event_source(m_eventQueue, al_get_mouse_event_source());
}
/*
* keyboard driver is called first, so initialize allegro here
*/
int init_allegro(void){
if(!al_init())
{
fprintf(stderr,"Error!, Allegro has failed to initialize.\n");
return 0;
} else {
//fprintf(stderr,"al_init successful\n");
}
//al_set_new_display_option(ALLEGRO_CAN_DRAW_INTO_BITMAP,1,ALLEGRO_REQUIRE);
display = al_create_display(800, 600);
if(display == NULL)
{
fprintf(stderr,"Error!, Failed to create the display.");
return 0;
}
al_set_system_mouse_cursor(display,ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT);
if(!al_install_keyboard())
{
fprintf(stderr,"Error!, Failed to install keyboard.\n");
return 0;
} else {
//fprintf(stderr,"al_install_keyboard successful\n");
}
if(!al_install_mouse())
{
fprintf(stderr,"Error!, Failed to install mouse.");
return 0;
}
a_event_queue_k = al_create_event_queue();
if(a_event_queue_k == NULL)
{
fprintf(stderr,"Error!, Failed to create the keyboard event queue.");
return 0;
}
al_register_event_source(a_event_queue_k, al_get_keyboard_event_source());
a_event_queue_m = al_create_event_queue();
if(a_event_queue_m == NULL)
{
fprintf(stderr,"Error!, Failed to create the mouse event queue.");
return 0;
}
al_register_event_source(a_event_queue_m, al_get_mouse_event_source());
a_event_queue_d = al_create_event_queue();
if(a_event_queue_d == NULL)
{
fprintf(stderr,"Error!, Failed to create the display event queue.");
return 0;
}
al_register_event_source(a_event_queue_d, al_get_display_event_source(display));
return 1; //ok
}
void EventQueue::listenEvents()
{
checkInit();
al_flush_event_queue(this->implementation->allegroEventQueue);
al_register_event_source(this->implementation->allegroEventQueue, al_get_display_event_source(fgeal::display->implementation->allegroDisplay));
al_register_event_source(this->implementation->allegroEventQueue, al_get_keyboard_event_source());
al_register_event_source(this->implementation->allegroEventQueue, al_get_mouse_event_source());
}
ALLEGRO_EVENT_SOURCE *
get_mouse_event_source (void)
{
ALLEGRO_EVENT_SOURCE *event_source = al_get_mouse_event_source ();
if (! event_source)
error (0, 0, "%s: failed to get mouse event source", __func__);
return event_source;
}
static int initialize(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
if (!al_install_keyboard()) {
printf("Could not init keyboard!\n");
return 0;
}
if (!al_install_mouse()) {
printf("Could not init mouse!\n");
return 0;
}
al_init_acodec_addon();
if (!al_install_audio()) {
printf("Could not init sound!\n");
return 0;
}
if (!al_reserve_samples(16)) {
printf("Could not set up voice and mixer.\n");
return 0;
}
display = al_create_display(640, 228);
if (!display) {
printf("Could not create display!\n");
return 0;
}
basic_font = al_load_font("data/font.tga", 0, 0);
if (!basic_font) {
printf("Could not load font!\n");
return 0;
}
timer = al_create_timer(1.000 / 30);
if (!timer) {
printf("Could not init timer!\n");
return 0;
}
queue = al_create_event_queue();
if (!queue) {
printf("Could not create event queue!\n");
return 0;
}
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
return 1;
}
bool init(int w, int h, bool fullscreen = false) {
// HWND hWndDisplay = NULL;
const char* err;
#define INIT(x, y) if(!(x)) { err = y; goto err; }
mt_seed();
// Allegro initialization
INIT( al_init() &&
al_install_mouse() &&
al_install_keyboard() &&
al_init_image_addon() &&
al_init_primitives_addon(),
"initialize allegro" );
if(fullscreen) al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
INIT(display = al_create_display(w, h), "create display")
al_set_window_title(display, "ŒwiteŸ");
// { auto icon = al_load_bitmap("img\\icon.gif");
// if(icon) al_set_display_icon(display, icon); }
// if(fullscreen) {
// hWndDisplay = al_get_win_window_handle(display);
// SetWindowLong(hWndDisplay, GWL_STYLE, 0);
// ShowWindow(hWndDisplay, SW_MAXIMIZE);
// }
INIT(timer = al_create_timer(1.0 / 60), "create timer")
INIT(event_queue = al_create_event_queue(), "create event queue")
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
// End of Allegro initialization
INIT(setup(display), "initialize renderer");
#undef INIT
return true;
err:
if(display) al_destroy_display(display);
{
char* buf = new char[strlen(err) + 13];
sprintf(buf, "Failed to %s!\n", err);
// MessageBoxA(NULL, buf, "Error", MB_ICONERROR);
delete buf;
}
return false;
}
bool Framework::initialize(std::string config_filename)
{
if (initialized) return initialized;
if (!al_init()) std::cerr << "al_init() failed" << std::endl;
ALLEGRO_PATH *resource_path = al_get_standard_path(ALLEGRO_RESOURCES_PATH);
al_change_directory(al_path_cstr(resource_path, ALLEGRO_NATIVE_PATH_SEP));
al_destroy_path(resource_path);
if (!al_install_mouse()) std::cerr << "al_install_mouse() failed" << std::endl;
if (!al_install_keyboard()) std::cerr << "al_install_keyboard() failed" << std::endl;
if (!al_install_joystick()) std::cerr << "al_install_joystick() failed" << std::endl;
if (!al_install_audio()) std::cerr << "al_install_audio() failed" << std::endl;
if (!al_init_native_dialog_addon()) std::cerr << "al_init_native_dialog_addon() failed" << std::endl;
if (!al_init_primitives_addon()) std::cerr << "al_init_primitives_addon() failed" << std::endl;
if (!al_init_image_addon()) std::cerr << "al_init_image_addon() failed" << std::endl;
if (!al_init_font_addon()) std::cerr << "al_init_font_addon() failed" << std::endl;
if (!al_init_ttf_addon()) std::cerr << "al_init_ttf_addon() failed" << std::endl;
if (!al_init_acodec_addon()) std::cerr << "al_init_acodec_addon() failed" << std::endl;
if (!al_reserve_samples(32)) std::cerr << "al_reserve_samples() failed" << std::endl;
srand(time(NULL));
primary_timer = al_create_timer(ALLEGRO_BPS_TO_SECS(60));
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
// al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR | ALLEGRO_MIPMAP);
builtin_font = al_create_builtin_font();
event_queue = al_create_event_queue();
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(primary_timer));
al_register_event_source(event_queue, al_get_joystick_event_source());
al_register_event_source(event_queue, al_get_default_menu_event_source());
if (al_get_num_joysticks()) joystick = al_get_joystick(0); // make this better eventually
else std::cerr << "no joystick(s) detected" << std::endl;
instance = new Framework(config_filename);
Attributes::create_datatype_definition(
AllegroColorAttributeDatatype::IDENTIFIER,
AllegroColorAttributeDatatype::to_val_func,
AllegroColorAttributeDatatype::to_str_func
);
initialized = true;
return true;
}
WPJInputUtil::~WPJInputUtil()
{
ClearAllTriggedEvents();
if (al_is_keyboard_installed())
al_unregister_event_source(m_pEventQueue, al_get_keyboard_event_source());
if (al_is_mouse_installed())
al_unregister_event_source(m_pEventQueue, al_get_mouse_event_source());
al_destroy_event_queue(m_pEventQueue);
}
void init_event_things(ALLEGRO_TIMER* &timer, ALLEGRO_EVENT_QUEUE* &queue) {
al_set_new_window_position(window_x, window_y);
display = al_create_display(scr_w, scr_h);
timer = al_create_timer(1.0 / game_fps);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_mouse_event_source());
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_joystick_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
}
void AllegroEventSource::init()
{
m_impl = new AllegroEventSourceImpl();
assert(m_impl != nullptr && "Unable to allocate AllegroEventSourceImpl");
m_impl->event_queue = al_create_event_queue();
assert(m_impl->event_queue != nullptr && "Unable to allocate Allegro Event Queue");
ALLEGRO_EVENT_QUEUE *q = m_impl->event_queue;
al_register_event_source(q, al_get_keyboard_event_source());
al_register_event_source(q, al_get_mouse_event_source());
al_register_event_source(q, al_get_joystick_event_source());
}
Mousebinds::Mousebinds()
{
m_events = al_create_event_queue();
if (m_events == nullptr)
{
auto msg = "failed to create event queue\n";
fprintf(stderr,"%s\n", msg);
GET_LOG.writeToLog(msg,"Mousebinds.cpp","MouseBinds()",Utils::Critical);
}
m_mouseEventSource = al_get_mouse_event_source();
al_register_event_source(m_events, m_mouseEventSource);
}
void SceneManager::registerEventSources()
{
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(m_gameTimer));
al_register_event_source(queue, al_get_display_event_source(m_devices->getDisplay()->getContext()));
#ifdef CGE_MOBILE
al_register_event_source(queue, al_get_touch_input_event_source());
al_register_event_source(queue, al_get_touch_input_mouse_emulation_event_source());
//al_register_event_source(queue, al_get_joystick_event_source());
#endif
Log::write("Scene Manager","Event sources registered");
}
void allegro_event_queue_init(Jogo* jogo){
jogo->event_queue = al_create_event_queue();
if(!jogo->event_queue){
al_show_native_message_box(jogo->display, "Erro", "Erro", "Falha ao iniciar a lista de eventos.", "OK", ALLEGRO_MESSAGEBOX_ERROR);
destroi_jogo(jogo);
exit(1);
}
al_register_event_source(jogo->event_queue, al_get_mouse_event_source());
al_register_event_source(jogo->event_queue, al_get_keyboard_event_source());
al_register_event_source(jogo->event_queue, al_get_timer_event_source(jogo->timer));
al_register_event_source(jogo->event_queue, al_get_display_event_source(jogo->display));
}
void AllegroFlasher::run()
{
const int zero = 0;
timer = al_create_timer(1.0 / FPS.at(zero));
display = al_create_display(width, height);
event_queue = al_create_event_queue();
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_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_start_timer(timer); // Start the timer
int counter = 0;
while(!done) // Main loop
{
EVENT Event = EventType(); // Wait for an event to occur
if (Event == ESCAPE) { // Quit the program
counter = frames.at(zero);
break;
}
else if (Event == UPDATE) { // A timer event
if(useBlankStart && counter < frames.at(zero)/2)
displayBlankScreen(); // Simply display a black screen
else
updateDisplay();
counter++;
}
else if (Event == UP) {
moveBlock(UP);
}
else if (Event == DOWN) {
moveBlock(DOWN);
}
else if (Event == LEFT) {
moveBlock(LEFT);
}
else if (Event == RIGHT) {
moveBlock(RIGHT);
}
if(counter == frames.at(zero))
done = true;
}
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
done = false; // Set again for the next time
}
// METODO PARA REGISTRAR OS SOURCES DO ALLEGRO NA FILA DE EVENTOS
void GerenciadorGrafico::RegistraSources()
{
// EVENTOS RELACIONADOS AO TECLADO
al_register_event_source(FilaEventos, al_get_keyboard_event_source());
// EVENTOS RELACIONADOS AO DISPLAY
al_register_event_source(FilaEventos, al_get_display_event_source(display));
// EVENTOS RELACIONADOS AO MOUSE
al_register_event_source(FilaEventos, al_get_mouse_event_source());
// EVENTOS RELACIONADOS AO TEMPORIZADOR
al_register_event_source(FilaEventos, al_get_timer_event_source(timer));
}
EventQueue::EventQueue()
: implementation(new Implementation)
{
checkInit();
this->implementation->allegroEventQueue = al_create_event_queue();
if(this->implementation->allegroEventQueue == NULL)
throw AdapterException("Could not create event queue");
al_register_event_source(this->implementation->allegroEventQueue, al_get_display_event_source(fgeal::display->implementation->allegroDisplay));
al_register_event_source(this->implementation->allegroEventQueue, al_get_keyboard_event_source());
al_register_event_source(this->implementation->allegroEventQueue, al_get_mouse_event_source());
}
int yes_no_dialog(const char *text){
ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue();
ALLEGRO_EVENT ev;
int noexit;
int yes_x, yes_y, no_x, no_y;
int dw = al_get_bitmap_width(al_get_target_bitmap());
int dh = al_get_bitmap_height(al_get_target_bitmap());
int ret=0;
int bh = 120, bw = 400;
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
al_clear_to_color(NULL_COLOR);
al_draw_filled_rectangle((dw - bw)/2, (dh-bh)/2, (dw+bw)/2, (dh+bh)/2, WINDOW_BG_COLOR);
al_draw_rectangle((dw - bw)/2, (dh-bh)/2, (dw+bw)/2, (dh+bh)/2, WINDOW_BD_COLOR,3);
al_draw_multiline_text(default_font, al_map_rgb_f(1,1,1), dw/2, (dh-bh)/2+20, 360, 18, ALLEGRO_ALIGN_CENTER, text);
yes_x = (dw-bw)/2 + 64;
yes_y = (dh+bh)/2 - 44;
no_x = (dw+bw)/2 - 128;
no_y = (dh+bh)/2 - 44;
al_draw_rectangle(yes_x, yes_y, yes_x+64, yes_y+24, al_map_rgb_f(1,1,1), 1);
al_draw_rectangle(no_x, no_y, no_x+64, no_y+24, al_map_rgb_f(1,1,1), 1);
al_draw_text(default_font, al_map_rgb_f(1,1,1), yes_x+32, yes_y+4, ALLEGRO_ALIGN_CENTER, "OK");
al_draw_text(default_font, al_map_rgb_f(1,1,1), no_x+32, no_y+4, ALLEGRO_ALIGN_CENTER, "Cancel");
al_flip_display();
noexit=1;
while(noexit){
al_wait_for_event(queue, &ev);
if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN){
if( (ev.mouse.x > yes_x) && (ev.mouse.x < yes_x+64) && (ev.mouse.y > yes_y) && (ev.mouse.y < yes_y+24) ){
ret = 1;
noexit = 0;
} else if( (ev.mouse.x > no_x) && (ev.mouse.x < no_x+64) && (ev.mouse.y > no_y) && (ev.mouse.y < no_y+24) ){
ret = 0; noexit = 0;
}
}
if(ev.type == ALLEGRO_EVENT_KEY_CHAR)
noexit = 0;
}
al_destroy_event_queue(queue);
return ret;
}
void AllegroShell::init(int disp_h, int disp_w, int step_flag){
fps = 30;
display_h = disp_h; // 480
display_w = disp_w; // 480
run_flag = true;
draw_flag = false;
this->step_flag = step_flag; // false
step_once_flag = false;
int x = 8;
x -= al_init();
x -= al_init_image_addon();
al_init_font_addon();
x -= al_init_ttf_addon();
x -= al_install_mouse();
x -= al_install_keyboard();
x -= al_install_audio();
x -= al_init_acodec_addon();
x -= al_init_primitives_addon();
//x -= al_reserve_samples(10);
printf("%d errors during loading.\n",x);
// initializing the allegro objects
display = al_create_display(display_w,display_h);
queue = al_create_event_queue();
timer = al_create_timer(1.0/fps);
// al_toggle_display_flag(display,ALLEGRO_FULLSCREEN_WINDOW,false);
// al_toggle_display_flag(display,ALLEGRO_NOFRAME,false);
// registering the even sourcees
al_register_event_source(queue,al_get_timer_event_source(timer));
al_register_event_source(queue,al_get_display_event_source(display));
al_register_event_source(queue,al_get_mouse_event_source());
al_register_event_source(queue,al_get_keyboard_event_source());
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
// instantiate my objects
mouse = new _Mouse();
model = new Model();
al_set_timer_speed(timer,1.0/model->speed);
view = new View(this,model);
al_register_event_source(queue,view->get_event_source());
view->emit_event();
}
bool CriaBotoes()
{
// Torna apto o uso de mouse na aplicação
if (!al_install_mouse())
{
fprintf(stderr, "Falha ao inicializar o mouse.\n");
return false;
}
// Alocamos o retângulo botaoiniciar
BotaoIniciar = al_create_bitmap(130, 20);
if (!BotaoIniciar)
{
fprintf(stderr, "Falha ao criar bitmap.\n");
return false;
}
// Alocamos o retângulo Carregar Jogo
BotaoCarrega = al_create_bitmap(190, 20);
if (!BotaoCarrega)
{
fprintf(stderr, "Falha ao criar bitmap.\n");
return false;
}
// Alocamos o retângulo Carregar Jogo
BotaoHistoria = al_create_bitmap(130, 20);
if (!BotaoHistoria)
{
fprintf(stderr, "Falha ao criar bitmap.\n");
return false;
}
// Alocamos o botão para fechar a aplicação
BotaoSair = al_create_bitmap(70, 20);
if (!BotaoSair)
{
fprintf(stderr, "Falha ao criar botão de saída.\n");
return false;
}
// Dizemos que vamos tratar os eventos vindos do mouse
al_register_event_source(Fila_Eventos, al_get_mouse_event_source());
return true;
}
void StateGameMode::InitState(ALLEGRO_DISPLAY *display, Settings *settings, Map *currentMap, ImageLoader *imageLoader){
SetImageLoader(imageLoader);
SetDisplay(display);
SetSettings(settings);
SetId(EnumDLL::STATES::EDITORMODE);
SetEventQueue(NULL);
SetRedraw(true);
SetDone(false);
SetRunning(true);
SetKeyPressReturnVal(EnumDLL::STATES::DEFAULT);
SetFont(al_load_font("arial.ttf", 20, 0));
SetTimer(al_create_timer(1.0/60));
SetEventQueue(al_create_event_queue());
SetStateDirection(EnumDLL::STATEDIRECTION::NA);
al_register_event_source(GetEventQueue(), al_get_keyboard_event_source());
al_register_event_source(GetEventQueue(), al_get_mouse_event_source());
al_register_event_source(GetEventQueue(), al_get_display_event_source(GetDisplay()));
al_register_event_source(GetEventQueue(), al_get_timer_event_source(GetTimer()));
SetMouseCursorPos(0,0);
SetRightMousePos(0,0);
SetRightMouseDown(false);
SetLeftMouseDown(false);
SetPlayerSelected(false);
SetMap(currentMap);
player1_ = new Player(GetSettings(),GetMap());
player1_->SetGravityY(-9.8);
for(int i = 0; i < GetImageLoader()->GetImageSetDictionary().size(); i++)
{
if(GetImageLoader()->GetImageSetDictionary()[i]->GetImageSetId() == EnumDLL::IMAGESETS::PLAYERIMAGESET)
{
player1_->SetObjectImageColor(GetImageLoader()->GetImageSetDictionary()[i]->GetImageDictionary()[0]);
}
}
SetChosenColor(al_map_rgb_f(1,1,1));
al_start_timer(GetTimer());
}
bool WPJInputUtil::Init()
{
int bRet;
// init input hardware driver
bRet = al_is_keyboard_installed() && al_is_mouse_installed();
// init event_queue
m_pEventQueue = al_create_event_queue();
if (bRet && m_pEventQueue)
{
al_register_event_source(m_pEventQueue, al_get_keyboard_event_source());
al_register_event_source(m_pEventQueue, al_get_mouse_event_source());
al_register_event_source(m_pEventQueue, al_get_display_event_source(m_pDisplay));
}
return bRet;
}
Mouse::Mouse() : AllowBoxing(false), ClickFidelity(3), isBoxing(false), DoubleClickFidelity(0.4), blockBoxing(false)
{
mouseQueue = al_create_event_queue();
al_register_event_source( mouseQueue, al_get_mouse_event_source() );
al_init_user_event_source( &mouseEventSource );
al_register_event_source( EventQueue, &mouseEventSource );
ALLEGRO_MOUSE_STATE state;
al_get_mouse_state( &state );
Position.X = state.x;
Position.Y = state.y;
mouseDownAt.X = 0;
mouseDownAt.Y = 0;
mouseDownButton = 0;
lastClickTime = 0;
}
BaseGame::BaseGame(Vector2 windowSize, ScreenType screenType, string screenTitle, double fps) : fps(fps),
windowSize(windowSize), running(true)
{
initScreen(screenType, screenTitle);
initModules();
al_get_keyboard_state(&keyState);
al_get_mouse_state(&mouseState);
eventQueue = al_create_event_queue();
timer = al_create_timer(1/this->fps);
//Events to read
al_register_event_source(eventQueue, al_get_keyboard_event_source());
al_register_event_source(eventQueue, al_get_timer_event_source(timer));
al_register_event_source(eventQueue, al_get_display_event_source(display));
al_register_event_source(eventQueue, al_get_mouse_event_source());
}
EventQueue::EventQueue(Renderer* r) {
//Obtém a event queue do Allegro, a registra e a torna default
//Nós vamos obter nossos eventos a partir dela
_allegro_queue = al_create_event_queue();
// Inicia os subsistemas de teclado e mouse do Allegro
al_install_keyboard();
al_install_mouse();
//Registra para receber eventos do display, do mouse e do teclado
al_register_event_source(_allegro_queue,
al_get_display_event_source(r->GetDisplay()));
al_register_event_source(_allegro_queue,
al_get_mouse_event_source());
al_register_event_source(_allegro_queue,
al_get_keyboard_event_source());
}
int CEngine::Init(void)
{
// Init Allegro core.
if (!al_init())
return -1;
// Load/manipulate image files.
if (!al_init_image_addon())
return -2;
// Ability to draw primitives.
if (!al_init_primitives_addon())
return -3;
// To receive keyboard events.
if (!al_install_keyboard())
return -4;
// To receive mouse events.
if (!al_install_mouse())
return -5;
m_display = al_create_display(1000, 600);
if (!m_display)
return -10;
m_timer = al_create_timer(1.0f / 60.0f);
if (!m_timer)
return -11;
m_evQ = al_create_event_queue();
if (!m_evQ)
return -12;
// Get display events.
al_register_event_source(m_evQ, al_get_display_event_source(m_display));
// Get timer events.
al_register_event_source(m_evQ, al_get_timer_event_source(m_timer));
// Get keyboard events.
al_register_event_source(m_evQ, al_get_keyboard_event_source());
// Get mouse events.
al_register_event_source(m_evQ, al_get_mouse_event_source());
// Renderer that controls what is shown on the screen.
m_renderer = new CRenderer(this);
return 0;
}
