/*******************************************************************************************
							 | 
						|
								*
							 | 
						|
								*   raylib - Advance Game template
							 | 
						|
								*
							 | 
						|
								*   <Game title>
							 | 
						|
								*   <Game description>
							 | 
						|
								*
							 | 
						|
								*   This game has been created using raylib (www.raylib.com)
							 | 
						|
								*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
							 | 
						|
								*
							 | 
						|
								*   Copyright (c) 2014-2017 Ramon Santamaria (@raysan5)
							 | 
						|
								*
							 | 
						|
								********************************************************************************************/
							 | 
						|
								
							 | 
						|
								#include "raylib.h"
							 | 
						|
								#include "screens/screens.h"    // NOTE: Defines global variable: currentScreen
							 | 
						|
								
							 | 
						|
								#if defined(PLATFORM_ANDROID)
							 | 
						|
								    #include "android_native_app_glue.h"
							 | 
						|
								#endif
							 | 
						|
								
							 | 
						|
								#if defined(PLATFORM_WEB)
							 | 
						|
								    #include <emscripten/emscripten.h>
							 | 
						|
								#endif
							 | 
						|
								
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								// Global Variables Definition (local to this module)
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								const int screenWidth = 800;
							 | 
						|
								const int screenHeight = 450;
							 | 
						|
								
							 | 
						|
								// Required variables to manage screen transitions (fade-in, fade-out)
							 | 
						|
								static float transAlpha = 0.0f;
							 | 
						|
								static bool onTransition = false;
							 | 
						|
								static bool transFadeOut = false;
							 | 
						|
								static int transFromScreen = -1;
							 | 
						|
								static int transToScreen = -1;
							 | 
						|
								
							 | 
						|
								// NOTE: Some global variables that require to be visible for all screens,
							 | 
						|
								// are defined in screens.h (i.e. currentScreen)
							 | 
						|
								    
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								// Local Functions Declaration
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								static void ChangeToScreen(int screen);     // No transition effect
							 | 
						|
								
							 | 
						|
								static void TransitionToScreen(int screen);
							 | 
						|
								static void UpdateTransition(void);
							 | 
						|
								static void DrawTransition(void);
							 | 
						|
								
							 | 
						|
								static void UpdateDrawFrame(void);          // Update and Draw one frame
							 | 
						|
								
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								// Main entry point
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								#if defined(PLATFORM_ANDROID)
							 | 
						|
								void android_main(struct android_app *app) 
							 | 
						|
								#else
							 | 
						|
								int main(void)
							 | 
						|
								#endif
							 | 
						|
								{
							 | 
						|
								    // Initialization
							 | 
						|
								    //---------------------------------------------------------
							 | 
						|
								#if defined(PLATFORM_ANDROID)
							 | 
						|
								    InitWindow(screenWidth, screenHeight, app);
							 | 
						|
								#else
							 | 
						|
								    InitWindow(screenWidth, screenHeight, "raylib template - advance game");
							 | 
						|
								#endif
							 | 
						|
								
							 | 
						|
								    // Global data loading (assets that must be available in all screens, i.e. fonts)
							 | 
						|
								    InitAudioDevice();
							 | 
						|
								
							 | 
						|
								    font = LoadSpriteFont("resources/mecha.png");
							 | 
						|
								    music = LoadMusicStream("resources/ambient.ogg");
							 | 
						|
								    fxCoin = LoadSound("resources/coin.wav");
							 | 
						|
								    
							 | 
						|
								    SetMusicVolume(music, 1.0f);
							 | 
						|
								    PlayMusicStream(music);
							 | 
						|
								
							 | 
						|
								    // Setup and Init first screen
							 | 
						|
								    currentScreen = LOGO;
							 | 
						|
								    InitLogoScreen();
							 | 
						|
								
							 | 
						|
								#if defined(PLATFORM_WEB)
							 | 
						|
								    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
							 | 
						|
								#else
							 | 
						|
								    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
							 | 
						|
								    //--------------------------------------------------------------------------------------
							 | 
						|
								
							 | 
						|
								    // Main game loop
							 | 
						|
								    while (!WindowShouldClose())    // Detect window close button or ESC key
							 | 
						|
								    {
							 | 
						|
								        UpdateDrawFrame();
							 | 
						|
								    }
							 | 
						|
								#endif
							 | 
						|
								
							 | 
						|
								    // De-Initialization
							 | 
						|
								    //--------------------------------------------------------------------------------------
							 | 
						|
								    
							 | 
						|
								    // Unload current screen data before closing
							 | 
						|
								    switch (currentScreen)
							 | 
						|
								    {
							 | 
						|
								        case LOGO: UnloadLogoScreen(); break;
							 | 
						|
								        case TITLE: UnloadTitleScreen(); break;
							 | 
						|
								        case GAMEPLAY: UnloadGameplayScreen(); break;
							 | 
						|
								        case ENDING: UnloadEndingScreen(); break;
							 | 
						|
								        default: break;
							 | 
						|
								    }
							 | 
						|
								    
							 | 
						|
								    // Unload all global loaded data (i.e. fonts) here!
							 | 
						|
								    UnloadSpriteFont(font);
							 | 
						|
								    UnloadMusicStream(music);
							 | 
						|
								    UnloadSound(fxCoin);
							 | 
						|
								
							 | 
						|
								    CloseAudioDevice();     // Close audio context
							 | 
						|
								    
							 | 
						|
								    CloseWindow();          // Close window and OpenGL context
							 | 
						|
								    //--------------------------------------------------------------------------------------
							 | 
						|
								#if !defined(PLATFORM_ANDROID)
							 | 
						|
								    return 0;
							 | 
						|
								#endif
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								// Module specific Functions Definition
							 | 
						|
								//----------------------------------------------------------------------------------
							 | 
						|
								
							 | 
						|
								// Change to next screen, no transition
							 | 
						|
								static void ChangeToScreen(int screen)
							 | 
						|
								{
							 | 
						|
								    // Unload current screen
							 | 
						|
								    switch (currentScreen)
							 | 
						|
								    {
							 | 
						|
								        case LOGO: UnloadLogoScreen(); break;
							 | 
						|
								        case TITLE: UnloadTitleScreen(); break;
							 | 
						|
								        case GAMEPLAY: UnloadGameplayScreen(); break;
							 | 
						|
								        case ENDING: UnloadEndingScreen(); break;
							 | 
						|
								        default: break;
							 | 
						|
								    }
							 | 
						|
								    
							 | 
						|
								    // Init next screen
							 | 
						|
								    switch (screen)
							 | 
						|
								    {
							 | 
						|
								        case LOGO: InitLogoScreen(); break;
							 | 
						|
								        case TITLE: InitTitleScreen(); break;
							 | 
						|
								        case GAMEPLAY: InitGameplayScreen(); break;
							 | 
						|
								        case ENDING: InitEndingScreen(); break;
							 | 
						|
								        default: break;
							 | 
						|
								    }
							 | 
						|
								    
							 | 
						|
								    currentScreen = screen;
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Define transition to next screen
							 | 
						|
								static void TransitionToScreen(int screen)
							 | 
						|
								{
							 | 
						|
								    onTransition = true;
							 | 
						|
								    transFadeOut = false;
							 | 
						|
								    transFromScreen = currentScreen;
							 | 
						|
								    transToScreen = screen;
							 | 
						|
								    transAlpha = 0.0f;
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Update transition effect
							 | 
						|
								static void UpdateTransition(void)
							 | 
						|
								{
							 | 
						|
								    if (!transFadeOut)
							 | 
						|
								    {
							 | 
						|
								        transAlpha += 0.02f;
							 | 
						|
								        
							 | 
						|
								        // NOTE: Due to float internal representation, condition jumps on 1.0f instead of 1.05f
							 | 
						|
								        // For that reason we compare against 1.01f, to avoid last frame loading stop
							 | 
						|
								        if (transAlpha > 1.01f)
							 | 
						|
								        {
							 | 
						|
								            transAlpha = 1.0f;
							 | 
						|
								        
							 | 
						|
								            // Unload current screen
							 | 
						|
								            switch (transFromScreen)
							 | 
						|
								            {
							 | 
						|
								                case LOGO: UnloadLogoScreen(); break;
							 | 
						|
								                case TITLE: UnloadTitleScreen(); break;
							 | 
						|
								                case OPTIONS: UnloadOptionsScreen(); break;
							 | 
						|
								                case GAMEPLAY: UnloadGameplayScreen(); break;
							 | 
						|
								                case ENDING: UnloadEndingScreen(); break;
							 | 
						|
								                default: break;
							 | 
						|
								            }
							 | 
						|
								            
							 | 
						|
								            // Load next screen
							 | 
						|
								            switch (transToScreen)
							 | 
						|
								            {
							 | 
						|
								                case LOGO: InitLogoScreen(); break;
							 | 
						|
								                case TITLE: InitTitleScreen(); break;
							 | 
						|
								                case GAMEPLAY: InitGameplayScreen(); break;
							 | 
						|
								                case ENDING: InitEndingScreen(); break;
							 | 
						|
								                default: break;
							 | 
						|
								            }
							 | 
						|
								            
							 | 
						|
								            currentScreen = transToScreen;
							 | 
						|
								            
							 | 
						|
								            // Activate fade out effect to next loaded screen
							 | 
						|
								            transFadeOut = true;
							 | 
						|
								        }
							 | 
						|
								    }
							 | 
						|
								    else  // Transition fade out logic
							 | 
						|
								    {
							 | 
						|
								        transAlpha -= 0.02f;
							 | 
						|
								        
							 | 
						|
								        if (transAlpha < -0.01f)
							 | 
						|
								        {
							 | 
						|
								            transAlpha = 0.0f;
							 | 
						|
								            transFadeOut = false;
							 | 
						|
								            onTransition = false;
							 | 
						|
								            transFromScreen = -1;
							 | 
						|
								            transToScreen = -1;
							 | 
						|
								        }
							 | 
						|
								    }
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Draw transition effect (full-screen rectangle)
							 | 
						|
								static void DrawTransition(void)
							 | 
						|
								{
							 | 
						|
								    DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), Fade(BLACK, transAlpha));
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Update and draw game frame
							 | 
						|
								static void UpdateDrawFrame(void)
							 | 
						|
								{
							 | 
						|
								    // Update
							 | 
						|
								    //----------------------------------------------------------------------------------
							 | 
						|
								    UpdateMusicStream(music);       // NOTE: Music keeps playing between screens
							 | 
						|
								    
							 | 
						|
								    if (!onTransition)
							 | 
						|
								    {
							 | 
						|
								        switch(currentScreen) 
							 | 
						|
								        {
							 | 
						|
								            case LOGO: 
							 | 
						|
								            {
							 | 
						|
								                UpdateLogoScreen();
							 | 
						|
								                
							 | 
						|
								                if (FinishLogoScreen()) TransitionToScreen(TITLE);
							 | 
						|
								
							 | 
						|
								            } break;
							 | 
						|
								            case TITLE: 
							 | 
						|
								            {
							 | 
						|
								                UpdateTitleScreen();
							 | 
						|
								                    
							 | 
						|
								                if (FinishTitleScreen() == 1) TransitionToScreen(OPTIONS);
							 | 
						|
								                else if (FinishTitleScreen() == 2) TransitionToScreen(GAMEPLAY);
							 | 
						|
								
							 | 
						|
								            } break;
							 | 
						|
								            case OPTIONS:
							 | 
						|
								            {
							 | 
						|
								                UpdateOptionsScreen();
							 | 
						|
								                    
							 | 
						|
								                if (FinishOptionsScreen()) TransitionToScreen(TITLE);
							 | 
						|
								
							 | 
						|
								            } break;
							 | 
						|
								            case GAMEPLAY:
							 | 
						|
								            {
							 | 
						|
								                UpdateGameplayScreen();
							 | 
						|
								                
							 | 
						|
								                if (FinishGameplayScreen() == 1) TransitionToScreen(ENDING);
							 | 
						|
								                //else if (FinishGameplayScreen() == 2) TransitionToScreen(TITLE);
							 | 
						|
								
							 | 
						|
								            } break;
							 | 
						|
								            case ENDING:
							 | 
						|
								            { 
							 | 
						|
								                UpdateEndingScreen();
							 | 
						|
								                
							 | 
						|
								                if (FinishEndingScreen() == 1) TransitionToScreen(TITLE);
							 | 
						|
								
							 | 
						|
								            } break;
							 | 
						|
								            default: break;
							 | 
						|
								        }
							 | 
						|
								    }
							 | 
						|
								    else UpdateTransition();    // Update transition (fade-in, fade-out)
							 | 
						|
								    //----------------------------------------------------------------------------------
							 | 
						|
								    
							 | 
						|
								    // Draw
							 | 
						|
								    //----------------------------------------------------------------------------------
							 | 
						|
								    BeginDrawing();
							 | 
						|
								        
							 | 
						|
								        ClearBackground(RAYWHITE);
							 | 
						|
								            
							 | 
						|
								        switch(currentScreen) 
							 | 
						|
								        {
							 | 
						|
								            case LOGO: DrawLogoScreen(); break;
							 | 
						|
								            case TITLE: DrawTitleScreen(); break;
							 | 
						|
								            case OPTIONS: DrawOptionsScreen(); break;
							 | 
						|
								            case GAMEPLAY: DrawGameplayScreen(); break;
							 | 
						|
								            case ENDING: DrawEndingScreen(); break;
							 | 
						|
								            default: break;
							 | 
						|
								        }
							 | 
						|
								         
							 | 
						|
								        // Draw full screen rectangle in front of everything
							 | 
						|
								        if (onTransition) DrawTransition();
							 | 
						|
								        
							 | 
						|
								        //DrawFPS(10, 10);
							 | 
						|
								        
							 | 
						|
								    EndDrawing();
							 | 
						|
								    //----------------------------------------------------------------------------------
							 | 
						|
								}
							 |