/*player_class::player_class(events_class* new_events)
{
tile=SDL_LoadBMP("red.bmp");
event1=new_events;
position.x=0;
position.y=0;
velocity.x=0;
velocity.y=0;
}*/
void player_class::update()
{
on_screen_check();
///does the physics won't be neccassarry until some sort of map is implemented
update_physics();
accelerate();
move();
}
void Game::run(int minimum_frame_per_seconds, int physics_frame_per_seconds)
{
sf::Clock clock;
const sf::Time timePerFrame = sf::seconds(1.f/minimum_frame_per_seconds);
const sf::Time timePerFramePhysics = sf::seconds(1.f/physics_frame_per_seconds);
while (_window.isOpen())
{
sf::Time time = clock.restart();
processEvents();
if(not _stats.isGameOver())
{
update_physics(time,timePerFramePhysics);
update(time,timePerFrame);
}
render();
}
}
int main(int argc, const char **argv){
struct Personaje prota[MAXIMO];
while(1){
for (int i=0; i<MAXIMO; i++)
update_physics(&prota[i]);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv){
struct Movil nave;
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_BITMAP *sprites = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
/* Alegro startup */
if(!al_init()) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize allegro!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
if(!al_init_image_addon()) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
if(!al_install_keyboard()){
al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
};
/* Alegro artifact creation */
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize display!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
al_show_native_message_box(display, "Error", "Error", "failed to create timer!\n",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return -1;
}
event_queue = al_create_event_queue();
if(!event_queue) {
al_show_native_message_box(display, "Error", "Error", "failed to create event_queue!\n",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
/* stitching */
sprites = al_load_bitmap("images/xenon2_sprites.png");
if(!sprites) {
al_show_native_message_box(display, "Error", "Error", "Failed to load sprites!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
return 0;
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
/* Init game objects */
init(sprites, &nave);
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
/* Game loop */
while(!doexit){
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
redraw = true;
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = true;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = true;
break;
}
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
update_physics(key, &nave);
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
//al_draw_bitmap(sprites,200,200,0);
al_draw_bitmap(nave.img, 100, 100, 0);
al_flip_display();
}
}
/* Housekeeping */
al_rest(2);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_bitmap(sprites);
return 0;
}
/* returns 1 if apple was hit, otherwise 0 */
int simulate_objects(object *objects, float audio_level)
{
enum object_ctr i;
if (objects[APPLE].invincibility_timer != 0)
objects[APPLE].invincibility_timer--;
/* handle respawn timing */
for (i = 0; i < LAST_MOVER; i++) {
object *o = &objects[i];
if (o->respawn_timer != 0)
o->respawn_timer--;
else if (o->destroyed && o->respawn_timer == 0) { /* time to respawn */
o->respawn_timer = 0;
o->destroyed = 0;
if (i == APPLE)
o->invincibility_timer = APPLE_INVINCIBILITY_TIME;
reset_object_physics(objects, i);
}
}
for (i = 0; i < LAST_MOVER; i++) {
object *o = &objects[i];
if (o->destroyed)
continue;
if (i == APPLE)
o->y_acc = G - MIC_SENSITIVITY*audio_level;
update_physics(objects, i, MODE_WRT_APPLE);
/*printf("%f %f\n", o->x_pos, o->y_pos);*/
if (i == APPLE && o->y_pos < 0) {
o->y_pos = 0; /* cap the apple to the top of the screen */
o->y_vel = 0;
}
if (i != APPLE &&
!objects[APPLE].destroyed &&
objects[APPLE].invincibility_timer == 0 &&
check_collision(o, &objects[APPLE]) == 1) {
objects[APPLE].destroyed = 1;
load_respawn(&objects[APPLE], APPLE, 1.0);
load_respawn(o, i, 20/(objects[APPLE].x_vel));
}
if ( (check_if_offscreen(o) == 1 ||
check_ground_collision(o, &objects[GROUND]) == 1)
&& !o->destroyed ) {
o->destroyed = 1;
if (i != APPLE) {
/* third arg is multiplier on respawn time -
decrease spawn interval as goes faster */
load_respawn(o, i, 20/(objects[APPLE].x_vel));
} else
load_respawn(o, i, 1.0);
}
}
/* apple has just been destroyed */
if (objects[APPLE].respawn_timer == APPLE_RESPAWN_INTERVAL) {
/* don't reset velocity */
objects[APPLE].reset_x_vel = objects[APPLE].x_vel;
return 1;
} else
return 0;
}
int main(int argc, char **argv){
/*declaramos nave como una estructura tipo móvil, q está definida
* en el archivo "physics.h"*/
struct Movil nave;
/*creamos las variables de allegro, que son punteros
* apuntando a NULL, de momento*/
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_BITMAP *sprites = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool key[4] = {false, false, false,false};//Array para las teclas, todos a false
bool redraw = true;
bool do_exit = false;
/* Inicializamos allegro */
if(!al_init()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize allegro!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
/* Inicializamos añadido de imágenes */
if(!al_init_image_addon()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize al_init_image_addon!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
ni /* Inicializamos el teclado */
if(!al_install_keyboard()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize al_init_image_addon!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
};
/* Alegro artifact creation
* del display, timer, cola eventos y sprites*/
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
al_show_native_message_box(
display,
"Error",
"Error",
"Failed to initialize display!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
al_show_native_message_box(
display,
"Error",
"Error",
"failed to create timer!\n",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return 0;
}
event_queue = al_create_event_queue();
if(!event_queue) {
al_show_native_message_box(
display,
"Error",
"Error",
"failed to create event_queue!\n",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
return 0;
}
sprites = al_load_bitmap("images/xenon2_sprites.png");
al_convert_mask_to_alpha(sprites, al_map_rgb(255,0,255));
if(!sprites) {
al_show_native_message_box(
display,
"Error",
"Error",
"Failed to load sprites!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
return 0;
}
/* registramos todos los eventos provenientes de la pantalla
* el keyboard y el temporizador*/
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
/* Init es una funcion definida como extern el "physics.h" , que le meto
* los sprites, que es el bitmap de la nave, y &nave, que es una dirección
* de memoria donde hemos declarado nave como estructura*/
init(sprites, &nave);
al_start_timer(timer);
while(!doexit){
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
redraw = true;
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
/* éste bloque funciona con el evento KEY_DOWN, y cuando apretamos
* cualquier tecla, se registra el avento KEY_DOWN q corresponda */
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_THROTTLE] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_BRAKE] = true;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_ROTATE_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_ROTATE_RIGHT] = true;
break;
}
/* Éste bloque funciona con el evento KEY_UP, cuando soltamos
* la tecla se registra el evento KEY_DOWN correspondiente.*/
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_THROTTLE] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_BRAKE] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_ROTATE_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_ROTATE_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
update_physics(key, &nave);
al_clear_to_color(al_map_rgb(0,0,0));
// al_draw_bitmap(sprites,200,200,0);
al_draw_bitmap(nave.img[2 + (int) (nave.v.x / ROLL) ],
SCREEN_W / 2 + nave.r.x,
SCREEN_H - 50 - nave.r.y,
0);
al_flip_display();
}
}
/* DEstrucción de los artefactos */
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_bitmap(sprites);
return 0;
}
int main(){
struct Movil nave;
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
bool keys[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
if(!al_init()){
fprintf(stderr, "fallo para iniciar allegro\n");
return -1;
}
if(!al_install_keyboard()){
fprintf(stderr, "Fallo al iniciar el teclado\n");
return -1;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "Fallo al iniciar el timer\n");
return -1;
}
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
fprintf(stderr, "Fallo al crear el display\n");
al_destroy_timer(timer);
return -1;
}
bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE);
if(!bouncer) {
fprintf(stderr, "Fallo al crear el bouncer\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(0,0,0));
al_set_target_bitmap(al_get_backbuffer(display));
event_queue = al_create_event_queue();
if(!event_queue) {
fprintf(stderr, "fallo al crear la cola de eventos\n");
al_destroy_bitmap(bouncer);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
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_clear_to_color(al_map_rgb(0,120,120));
al_flip_display();
al_start_timer(timer);
while(!doexit){
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
redraw = true;
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
keys[KEY_THROTTLE] = true;
break;
case ALLEGRO_KEY_DOWN:
keys[KEY_BRAKE] = true;
break;
case ALLEGRO_KEY_LEFT:
keys[KEY_ROTATE_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
keys[KEY_ROTATE_RIGHT] = true;
break;
}
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
keys[KEY_THROTTLE] = false;
break;
case ALLEGRO_KEY_DOWN:
keys[KEY_BRAKE] = false;
break;
case ALLEGRO_KEY_LEFT:
keys[KEY_ROTATE_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
keys[KEY_ROTATE_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)){
redraw = false;
update_physics(keys, &nave);
al_clear_to_color(al_map_rgb(0,120,120));
al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);
al_flip_display();
}
}
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return EXIT_SUCCESS;
}
