static void init_sdl()
{
SDL_putenv("SDL_NOMOUSE=1");
SDL_putenv("SDL_VIDEO_CENTERED=1");
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_NOPARACHUTE);
atexit(SDL_Quit);
signal(SIGINT, SIG_DFL);
SDL_EnableUNICODE(1);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
SDL_AudioSpec desired = {.freq = 8000, .format = AUDIO_U8, .channels = 1, .callback = snd_callback, .samples=128};
if(SDL_OpenAudio(&desired, NULL)) {
fprintf(stderr, "%s\n", SDL_GetError());
sound_playing = -1;
}
SDL_initFramerate(&fps);
SDL_setFramerate(&fps, 60);
inited_sdl = 1;
}
static void button_change(int up, SDLKey keysym)
{
const uint32_t key_map[SDLK_LAST] = {
[SDLK_LEFT] = KEY_LF,
[SDLK_RIGHT] = KEY_RT,
[SDLK_UP] = KEY_UP,
[SDLK_DOWN] = KEY_DN,
[SDLK_RETURN] = KEY_A,
[SDLK_SPACE] = KEY_A,
[SDLK_z] = KEY_A,
[SDLK_x] = KEY_B,
[SDLK_LSHIFT] = KEY_B,
[SDLK_RSHIFT] = KEY_A
};
/* Don't invoke undefined behavior if they've added keysyms
* since this was compiled.
*/
if(keysym > SDLK_LAST)
return;
if(!key_map[keysym])
return;
if(up) {
buttons &= ~key_map[keysym];
} else {
buttons |= key_map[keysym];
}
}
void initSDL()
{
SDL_DisplayMode video_info;
int init_flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK;
if(SDL_Init(init_flags) < 0)
{
printf("SDL Failed to Init!!!! (%s)\n", SDL_GetError());
borExit(0);
}
SDL_ShowCursor(SDL_DISABLE);
atexit(SDL_Quit);
#ifdef LOADGL
if(SDL_GL_LoadLibrary(NULL) < 0)
{
printf("Warning: couldn't load OpenGL library (%s)\n", SDL_GetError());
}
#endif
SDL_GetCurrentDisplayMode(0, &video_info);
nativeWidth = video_info.w;
nativeHeight = video_info.h;
printf("debug:nativeWidth, nativeHeight, bpp, Hz %d, %d, %d, %d\n", nativeWidth, nativeHeight, SDL_BITSPERPIXEL(video_info.format), video_info.refresh_rate);
SDL_initFramerate(&framerate_manager);
SDL_setFramerate(&framerate_manager, 200);
}
void initSimulation (Simulation* sim)
{
//initialisation de la simulation
sim->sdlInitialisee = false;
sim->simulationLancee = false;
sim->map.largeur_map = NB_CASE_LARGEUR_DEFAUT;
sim->map.hauteur_map = NB_CASE_HAUTEUR_DEFAUT;
sim->genererNouvelleMap=1;
sim->genererPosEspeces=1;
sim->map.mapInitialisee=0;
sim->nomSimulation=(char*)malloc(TAILLE_MAX*sizeof(char));
strcpy(sim->nomSimulation,"nouvelle simulation");
//initialisation de la generation aleatoire
srand(time(NULL));
//initialisation de SDL_framerate qui gere le fps
SDL_Init(SDL_INIT_TIMER // pour SDL_framerate
|SDL_INIT_NOPARACHUTE); // pour mieux débugger, à enlever si besoin
SDL_initFramerate(&(sim->fps));
SDL_setFramerate((&sim->fps), 30);
//évite le problème d'affichage de la première ligne // @fixme: aucun printf ne marche sur windows, les g_print non plus (à vérifier)
printf("\n");
}
void Draw(SDL_Surface *screen)
{
int i,rate,x,y,dx,dy,r,g,b;
FPSmanager fpsm;
/* Initialize variables */
srand(time(NULL));
i=0;
x=screen->w/2;
y=screen->h/2;
dx=7;
dy=5;
r=g=b=255;
SDL_initFramerate(&fpsm);
while (1) {
/* Set/switch framerate */
i -= 1;
if (i<0) {
/* Set new rate */
rate=5+5*(rand() % 10);
SDL_setFramerate(&fpsm,rate);
printf ("\nFramerate set to %i Hz ...\n\n",rate);
/* New timeout */
i=2*rate;
/* New Color */
r=rand() & 255;
g=rand() & 255;
b=rand() & 255;
}
HandleEvent();
/* Black screen */
ClearScreen(screen);
/* Move */
x += dx;
y += dy;
/* Reflect */
if ((x<0) || (x>screen->w)) { dx=-dx; }
if ((y<0) || (y>screen->h)) { dy=-dy; }
/* Draw */
filledCircleRGBA (screen,x,y,30,r,g,b,255);
circleRGBA(screen,x,y,30,255,255,255,255);
/* Display by flipping screens */
SDL_UpdateRect(screen,0,0,0,0);
/* Delay to fix rate */
SDL_framerateDelay(&fpsm);
}
}
int main(int argc, char *argv[])
{
int gui_done = 0;
scroll_count = 800;
selected_menu = ROMS;
alpha_up = 1;
alpha = 0;
mouse_y_pos = 120;
selected_option_item = 0;
if(!cfg_read("config.txt"))
{
printf("Fail => cfg_read()\n");
exit(0);
}
if(!gui_init_sdl())
{
printf("Fail => gui_init_sdl()\n");
exit(0);
}
emu_config_init();
gui_load();
strncpy(now_path, config->roms_path, MAXPATH);
filer_read_dir(now_path);
SDL_initFramerate( &sixteen );
SDL_setFramerate( &sixteen, 65 );
while(!gui_done)
{
handle_mouse();
while( SDL_PollEvent( &event ) )
{
switch(event.type)
{
case SDL_QUIT:
{
gui_clean();
free(emu);
exit(0);
}
break;
}
}
gui_draw();
SDL_Flip(myscreen);
SDL_framerateDelay( &sixteen );
}
return 0;
}
void FPSWrapper::initialize(FPSmanager& fpsManager_){
SDL_initFramerate(&fpsManager_);
const int framerateIsSet = SDL_setFramerate(&fpsManager_, Configuration::getMaxFramerate());
if(framerateIsSet == 0){
Logger::log("Successfully started the framerate manager.");
}
else{
Logger::warning("Failed to start the framerate manager.");
}
}
int initViewer(char* resolution, void(*drawingProcedure)(SDL_Surface*,int,int,void*), char isFullscreen) {
const SDL_VideoInfo *info;
Uint8 video_bpp;
Uint32 videoflags;
/* Initialize SDL */
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
return -1;
}
atexit(SDL_Quit);
putenv("SDL_VIDEO_WINDOW_POS=center");
/* Alpha blending doesn't work well at 8-bit color */
info = SDL_GetVideoInfo();
if(info->vfmt->BitsPerPixel > 8)
video_bpp = info->vfmt->BitsPerPixel;
else
video_bpp = 16;
videoflags = SDL_HWSURFACE | SDL_SRCALPHA | SDL_RESIZABLE | SDL_DOUBLEBUF;
if(isFullscreen)
videoflags |= SDL_FULLSCREEN;
/* Set 640x480 video mode */
screenWidth = atoi(strtok(resolution, "x"));
screenHeight = atoi(strtok(NULL, "x"));
if((screen=SDL_SetVideoMode(screenWidth,screenHeight,video_bpp,videoflags)) == NULL) {
fprintf(stderr, "Couldn't set %ix%i video mode: %s\n",screenWidth, screenHeight,SDL_GetError());
return -1;
}
/* Use alpha blending */
SDL_SetAlpha(screen, SDL_SRCALPHA, 0);
/* Set title for window */
SDL_WM_SetCaption("Double Cart Pole Viewer","Double Cart Pole Viewer");
SDL_initFramerate(&fpsm);
SDL_setFramerate(&fpsm, 1.0 / timeStep);
algorithm_drawingProcedure = drawingProcedure;
return 0;
}
int main(int argc, char* argv[])
{
FPSmanager framerate_manager;
(void)argc;
(void)argv;
if (SDL_Init(SDL_INIT_EVERYTHING) < 0) return 1;
SDL_initFramerate(&framerate_manager);
SDL_setFramerate(&framerate_manager, 60);
SDL_framerateDelay(&framerate_manager);
SDL_Quit();
return 0;
}
/*!
\brief Delay execution to maintain a constant framerate and calculate fps.
Generate a delay to accomodate currently set framerate. Call once in the
graphics/rendering loop. If the computer cannot keep up with the rate (i.e.
drawing too slow), the delay is zero and the delay interpolation is reset.
\param manager Pointer to the framerate manager.
\return The time that passed since the last call to the function in ms. May return 0.
*/
Uint32 SDL_framerateDelay(FPSmanager * manager)
{
Uint32 current_ticks;
Uint32 target_ticks;
Uint32 the_delay;
Uint32 time_passed = 0;
/*
* No manager, no delay
*/
if (manager == NULL) {
return 0;
}
/*
* Initialize uninitialized manager
*/
if (manager->baseticks == 0) {
SDL_initFramerate(manager);
}
/*
* Next frame
*/
manager->framecount++;
/*
* Get/calc ticks
*/
current_ticks = _getTicks();
time_passed = current_ticks - manager->lastticks;
manager->lastticks = current_ticks;
target_ticks = manager->baseticks + (Uint32) ((float) manager->framecount * manager->rateticks);
if (current_ticks <= target_ticks) {
the_delay = target_ticks - current_ticks;
SDL_Delay(the_delay);
} else {
manager->framecount = 0;
manager->baseticks = _getTicks();
}
return time_passed;
}
Display::Display(){
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
cout << "Erreur d'initialisation de SDL_Init\n";
exit(EXIT_FAILURE);
}
if(TTF_Init() == -1)
{
cout << "Erreur d'initialisation de TTF_Init : \n"<< TTF_GetError();
exit(EXIT_FAILURE);
}
SDL_initFramerate(&manager);
//t0 = SDL_LoadBMP("watter.bmp");
//t1 = SDL_LoadBMP("sand.bmp");
//t2 = SDL_LoadBMP("mountain.bmp");
//t3 = SDL_LoadBMP("grass.bmp");
}
/*!
\brief Delay execution to maintain a constant framerate and calculate fps.
Generate a delay to accomodate currently set framerate. Call once in the
graphics/rendering loop. If the computer cannot keep up with the rate (i.e.
drawing too slow), the delay is zero and the delay interpolation is reset.
\param manager Pointer to the framerate manager.
*/
void SDL_framerateDelay(FPSmanager * manager)
{
Uint32 current_ticks;
Uint32 target_ticks;
Uint32 the_delay;
/*
* No manager, no delay
*/
if (manager == NULL)
return;
/*
* Initialize uninitialized manager
*/
if (manager->lastticks == 0)
SDL_initFramerate(manager);
/*
* Next frame
*/
manager->framecount++;
/*
* Get/calc ticks
*/
current_ticks = SDL_GetTicks();
target_ticks = manager->lastticks + (Uint32) ((float) manager->framecount * manager->rateticks);
if (current_ticks <= target_ticks)
{
the_delay = target_ticks - current_ticks;
SDL_Delay(the_delay);
}
else
{
manager->framecount = 0;
manager->lastticks = SDL_GetTicks();
}
}
int sdl_init( void ) {
int mode = SDL_SWSURFACE|SDL_OPENGL;
const struct config *config = config_get();
if( SDL_Init(SDL_INIT_EVERYTHING) < 0 ) {
fprintf(stderr, "Error: Unable to initialise SDL: %s\n", SDL_GetError());
return 1;
}
SDL_ShowCursor(SDL_DISABLE);
memcpy( &saved_video, SDL_GetVideoInfo(), sizeof(SDL_VideoInfo) );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
if( config->iface.full_screen )
mode |= SDL_FULLSCREEN;
screen = SDL_SetVideoMode( config->iface.screen_width, config->iface.screen_height, SDL_SCREEN_BPP, mode );
if( screen == NULL ) {
fprintf(stderr, "Error: Unable to set video mode: %s\n", SDL_GetError());
return 1;
}
SDL_initFramerate( &manager );
frame_rate = config->iface.frame_rate;
if( frame_rate < 0 ) {
frame_rate = 0;
fprintf( stderr, "Warning: Negative frame rate, setting to 0 (unlimited)\n" );
}
if( frame_rate > MAX_FRAME_RATE ) {
frame_rate = MAX_FRAME_RATE;
fprintf( stderr, "Warning: Frame rate above maximum allowed (%d) setting to maximum\n", MAX_FRAME_RATE );
}
if( frame_rate ) {
SDL_setFramerate( &manager, frame_rate );
}
SDL_WM_SetCaption( title, NULL );
return 0;
}
/*----------------------------------------------------------------------------
* Initialize
*----------------------------------------------------------------------------*/
int
media_init(void)
{
if (SDL_Init(SDL_INIT_VIDEO)) {
fprintf(stderr, "%s\n", SDL_GetError());
exit(0);
}
// Initialize window and load all graphics. Exit on failure (we need all
// graphics to play).
if ((media.canvas = SDL_SetVideoMode(800, 600, 16, SDL_DOUBLEBUF)) == NULL) {
fprintf(stderr, "%s\n", SDL_GetError());
exit(0);
}
media.surface_title = load_texture("title.png");
media.surface_frame = load_texture("frame.png");
media.surface_objects = load_texture("objects.png");
media.surface_effects = load_texture("effects.png");
media.surface_manual = load_texture("manual.png");
media.surface_properties = load_texture("properties.png");
media.surface_circle = load_texture("circle.png");
if ((media.surface_background =
SDL_CreateRGBSurface(SDL_SWSURFACE, media.canvas->w, media.canvas->h + 4,
media.canvas->format->BitsPerPixel,
media.canvas->format->Rmask, media.canvas->format->Gmask,
media.canvas->format->Bmask,
media.canvas->format->Amask)) == NULL) {
fprintf(stderr, "%s\n", SDL_GetError());
exit(0);
}
SDL_Surface *tmp;
SDL_Rect dst;
tmp = load_texture("background.png");
for (dst.x = 0; dst.x < media.surface_background->w; dst.x += tmp->w)
for (dst.y = 0; dst.y < media.surface_background->h; dst.y += tmp->h) {
SDL_BlitSurface(tmp, NULL, media.surface_background, &dst);
}
SDL_FreeSurface(tmp);
// Initialize and load true type fonts. Exit on failure.
if (TTF_Init()) {
fprintf(stderr, "%s\n", TTF_GetError());
exit(0);
}
media.font_small = load_font("underwood_champion.ttf", 16);
media.font_normal = load_font("underwood_champion.ttf", 18);
media.font_large = load_font("underwood_champion.ttf", 30);
media.font_input = load_font("underwood_champion.ttf", 26);
media.font_equation = load_font("underwood_champion.ttf", 20);
media.font_button = load_font("j_d_handcrafted.ttf", 22);
media.surface_hforhelp =
TTF_RenderUTF8_Blended(media.font_normal, lang.hforhelp, color_white);
// Initialize audio if wanted and load all samples. Disable audio on failure
// (audio is not indispensable)
if (media.enable_audio) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO)) {
fprintf(stderr, "%s\n", SDL_GetError());
media.enable_audio = 0;
} else if (Mix_OpenAudio(22050, AUDIO_S16SYS, 2, 1024)) {
fprintf(stderr, "%s\n", Mix_GetError());
media.enable_audio = 0;
} else {
media.chunk_press = load_sample("press.wav");
media.chunk_release = load_sample("release.wav");
media.chunk_open = load_sample("open.wav");
media.chunk_fail = load_sample("fail.wav");
media.chunk_wodox = load_sample("wodox.wav");
media.chunk_keystroke = load_sample("typewriter.wav");
media.chunk_marker = load_sample("marker01.wav");
}
}
// Give the window a name.
SDL_WM_SetCaption("Wodox", "wodox");
// Initialize frame rate control.
SDL_initFramerate(&media.fpsmanager);
SDL_setFramerate(&media.fpsmanager, 30);
// Most of the time keyrepeat is set to true.
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,
SDL_DEFAULT_REPEAT_INTERVAL);
return 0;
}
void Draw(SDL_Surface *screen)
{
int i,rate,x,y,dx,dy;
int psize = NUM_POINTS;
double sin_start = 0;
double sin_amp = 100;
Sint16 polygon_x[NUM_POINTS], polygon_y[NUM_POINTS];
Sint16 polygon_alpha_x[4], polygon_alpha_y[4];
SDL_Surface *texture;
SDL_Surface *texture_alpha;
FPSmanager fpsm;
int width_half = screen->w/2;
int height_half = screen->h/2;
/* Load texture surfaces */
texture = SDL_LoadBMP("texture.bmp");
texture_alpha = SDL_LoadBMP("texture_alpha.bmp");
SDL_SetAlpha(texture_alpha, SDL_SRCALPHA, 128);
/* Initialize variables */
srand((int)time(NULL));
i=0;
x=width_half;
y=height_half;
dx=7;
dy=5;
/* Initialize Framerate manager */
SDL_initFramerate(&fpsm);
/* Polygon for blended texture */
polygon_alpha_x[0]= 0;
polygon_alpha_y[0]= 0;
polygon_alpha_x[1]= width_half;
polygon_alpha_y[1]= 0;
polygon_alpha_x[2]= screen->w*2 / 3;
polygon_alpha_y[2]= screen->h;
polygon_alpha_x[3]= 0;
polygon_alpha_y[3]= screen->h;
/* Set/switch framerate */
rate=25;
SDL_setFramerate(&fpsm,rate);
/* Drawing loop */
while (1) {
/* Generate wave polygon */
sin_start++;
polygon_x[0]= 0;
polygon_y[0]= screen->h;
polygon_x[1]= 0;
polygon_y[1]= height_half;
for (i=2; i < psize -2 ; i++){
polygon_x[i]= (screen->w * (i-2)) / (psize -5) ;
polygon_y[i]= (Sint16)(sin(sin_start/100) * 200) + height_half - (Sint16)(sin((i + sin_start) / 20) * sin_amp);
}
polygon_x[psize-2]= screen->w;
polygon_y[psize-2]= height_half;
polygon_x[psize-1]= screen->w;
polygon_y[psize-1]= screen->h;
/* Event handler */
HandleEvent();
/* Black screen */
ClearScreen(screen);
/* Move */
x += dx;
y += dy;
/* Reflect */
if ((x<0) || (x>screen->w)) { dx=-dx; }
if ((y<0) || (y>screen->h)) { dy=-dy; }
/* Draw */
texturedPolygon(screen,polygon_x,polygon_y,psize,texture, -(screen->w * (Sint16)(sin_start-2)) / (psize - 5), -(Sint16)(sin(sin_start/100) * 200));
texturedPolygon(screen,polygon_alpha_x,polygon_alpha_y,4,texture_alpha,(Sint16)sin_start,-(Sint16)sin_start);
/* Display by flipping screens */
SDL_Flip(screen);
/* Delay to fix rate */
SDL_framerateDelay(&fpsm);
}
}
int main(int argc, char *argv[])
{
int i;
SDL_Event event;
Uint32 then, now, frames;
FPSmanager fpsm;
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
}
SDL_Log("SDL2_gfx %i.%i.%i: testframerate", SDL2_GFXPRIMITIVES_MAJOR, SDL2_GFXPRIMITIVES_MINOR, SDL2_GFXPRIMITIVES_MICRO);
SDL_Log("Platform: %s", SDL_GetPlatform());
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed == 0) {
consumed = -1;
if (SDL_strcasecmp(argv[i], "--x") == 0) {
if (argv[i + 1]) {
x = SDL_atoi(argv[i + 1]);
if (x < 0) x = 0;
if (x >= WIDTH) x = WIDTH - 1;
consumed = 2;
}
}
else if (SDL_strcasecmp(argv[i], "--y") == 0) {
if (argv[i + 1]) {
y = SDL_atoi(argv[i + 1]);
if (y < 0) y = 0;
if (y >= HEIGHT) y = HEIGHT - 1;
consumed = 2;
}
}
}
if (consumed < 0) {
SDL_Log("Usage: %s %s [--x #] [--y #]\n",
argv[0], SDLTest_CommonUsage(state));
return 1;
}
i += consumed;
}
if (!SDLTest_CommonInit(state)) {
return 2;
}
/* Create the windows and initialize the renderers */
for (i = 0; i < state->num_windows; ++i) {
SDL_Renderer *renderer = state->renderers[i];
SDL_RendererInfo info;
SDL_GetRendererInfo(state->renderers[i], &info);
SDL_Log("Renderer %i: %s %s", i, info.name, (info.flags | SDL_RENDERER_ACCELERATED) ? "(Accelerated)" : "");
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
}
/* Initialize random number generator */
srand((unsigned int)time(NULL));
/* Create common message buffer */
messageText = (char *)SDL_malloc(1024);
if (messageText == NULL) {
return -1;
}
/* Initialize framerate manager */
SDL_initFramerate(&fpsm);
/* Main render loop */
frames = 0;
then = SDL_GetTicks();
done = 0;
while (!done) {
/* Check for events */
++frames;
while (SDL_PollEvent(&event) && !done) {
SDLTest_CommonEvent(state, &event, &done);
}
/* Do all the drawing work */
Draw(state->renderers[0], &fpsm);
}
/* Print out some timing information */
now = SDL_GetTicks();
if (now > then) {
double fps = ((double) frames * 1000) / (now - then);
SDL_Log("%2.2f frames per second\n", fps);
}
/* Free common message buffer */
if (messageText) {
free(messageText);
}
/* Shutdown SDL */
SDLTest_CommonQuit(state);
return 0;
}
void CShooterGame::Initialize()
{
// Must call base class initializations first
CGame::Initialize();
#ifdef DEBUG
cout << "CShooterGame::Initialize() called" << endl;
#endif
auto& renderer = CSingleton<CRenderer>::Instance();
SDL_WM_SetCaption("Space Attackers!", "Space Attackers!");
auto screen = renderer->GetScreen();
m_iScreenW = screen->w;
m_iScreenH = screen->h;
// Create global mutex using Factory pattern
{
// Prepare Mutex singleton for access from multiple threads at the same time
MutexFactory::Instance()->Initialize( RESOURCE::MUTEX_MAINAPP );
}
// Prepare rand() for multithreaded execution
{
CSingleton<CRandom>::Instance()->nextNumber();
}
// Load window icon using Factory pattern
{
ImageColorkeyFactory::Instance()->Get( RESOURCE::WINDOW_ICON )->Load( "Assets/Icon/icon.bmp" );
ImageColorkeyFactory::Instance()->Get( RESOURCE::WINDOW_ICON )->SetColorKeyRGB( 0, 255, 255 );
SDL_WM_SetIcon( ImageColorkeyFactory::Instance()->Get( RESOURCE::WINDOW_ICON )->GetSurface(), 0 );
}
// Load sprites using Factory pattern
{
ImageAlphaFactory::Instance()->Get( RESOURCE::PLAYER_PLANE )->Load( "Assets/Sprites/player_plane.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::PLAYER_PLANE_HIT )->Load( "Assets/Sprites/player_plane_hit.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::PLAYER_PLANE_SHADOW )->Load( "Assets/Sprites/player_plane_shadow_0.5x.png" );
AnimationFactory::Instance()->Get( RESOURCE::PLAYER_PLANE )->LoadAnimation( "Assets/Sprites/player_plane.anim" );
AnimationFactory::Instance()->Get( RESOURCE::PLAYER_PLANE_SHADOW )->LoadAnimation( "Assets/Sprites/player_plane_shadow_0.5x.anim" );
ImageAlphaFactory::Instance()->Get( RESOURCE::PLAYER_PROJECTILE )->Load( "Assets/Sprites/plasma_up_yellow.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::PLAYER_PROJECTILE_GUIDED )->Load( "Assets/Sprites/plasma_ball_blue.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PROJECTILE_SLOW )->Load( "Assets/Sprites/plasma_ball_green.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PROJECTILE_FAST )->Load( "Assets/Sprites/plasma_ball_red.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PLANE_GREEN )->Load( "Assets/Sprites/plane_green_down.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PLANE_RED )->Load( "Assets/Sprites/plane_red_down.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PLANE_GREEN_HIT )->Load( "Assets/Sprites/plane_green_down_hit.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PLANE_RED_HIT )->Load( "Assets/Sprites/plane_red_down_hit.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::ENEMY_PLANE_SHADOW )->Load( "Assets/Sprites/plane_down_shadow_0.5x.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::EXPLOSION )->Load( "Assets/Sprites/explosion.png" );
AnimationFactory::Instance()->Get( RESOURCE::EXPLOSION )->LoadAnimation( "Assets/Sprites/explosion.anim" );
}
// Create interpolation sets for intro screen and level start message
{
auto& introOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_INTRO_SHOW );
introOverTime->AddValue( 0.0f, 0 );
introOverTime->AddValue( 0.5f, 255, Math::Interpolation::easeOutCirc<float,float> );
introOverTime->AddValue( 3.5f, 255 );
introOverTime->AddValue( 5.0f, 0, Math::Interpolation::easeInCirc<float,float> );
auto& levelStartOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_LEVEL_START );
levelStartOverTime->AddValue( 0.0f, m_iScreenH );
levelStartOverTime->AddValue( 1.5f, m_iScreenH/2 - 32, Math::Interpolation::easeOutCirc<float,float> );
levelStartOverTime->AddValue( 3.5f, m_iScreenH/2 - 32 );
levelStartOverTime->AddValue( 5.0f, -64, Math::Interpolation::easeInCirc<float,float> );
}
// Load menu sprites using Factory pattern
{
ImageAlphaFactory::Instance()->Get( RESOURCE::MENU_TEXT )->Load( "Assets/Menu/texts.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::MENU_TEXT_SELECTED )->Load( "Assets/Menu/texts_selected.png" );
AnimationFactory::Instance()->Get( RESOURCE::MENU_TEXT )->LoadAnimation( "Assets/Menu/texts.anim" );
}
// load backgrounds using Factory pattern
{
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_INTRO )->Load( "Assets/Backgrounds/intro_screen.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_TITLE )->Load( "Assets/Backgrounds/title_screen.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_DEATH )->Load( "Assets/Backgrounds/death.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_HELP1 )->Load( "Assets/Backgrounds/help1.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_HELP2 )->Load( "Assets/Backgrounds/help2.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_MOONSURFACE )->Load( "Assets/Backgrounds/moon.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_CLOUDS1 )->Load( "Assets/Backgrounds/clouds1_tr50.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_CLOUDS2 )->Load( "Assets/Backgrounds/clouds2_tr50.png" );
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_MOONSURFACE )->SetAlpha(255);
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_CLOUDS1 )->SetAlpha(0);
ImageAlphaFactory::Instance()->Get( RESOURCE::BACKGROUND_CLOUDS2 )->SetAlpha(0);
// Create layers and set the bitmaps
ScrollingBackgroundFactory::Instance()->Get( RESOURCE::SCROLLING_MOONSURFACE )->Initialize(1);
ScrollingBackgroundFactory::Instance()->Get( RESOURCE::SCROLLING_CLOUDS )->Initialize(2);
auto& moonSurfaceLayer = ScrollingBackgroundFactory::Instance()->Get( RESOURCE::SCROLLING_MOONSURFACE );
moonSurfaceLayer->SetLayer( 0, RESOURCE::BACKGROUND_MOONSURFACE );
moonSurfaceLayer->SetLayerSpeed( 0, 8, 8 ); // 1:15 movement speed
moonSurfaceLayer->SetSpeed( 0, -250 );
auto& cloudsLayers = ScrollingBackgroundFactory::Instance()->Get( RESOURCE::SCROLLING_CLOUDS );
cloudsLayers->SetLayer( 0, RESOURCE::BACKGROUND_CLOUDS1 );
cloudsLayers->SetLayer( 1, RESOURCE::BACKGROUND_CLOUDS2 );
cloudsLayers->SetLayerSpeed( 0, 4, 4 ); // 1:7 movement speed
cloudsLayers->SetLayerSpeed( 1, 1, 1 ); // 1:1 movement speed
cloudsLayers->SetSpeed( 0, -250 );
}
// Load fonts using Factory pattern
{
FontFactory::Instance()->Get( RESOURCE::FONT_INFO )->Load( "Assets/Fonts/failed.ttf", 24 );
FontFactory::Instance()->Get( RESOURCE::FONT_SCORE )->Load( "Assets/Fonts/digital-7_mono.ttf", 32 );
FontFactory::Instance()->Get( RESOURCE::FONT_SMALL )->Load( "Assets/Fonts/ProFontWindows.ttf", 9 );
FontFactory::Instance()->Get( RESOURCE::FONT_MENU )->Load( "Assets/Fonts/impact.ttf", 35 );
}
// Load sounds using Factory pattern
{
SoundFactory::Instance()->Get( RESOURCE::SOUND_INTRO_AMIGADISKFX )->Load( "Assets/Sounds/intro_disksound.ogg" );
SoundFactory::Instance()->Get( RESOURCE::SOUND_PLAYER_FIRE )->Load( "Assets/Sounds/laser.ogg" );
SoundFactory::Instance()->Get( RESOURCE::SOUND_ENEMY_FIRE )->Load( "Assets/Sounds/machinegun2.ogg" );
SoundFactory::Instance()->Get( RESOURCE::SOUND_EXPLOSION1 )->Load( "Assets/Sounds/explosion_1.ogg" );
SoundFactory::Instance()->Get( RESOURCE::SOUND_EXPLOSION2 )->Load( "Assets/Sounds/explosion_2.ogg" );
}
// Preload musics using Factory pattern
{
MusicFactory::Instance()->Get( RESOURCE::MUSIC_SPLASH )->Load( "Assets/Musics/cdk_-_Song_Of_Peace.ogg" );
MusicFactory::Instance()->Get( RESOURCE::MUSIC_INGAME )->Load( "Assets/Musics/Astroboy_Sprung-160.ogg" );
MusicFactory::Instance()->Get( RESOURCE::MUSIC_GAMEOVER )->Load( "Assets/Musics/Syenta_-_Cytheres_Reves_(Cytheres_Dreams)_2.ogg" );
}
// Create texts using Factory pattern
{
auto& fontSmall = FontFactory::Instance()->Get( RESOURCE::FONT_SMALL );
auto& fontInfo = FontFactory::Instance()->Get( RESOURCE::FONT_INFO );
auto& fontMenu = FontFactory::Instance()->Get( RESOURCE::FONT_MENU );
TextFactory::Instance()->Get( RESOURCE::TEXT_BETA_BUILD_NOTE )->Create( fontSmall, "Space Attackers : Beta build, not for distribution! // Programming by Mika Luoma-aho <*****@*****.**>", 80, 128, 75, 64 );
TextFactory::Instance()->Get( RESOURCE::TEXT_STARTGAME )->Create( fontInfo, "< Press space to start a new game or ESC to quit >" );
TextFactory::Instance()->Get( RESOURCE::TEXT_SPACE_TO_CONTINUE )->Create( fontInfo, "< Press space to continue >" );
TextFactory::Instance()->Get( RESOURCE::TEXT_ENTER_TO_CONTINUE )->Create( fontInfo, "< Press enter to continue >" );
TextFactory::Instance()->Get( RESOURCE::TEXT_HIGHSCORES )->Create( fontMenu, "< HI-SCORES >" );
TextFactory::Instance()->Get( RESOURCE::TEXT_LEVEL_STARTING )->Create( fontMenu, "Get ready for" );
TextFactory::Instance()->Get( RESOURCE::TEXT_GAMEOVER_SCORE )->Create( fontMenu, "SCORE" );
TextFactory::Instance()->Get( RESOURCE::TEXT_GAMEOVER_ENTERYOURNAME )->Create( fontMenu, "ENTER YOUR NAME", 255, 220, 100 );
TextFactory::Instance()->Get( RESOURCE::TEXT_GAMEOVER_NAME )->Create( fontMenu, "" );
TextFactory::Instance()->Get( RESOURCE::TEXT_GAMEOVER_NAME_PROMPT )->Create( fontMenu, "_" /*«*/ );
}
// Create particle effects
{
// Create Explosion
{
auto& velocityOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_EXPLOSION_VELOCITY );
velocityOverTime->AddValue( 0.0f, 20.0f );
velocityOverTime->AddValue( 0.7f, 10.5f, Math::Interpolation::easeOutCirc<float,float> );
auto& alphaOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_EXPLOSION_ALPHA );
alphaOverTime->AddValue( 0.0f, 1.0f );
alphaOverTime->AddValue( 1.0f, 0.0f, Math::Interpolation::linearTween<float,float> );
auto& sizeOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_EXPLOSION_SIZE );
sizeOverTime->AddValue( 0.0f, 3.0f );
sizeOverTime->AddValue( 1.0f, 1.0f, Math::Interpolation::linearTween<float,float> );
// Flame colors
// http://kuler.adobe.com/#themeID/177302
//
Math::Colors::HSV h1, h2, h3, h4, h5;
h1 = { 41, 0.84f, 1.0f };
h2 = { 43, 0.70f, 1.0f };
h3 = { 63, 0.37f, 0.97f };
h4 = { 30, 0.85f, 1.0f };
h5 = { 17, 0.95f, 0.73f };
auto& colorOverTime = SDLColorInterpolationSetFactory::Instance()->Get( RESOURCE::IS_EXPLOSION_COLOR );
colorOverTime->AddValue( 0.0f, Math::Colors::HSV2SDLColor(h1) );
colorOverTime->AddValue( 0.2f, Math::Colors::HSV2SDLColor(h2) );
colorOverTime->AddValue( 0.4f, Math::Colors::HSV2SDLColor(h3) );
colorOverTime->AddValue( 0.6f, Math::Colors::HSV2SDLColor(h4) );
colorOverTime->AddValue( 0.8f, Math::Colors::HSV2SDLColor(h5) );
// Set parameters
auto& psExplosion = ExplosionSystemFactory::Instance()->Get( RESOURCE::PS_EXPLOSION );
psExplosion->Initialize( 500 );
psExplosion->SetVelocityOverTime( RESOURCE::IS_EXPLOSION_VELOCITY );
psExplosion->SetAlphaOverTime( RESOURCE::IS_EXPLOSION_ALPHA );
psExplosion->SetColorOverTime( RESOURCE::IS_EXPLOSION_COLOR );
psExplosion->SetSizeOverTime( RESOURCE::IS_EXPLOSION_SIZE );
psExplosion->SetPrimitiveType( 2 );
psExplosion->SetTrails( false );
}
// Create Smoke
{
auto& velocityOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_SMOKE_VELOCITY );
velocityOverTime->AddValue( 0.0f, 15.0f );
velocityOverTime->AddValue( 1.0f, 0.0f, Math::Interpolation::linearTween<float,float> );
auto& alphaOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_SMOKE_ALPHA );
alphaOverTime->AddValue( 0.0f, 0.5f );
alphaOverTime->AddValue( 1.0f, 0.1f, Math::Interpolation::easeInCirc<float,float> );
auto& sizeOverTime = InterpolationSetFactory::Instance()->Get( RESOURCE::IS_SMOKE_SIZE );
sizeOverTime->AddValue( 0.0f, 1.0f );
sizeOverTime->AddValue( 1.0f, 3.0f, Math::Interpolation::linearTween<float,float> );
// Smoke colors
// http://kuler.adobe.com/#themeID/1262268
//
Math::Colors::HSV h1, h2, h3, h4;
h1 = { 226, 0.25f, 0.16f };
h2 = { 235, 0.07f, 0.34f };
h3 = { 40, 0.08f, 0.41f };
h4 = { 43, 0.15f, 0.53f };
auto& colorOverTime = SDLColorInterpolationSetFactory::Instance()->Get( RESOURCE::IS_SMOKE_COLOR );
colorOverTime->AddValue( 0.0f, Math::Colors::HSV2SDLColor(h1) );
colorOverTime->AddValue( 0.3f, Math::Colors::HSV2SDLColor(h2) );
colorOverTime->AddValue( 0.6f, Math::Colors::HSV2SDLColor(h3) );
colorOverTime->AddValue( 1.0f, Math::Colors::HSV2SDLColor(h4) );
// Set parameters
auto& psSmoke = SmokeSystemFactory::Instance()->Get( RESOURCE::PS_SMOKE );
psSmoke->Initialize( 300 );
psSmoke->SetVelocityOverTime( RESOURCE::IS_SMOKE_VELOCITY );
psSmoke->SetAlphaOverTime( RESOURCE::IS_SMOKE_ALPHA );
psSmoke->SetColorOverTime( RESOURCE::IS_SMOKE_COLOR );
psSmoke->SetSizeOverTime( RESOURCE::IS_SMOKE_SIZE );
psSmoke->SetPrimitiveType( 2 );
psSmoke->SetTrails( false );
}
}
// Create explosion thread to be used in highscore screen
{
ExplosionThreadFactory::Instance()->Get( RESOURCE::THREAD_EXPLOSION )->SetExplosion( RESOURCE::PS_EXPLOSION );
}
// Create note
{
auto& noteText = TextFactory::Instance()->Get( RESOURCE::TEXT_BETA_BUILD_NOTE );
m_noteImgWidth = noteText->GetSurface()->w;
}
// Load scenes into memory and set first scene as running
{
unique_ptr<CScene> SplashScene = unique_ptr<SceneSplashScreen>(new SceneSplashScreen);
unique_ptr<CScene> Level1Scene = unique_ptr<SceneLevel>(new SceneLevel);
unique_ptr<CScene> GameOverScene = unique_ptr<SceneGameOver>(new SceneGameOver);
unique_ptr<CScene> HighscoresScene = unique_ptr<SceneHighscores>(new SceneHighscores);
unique_ptr<CScene> HelpScene = unique_ptr<SceneHelp>(new SceneHelp);
// Add scenes (order is also the render order!)
AddScene( SCENE_0_Intro, SplashScene );
AddScene( SCENE_1_Game, Level1Scene );
AddScene( SCENE_2_GameOver, GameOverScene );
AddScene( SCENE_3_Highscores, HighscoresScene );
AddScene( SCENE_4_Help, HelpScene );
}
// Load and run the first scene
//#ifdef DEBUG_SCENE1
//LoadAndRunScene( SCENE_1_Game );
//SetState( (int)STATE::GAME );
auto& properties = CSingleton<CProperties>::Instance();
#ifdef DEBUG_GAMEOVER
properties->Property( "Player", "Name" ) = (std::string)"";
properties->Property( "Player", "Score" ) = static_cast<int>(1234567);
properties->Property( "Player", "Fired" ) = static_cast<int>(1000);
properties->Property( "Player", "Kills" ) = static_cast<int>(20);
properties->Property( "Player", "Accuracy" ) = static_cast<int>(98);
properties->Property( "Player", "Level" ) = static_cast<int>(27);
LoadAndRunScene( SCENE_2_GameOver );
SetState( (int)STATE::GAME_OVER );
#else
properties->Property( "Player", "Name" ) = (std::string)"";
LoadAndRunScene( SCENE_0_Intro );
SetState( (int)STATE::SPLASH_SCREEN );
#endif
// Default to 60fps
SDL_initFramerate( &m_fpsManager );
SDL_setFramerate( &m_fpsManager, 60 );
// Initialize state handlers
InitHandlers();
}
bool Initialize (int w, int h, bool fullScreen, System::State* StartingState, int FrameRate, std::string windowTitle, std::string iconFile){
// Initiate SDL
if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0 ){
fprintf( stderr, "Video query failed: %s\n", SDL_GetError());
exit(1);
return false;
}
atexit(SDL_Quit); // At quit, destroy SDL
int flags;
if(fullScreen)
flags = SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF | SDL_FULLSCREEN;
else
flags = SDL_HWSURFACE | SDL_HWACCEL | SDL_DOUBLEBUF;
Screen = SDL_SetVideoMode(w, h, 32, flags);
if(Screen == NULL){
fprintf( stderr, "Video mode set failed: %s\nWidth(%d), Height(%d)\n", SDL_GetError(), w, h);
exit(1);
return false;
}
/*
// Set up the window and video mode
if(fullScreen)
Screen = SDL_SetVideoMode(w,h,32,SDL_OPENGL|SDL_HWSURFACE|SDL_NOFRAME|SDL_DOUBLEBUF|SDL_FULLSCREEN|SDL_OPENGL);
else
Screen = SDL_SetVideoMode(w,h,32,SDL_OPENGL|SDL_HWSURFACE|SDL_NOFRAME|SDL_DOUBLEBUF|SDL_OPENGL);
if ( Screen == NULL )
return false;
*/
// Set the caption of the window
SDL_WM_SetCaption(windowTitle.c_str(), NULL);
// Set the window icon
if(iconFile != ""){
SDL_Surface* WindowIcon = IMG_Load(iconFile.c_str());
if(WindowIcon){
SDL_SetColorKey(WindowIcon, SDL_SRCCOLORKEY,
SDL_MapRGB(WindowIcon->format, 255, 0, 255));
SDL_WM_SetIcon(WindowIcon, NULL);
SDL_FreeSurface(WindowIcon);
} else {
fprintf( stderr, "Error loading window icon file \"%s\"\n", iconFile.c_str());
}
}
// Input
System::Input::Initialize();
// Math
System::Math::Initialize();
// Text
if(System::Text::Initialize() == false){
fprintf( stderr, "Error initializing text\n");
}
// Framerate
SDL_initFramerate(&fpsm);
if(FrameRate < 0) FrameRate = 1;
SDL_setFramerate(&fpsm, FrameRate);
// Default values
Width = w;
Height = h;
Title = windowTitle;
SetState(StartingState);
Going = true;
return true;
}
void fps_init(int hz)
{
fpsHz = hz;
SDL_initFramerate(&fpsManager);
fps_sethz(hz);
}
Client::Client(const Options &options):
mOptions(options),
mGame(0),
mCurrentDialog(0),
mQuitDialog(0),
mDesktop(0),
mSetupButton(0),
mState(STATE_CHOOSE_SERVER),
mOldState(STATE_START),
mStateAfterOkDialog(mState),
mIcon(0),
mLogicCounterId(0),
mSecondsCounterId(0),
mLimitFps(false)
{
assert(!mInstance);
mInstance = this;
logger = new Logger;
// Set default values for configuration files
branding.setDefaultValues(getBrandingDefaults());
paths.setDefaultValues(getPathsDefaults());
config.setDefaultValues(getConfigDefaults());
// Load branding information
if (!options.brandingPath.empty())
{
branding.init(options.brandingPath);
}
initRootDir();
initHomeDir();
initConfiguration();
chatLogger = new ChatLogger;
if (options.chatLogDir.empty())
chatLogger->setLogDir(mLocalDataDir + std::string("/logs/"));
else
chatLogger->setLogDir(options.chatLogDir);
// Configure logger
logger->setLogFile(mLocalDataDir + std::string("/mana.log"));
logger->setLogToStandardOut(config.getBoolValue("logToStandardOut"));
// Log the mana version
logger->log("Mana %s", FULL_VERSION);
initScreenshotDir();
// Initialize SDL
logger->log("Initializing SDL...");
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
{
logger->error(strprintf("Could not initialize SDL: %s",
SDL_GetError()));
}
atexit(SDL_Quit);
SDL_EnableUNICODE(1);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
SDL_WM_SetCaption(branding.getValue("appName", "Mana").c_str(), NULL);
ResourceManager *resman = ResourceManager::getInstance();
if (!resman->setWriteDir(mLocalDataDir))
{
logger->error(strprintf("%s couldn't be set as home directory! "
"Exiting.", mLocalDataDir.c_str()));
}
Image::SDLsetEnableAlphaCache(config.getValue("alphaCache", true));
#if defined __APPLE__
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
char path[PATH_MAX];
if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path,
PATH_MAX))
{
fprintf(stderr, "Can't find Resources directory\n");
}
CFRelease(resourcesURL);
strncat(path, "/data", PATH_MAX - 1);
resman->addToSearchPath(path, false);
mPackageDir = path;
#else
resman->addToSearchPath(PKG_DATADIR "data", false);
mPackageDir = PKG_DATADIR "data";
#endif
resman->addToSearchPath("data", false);
// Add branding/data to PhysFS search path
if (!options.brandingPath.empty())
{
std::string path = options.brandingPath;
// Strip blah.mana from the path
#ifdef _WIN32
int loc1 = path.find_last_of('/');
int loc2 = path.find_last_of('\\');
int loc = std::max(loc1, loc2);
#else
int loc = path.find_last_of('/');
#endif
if (loc > 0)
resman->addToSearchPath(path.substr(0, loc + 1) + "data", false);
}
// Add the main data directories to our PhysicsFS search path
if (!options.dataPath.empty())
resman->addToSearchPath(options.dataPath, false);
// Add the local data directory to PhysicsFS search path
resman->addToSearchPath(mLocalDataDir, false);
std::string iconFile = branding.getValue("appIcon", "icons/mana");
#ifdef _WIN32
iconFile += ".ico";
#else
iconFile += ".png";
#endif
iconFile = resman->getPath(iconFile);
logger->log("Loading icon from file: %s", iconFile.c_str());
#ifdef _WIN32
static SDL_SysWMinfo pInfo;
SDL_GetWMInfo(&pInfo);
// Attempt to load icon from .ico file
HICON icon = (HICON) LoadImage(NULL,
iconFile.c_str(),
IMAGE_ICON, 64, 64, LR_LOADFROMFILE);
// If it's failing, we load the default resource file.
if (!icon)
icon = LoadIcon(GetModuleHandle(NULL), "A");
if (icon)
SetClassLong(pInfo.window, GCL_HICON, (LONG) icon);
#else
mIcon = IMG_Load(iconFile.c_str());
if (mIcon)
{
SDL_SetAlpha(mIcon, SDL_SRCALPHA, SDL_ALPHA_OPAQUE);
SDL_WM_SetIcon(mIcon, NULL);
}
#endif
bool useOpenGL = !mOptions.noOpenGL && (config.getValue("opengl", 1) == 1);
// Set up the transparency option for low CPU when not using OpenGL.
if (!useOpenGL && (config.getValue("disableTransparency", 0) == 1))
Image::SDLdisableTransparency();
#ifdef USE_OPENGL
// Setup image loading for the right image format
Image::setLoadAsOpenGL(useOpenGL);
// Create the graphics context
graphics = useOpenGL ? new OpenGLGraphics : new Graphics;
#else
// Create the graphics context
graphics = new Graphics;
#endif
const int width = config.getIntValue("screenwidth");
const int height = config.getIntValue("screenheight");
const int bpp = 0;
const bool fullscreen = config.getBoolValue("screen");
const bool hwaccel = config.getBoolValue("hwaccel");
// Try to set the desired video mode
if (!graphics->setVideoMode(width, height, bpp, fullscreen, hwaccel))
{
logger->error(strprintf("Couldn't set %dx%dx%d video mode: %s",
width, height, bpp, SDL_GetError()));
}
// Initialize for drawing
graphics->_beginDraw();
Theme::prepareThemePath();
// Initialize the item and emote shortcuts.
itemShortcut = new ItemShortcut;
emoteShortcut = new EmoteShortcut;
gui = new Gui(graphics);
// Initialize sound engine
try
{
if (config.getBoolValue("sound"))
sound.init();
sound.setSfxVolume(config.getIntValue("sfxVolume"));
sound.setNotificationsVolume(config.getIntValue("notificationsVolume"));
sound.setMusicVolume(config.getIntValue("musicVolume"));
}
catch (const char *err)
{
mState = STATE_ERROR;
errorMessage = err;
logger->log("Warning: %s", err);
}
// Initialize keyboard
keyboard.init();
// Initialise player relations
player_relations.init();
userPalette = new UserPalette;
setupWindow = new Setup;
sound.playMusic(branding.getStringValue("loginMusic"));
// Initialize default server
mCurrentServer.hostname = options.serverName;
mCurrentServer.port = options.serverPort;
loginData.username = options.username;
loginData.password = options.password;
loginData.remember = config.getBoolValue("remember");
loginData.registerLogin = false;
if (mCurrentServer.hostname.empty())
mCurrentServer.hostname = branding.getValue("defaultServer","").c_str();
if (mCurrentServer.port == 0)
{
mCurrentServer.port = (short) branding.getValue("defaultPort",
DEFAULT_PORT);
mCurrentServer.type = ServerInfo::parseType(
branding.getValue("defaultServerType", "tmwathena"));
}
if (chatLogger)
chatLogger->setServerName(mCurrentServer.hostname);
if (loginData.username.empty() && loginData.remember)
loginData.username = config.getStringValue("username");
if (mState != STATE_ERROR)
mState = STATE_CHOOSE_SERVER;
// Initialize logic and seconds counters
tick_time = 0;
mLogicCounterId = SDL_AddTimer(MILLISECONDS_IN_A_TICK, nextTick, NULL);
mSecondsCounterId = SDL_AddTimer(1000, nextSecond, NULL);
// Initialize frame limiting
SDL_initFramerate(&mFpsManager);
listen(Event::ConfigChannel);
//TODO: fix having to fake a option changed event
Event fakeevent(Event::ConfigOptionChanged);
fakeevent.setString("option", "fpslimit");
event(Event::ConfigChannel, fakeevent);
// Initialize PlayerInfo
PlayerInfo::init();
}
void Draw(SDL_Surface *screen)
{
int rate,x,y,s;
SDL_Rect dest,clip;
SDL_Surface *texture_image;
SDL_Surface *texture_target1;
SDL_Surface *texture_target2;
FPSmanager fpsm;
Uint32 rmask, gmask, bmask, amask;
int width_half = screen->w/2;
int height_half = screen->h/2;
Uint32 text_color = 0xffffffff;
/* Define masks for 32bit surface */
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
/* Create semi-transparent textured surface */
s=64;
texture_image = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, s, s, 32, rmask, gmask, bmask, amask));
/* Add some color */
boxRGBA(texture_image, 0, 0, s/2, s/2, 255, 0, 0, 255);
boxRGBA(texture_image, s/2, 0, s, s/2, 0, 255, 0, 255);
boxRGBA(texture_image, 0, s/2, s/2, s, 0, 0, 255, 255);
boxRGBA(texture_image, s/2, s/2, s, s, 255, 255, 255, 255);
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_image, 96);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_image, SDL_SRCALPHA, 255);
/* Create an all transparent surface */
texture_target1 = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, 256, 256, 32, rmask, gmask, bmask, amask));
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_target1, 64);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_target1, SDL_SRCALPHA, 255);
/* Create an all transparent surface (2) */
texture_target2 = SDL_DisplayFormatAlpha(SDL_CreateRGBSurface(SDL_SWSURFACE, 256, 256, 32, rmask, gmask, bmask, amask));
/* Make 75%-transparent */
SDL_gfxSetAlpha(texture_target2, 64);
/* Set alpha channel use to per-pixel blending */
SDL_SetAlpha(texture_target2, SDL_SRCALPHA, 255);
/* Define clipping region for left box */
clip.x = width_half-256-10 ;
clip.y = height_half-256/2 ;
clip.w = 256;
clip.h = 256;
/* Initialize Framerate manager */
SDL_initFramerate(&fpsm);
/* Set/switch framerate */
rate=5;
SDL_setFramerate(&fpsm,rate);
/* --- Drawing loop */
while (1) {
/* Event handler */
HandleEvent();
/* Black screen */
ClearScreen(screen);
/* Random position of new texture */
x=(rand() % (256+2*s))-s;
y=(rand() % (256+2*s))-s;
/* Same for comparison texture */
dest.x = x;
dest.y = y;
dest.w = texture_image->w;
dest.h = texture_image->h;
SDL_BlitSurface(texture_image, NULL, texture_target1, &dest);
/* Blit image into the target using custom Blit function. */
dest.x = x;
dest.y = y;
dest.w = texture_image->w;
dest.h = texture_image->h;
SDL_gfxBlitRGBA(texture_image, NULL, texture_target2, &dest);
/* Draw comparison target on screen (left) */
dest.x = width_half-256-10;
dest.y = height_half-256/2;
dest.w = 256;
dest.h = 256;
SDL_BlitSurface(texture_target1, NULL, screen, &dest);
/* Draw combiner target on screen (right) */
dest.x = width_half+10;
dest.y = height_half-256/2;
dest.w = 256;
dest.h = 256;
SDL_BlitSurface(texture_target2, NULL, screen, &dest);
/* Draw some frames with titles */
rectangleColor(screen, width_half-256-10-1, height_half-256/2-1, width_half-256-10-1+257, height_half-256/2-1+257, text_color);
rectangleColor(screen, width_half+10-1, height_half-256/2-1, width_half+10-1+257, height_half-256/2-1+257, text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-36, " SDL Standard Blitter ", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-24, "Image --sdlBlit--> Target1", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-12, "Target1 --sdlBlit--> Screen", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-36, " SDL_gfx Compositing Blitter", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-24, "Image --gfxBlit--> Target2", text_color);
stringColor(screen, width_half+10-1, height_half-256/2-1-12, "Target2 --sdlBlit--> Screen", text_color);
stringColor(screen, width_half-256-10-1, height_half-256/2-1-60, "gfxBlitRGBA Demo: Target1/2 A=64 (25%), Image A=96 (37%)", text_color);
/* Display by flipping screens */
SDL_Flip(screen);
/* Delay to fix rate */
SDL_framerateDelay(&fpsm);
}
}
int main(){
//config_manager config("data/settings.sqlite");
//config.set_setting_int("int", "Settings",100);
//cout << config.get_setting_int("int", "Settings") << "\n";
new message_log(MESSAGE_EVENT,"WWSiGE Loading");
game_engine * engine=new game_engine();
if (! engine->load(640,480,0))
{
new message_log(MESSAGE_FATAL_ERROR,"WWSiGE Failed To Load Necessary Resources, Quitting ...");
return 100;
}
new message_log(MESSAGE_EVENT,"WWSiGE Started");
FPSmanager manager;
SDL_initFramerate(&manager);
SDL_setFramerate(&manager, 30);
uint32_t last_tick=0;
char counter=0;
float fps=0;
float fps_average=0;
bool run=1;
while (run)
{
last_tick=SDL_GetTicks();
run=engine->update();
SDL_framerateDelay(&manager);
fps=SDL_GetTicks()-last_tick;
fps/=1000;
fps=1/fps;
fps_average=(fps_average+fps)/2;
counter++;
if (counter > 59)
{
counter=0;
new message_log("FPS" ,"%f (%f)", fps_average, fps);
}
controller * fps_text = engine->get_object("fps-text");
if (fps_text==NULL)
{
fps_text=new text(engine,"fps-text",625,0,"jura_medium-12","",BLIT_ABSOLUTE);
engine->add_object(fps_text);
int value=0xFF;
engine->get_object("fps-text")->set("font_green",value);
}
string text=convert_int_string(fps_average);
fps_text->set("text",text);
}
new message_log(MESSAGE_EVENT,"WWSiGE Closed");
return 0;
}
void output_run(void* args)
{
FPSmanager fps_manager;
unsigned char frame[4096];
SDL_initFramerate(&fps_manager);
SDL_setFramerate(&fps_manager, 100);
stat_ops = 100;
output_running = 1;
unsigned int last_tick = SDL_GetTicks();
while(output_running)
{
mbeat_t tb = timebase_get();
update_patterns(tb);
update_signals(tb);
for(int i=0; i<n_output_strips; i++)
{
if(!output_strips[i].bus)
continue;
output_to_buffer(&output_strips[i], output_buffers[i]);
float energy = 0.;
float scalar = 1.0;
for(int k = 0; k < output_strips[i].length; k++){
energy += output_buffers[i][k].r;
energy += output_buffers[i][k].g;
energy += output_buffers[i][k].b;
}
scalar = output_strips[i].length * config.output.max_energy / energy * 255.;
if(scalar > 255.)
scalar = 255.;
int j = 0;
for(int k = 0; k < output_strips[i].length; k++){
frame[j++] = output_buffers[i][k].r * scalar;
frame[j++] = output_buffers[i][k].g * scalar;
frame[j++] = output_buffers[i][k].b * scalar;
}
if(output_on_flux && (output_strips[i].bus & OUTPUT_FLUX))
output_flux_push(&output_strips[i], frame, j);
}
SDL_framerateDelay(&fps_manager);
//stat_ops = SDL_getFramerate(&fps_manager);
stat_ops = 0.8 * stat_ops + 0.2 * (1000. / (SDL_GetTicks() - last_tick));
last_tick = SDL_GetTicks();
}
for(int i=0; i<n_output_strips; i++)
{
free(output_buffers[i]);
}
free(output_buffers);
if(output_on_flux)
output_flux_del();
}
/// \brief Main program function
///
/// This function does very little on its own. It manages some output to
/// player's console, directs subsystems to initialize themselves and makes
/// choice of rendering engine. Then it runs the main game loop, processing
/// events and sending them further into the game.
int main(int argc, char *argv[])
{
#if !defined(WIN32) && !defined(__APPLE__)
#ifdef _GLIBCXX_DEBUG
/*#if __WORDSIZE != 64*/
/* Install our signal handler */
struct sigaction sa;
sa.sa_sigaction = /*(void *)*/crashhndl;
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_SIGINFO;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGFPE, &sa, NULL);
/*#endif*/
#endif
#endif
#ifdef WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD( 2, 2 );
if(WSAStartup(wVersionRequested, &wsaData) != 0){
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Winsock startup failed!!");
return -1;
}
if((LOBYTE(wsaData.wVersion) != 2) || (HIBYTE(wsaData.wVersion) != 2)){
WSACleanup( );
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "No Winsock 2.2 found!");
return -1;
}
#endif
//setenv("SDL_VIDEODRIVER", "aalib", 0);
//setenv("AAOPTS","-width 200 -height 70 -dim -reverse -bold -normal -boldfont -eight -extended ",0);
//setenv("AAFont","-*-fixed-bold-*-*-*-*-55-*-*-*-*-*-*",0);
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, PRODUCTLONG "\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "================================\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "version " PRODUCTVERSION "\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "compiled on " __DATE__ " " __TIME__ "\n");
#ifdef BUILDVERSION
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "build %s\n", BUILDVERSION);
#endif
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, " This is free software: you are free to change and redistribute it.\n"
" There is NO WARRANTY, to the extent permitted by law. \n"
" Review LICENSE in " PRODUCTSHORT " distribution for details.\n");
yatc_fopen_init(argv[0]);
options.Load();
MAXFPS = options.maxfps;
#if HAVE_LIBINTL_H
// set up i18n stuff
if(options.lang.size())
{
std::string l("LANG=");
l+=options.lang;
putenv((char*)l.c_str());
}
setlocale( LC_ALL, "");//options.lang.c_str() );
setlocale( LC_NUMERIC, "C");
#if !BAZEL_BUILD
bindtextdomain( "yatc", "./translations" );
#else
bindtextdomain( "yatc", (yatc_path_to_binary() + "yatc.runfiles/yatc/translations").c_str());
#endif
textdomain( "yatc" );
bind_textdomain_codeset("yatc","windows-1252");
#endif
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Checking graphics files existence...\n");
checkFiles();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "All graphics files were found.\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Initializing windowing...\n");
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0){
std::stringstream out;
out << "Couldn't initialize SDL: " << SDL_GetError() << std::endl;
DEBUGPRINT(DEBUGPRINT_ERROR, DEBUGPRINT_LEVEL_OBLIGATORY, out.str().c_str());
NativeGUIError(out.str().c_str(), PRODUCTSHORT " Fatal Error");
exit(1);
}
// We are no longer dependant on .dat for this!
// ivucica asks: nate, not dependant for what? why is this removed?
// because of .ico? disagree.
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Loading data...\n");
if(!Objects::getInstance()->loadDat("Tibia.dat")){
DEBUGPRINT(DEBUGPRINT_ERROR, DEBUGPRINT_LEVEL_OBLIGATORY, gettext("Loading data file failed!"));
std::string forreplace = gettext("Loading the data file '$$FILENAME$$' has failed.\nPlease place '$$FILENAME$$' in the same folder as $$PRODUCTSHORT$$.\n");
forreplace = str_replace("$$FILENAME$$", "Tibia.dat", forreplace);
forreplace = str_replace("$$PRODUCTSHORT$$", PRODUCTSHORT, forreplace);
NativeGUIError(forreplace.c_str(), str_replace("$$PRODUCTSHORT$$", PRODUCTSHORT, gettext("$$PRODUCTSHORT$$ Fatal Error")).c_str());
exit(1);
}
setIcon(); // must be called prior to first call to SDL_SetVideoMode() (currently done in engine)
SDL_EnableKeyRepeat(200, 50);
SDL_EnableUNICODE(1);
try{
g_engine = NULL; // set to null, in case anything that happens inside engine constructor wants to know we're just constructing
switch(options.engine){
#ifdef USE_OPENGL
case ENGINE_OPENGL:
g_engine = new EngineGL;
break;
#endif
default:
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_WARNING, "Unknown engine was selected. Falling back to SDL.");
options.engine = ENGINE_SDL;
case ENGINE_SDL:
g_engine = new EngineSDL;
break;
}
if(!g_engine->isSupported()){
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_WARNING, "The selected graphics engine is not supported. Falling back to SDL.");
delete g_engine;
g_engine = NULL; // set to null, in case anything that happens inside engine constructor wants to know we're just constructing
options.engine = ENGINE_SDL;
g_engine = new EngineSDL;
}
// NOTE (nfries88): Make sure the window is sized as per the options
int w = MAX(options.w, 656);
int h = MAX(options.h, 352+options.consoleh);
g_engine->doResize(w, h);
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Loading skin...\n");
g_skin.loadSkin();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Skin has been loaded\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Constructing gamemode...\n");
resetDefaultCursor();
if (argc == 1)
{
g_game = new GM_MainMenu();
//g_game = new GM_Debug(); // ivucica: this is for testing -- choice should be a cmd line option
} else
{
g_game = new GM_MainMenu();
ProtocolGame* protocol = ProtocolConfig::createGameProtocol(854,"","","",false);
g_connection = new ConnectionReplay(argv[1], protocol);
if (argc==3)
{
sscanf(argv[2], "%f", &g_replayspeed);
}
}
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Initializing framerate manager...\n");
SDL_initFramerate(&g_fpsmgr);
SDL_setFramerate(&g_fpsmgr,MAXFPS);
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Running\n");
g_running = true;
#ifdef WIN32
SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
#endif
SDL_Event event;
while(g_running){
//g_engine->fpsMutexLock();
//int beginticks = SDL_GetTicks();
g_engine->performFpsCalc();
//first process sdl events
while(SDL_PollEvent(&event)){
switch (event.type){
case SDL_VIDEORESIZE:
g_engine->doResize(event.resize.w, event.resize.h);
g_game->doResize(event.resize.w, event.resize.h);
break;
case SDL_QUIT:
g_game->onExitAttempt();
break;
case SDL_KEYDOWN:
onKeyDown(event);
break;
case SDL_KEYUP:
if((event.key.keysym.sym == SDLK_LSUPER)
|| (event.key.keysym.sym == SDLK_RSUPER))
superkey_state = false;
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
#ifdef WINCE
if (ptrx < 5 && ptry < 5)
SDL_WM_IconifyWindow(); // appears to crash the application?! ah nevermind
#endif
g_game->mouseEvent(event);
break;
case SDL_MOUSEMOTION:
ptrx = event.motion.x;
ptry = event.motion.y;
g_game->mouseEvent(event);
break;
default:
break;
}
}
//update current frame time
g_frameDiff = SDL_GetTicks() - g_frameTime;
g_frameTime = SDL_GetTicks();
if (MAXFPS) {
SDL_framerateDelay(&g_fpsmgr);
}
//check connection
if(g_connection){
g_connection->executeNetwork();
}
if (!(SDL_GetAppState() & SDL_APPACTIVE)) {// if the application is minimized
#ifdef WIN32
Sleep(100); // sleep a while, and don't paint
#else
usleep(100 * 1000);
#endif
} else { //otherwise update scene
g_game->updateScene();
g_engine->Flip();
}
g_frames ++;
//g_engine->fpsMutexUnlock();
}
}
catch(std::string errtext){
DEBUGPRINT(DEBUGPRINT_ERROR, DEBUGPRINT_LEVEL_OBLIGATORY, "%s", errtext.c_str());
}
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Game over\n");
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Terminating protocol connection from main...\n");
delete g_connection;
g_connection = NULL;
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Destroying map...\n");
Map::getInstance().clear();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Destroying creature cache...\n");
Creatures::getInstance().clear();
Creatures::destroyInstance();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Destroying inventory...\n");
Inventory::getInstance().clear();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Unloading data...\n");
Objects::getInstance()->unloadDat();
Objects::destroyInstance();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Unloading skin...\n");
g_skin.unloadSkin();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Saving options...\n");
options.Save();
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Finishing engine...\n");
delete g_engine;
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Ending game...\n");
delete g_game;
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Shutting down SDL...\n");
SDL_Quit();
#ifdef WIN32
WSACleanup();
#endif
DEBUGPRINT(DEBUGPRINT_LEVEL_OBLIGATORY, DEBUGPRINT_NORMAL, "Thanks for playing!\n");
return 0;
}
void * hax_sdl_main(void *configuration) {
hax_thread_config_t * hax_configs = (hax_thread_config_t *) configuration;
hax_general_settings_t * hax_user_settings = &hax_configs->user_settings;
hax_sdl_data * hax_sound_data = (hax_sdl_data *) hax_configs->data_zone;
printf("[SDL] Thread Start!\n");
FPSmanager hax_fps;
float displ = 0;
SDL_initFramerate(&hax_fps);
SDL_setFramerate(&hax_fps, 60);
// SDL video initialisation
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
printf( "Unable to init SDL: %s\n", SDL_GetError() );
pthread_exit((void *) 1);
}
atexit(SDL_Quit);
SDL_Surface* screen = SDL_SetVideoMode(hax_user_settings->window_w,
hax_user_settings->window_h, 32,
SDL_HWSURFACE|SDL_DOUBLEBUF);
if ( !screen ) {
printf("Unable to set %i x %i video: %s\n", hax_user_settings->window_w,
hax_user_settings->window_h, SDL_GetError());
pthread_exit((void *) 1);
}
printf("[SDL] Waiting to start...\n");
fflush(stdout);
std::cout.flush();
hax_configs->timer->start();
printf("[SDL] Firing Loop!\n");
fflush(stdout);
std::cout.flush();
while (*hax_user_settings->message) {
hax_configs->timer->wait_next_activation();
hax_configs->timer->stat_execution_start();
// We catch an SDL signal
SDL_Event event;
while (SDL_PollEvent(&event)) {
// If there was any signal
switch (event.type) {
// We exit if the window is closed
case SDL_QUIT:
*hax_user_settings->message = false;
break;
// We also check for keypresses
case SDL_KEYDOWN: {
// Then we exit if ESCAPE is pressed
if (event.key.keysym.sym == SDLK_ESCAPE)
*hax_user_settings->message = false;
break;
}
}
} // end of message processing
// At first we clear the screen
SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));
vlineColor(screen, screen->w / 2, 0, screen->h, 0xffffffff);
printf("[SDL] Requiring Locks!\n");
fflush(stdout);
std::cout.flush();
// Here we lock the data and then plot amplitude and spectrums
hax_sound_data->lock_data();
printf("[SDL] Plotting Sound Data!\n");
fflush(stdout);
std::cout.flush();
draw_sound(screen, hax_sound_data->get_frames(), hax_sound_data->get_left_sound_channel(),
hax_sound_data->get_right_sound_channel(), (screen->h)/7, (screen->h)/7, 0xff00ffff);
draw_real_spectrum(screen, hax_sound_data->get_frames(), hax_sound_data->get_right_spectrum(),
(screen->h*7)/14, ((screen->h)/14), (char *)"Right", 0x00ffffff );
draw_imaginary_spectrum(screen, hax_sound_data->get_frames(),
hax_sound_data->get_right_spectrum(), (screen->h*9)/14, ((screen->h)/14),
(char *)"Right", 0x00ffffff );
draw_real_spectrum(screen, hax_sound_data->get_frames(), hax_sound_data->get_left_spectrum(),
(screen->h*11)/14, ((screen->h)/14), (char *)"Left", 0x00ffffff);
draw_imaginary_spectrum(screen, hax_sound_data->get_frames(),
hax_sound_data->get_left_spectrum(), (screen->h*13)/14, ((screen->h)/14),
(char *)"Left", 0x00ffffff );
printf("[SDL] Releasing Locks!\n");
fflush(stdout);
std::cout.flush();
hax_sound_data->unlock_data();
// Finally, we update the screen
SDL_Flip(screen);
displ ++;
hax_configs->timer->stat_update();
}
printf("Exited cleanly\n");
// Printing Thread Statistics
hax_configs->timer->stats_print();
pthread_exit((void *) 0);
}
/*!
* \fn int main (int argc, char **argv)
* \param argc Number of arguments.
* \param argv Arguments.
* \return Return the program state at exit: 0 if everything is fine, 1 if an error occur.
*
* Main function of MapMe.
* Start the programme, initialize libraries, then start game pipe, wich contain menu and game.
*/
int main(int argc, char **argv)
#endif
{
/* States initialization */
StateManager &StateManager= StateManager::getInstance();
StateManager.setSoftwareState(1);
/* Loading configuration */
ConfigManager &ConfigManager= ConfigManager::getInstance();
if (ConfigManager.LoadConfig() == false)
{
std::cerr << "[X] Loading configuration : CRITICAL ERROR." << std::endl;// debug
std::cerr << "[X] Attempt to shutdone." << std::endl; // debug
return EXIT_FAILURE;
}
/* Graphics initialization */
GfxManager &GfxManager= GfxManager::getInstance();
if (GfxManager.createScreen() == false)
{
std::cerr << "[X] Screen initialization : CRITICAL ERROR." << std::endl;// debug
std::cerr << "[X] Attempt to shutdone." << std::endl; // debug
return EXIT_FAILURE;
}
// Temporary loading screen
GfxManager.loadingScreen();
// Load all gfx ressources
GfxManager.loadRessources(0);
/* Events initialization */
EventManager &EventManager= EventManager::getInstance();
/* Audio initialization */
SoundManager &SoundManager= SoundManager::getInstance();
if (SoundManager.initAudio() == false)
{
std::cerr << "[X] Audio initialization : CRITICAL ERROR." << std::endl; // debug
std::cerr << "[X] Attempt to shutdone." << std::endl; // debug
return EXIT_FAILURE;
}
SoundManager.loadRessources();
/* Menu and Game initialization */
GameWorld *pGAME= NULL;
Menu *pMENU= NULL;
/* FPS manager initialization */
FPSmanager FramesManager;
SDL_initFramerate(&FramesManager);
SDL_setFramerate(&FramesManager, 30);
// Main loop start
/////////////////////
std::cout << "[Y] Program started successfully !" << std::endl;
while(StateManager.isExitCode() == false)
{
// Menu
if ((StateManager.getSoftwareState() == 1) && (pMENU != NULL))
{
pMENU->MenuPipe();
}
else if ((StateManager.getSoftwareState() == 1) && (pMENU == NULL))
{
pMENU= new Menu();
//GfxManager.loadRessources(1);
if (pGAME != NULL)
{
delete pGAME;
//GfxManager.unloadRessources(2);
pGAME= NULL;
}
}
// Game
if ((StateManager.getSoftwareState() == 2) && (pGAME != NULL))
{
pGAME->GamePipe();
}
else if ((StateManager.getSoftwareState() == 2) && (pGAME == NULL))
{
pGAME= new GameWorld();
//GfxManager.loadRessources(2);
if (pMENU != NULL)
{
delete pMENU;
//GfxManager.unloadRessources(1);
pMENU= NULL;
}
}
GfxManager.flipVideoBuffers();
/* fps */
SDL_framerateDelay(&FramesManager);
//std::cout << "FPS : " << SDL_getFramerate(&FramesManager) << std::endl;
}
if (pMENU != NULL)
delete pMENU;
if (pGAME != NULL)
delete pGAME;
/////////////////////
// Main loop end
// Exit sequence
std::cout << "[Y] Program shutting-done." << std::endl; // debug
ConfigManager.destroyInstance();
SoundManager.destroyInstance();
GfxManager.destroyInstance();
EventManager.destroyInstance();
StateManager.destroyInstance();
return EXIT_SUCCESS;
}
int main ( int argc, char** argv )
{
std::cout << "Starting\n";
initalize();
//TODO add resource load error handling
add_surface("spaceb", load_surface("gray_space.png",1) );
add_surface("spacem", load_surface("gray_space.png",1) );
add_surface("spacef", load_surface("gray_space.png",1) );
for(int i=-2; i < 20+2; i++)
meta::objects.push_back(new psrect_static(200*i, 200, 200, 200));
//meta::objects.push_back(new psrect_static(320, 20, 320, 20));
//meta::objects.push_back(new psrect_static(0, -400,1, 1000));
//meta::objects.push_back(new psrect_static(1000, -400, 1, 1000));
meta::objects.push_back(new rocket(2000,-100, 50,70));
//load_map("test.json");
float32 timeStep = 1.0f / 30.0f;
int32 velocityIterations = 6;
int32 positionIterations = 2;
FPSmanager manager;
SDL_initFramerate(&manager);
SDL_setFramerate(&manager, 30);
// program main loop
bool done = false;
while (!done)
{
SDL_framerateDelay(&manager);
// message processing loop
SDL_Event event;
while (SDL_PollEvent(&event))
{
// check for messages
switch (event.type)
{
// exit if the window is closed
case SDL_QUIT:
done = true;
break;
// check for keypresses
case SDL_KEYDOWN:
// exit if ESCAPE is pressed
if (event.key.keysym.sym == SDLK_ESCAPE)
done = true;
break;
} // end switch
} // end of message processing
// DRAWING STARTS HERE
// clear screen
//SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, 0, 0, 0 ));
SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, meta::background_red , meta::background_green, meta::background_blue ));
draw_background();
// Instruct the world to perform a single step of simulation.
// It is generally best to keep the time step and iterations fixed.
meta::world.Step(timeStep, velocityIterations, positionIterations);
update_objects();
meta::world.DrawDebugData();
// DRAWING ENDS HERE
// finally, update the screen :)
SDL_Flip(meta::screen);
} // end main loop
// all is well ;)
printf("Exited cleanly\n");
return 0;
}
