void retro_init()
{
int frames = 0;
int c, d;
install_timer();
install_int_ex(timer_rout, BPS_TO_TIMER(100));
install_int_ex(onesec, BPS_TO_TIMER(1));
midi_init();
initpc();
struct retro_log_callback log;
unsigned colorMode = RETRO_PIXEL_FORMAT_XRGB8888;
screen_pitch = 0;
if (environ_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log))
log_cb = log.log;
else
log_cb = NULL;
if (environ_cb(RETRO_ENVIRONMENT_GET_PERF_INTERFACE, &perf_cb))
perf_get_cpu_features_cb = perf_cb.get_cpu_features;
else
perf_get_cpu_features_cb = NULL;
environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &colorMode);
environ_cb(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumble);
}
/* allegInitializations()
Initializes allegro and its associated packages (algif), as well as installing
hardware settings for mouse, keyboard, sound, timers, and the screen.
Autochecks for errors, and displays message and exits(1) on error.
*/
void allegInitializations()
{
int error = 0;
srand(time(0));
error |= allegro_init ();
algif_init ();
set_color_depth (16);
//set_gfx_mode(GFX_AUTODETECT_WINDOWED, 900,600,0,0);
set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 1024,768,0,0);
install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL);
install_keyboard ();
install_mouse();
error |= install_timer();
error |= install_int_ex(incrementTimer, BPS_TO_TIMER(60));
error |= install_int_ex(incrementUpdateCounter, BPS_TO_TIMER(4));
error |= install_int_ex(incrementAnimateCounter, BPS_TO_TIMER(8));
error |= install_int_ex(incrementEconomyCounter, BPM_TO_TIMER(60));
error |= install_int_ex(incrementFireCounter, BPS_TO_TIMER(12));
if (error)
{
set_gfx_mode(GFX_TEXT, 1024,768,0,0);
allegro_message("Allegro Failed to Initialize!");
exit(1);
}
}
void init_frame_speed()
{
LOCK_VARIABLE(frame_counter);
LOCK_FUNCTION(increment_frame_counter);
if(install_int_ex(increment_frame_counter, BPS_TO_TIMER(1000))<0)return;
}
bool OSD::Init (bool fFirstInit_/*=false*/)
{
bool fRet = false;
#ifndef _DEBUG
// Ignore Ctrl-C and Ctrl-Break in release modes
signal(SIGINT, SIG_IGN);
#endif
#ifdef ALLEGRO_WINDOWS
// We'll do our own error handling, so suppress any windows error dialogs
SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
LOCK_VARIABLE(OSD::s_nTicks);
LOCK_FUNCTION(TimerCallback);
if (fFirstInit_ && !fAllegroInit)
allegro_init();
install_int_ex(TimerCallback, BPS_TO_TIMER(EMULATED_FRAMES_PER_SECOND));
fRet = true;
return fRet;
}
static int init_vidmode ()
{
int i;
RGB p;
install_keyboard();
install_timer();
/*install_mouse();*/
LOCK_VARIABLE (clock_ticks);
LOCK_FUNCTION (tick_increment);
install_int_ex (tick_increment, BPS_TO_TIMER (TICK_SECONDS));
screen_buffer = create_bitmap (GFX_WIDTH, GFX_HEIGHT);
clear(screen_buffer);
clock_count = 0;
clock_ticks = 0;
set_gfx_mode(GFX_VGA, GFX_WIDTH, GFX_HEIGHT, 0, 0);
for(i = 0; i < 32; i++) {
p.r = palette[(i*3)+0];
p.g = palette[(i*3)+1];
p.b = palette[(i*3)+2];
set_color(i, &p);
}
return err_OK;
}
void Time::init()
{
install_timer();
LOCK_VARIABLE(myCurrentTick);
LOCK_FUNCTION(callback);
install_int_ex(callback, BPS_TO_TIMER(Time::TicksPerSecond));
}
void start_serial_timer(int delay)
{
stop_serial_timer();
install_int_ex(serial_time_out_handler, MSEC_TO_TIMER(delay)); // install the timer
serial_time_out = FALSE;
serial_timer_running = TRUE;
}
void set_up_timer()
{
install_timer();
srand(time(NULL));
LOCK_VARIABLE(elapsed_time);
LOCK_FUNCTION(__inc_elapsed_time);
install_int_ex(__inc_elapsed_time, BPS_TO_TIMER(1000));
}
void sleep_timeout(void)
{
remove_int(sleep_timeout);
if(sleep_want_fade)
install_int_ex(sleep_fadeout, BPS_TO_TIMER(2));
else
need_to_quit_program = TRUE;
}
void clock_init()
{
// Install timer related stuff
LOCK_VARIABLE(clock_var);
LOCK_FUNCTION(clock_inc);
install_int_ex(clock_inc, BPS_TO_TIMER(1000));
}
int main()
{
Game_sys game;
LOCK_VARIABLE( counter ); // FPS control
LOCK_FUNCTION( incrctrl );
install_int_ex( incrctrl, BPS_TO_TIMER( 30 ) );
game.LoadFiles();
game.ConfigureMusic();
while( !game.GetDone() && game.GetGameState() == 1 ) // splash screen and story
{
while( counter > 0 )
{
game.UpdateSplashNStory();
counter -= 1;
}
game.DrawCrntScreen();
}
game.ConfigureMusic();
while( !game.GetDone() && game.GetGameState() == 2 ) // gameplay
{
while( counter > 0 )
{
game.Update();
counter -= 1;
}
game.Draw();
}
game.ConfigureMusic();
while( !game.GetDone() && game.GetGameState() == 3 ) // story good end
{
while( counter > 0 )
{
game.UpdateSplashNStory();
counter -= 1;
}
game.DrawCrntScreen();
}
while( !game.GetDone() && game.GetGameState() == 4 ) // story bad end
{
while( counter > 0 )
{
game.UpdateSplashNStory();
counter -= 1;
}
game.DrawCrntScreen();
}
return 0;
}
/**
* Initialization routine.
*
* Sets all stars to the starting position. Their initial coordinates
* are determined in the main loop. Also installs the algorithm timer.
*/
void initialize_starfield() {
for (int a = 0; a < STAR_AMOUNT; ++a) {
starfield[a].z = 0;
}
// Install algorithm selection timer.
install_int_ex(update_starfield_counter, BPS_TO_TIMER(60));
// Set up the initial star positions.
set_star_pos_algo();
initialize_star_positions();
}
int startGame(){
configAll();
BITMAP * nave = load_bitmap("img/35x45/nave.bmp",NULL);
BITMAP * alien = load_bitmap("img/35x45/alien.bmp", NULL);
BITMAP * gun = load_bitmap("img/35x45/gun.bmp", NULL);
BITMAP * init = load_bitmap("img/start.bmp", NULL);
BITMAP * bg = load_bitmap("img/bartop.bmp", NULL);
BITMAP * buffer = create_bitmap(SCREEN_W,SCREEN_H);
SAMPLE * sound = load_wav("wav/tiro.wav");
SAMPLE * music = load_sample("wav/laserHit.wav");
initStart(buffer,init);
install_int_ex(countXa,SECS_TO_TIMER(1));
install_int_ex(countGun,MSEC_TO_TIMER(1));
gameControll(nave,buffer,alien,gun,bg,sound,music);
destroyAll(nave,buffer,alien,gun,init,bg,sound,music);
return 0;
}
int main()
{
std::srand(std::time(NULL));
allegro_init();
install_timer();
install_keyboard();
// install_mouse();
install_joystick(JOY_TYPE_AUTODETECT);
override_config_file(redir("defnot.ini").c_str());
gfx_widescreen = get_config_int("Game", "Widescreen", gfx_widescreen);
gfx_fullscreen = get_config_int("Game", "Fullscreen", gfx_fullscreen);
if (!setup_gfx() != 0) {
allegro_message("Unable to setup the graphics mode\n");
return 1;
}
// if (gfx_capabilities & GFX_HW_CURSOR) {
// enable_hardware_cursor();
// select_mouse_cursor(MOUSE_CURSOR_ARROW);
// show_mouse(screen);
// }
if (!load_media()) {
allegro_message("Unable to load data files to play the game\n");
return 1;
}
// install the timer to control the game speed
LOCK_VARIABLE(beats);
LOCK_FUNCTION(timer_control);
beats = 0;
install_int_ex(timer_control, BPS_TO_TIMER(BPS));
// insert the callback routine for the close-button
LOCK_VARIABLE(continuing);
LOCK_FUNCTION(close_button);
set_close_button_callback(close_button);
// play the game
game_loop();
set_config_int("Game", "Widescreen", gfx_widescreen);
set_config_int("Game", "Fullscreen", gfx_fullscreen);
remove_int(timer_control);
allegro_exit();
return 0;
}
void Frame_Skipper_Init (void)
{
// Auto Frame Skipper
LOCK_VARIABLE (fskipper.Automatic_Frame_Elapsed);
LOCK_FUNCTION (Frame_Skipper_Auto_Adjust_Handler);
Frame_Skipper_Auto_Install_Handler ();
// FPS Counter
LOCK_VARIABLE (fskipper.New_Second);
LOCK_FUNCTION (Frame_Skipper_New_Second_Handler);
Frame_Skipper_New_Second_Handler ();
install_int_ex (Frame_Skipper_New_Second_Handler, TIMERS_PER_SECOND);
}
// Setup game
void setup(){
// Setup for FPS system
LOCK_VARIABLE(ticks);
LOCK_FUNCTION(ticker);
install_int_ex(ticker, BPS_TO_TIMER(updates_per_second));
LOCK_VARIABLE(game_time);
LOCK_FUNCTION(game_time_ticker);
install_int_ex(game_time_ticker, BPS_TO_TIMER(10));
// Close button
LOCK_FUNCTION(close_button_handler);
set_close_button_callback(close_button_handler);
// Game state
int stateID = STATE_NULL;
int nextState = STATE_NULL;
// Variables
closeGame = false;
}
int main(int argc, char **argv) {
allegro_init();
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, SCRW, SCRH, 0, 0);
install_keyboard();
install_mouse();
install_timer();
LOCK_VARIABLE(timer);
LOCK_FUNCTION(timerupdate);
install_int_ex(timerupdate, BPS_TO_TIMER(TIMER_BPS));
srand((unsigned)time(NULL));
set_window_title("Skat");
LOCK_FUNCTION(close_handler);
set_close_button_callback(close_handler);
cards = load_bitmap("images/cards.tga", NULL);
game.p[0] = &human;
game.p[1] = &cpu1;
game.p[2] = &cpu2;
human.choose_card = human_choose_card;
cpu1.choose_card = cpu_choose_card;
cpu2.choose_card = cpu_choose_card;
human.choose_game = human_choose_game;
cpu1.choose_game = cpu_choose_game;
cpu2.choose_game = cpu_choose_game;
human.reizen = human_reizen;
cpu1.reizen = cpu_reizen;
cpu2.reizen = cpu_reizen;
human.schieben = human_schieben;
cpu1.schieben = cpu_schieben;
cpu2.schieben = cpu_schieben;
human.kontra = human_kontra;
cpu1.kontra = cpu_kontra;
cpu2.kontra = cpu_kontra;
human.name = "Stefan";
cpu1.name = "Robert";
cpu2.name = "Thomas";
human.rtext = cpu1.rtext = cpu2.rtext = NULL;
human.total_points = 0;
cpu1.total_points = 0;
cpu2.total_points = 0;
enable_hardware_cursor();
show_mouse(screen);
buffered_do_dialog(main_dlg, -1);
destroy_bitmap(cards);
}
/* do_open_fli:
* Worker function used by open_fli() and open_memory_fli().
*/
static int do_open_fli(void)
{
long speed;
/* read the header */
if (_fli_read_header(&fli_header) != 0) {
close_fli();
return FLI_ERROR;
}
/* check magic numbers */
if (((fli_header.bits_a_pixel != 8) && (fli_header.bits_a_pixel != 0)) ||
((fli_header.type != FLI_MAGIC1) && (fli_header.type != FLI_MAGIC2))) {
close_fli();
return FLI_ERROR;
}
if (fli_header.width == 0)
fli_header.width = 320;
if (fli_header.height == 0)
fli_header.height = 200;
/* create the frame bitmap */
fli_bitmap = create_bitmap_ex(8, fli_header.width, fli_header.height);
if (!fli_bitmap) {
close_fli();
return FLI_ERROR;
}
reset_fli_variables();
fli_frame = 0;
fli_timer = 2;
fli_status = FLI_OK;
/* install the timer handler */
LOCK_VARIABLE(fli_timer);
LOCK_FUNCTION(fli_timer_callback);
if (fli_header.type == FLI_MAGIC1)
speed = BPS_TO_TIMER(70) * (long)fli_header.speed;
else
speed = MSEC_TO_TIMER((long)fli_header.speed);
if (speed == 0)
speed = BPS_TO_TIMER(70);
install_int_ex(fli_timer_callback, speed);
return fli_status;
}
int main()
{
inicia_allegro(500,450);
inicia_audio(70,70);
BITMAP *nave = load_bitmap("nave.bmp",NULL);
BITMAP *nube = load_tga("Galaxy2.tga",NULL);
BITMAP *bala = load_bitmap("Bala2.bmp", NULL); // otra cosa
BITMAP *buffer = create_bitmap(500,450);
LOCK_VARIABLE(speed_counter);
LOCK_FUNCTION(inc_speed_counter);
install_int_ex(inc_speed_counter, BPS_TO_TIMER(30));
int i = 450 , dsw = 0 , cont = 0;
while(!key[KEY_ESC]){
blit(nube,buffer,0,--i,0,0,500,450);
if(i == 0)
i=450;
pintar_nave(nave,buffer,nav);
if(key[KEY_UP]){
nav.dir = 1;
nav.y -= 1;
}
else if(key[KEY_DOWN]) {
nav.dir = 1;
nav.y += 2;
}
if(key[KEY_RIGHT]){
nav.dir = 2;
nav.x += 1;
}
else if(key[KEY_LEFT]){
nav.dir = 0;
nav.x -= 1;
}
else nav.dir = 1;
blit(buffer,screen,0,0,0,0,500,450);
rest(5);
}
destroy_bitmap(buffer);
destroy_bitmap(nave);
destroy_bitmap(nube);
return 0;
}
void allegInitializations()
{
int error = 0;
srand(time(0));
error |= allegro_init ();
algif_init ();
set_color_depth (32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, 1024,768,0,0);
//set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 1024,768,0,0);
install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL);
error |= install_keyboard ();
install_mouse();
error |= install_timer();
error |= install_int_ex(incrementTimer, BPS_TO_TIMER(130));
error |= install_int_ex(incrementMoveTimer, BPS_TO_TIMER(30));
if (error)
{
set_gfx_mode(GFX_TEXT, 1024,768,0,0);
allegro_message("Allegro Failed to Initialize!");
exit(1);
}
}
void set_mod_speed (int speed)
{
if (speed <= 0)
speed = 1;
else if (speed > 400)
speed = 400;
mi.speed_ratio = speed;
if (is_mod_playing() == TRUE)
{
//remove_int (mod_interrupt);
install_int_ex (mod_interrupt, BPM_TO_TIMER (24 * mi.bpm * mi.speed_ratio / 100));
}
}
//Game Loop
bool ce_game::start_game(){
//Create the tick timer functions
LOCK_VARIABLE(ticks);
LOCK_FUNCTION(ticker);
install_int_ex(ticker, BPS_TO_TIMER(fps));
//----------GameLoop----------
while (isPlaying || end_timer > 0 || start_timer > 0){
//Wait until a tick has happened
while(ticks == 0){
rest(1);
}
//If there is a tick pending update the logic and remve the tick
while(ticks > 0){
//Do game logic or decriment end/start timers
if (isPlaying){
checkEscape();
update();
checkState();
}else if (start_timer >= 0){
if (start_timer == 0){
isPlaying = true;
start_timer = -1;
}else{
start_timer--;
}
}else{
end_timer--;
}
ticks--;
}
//Draw game or start/end screens
if (start_timer > 0){
drawStart();
}else if (isPlaying || end_timer > 150){
draw();
}else{
drawEnd();
}
}
return hasWon;
}
void Init_video(char* argv[])
{
allegro_init();
install_timer();
install_keyboard();
install_joystick(JOY_TYPE_AUTODETECT);
request_refresh_rate(FPS_VIDEO);
set_color_depth(32);
/*set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 320, 240, 0, 0);*/
set_gfx_mode(GFX_AUTODETECT_WINDOWED, 320, 240, 0, 0);
set_window_title(game_name);
clear_to_color(screen, makecol(0, 0, 0));
LOCK_VARIABLE(ticks);
LOCK_FUNCTION(ticker);
install_int_ex(ticker, BPS_TO_TIMER(FPS_VIDEO));
}
static void register_timer_callback(void)
{
if (timer_speed == 0) {
remove_int(my_timer_callback);
} else {
int rate = (int)((double)TIMERS_PER_SECOND / (refresh_frequency * ((double)timer_speed / 100.0)) + .5);
/* We use `install_int_ex()' instead of `install_int()' for increased
accuracy. */
if (install_int_ex(my_timer_callback, rate) < 0) {
/* FIXME: Maybe we could handle this better? Well, it is not
very likely to happen after all... */
relative_speed = timer_speed = 0;
}
}
}
void sleep_init(int mins)
{
char txt[256];
LOCK_FUNCTION(sleep_timeout);
LOCK_FUNCTION(sleep_fadeout);
/* See if fading is required */
sprintf(txt,get_config_string("[options]","sleep_fade","yes"));
if(stricmp(txt,"YES") == 0)
sleep_want_fade = TRUE;
install_int_ex(sleep_timeout, SECS_TO_TIMER(mins*60));
}
//Allegro init fun!
void techInit(){
allegro_init(); // all Allegro programs need this
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, WIDTH, HEIGHT, 0, 0);
srand((unsigned)time(0));
screenBuffer = create_bitmap(WIDTH, HEIGHT);
install_keyboard();
install_mouse();
LOCK_VARIABLE(speed_counter);
LOCK_FUNCTION(increment_speed_counter);
install_int_ex(increment_speed_counter,BPS_TO_TIMER(120));
/* add other initializations here*/
}
int main(int argc, char **argv) {
srand((unsigned)time(NULL));
allegro_init();
install_keyboard();
install_timer();
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);
BITMAP *orig_screen = screen;
screen = create_bitmap(SCREEN_W, SCREEN_H);
LOCK_VARIABLE(timer);
LOCK_FUNCTION(timer_increment);
install_int_ex(timer_increment, BPS_TO_TIMER(60));
int need_redraw = 1;
Game game;
init_game(&game);
while(!game.end) {
for(; timer > 0; --timer) {
need_redraw = 1;
get_input(&game);
update_game(&game);
if(timer > 4) {
timer = 0;
break;
}
}
if(need_redraw) {
clear_to_color(screen, makecol(0,0,0));
draw_game(&game, screen);
blit(screen, orig_screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
}
else
sched_yield();
}
delete_list(game.asteroids);
delete_list(game.shot);
delete_list(game.particles);
return 0;
}
int _ji_system_init()
{
/* Install timer related stuff. */
LOCK_VARIABLE(ji_clock);
LOCK_VARIABLE(m_b);
LOCK_FUNCTION(clock_inc);
if (install_int_ex(clock_inc, BPS_TO_TIMER(1000)) < 0)
return -1;
if (screen)
jmouse_poll();
moved = true;
mouse_cursor_type = kNoCursor;
return 0;
}
//---------------------------------------------------
void initAllegroTimer()
{
if(isInit)
return;
LOCK_VARIABLE(speed_counter);
LOCK_VARIABLE(milliSec);
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_counter);
LOCK_FUNCTION(inc_milliSec);
LOCK_FUNCTION(increment_speed_counter);
LOCK_FUNCTION(fps_proc);
install_int(inc_milliSec, 10);// every second //ever 10 of a sec
install_int_ex(increment_speed_counter, BPS_TO_TIMER(60));
install_int(fps_proc, 1000);
isInit = true;
}
void lcd_init(void)
{
set_config_file(damp_ini_file);
/* Load the driver */
lcd_load_driver(get_config_string("[lcd]","driver","NONE"));
/* Call the driver's init function */
lcd_external_function("lcd_driver_init");
/* Read LCD variables from the ini file */
lcd_scroll_speed = get_config_int("[lcd]","scroll_speed",4);
lcd_display_width = get_config_int("[lcd]","display_width",16);
lcd_display_lines = get_config_int("[lcd]","display_lines",2);
lcd_require_update = FALSE;
/* Set up the scroller */
lcd_scroll_pos = 0;
sprintf(lcd_scroll_text,"%*c\n",lcd_display_width,' ');
LOCK_FUNCTION(lcd_scroll);
LOCK_VARIABLE(lcd_scroll_pos);
LOCK_VARIABLE(lcd_require_update);
install_int_ex(lcd_scroll,BPS_TO_TIMER(lcd_scroll_speed));
/* Display driver details */
printf("======================================================================\n");
printf("DAMP LCD Driver\n");
printf("======================================================================\n");
printf("Driver name : %s\n",lcd_driver_name);
printf("Driver version : %.2f\n",lcd_driver_version);
printf("Author name : %s\n",lcd_driver_author);
printf("Author email : %s\n",lcd_driver_author_email);
printf("Driver description : %s\n",lcd_driver_description);
printf("\n\n");
}