void clear_input_events(double older_than)
{
if (older_than < 0) {
drop_input_events_older_than = al_get_time();
}
else {
drop_input_events_older_than = older_than;
}
while (input_events.size() > 0) {
INPUT_EVENT &ie = *input_events.begin();
if (ie.timestamp >= drop_input_events_older_than) {
break;
}
input_events.erase(input_events.begin());
}
for (int i = 0; i < JOY_NUM_REPEATABLE; i++) {
joystick_initial_repeat_countdown[i] = JOY_INITIAL_REPEAT_TIME;
joystick_repeat_countdown[i] = JOY_REPEAT_TIME;
joystick_repeat_started[i] = false;
joystick_repeat_events[i] = EMPTY_INPUT_EVENT;
}
joy_axes[0] = joy_axes[1] = 0;
Input *i = getInput();
if (i) {
i->reset();
}
clear_touches();
released = true;
}
void SystemManager::update(float time, const ALLEGRO_EVENT &ev)
{
std::multimap<int, System*>::iterator i;
static float lastTime = al_get_time();
std::vector<EntityData>&list = EntityManager::getInstance().getList();
float difTime = time - lastTime;
i = list_.begin();
while (i != list_.end())
{
i->second->updateBegin(time, ev);
for (unsigned int it = 0; it < EntityManager::getInstance().end(); ++it)
{
// // if (!e.active)
// // continue;
EntityData &e = list[it];
if (i->second->match(e))
i->second->update(e, difTime, ev);
}
i->second->updateEnd(time, ev);
++i;
}
lastTime = time;
}
void play()
{
bool draw;
ALLEGRO_EVENT ev;
float time;
this->run_->setValue(true);
draw = false;
while (this->run_->getValue())
{
time = al_get_time();
al_wait_for_event(this->event_queue_, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER)
{
draw = true;
}
if (upt_)
this->upt_(time, ev);
if (draw && al_is_event_queue_empty(this->event_queue_) && this->draw_)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
this->draw_(time, ev);
al_flip_display();
draw = false;
}
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
this->stop();
}
}
}
/* generate_mouse_event: [bgman thread]
* Helper to generate a mouse event.
*/
static void generate_mouse_event(unsigned int type,
int x, int y, int z, int w, float pressure,
int dx, int dy, int dz, int dw,
unsigned int button,
ALLEGRO_DISPLAY *display)
{
ALLEGRO_EVENT event;
if (!_al_event_source_needs_to_generate_event(&the_mouse.parent.es))
return;
event.mouse.type = type;
event.mouse.timestamp = al_get_time();
event.mouse.display = display;
event.mouse.x = x;
event.mouse.y = y;
event.mouse.z = z;
event.mouse.w = w;
event.mouse.dx = dx;
event.mouse.dy = dy;
event.mouse.dz = dz;
event.mouse.dw = dw;
event.mouse.button = button;
event.mouse.pressure = pressure;
_al_event_source_emit_event(&the_mouse.parent.es, &event);
}
/* handle_key_release: [fdwatch thread]
* Helper: stuff to do when a key is released.
*/
static void handle_key_release(int mycode)
{
ALLEGRO_EVENT event;
/* This can happen, e.g. when we are switching back into a VT with
* ALT+Fn, we only get the release event of the function key.
*/
if (!_AL_KEYBOARD_STATE_KEY_DOWN(the_keyboard.state, mycode))
return;
/* Maintain the key_down array. */
_AL_KEYBOARD_STATE_CLEAR_KEY_DOWN(the_keyboard.state, mycode);
/* Generate key release events if necessary. */
if (!_al_event_source_needs_to_generate_event(&the_keyboard.parent.es))
return;
event.keyboard.type = ALLEGRO_EVENT_KEY_UP;
event.keyboard.timestamp = al_get_time();
event.keyboard.display = NULL;
event.keyboard.keycode = mycode;
event.keyboard.unichar = 0;
event.keyboard.modifiers = 0;
_al_event_source_emit_event(&the_keyboard.parent.es, &event);
}
void newFrame(FrameInfo &infos)
{
_currentImage = std::unique_ptr<Image>(new Image(infos.path));
_counter = _delay;
_last = al_get_time();
update();
}
void ImGui_ImplAllegro5_NewFrame()
{
if (!g_Texture)
ImGui_ImplAllegro5_CreateDeviceObjects();
ImGuiIO &io = ImGui::GetIO();
// Setup display size (every frame to accommodate for window resizing)
int w, h;
w = al_get_display_width(g_Display);
h = al_get_display_height(g_Display);
io.DisplaySize = ImVec2((float)w, (float)h);
// Setup time step
double current_time = al_get_time();
io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
g_Time = current_time;
// Setup inputs
ALLEGRO_KEYBOARD_STATE keys;
al_get_keyboard_state(&keys);
io.KeyCtrl = al_key_down(&keys, ALLEGRO_KEY_LCTRL) || al_key_down(&keys, ALLEGRO_KEY_RCTRL);
io.KeyShift = al_key_down(&keys, ALLEGRO_KEY_LSHIFT) || al_key_down(&keys, ALLEGRO_KEY_RSHIFT);
io.KeyAlt = al_key_down(&keys, ALLEGRO_KEY_ALT) || al_key_down(&keys, ALLEGRO_KEY_ALTGR);
io.KeySuper = al_key_down(&keys, ALLEGRO_KEY_LWIN) || al_key_down(&keys, ALLEGRO_KEY_RWIN);
ImGui_ImplAllegro5_UpdateMouseCursor();
}
void move()
{
if (al_get_time() > nextStyleChange_)
{
if (currentMove_ == chasingMove_)
{
currentMove_ = randomMove_;
}
else if (rand()%2 == 0)
currentMove_ = chasingMove_;
else
currentMove_ = randomMove_;
nextStyleChange_ = al_get_time() + 5;
}
currentMove_->move();
}
void enemyshot(Game *game, int i)
{
Enemy enemy;
enemy = game->room->enemies[i];
switch (enemy.shottype)
{
case 0: //4 prostopadle
{
if (enemy.lastshot + enemy.shotfreq < al_get_time())
{
newshot(game, enemy.shotpic, enemy.posx+enemy.szer/2, enemy.posy,20,20,20,enemy.shotspeed,
0,enemy.range,1,0,enemy.dmg);
newshot(game, enemy.shotpic, enemy.posx+enemy.szer/2, enemy.posy,20,20,20,-enemy.shotspeed,
0,enemy.range,1,0,enemy.dmg);
newshot(game, enemy.shotpic, enemy.posx+enemy.szer/2, enemy.posy,20,20,20,0,enemy.shotspeed,
enemy.range,1,0,enemy.dmg);
newshot(game, enemy.shotpic, enemy.posx+enemy.szer/2, enemy.posy,20,20,20,0,-enemy.shotspeed,
enemy.range,1,0,enemy.dmg);
game->room->enemies[i].lastshot = al_get_time();
}
break;
}
case 1: // 1 skierowany
{
if (enemy.lastshot + enemy.shotfreq < al_get_time())
{
if (pow(enemy.posy-enemy.grub/2+5 - (game->bunny.posy-game->bunny.grub/2+5),2)
+ pow(enemy.posx+enemy.szer/2 - (game->bunny.posx+game->bunny.szer/2),2) < pow(enemy.range,2) )
{
double speedx, speedy;
speedx = enemy.shotspeed * -(enemy.posx+enemy.szer/2 - (game->bunny.posx+game->bunny.szer/2))
/ sqrt(pow(enemy.posy-enemy.grub/2+5 - (game->bunny.posy-game->bunny.grub/2+5),2)
+ pow(enemy.posx+enemy.szer/2 - (game->bunny.posx+game->bunny.szer/2),2));
speedy = enemy.shotspeed * -(enemy.posy-enemy.grub/2+5 - (game->bunny.posy-game->bunny.grub/2+5))
/ sqrt(pow(enemy.posy-enemy.grub/2+5 - (game->bunny.posy-game->bunny.grub/2+5),2)
+ pow(enemy.posx+enemy.szer/2 - (game->bunny.posx+game->bunny.szer/2),2));
newshot(game,enemy.shotpic, enemy.posx+enemy.szer/2, enemy.posy,20,20,20,speedx,
speedy,enemy.range,1,0,enemy.dmg);
}
game->room->enemies[i].lastshot = al_get_time();
}
break;
}
}
}
void Enemy::draw()
{
al_draw_filled_ellipse(posx_+width_/2, posy_- height_/2+5, width_/2, height_/2, al_map_rgba(0,0,0,50));
if (lastHurt_ + 0.5 < al_get_time())
al_draw_bitmap_region(picture_, animationState_*pic_width_, 0, pic_width_, pic_height_, posx_, posy_ - pic_height_ - posz_, 0);
else
al_draw_tinted_bitmap_region(picture_, al_map_rgba(200,100,100,100), animationState_*pic_width_, 0, pic_width_, pic_height_, posx_, posy_ - pic_height_ - posz_, 0);
}
/*
Function: wz_craft_event
Crafts a simple GUI event.
Parameters:
type - Type of the event
source - The widget that launched the event, or 0 if it has no source
data - data you wish to attach to the event
*/
void wz_craft_event(ALLEGRO_EVENT* event, int type, WZ_WIDGET* source, intptr_t data)
{
event->user.type = type;
event->user.timestamp = al_get_time();
event->user.data1 = source == 0 ? -1 : source->id;
event->user.data2 = (intptr_t)source;
event->user.data3 = data;
}
vector<Shot*> shoot()
{
vector<Shot*> shots;
if (lastShot_ + shotTime_ > al_get_time())
return shots;
lastShot_ = al_get_time();
double* enemyPos = enemy_->getPos();
int* enemySize = enemy_->getSize();
double* bunnyPos = bunny_->getPos();
int* bunnySize = bunny_->getSize();
double xdistance = bunnyPos[0] + bunnySize[0]/2 - enemyPos[0] - enemySize[0]/2;
double ydistance = bunnyPos[1] - bunnySize[1]/2 - enemyPos[1] + enemySize[1]/2;
shots.push_back(new Shot(picture_, enemyPos[0] + enemySize[0]/2 - 10, enemyPos[1] + 1, enemySize[1]/2, xdistance, ydistance,
range_, true, 1));
return shots;
}
void MonopolyGame::calcFramerate() {
double gameTime = al_get_time();
if( gameTime - m_oldFps >= 1.0 ) {
m_currFps = m_framesDone / ( gameTime - m_oldFps );
m_framesDone = 0;
m_oldFps = gameTime;
}
}
int main(int argc, char **argv)
{
ALLEGRO_BITMAP *bitmap;
double t0;
double t1;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
if (argc < 3) {
log_printf("This example needs to be run from the command line.\n");
log_printf("Usage: %s <infile> <outfile>\n", argv[0]);
log_printf("\tPossible file types: BMP PCX PNG TGA\n");
goto done;
}
al_init_image_addon();
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ARGB_8888);
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP
| ALLEGRO_NO_PREMULTIPLIED_ALPHA);
bitmap = al_load_bitmap(argv[1]);
if (!bitmap) {
log_printf("Error loading input file\n");
goto done;
}
t0 = al_get_time();
if (!al_save_bitmap(argv[2], bitmap)) {
log_printf("Error saving bitmap\n");
goto done;
}
t1 = al_get_time();
log_printf("Saving took %.4f seconds\n", t1 - t0);
al_destroy_bitmap(bitmap);
done:
close_log(true);
return 0;
}
void mw2_Application::StartGame()
{
mLastFrameTime = (float) al_get_time();
while (true)
{
mCurrentFrameTime = (float) al_get_time();
float deltaTime = mCurrentFrameTime - mLastFrameTime;
mLastFrameTime = mCurrentFrameTime;
mw2_Input::CheckDevices();
if (mIsExit) break;
RunUpdate(deltaTime);
if (mIsExit) break;
RunRender();
}
}
FiveShots(Enemy* enemy, int range, double shotTime, ALLEGRO_BITMAP* picture)
{
enemy_ = enemy;
range_ = range;
picture_ = picture;
lastShot_ = al_get_time() + rand()%10/10.0;
shotTime_ = shotTime;
}
static SCM
game_get_time (SCM game_smob)
{
// We don't actually need to use the game struct here.
check_game (game_smob);
return scm_from_double (al_get_time ());
}
//Init for States
int
state_init ()
{
prev_time = al_get_time ();
set_shader (identity_shader ());
gui_init ();
return handlers[state].proc_init ();
}
static void ljoy_generate_configure_event(void)
{
ALLEGRO_EVENT event;
event.joystick.type = ALLEGRO_EVENT_JOYSTICK_CONFIGURATION;
event.joystick.timestamp = al_get_time();
_al_generate_joystick_event(&event);
}
void Motion::cmove_to(float *val, float end_val, float duration, float (*interpolator_func)(float), void (*callback_func)(void *), void *callback_data)
{
double time_now = al_get_time();
int new_index = get_new_index();
clear_animations_on(val);
control[new_index]->clear();
control[new_index]->set(val, time_now, time_now+duration, *val, end_val, interpolator_func, callback_func, callback_data);
}
void Ak47::reload()
{
if(bullets == magazineSize)
return;
if(totalBulletes - (magazineSize - bullets) < 0)
return;
if(al_get_time() - lastReload < reloadTime)
return;
//tocar som de reload
al_play_sample(aReloadSound, 0.7, 0, 1, ALLEGRO_PLAYMODE_ONCE, 0);
totalBulletes -= magazineSize - bullets;
bullets = magazineSize;
lastReload = al_get_time();
}
void update()
{
al_set_target_backbuffer(_display);
al_clear_to_color(al_map_rgb(0,255,0));
if (_counter <= 0.0f)
{
_waitingImage->display();
}
else
{
float d = al_get_time() - _last;
_counter -= d;
_currentImage->display();
_last = al_get_time();
}
_testingImage->displayMini();
al_flip_display();
}
void update_reposition_camera()
{
static float reposition_timer = 0;
// update the camera's scale and rotation
// initiate motion with the camera
reposition_timer -= 1/60.0;
if (reposition_timer <= 0)
{
reposition_timer = 3;
motion.cmove_to(&camera.placement.position.x, random_float(0, 40*21), 3, interpolator::double_slow_in_out);
motion.cmove_to(&camera.placement.position.y, random_float(0, 20*21), 3, interpolator::double_slow_in_out);
}
camera.placement.scale.x = sin(al_get_time())*0.1 + 2;
camera.placement.scale.y = camera.placement.scale.x;
camera.placement.rotation = sin(al_get_time())*TAU * 0.03;
}
DirectedShots(Enemy* enemy, int range, double shotTime, ALLEGRO_BITMAP* picture, Bunny* bunny)
{
enemy_ = enemy;
range_ = range;
picture_ = picture;
lastShot_ = al_get_time() + rand()%10/10.0;
shotTime_ = shotTime;
bunny_ = bunny;
}
static void emit_close_event(ALLEGRO_NATIVE_DIALOG *textlog, bool keypress)
{
ALLEGRO_EVENT event;
event.user.type = ALLEGRO_EVENT_NATIVE_DIALOG_CLOSE;
event.user.timestamp = al_get_time();
event.user.data1 = (intptr_t)textlog;
event.user.data2 = (intptr_t)keypress;
al_emit_user_event(&textlog->tl_events, &event, NULL);
}
static bool hapxi_poll_haptic_effect_delayed(ALLEGRO_HAPTIC_XINPUT *hapxi,
ALLEGRO_HAPTIC_EFFECT_XINPUT *effxi)
{
double now = al_get_time();
if (now > (effxi->loop_start + effxi->effect.replay.delay)) {
return hapxi_force_play(hapxi, effxi);
}
return false;
}
PikachuMove(Enemy* enemy, Bunny* bunny)
{
enemy_ = enemy;
bunny_ = bunny;
nextStyleChange_ = al_get_time() + 5;
chasingMove_ = new ChasingMove(enemy, bunny);
randomMove_ = new RandomMove(enemy);
currentMove_ = randomMove_;
}
void add_input_event(INPUT_EVENT ie)
{
al_lock_mutex(input_event_mutex);
ie.timestamp = al_get_time();
input_events.push_back(ie);
al_unlock_mutex(input_event_mutex);
}
Enemy_Avatar_Wander_Character_Role::Enemy_Avatar_Wander_Character_Role(
Character_Map_Entity *character,
int max_distance_from_home,
double pause_min,
double pause_max) :
Wander_Character_Role(character, max_distance_from_home, pause_min, pause_max)
{
next_check = al_get_time() + (General::rand()%1000)/1000.0*5.0 + 5.0;
}
vector<Shot*> shoot()
{
vector<Shot*> shots;
if (lastShot_ + shotTime_ > al_get_time())
return shots;
lastShot_ = al_get_time();
double* enemyPos = enemy_->getPos();
int* enemySize = enemy_->getSize();
for (int i = 0; i < 5; i++)
{
double speedx = rand()%200 - 100;
double speedy = rand()%200 - 100;
int range = range_ * (rand()%10 + 1)/10.0;
shots.push_back(new Shot(picture_, enemyPos[0] + enemySize[0]/2 - 10, enemyPos[1] + 1, enemySize[1]/2, speedx, speedy,
range, true, 1));
}
return shots;
}
