Added a bunch of sample games

Those games have been developed by students and ported to a common base
template. Some of them still require some review to be consistent with
each other (formatting, variables naming, code structure...)

games/samples/arkanoid.c

@@ -0,0 +1,349 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: arkanoid
+*
+*   Sample game Marc Palau and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+
+#define PLAYER_MAX_LIFE         5
+#define LINES_OF_BRICKS         5
+#define BRICKS_PER_LINE        20
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef enum GameScreen { LOGO, TITLE, GAMEPLAY, ENDING } GameScreen;
+
+typedef struct Player {
+    Vector2 position;
+    Vector2 size;
+    int life;
+} Player;
+
+typedef struct Ball {
+    Vector2 position;
+    Vector2 speed;
+    int radius;
+    bool active;
+} Ball;
+
+typedef struct Brick {
+    Vector2 position;
+    bool active;
+} Brick;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+
+static Player player;
+static Ball ball;
+static Brick brick[LINES_OF_BRICKS][BRICKS_PER_LINE];
+static Vector2 brickSize;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+// Additional module functions
+static void UpdateBall(void);
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: arkanoid");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    brickSize = (Vector2){ GetScreenWidth()/BRICKS_PER_LINE, 40 };
+
+    // Initialize player
+    player.position = (Vector2){ screenWidth/2, screenHeight*7/8 };
+    player.size = (Vector2){ screenWidth/10, 20 };
+    player.life = PLAYER_MAX_LIFE;
+    
+    // Initialize ball
+    ball.position = (Vector2){ screenWidth/2, screenHeight*7/8 - 30 };
+    ball.speed = (Vector2){ 0, 0 };
+    ball.radius = 7;
+    ball.active = false;
+    
+    // Initialize bricks
+    int initialDownPosition = 50;
+
+    for (int i = 0; i < LINES_OF_BRICKS; i++)
+    {
+        for (int j = 0; j < BRICKS_PER_LINE; j++)
+        {
+            brick[i][j].position = (Vector2){ j*brickSize.x + brickSize.x/2, i*brickSize.y + initialDownPosition };
+            brick[i][j].active = true;
+        }
+    }
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            // Player movement
+            if (IsKeyDown(KEY_LEFT)) player.position.x -= 5;
+            if ((player.position.x - player.size.x/2) <= 0) player.position.x = player.size.x/2;
+            if (IsKeyDown(KEY_RIGHT)) player.position.x += 5;
+            if ((player.position.x + player.size.x/2) >= screenWidth) player.position.x = screenWidth - player.size.x/2;
+
+            // Launch ball
+            if (!ball.active)
+            {
+                if (IsKeyPressed(KEY_SPACE))
+                {
+                    ball.active = true;
+                    ball.speed = (Vector2){ 0, -5 };
+                }
+            }
+            
+            UpdateBall();
+
+            // Game over logic
+            if (player.life <= 0) gameOver = true;
+            else
+            {
+                gameOver = true;
+                
+                for (int i = 0; i < LINES_OF_BRICKS; i++)
+                {
+                    for (int j = 0; j < BRICKS_PER_LINE; j++)
+                    {
+                        if (brick[i][j].active) gameOver = false;
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+    
+
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (!gameOver)
+        {
+            // Draw player bar
+            DrawRectangle(player.position.x - player.size.x/2, player.position.y - player.size.y/2, player.size.x, player.size.y, BLACK);
+
+            // Draw player lives
+            for (int i = 0; i < player.life; i++) DrawRectangle(20 + 40*i, screenHeight - 30, 35, 10, LIGHTGRAY);
+            
+            // Draw ball
+            DrawCircleV(ball.position, ball.radius, MAROON);
+            
+            // Draw bricks
+            for (int i = 0; i < LINES_OF_BRICKS; i++)
+            {
+                for (int j = 0; j < BRICKS_PER_LINE; j++)
+                {
+                    if (brick[i][j].active)
+                    {
+                        if ((i + j) % 2 == 0) DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, GRAY);
+                        else DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, DARKGRAY);
+                    }
+                }
+            }
+            
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}
+
+//--------------------------------------------------------------------------------------
+// Additional module functions
+//--------------------------------------------------------------------------------------
+static void UpdateBall()
+{
+    // Update position
+    if (ball.active)
+    {
+        ball.position.x += ball.speed.x;
+        ball.position.y += ball.speed.y;
+    }
+    else
+    {
+        ball.position = (Vector2){ player.position.x, screenHeight*7/8 - 30 };
+    }
+
+    // Bounce in x
+    if (((ball.position.x + ball.radius) >= screenWidth) || ((ball.position.x - ball.radius) <= 0)) ball.speed.x *= -1;
+
+    // Bounce in y
+    if ((ball.position.y - ball.radius) <= 0) ball.speed.y *= -1;
+
+    // Ball reaches bottom of the screen
+    if ((ball.position.y + ball.radius) >= screenHeight)
+    {
+        ball.speed = (Vector2){ 0, 0 };
+        ball.active = false;
+
+        player.life--;
+    }
+
+    // Collision logic: ball vs player
+    if (CheckCollisionCircleRec(ball.position, ball.radius,
+        (Rectangle){ player.position.x - player.size.x/2, player.position.y - player.size.y/2, player.size.x, player.size.y}))
+    {
+        if (ball.speed.y > 0)
+        {
+            ball.speed.y *= -1;
+            ball.speed.x = (ball.position.x - player.position.x)/(player.size.x/2)*5;
+        }
+    }
+
+    // Collision logic: ball vs bricks
+    for (int i = 0; i < LINES_OF_BRICKS; i++)
+    {
+        for (int j = 0; j < BRICKS_PER_LINE; j++)
+        {
+            if (brick[i][j].active)
+            {
+                // Hit below
+                if (((ball.position.y - ball.radius) <= (brick[i][j].position.y + brickSize.y/2)) &&
+                    ((ball.position.y - ball.radius) > (brick[i][j].position.y + brickSize.y/2 + ball.speed.y)) &&
+                    ((fabs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) && (ball.speed.y < 0))
+                {
+                    brick[i][j].active = false;
+                    ball.speed.y *= -1;
+                }
+                // Hit above
+                else if (((ball.position.y + ball.radius) >= (brick[i][j].position.y - brickSize.y/2)) &&
+                        ((ball.position.y + ball.radius) < (brick[i][j].position.y - brickSize.y/2 + ball.speed.y)) &&
+                        ((fabs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) && (ball.speed.y > 0))
+                {
+                    brick[i][j].active = false;
+                    ball.speed.y *= -1;
+                }
+                // Hit left
+                else if (((ball.position.x + ball.radius) >= (brick[i][j].position.x - brickSize.x/2)) &&
+                        ((ball.position.x + ball.radius) < (brick[i][j].position.x - brickSize.x/2 + ball.speed.x)) &&
+                        ((fabs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) && (ball.speed.x > 0))
+                {
+                    brick[i][j].active = false;
+                    ball.speed.x *= -1;
+                }
+                // Hit right
+                else if (((ball.position.x - ball.radius) <= (brick[i][j].position.x + brickSize.x/2)) &&
+                        ((ball.position.x - ball.radius) > (brick[i][j].position.x + brickSize.x/2 + ball.speed.x)) &&
+                        ((fabs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) && (ball.speed.x < 0))
+                {
+                    brick[i][j].active = false;
+                    ball.speed.x *= -1;
+                }
+            }
+        }
+    }
+}

games/samples/asteroids.c

@@ -0,0 +1,596 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: asteroids
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_SPEED           6
+#define METEORS_SPEED       2
+#define NUM_SHOOTS          10
+#define NUM_BIG_METEORS     4
+#define NUM_MEDIUM_METEORS  8
+#define NUM_SMALL_METEORS   16
+#define SHIP_BASE_SIZE      20.0f
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+typedef struct Player {
+    Vector2 position;
+    Vector2 speed;
+    float acceleration;
+    float rotation;
+    Vector3 collider;
+    Color color;
+} Player;
+
+typedef struct Shoot {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    float rotation;
+    int lifeSpawn;
+    bool active;
+    Color color;
+} Shoot;
+
+typedef struct BigMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    bool active;
+    Color color;
+} BigMeteor;
+
+typedef struct MediumMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    bool active;
+    Color color;
+} MediumMeteor;
+
+typedef struct SmallMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    bool active;
+    Color color;
+} SmallMeteor;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+static bool victory;
+
+// NOTE: Defined triangle is isosceles with common angles of 70 degrees.
+static float shipHeight;
+
+static Player player;
+static Shoot shoot[NUM_SHOOTS];
+static BigMeteor bigMeteor[NUM_BIG_METEORS];
+static MediumMeteor mediumMeteor[NUM_MEDIUM_METEORS];
+static SmallMeteor smallMeteor[NUM_SMALL_METEORS];
+
+static int countMediumMeteors;
+static int countSmallMeteors;
+static int meteorsDestroyed;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+static void InitShoot(Shoot shoot);
+static void DrawSpaceship(Vector2 position, float rotation, Color color);
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: asteroids");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    int posx, posy;
+    int velx, vely;
+    bool correctRange = false;
+    victory = false;
+    pause = false;
+
+    shipHeight = (SHIP_BASE_SIZE/2)/tanf(20*DEG2RAD);
+
+    // Initialization player
+    player.position = (Vector2){screenWidth/2, screenHeight/2 - shipHeight/2};
+    player.speed = (Vector2){0, 0};
+    player.acceleration = 0;
+    player.rotation = 0;
+    player.collider = (Vector3){player.position.x + sin(player.rotation*DEG2RAD)*(shipHeight/2.5f), player.position.y - cos(player.rotation*DEG2RAD)*(shipHeight/2.5f), 12};
+    player.color = LIGHTGRAY;
+
+    meteorsDestroyed = 0;
+
+    //InitShoot(&shoot);
+
+    // Initialization shoot
+    for (int i = 0; i < NUM_SHOOTS; i++)
+    {
+        shoot[i].position = (Vector2){0, 0};
+        shoot[i].speed = (Vector2){0, 0};
+        shoot[i].radius = 2;
+        shoot[i].active = false;
+        shoot[i].lifeSpawn = 0;
+        shoot[i].color = WHITE;
+    }
+
+    for (int i = 0; i < NUM_BIG_METEORS; i++)
+    {
+        posx = GetRandomValue(0, screenWidth);
+
+        while(!correctRange)
+        {
+            if (posx > screenWidth/2 - 150 && posx < screenWidth/2 + 150) posx = GetRandomValue(0, screenWidth);
+            else correctRange = true;
+        }
+
+        correctRange = false;
+
+        posy = GetRandomValue(0, screenHeight);
+
+        while(!correctRange)
+        {
+            if (posy > screenHeight/2 - 150 && posy < screenHeight/2 + 150)  posy = GetRandomValue(0, screenHeight);
+            else correctRange = true;
+        }
+
+        bigMeteor[i].position = (Vector2){posx, posy};
+
+        correctRange = false;
+        velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+        vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+
+        while(!correctRange)
+        {
+            if (velx == 0 && vely == 0)
+            {
+                velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+                vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+            }
+            else correctRange = true;
+        }
+
+        bigMeteor[i].speed = (Vector2){velx, vely};
+        bigMeteor[i].radius = 40;
+        bigMeteor[i].active = true;
+        bigMeteor[i].color = BLUE;
+    }
+
+    for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+    {
+        mediumMeteor[i].position = (Vector2){-100, -100};
+        mediumMeteor[i].speed = (Vector2){0,0};
+        mediumMeteor[i].radius = 20;
+        mediumMeteor[i].active = false;
+        mediumMeteor[i].color = BLUE;
+    }
+
+    for (int i = 0; i < NUM_SMALL_METEORS; i++)
+    {
+        smallMeteor[i].position = (Vector2){-100, -100};
+        smallMeteor[i].speed = (Vector2){0,0};
+        smallMeteor[i].radius = 10;
+        smallMeteor[i].active = false;
+        smallMeteor[i].color = BLUE;
+    }
+
+    countMediumMeteors = 0;
+    countSmallMeteors = 0;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            // Player logic
+
+            // Rotation
+            if (IsKeyDown(KEY_LEFT)) player.rotation -= 5;
+            if (IsKeyDown(KEY_RIGHT)) player.rotation += 5;
+
+            // Speed
+            player.speed.x = sin(player.rotation*DEG2RAD)*MAX_SPEED;
+            player.speed.y = cos(player.rotation*DEG2RAD)*MAX_SPEED;
+
+            // Controller
+            if (IsKeyDown(KEY_UP))
+            {
+                if (player.acceleration < 1) player.acceleration += 0.04f;
+            }
+            else
+            {
+                if (player.acceleration > 0) player.acceleration -= 0.02f;
+                else if (player.acceleration < 0) player.acceleration = 0;
+            }
+            if (IsKeyDown(KEY_DOWN))
+            {
+                if (player.acceleration > 0) player.acceleration -= 0.04f;
+                else if (player.acceleration < 0) player.acceleration = 0;
+            }
+
+            // Movement
+            player.position.x += (player.speed.x*player.acceleration);
+            player.position.y -= (player.speed.y*player.acceleration);
+
+            // Wall behaviour for player
+            if (player.position.x > screenWidth + shipHeight) player.position.x = -(shipHeight);
+            else if (player.position.x < -(shipHeight)) player.position.x = screenWidth + shipHeight;
+            if (player.position.y > (screenHeight + shipHeight)) player.position.y = -(shipHeight);
+            else if (player.position.y < -(shipHeight)) player.position.y = screenHeight + shipHeight;
+
+             // Activation of shoot
+            if (IsKeyPressed(KEY_SPACE))
+            {
+                for (int i = 0; i < NUM_SHOOTS; i++)
+                {
+                    if (!shoot[i].active)
+                    {
+                        shoot[i].position = (Vector2){ player.position.x + sin(player.rotation*DEG2RAD)*(shipHeight), player.position.y - cos(player.rotation*DEG2RAD)*(shipHeight) };
+                        shoot[i].active = true;
+                        shoot[i].speed.x = 1.5*sin(player.rotation*DEG2RAD)*MAX_SPEED;
+                        shoot[i].speed.y = 1.5*cos(player.rotation*DEG2RAD)*MAX_SPEED;
+                        shoot[i].rotation = player.rotation;
+                        break;
+                    }
+                }
+            }
+
+            // Shoot life timer
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active) shoot[i].lifeSpawn++;
+            }
+
+            // Shot logic
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active)
+                {
+                    // Movement
+                    shoot[i].position.x += shoot[i].speed.x;
+                    shoot[i].position.y -= shoot[i].speed.y;
+
+                    // Wall behaviour for shoot
+                    if  (shoot[i].position.x > screenWidth + shoot[i].radius)
+                    {
+                        shoot[i].active = false;
+                        shoot[i].lifeSpawn = 0;
+                    }
+                    else if (shoot[i].position.x < 0 - shoot[i].radius)
+                    {
+                        shoot[i].active = false;
+                        shoot[i].lifeSpawn = 0;
+                    }
+                    if (shoot[i].position.y > screenHeight + shoot[i].radius)
+                    {
+                        shoot[i].active = false;
+                        shoot[i].lifeSpawn = 0;
+                    }
+                    else if (shoot[i].position.y < 0 - shoot[i].radius)
+                    {
+                        shoot[i].active = false;
+                        shoot[i].lifeSpawn = 0;
+                    }
+
+                    // Life of shoot
+                    if (shoot[i].lifeSpawn >= 60)
+                    {
+                        shoot[i].position = (Vector2){0, 0};
+                        shoot[i].speed = (Vector2){0, 0};
+                        shoot[i].lifeSpawn = 0;
+                        shoot[i].active = false;
+                    }
+                }
+            }
+
+            // Collision Player to meteors
+            player.collider = (Vector3){player.position.x + sin(player.rotation*DEG2RAD)*(shipHeight/2.5f), player.position.y - cos(player.rotation*DEG2RAD)*(shipHeight/2.5f), 12};
+
+            for (int a = 0; a < NUM_BIG_METEORS; a++)
+            {
+                if (CheckCollisionCircles((Vector2){player.collider.x, player.collider.y}, player.collider.z, bigMeteor[a].position, bigMeteor[a].radius) && bigMeteor[a].active) gameOver = true;
+            }
+
+            for (int a = 0; a < NUM_MEDIUM_METEORS; a++)
+            {
+                if (CheckCollisionCircles((Vector2){player.collider.x, player.collider.y}, player.collider.z, mediumMeteor[a].position, mediumMeteor[a].radius) && mediumMeteor[a].active) gameOver = true;
+            }
+
+            for (int a = 0; a < NUM_SMALL_METEORS; a++)
+            {
+                if (CheckCollisionCircles((Vector2){player.collider.x, player.collider.y}, player.collider.z, smallMeteor[a].position, smallMeteor[a].radius) && smallMeteor[a].active) gameOver = true;
+            }
+
+            // Meteor logic
+            for (int i = 0; i < NUM_BIG_METEORS; i++)
+            {
+                if (bigMeteor[i].active)
+                {
+                    // movement
+                    bigMeteor[i].position.x += bigMeteor[i].speed.x;
+                    bigMeteor[i].position.y += bigMeteor[i].speed.y;
+
+                    // wall behaviour
+                    if  (bigMeteor[i].position.x > screenWidth + bigMeteor[i].radius) bigMeteor[i].position.x = -(bigMeteor[i].radius);
+                    else if (bigMeteor[i].position.x < 0 - bigMeteor[i].radius) bigMeteor[i].position.x = screenWidth + bigMeteor[i].radius;
+                    if (bigMeteor[i].position.y > screenHeight + bigMeteor[i].radius) bigMeteor[i].position.y = -(bigMeteor[i].radius);
+                    else if (bigMeteor[i].position.y < 0 - bigMeteor[i].radius) bigMeteor[i].position.y = screenHeight + bigMeteor[i].radius;
+                }
+            }
+
+            for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+            {
+                if (mediumMeteor[i].active)
+                {
+                    // movement
+                    mediumMeteor[i].position.x += mediumMeteor[i].speed.x;
+                    mediumMeteor[i].position.y += mediumMeteor[i].speed.y;
+
+                    // wall behaviour
+                    if  (mediumMeteor[i].position.x > screenWidth + mediumMeteor[i].radius) mediumMeteor[i].position.x = -(mediumMeteor[i].radius);
+                    else if (mediumMeteor[i].position.x < 0 - mediumMeteor[i].radius) mediumMeteor[i].position.x = screenWidth + mediumMeteor[i].radius;
+                    if (mediumMeteor[i].position.y > screenHeight + mediumMeteor[i].radius) mediumMeteor[i].position.y = -(mediumMeteor[i].radius);
+                    else if (mediumMeteor[i].position.y < 0 - mediumMeteor[i].radius) mediumMeteor[i].position.y = screenHeight + mediumMeteor[i].radius;
+                }
+            }
+
+            for (int i = 0; i < NUM_SMALL_METEORS; i++)
+            {
+                if (smallMeteor[i].active)
+                {
+                    // movement
+                    smallMeteor[i].position.x += smallMeteor[i].speed.x;
+                    smallMeteor[i].position.y += smallMeteor[i].speed.y;
+
+                    // wall behaviour
+                    if  (smallMeteor[i].position.x > screenWidth + smallMeteor[i].radius) smallMeteor[i].position.x = -(smallMeteor[i].radius);
+                    else if (smallMeteor[i].position.x < 0 - smallMeteor[i].radius) smallMeteor[i].position.x = screenWidth + smallMeteor[i].radius;
+                    if (smallMeteor[i].position.y > screenHeight + smallMeteor[i].radius) smallMeteor[i].position.y = -(smallMeteor[i].radius);
+                    else if (smallMeteor[i].position.y < 0 - smallMeteor[i].radius) smallMeteor[i].position.y = screenHeight + smallMeteor[i].radius;
+                }
+            }
+
+            // Collision behaviour
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if ((shoot[i].active))
+                {
+                    for (int a = 0; a < NUM_BIG_METEORS; a++)
+                    {
+                        if (bigMeteor[a].active && CheckCollisionCircles(shoot[i].position, shoot[i].radius, bigMeteor[a].position, bigMeteor[a].radius))
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                            bigMeteor[a].active = false;
+                            meteorsDestroyed++;
+                            for (int j = 0; j < 2; j ++)
+                            {
+                                if (countMediumMeteors%2 == 0)
+                                {
+                                    mediumMeteor[countMediumMeteors].position = (Vector2){bigMeteor[a].position.x, bigMeteor[a].position.y};
+                                    mediumMeteor[countMediumMeteors].speed = (Vector2){cos(shoot[i].rotation*DEG2RAD)*METEORS_SPEED*-1, sin(shoot[i].rotation*DEG2RAD)*METEORS_SPEED*-1};
+                                }
+                                else
+                                {
+                                    mediumMeteor[countMediumMeteors].position = (Vector2){bigMeteor[a].position.x, bigMeteor[a].position.y};
+                                    mediumMeteor[countMediumMeteors].speed = (Vector2){cos(shoot[i].rotation*DEG2RAD)*METEORS_SPEED, sin(shoot[i].rotation*DEG2RAD)*METEORS_SPEED};
+                                }
+
+                                mediumMeteor[countMediumMeteors].active = true;
+                                countMediumMeteors ++;
+                            }
+                            //bigMeteor[a].position = (Vector2){-100, -100};
+                            bigMeteor[a].color = RED;
+                            a = NUM_BIG_METEORS;
+                        }
+                    }
+                }
+                if ((shoot[i].active))
+                {
+                    for (int b = 0; b < NUM_MEDIUM_METEORS; b++)
+                    {
+                        if (mediumMeteor[b].active && CheckCollisionCircles(shoot[i].position, shoot[i].radius, mediumMeteor[b].position, mediumMeteor[b].radius))
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                            mediumMeteor[b].active = false;
+                            meteorsDestroyed++;
+                            for (int j = 0; j < 2; j ++)
+                            {
+                                 if (countSmallMeteors%2 == 0)
+                                {
+                                    smallMeteor[countSmallMeteors].position = (Vector2){mediumMeteor[b].position.x, mediumMeteor[b].position.y};
+                                    smallMeteor[countSmallMeteors].speed = (Vector2){cos(shoot[i].rotation*DEG2RAD)*METEORS_SPEED*-1, sin(shoot[i].rotation*DEG2RAD)*METEORS_SPEED*-1};
+                                }
+                                else
+                                {
+                                    smallMeteor[countSmallMeteors].position = (Vector2){mediumMeteor[b].position.x, mediumMeteor[b].position.y};
+                                    smallMeteor[countSmallMeteors].speed = (Vector2){cos(shoot[i].rotation*DEG2RAD)*METEORS_SPEED, sin(shoot[i].rotation*DEG2RAD)*METEORS_SPEED};
+                                }
+
+                                smallMeteor[countSmallMeteors].active = true;
+                                countSmallMeteors ++;
+                            }
+                            //mediumMeteor[b].position = (Vector2){-100, -100};
+                            mediumMeteor[b].color = GREEN;
+                            b = NUM_MEDIUM_METEORS;
+                        }
+                    }
+                }
+                if ((shoot[i].active))
+                {
+                    for (int c = 0; c < NUM_SMALL_METEORS; c++)
+                    {
+                        if (smallMeteor[c].active && CheckCollisionCircles(shoot[i].position, shoot[i].radius, smallMeteor[c].position, smallMeteor[c].radius))
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                            smallMeteor[c].active = false;
+                            meteorsDestroyed++;
+                            smallMeteor[c].color = YELLOW;
+                           // smallMeteor[c].position = (Vector2){-100, -100};
+                            c = NUM_SMALL_METEORS;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (meteorsDestroyed == NUM_BIG_METEORS + NUM_MEDIUM_METEORS + NUM_SMALL_METEORS) victory = true;
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(DARKGRAY);
+
+        if (!gameOver)
+        {
+            // Draw spaceship
+            Vector2 v1 = { player.position.x + sinf(player.rotation*DEG2RAD)*(shipHeight), player.position.y - cosf(player.rotation*DEG2RAD)*(shipHeight) };
+            Vector2 v2 = { player.position.x - cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y - sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+            Vector2 v3 = { player.position.x + cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y + sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+            DrawTriangleLines(v1, v2, v3, player.color);
+            
+            // Draw meteors
+            for (int i = 0; i < NUM_BIG_METEORS; i++)
+            {
+                if (bigMeteor[i].active) DrawCircleV(bigMeteor[i].position, bigMeteor[i].radius, bigMeteor[i].color);
+                else DrawCircleV(bigMeteor[i].position, bigMeteor[i].radius, Fade(bigMeteor[i].color, 0.25f));
+            }
+
+            for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+            {
+                if (mediumMeteor[i].active) DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, mediumMeteor[i].color);
+                else DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, Fade(mediumMeteor[i].color, 0.25f));
+            }
+
+            for (int i = 0; i < NUM_SMALL_METEORS; i++)
+            {
+                if (smallMeteor[i].active) DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, smallMeteor[i].color);
+                else DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, Fade(smallMeteor[i].color, 0.25f));
+            }
+
+            // Draw shoot
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active) DrawCircleV(shoot[i].position, shoot[i].radius, shoot[i].color);
+            }
+
+            if (victory) DrawText("VICTORY", screenWidth/2 - MeasureText("VICTORY", 20)/2, screenHeight/2, 20, LIGHTGRAY);
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+        
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/asteroids_survival.c

@@ -0,0 +1,395 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: asteroids survival
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_SPEED           6
+#define METEORS_SPEED       2
+#define NUM_SHOOTS          10
+#define NUM_BIG_METEORS     4
+#define NUM_MEDIUM_METEORS  8
+#define NUM_SMALL_METEORS   16
+#define SHIP_BASE_SIZE      20.0f
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+typedef struct Player {
+    Vector2 position;
+    Vector2 speed;
+    float acceleration;
+    float rotation;
+    Vector3 collider;
+    Color color;
+} Player;
+
+typedef struct MediumMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    bool active;
+    Color color;
+} MediumMeteor;
+
+typedef struct SmallMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    bool active;
+    Color color;
+} SmallMeteor;
+
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+
+// NOTE: Defined triangle is isosceles with common angles of 70 degrees.
+static float shipHeight;
+
+static Player player;
+static MediumMeteor mediumMeteor[NUM_MEDIUM_METEORS];
+static SmallMeteor smallMeteor[NUM_SMALL_METEORS];
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+static void DrawSpaceship(Vector2 position, float rotation, Color color);
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: asteroids survival");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    int posx, posy;
+    int velx, vely;
+    bool correctRange = false;
+
+    pause = false;
+
+    framesCounter = 0;
+
+    shipHeight = (SHIP_BASE_SIZE/2)/tanf(20*DEG2RAD);
+
+    // Initialization player
+    player.position = (Vector2){screenWidth/2, screenHeight/2 - shipHeight/2};
+    player.speed = (Vector2){0, 0};
+    player.acceleration = 0;
+    player.rotation = 0;
+    player.collider = (Vector3){player.position.x + sin(player.rotation*DEG2RAD)*(shipHeight/2.5f), player.position.y - cos(player.rotation*DEG2RAD)*(shipHeight/2.5f), 12};
+    player.color = LIGHTGRAY;
+
+    for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+    {
+        posx = GetRandomValue(0, screenWidth);
+
+        while(!correctRange)
+        {
+            if (posx > screenWidth/2 - 150 && posx < screenWidth/2 + 150) posx = GetRandomValue(0, screenWidth);
+            else correctRange = true;
+        }
+
+        correctRange = false;
+
+        posy = GetRandomValue(0, screenHeight);
+
+        while(!correctRange)
+        {
+            if (posy > screenHeight/2 - 150 && posy < screenHeight/2 + 150)  posy = GetRandomValue(0, screenHeight);
+            else correctRange = true;
+        }
+
+        correctRange = false;
+        velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+        vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+
+        while(!correctRange)
+        {
+            if (velx == 0 && vely == 0)
+            {
+                velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+                vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+            }
+            else correctRange = true;
+        }
+        mediumMeteor[i].position = (Vector2){posx, posy};
+        mediumMeteor[i].speed = (Vector2){velx, vely};
+        mediumMeteor[i].radius = 20;
+        mediumMeteor[i].active = true;
+        mediumMeteor[i].color = GREEN;
+    }
+
+    for (int i = 0; i < NUM_SMALL_METEORS; i++)
+    {
+        posx = GetRandomValue(0, screenWidth);
+
+        while(!correctRange)
+        {
+            if (posx > screenWidth/2 - 150 && posx < screenWidth/2 + 150) posx = GetRandomValue(0, screenWidth);
+            else correctRange = true;
+        }
+
+        correctRange = false;
+
+        posy = GetRandomValue(0, screenHeight);
+
+        while(!correctRange)
+        {
+            if (posy > screenHeight/2 - 150 && posy < screenHeight/2 + 150)  posy = GetRandomValue(0, screenHeight);
+            else correctRange = true;
+        }
+
+        correctRange = false;
+        velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+        vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+
+        while(!correctRange)
+        {
+            if (velx == 0 && vely == 0)
+            {
+                velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+                vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+            }
+            else correctRange = true;
+        }
+        smallMeteor[i].position = (Vector2){posx, posy};
+        smallMeteor[i].speed = (Vector2){velx, vely};
+        smallMeteor[i].radius = 10;
+        smallMeteor[i].active = true;
+        smallMeteor[i].color = YELLOW;
+    }
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            framesCounter++;
+
+            // Player logic
+
+            // Rotation
+            if (IsKeyDown(KEY_LEFT)) player.rotation -= 5;
+            if (IsKeyDown(KEY_RIGHT)) player.rotation += 5;
+
+            // Speed
+            player.speed.x = sin(player.rotation*DEG2RAD)*MAX_SPEED;
+            player.speed.y = cos(player.rotation*DEG2RAD)*MAX_SPEED;
+
+            // Controller
+            if (IsKeyDown(KEY_UP))
+            {
+                if (player.acceleration < 1) player.acceleration += 0.04f;
+            }
+            else
+            {
+                if (player.acceleration > 0) player.acceleration -= 0.02f;
+                else if (player.acceleration < 0) player.acceleration = 0;
+            }
+            if (IsKeyDown(KEY_DOWN))
+            {
+                if (player.acceleration > 0) player.acceleration -= 0.04f;
+                else if (player.acceleration < 0) player.acceleration = 0;
+            }
+
+            // Movement
+            player.position.x += (player.speed.x*player.acceleration);
+            player.position.y -= (player.speed.y*player.acceleration);
+
+            // Wall behaviour for player
+            if (player.position.x > screenWidth + shipHeight) player.position.x = -(shipHeight);
+            else if (player.position.x < -(shipHeight)) player.position.x = screenWidth + shipHeight;
+            if (player.position.y > (screenHeight + shipHeight)) player.position.y = -(shipHeight);
+            else if (player.position.y < -(shipHeight)) player.position.y = screenHeight + shipHeight;
+
+            // Collision Player to meteors
+            player.collider = (Vector3){player.position.x + sin(player.rotation*DEG2RAD)*(shipHeight/2.5f), player.position.y - cos(player.rotation*DEG2RAD)*(shipHeight/2.5f), 12};
+
+            for (int a = 0; a < NUM_MEDIUM_METEORS; a++)
+            {
+                if (CheckCollisionCircles((Vector2){player.collider.x, player.collider.y}, player.collider.z, mediumMeteor[a].position, mediumMeteor[a].radius) && mediumMeteor[a].active) gameOver = true;
+            }
+
+            for (int a = 0; a < NUM_SMALL_METEORS; a++)
+            {
+                if (CheckCollisionCircles((Vector2){player.collider.x, player.collider.y}, player.collider.z, smallMeteor[a].position, smallMeteor[a].radius) && smallMeteor[a].active) gameOver = true;
+            }
+
+            // Meteor logic
+
+            for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+            {
+                if (mediumMeteor[i].active)
+                {
+                    // movement
+                    mediumMeteor[i].position.x += mediumMeteor[i].speed.x;
+                    mediumMeteor[i].position.y += mediumMeteor[i].speed.y;
+
+                    // wall behaviour
+                    if  (mediumMeteor[i].position.x > screenWidth + mediumMeteor[i].radius) mediumMeteor[i].position.x = -(mediumMeteor[i].radius);
+                    else if (mediumMeteor[i].position.x < 0 - mediumMeteor[i].radius) mediumMeteor[i].position.x = screenWidth + mediumMeteor[i].radius;
+                    if (mediumMeteor[i].position.y > screenHeight + mediumMeteor[i].radius) mediumMeteor[i].position.y = -(mediumMeteor[i].radius);
+                    else if (mediumMeteor[i].position.y < 0 - mediumMeteor[i].radius) mediumMeteor[i].position.y = screenHeight + mediumMeteor[i].radius;
+                }
+            }
+
+            for (int i = 0; i < NUM_SMALL_METEORS; i++)
+            {
+                if (smallMeteor[i].active)
+                {
+                    // movement
+                    smallMeteor[i].position.x += smallMeteor[i].speed.x;
+                    smallMeteor[i].position.y += smallMeteor[i].speed.y;
+
+                    // wall behaviour
+                    if  (smallMeteor[i].position.x > screenWidth + smallMeteor[i].radius) smallMeteor[i].position.x = -(smallMeteor[i].radius);
+                    else if (smallMeteor[i].position.x < 0 - smallMeteor[i].radius) smallMeteor[i].position.x = screenWidth + smallMeteor[i].radius;
+                    if (smallMeteor[i].position.y > screenHeight + smallMeteor[i].radius) smallMeteor[i].position.y = -(smallMeteor[i].radius);
+                    else if (smallMeteor[i].position.y < 0 - smallMeteor[i].radius) smallMeteor[i].position.y = screenHeight + smallMeteor[i].radius;
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(DARKGRAY);
+        
+        if (!gameOver)
+        {
+            // Draw spaceship
+            Vector2 v1 = { player.position.x + sinf(player.rotation*DEG2RAD)*(shipHeight), player.position.y - cosf(player.rotation*DEG2RAD)*(shipHeight) };
+            Vector2 v2 = { player.position.x - cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y - sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+            Vector2 v3 = { player.position.x + cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y + sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+
+            DrawTriangleLines(v1, v2, v3, player.color);
+
+            // Draw meteor
+            for (int i = 0;i < NUM_MEDIUM_METEORS; i++)
+            {
+                if (mediumMeteor[i].active) DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, mediumMeteor[i].color);
+                else DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, Fade(mediumMeteor[i].color, 0.25f));
+            }
+
+            for (int i = 0;i < NUM_SMALL_METEORS; i++)
+            {
+                if (smallMeteor[i].active) DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, smallMeteor[i].color);
+                else DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, Fade(smallMeteor[i].color, 0.25f));
+            }
+
+            DrawText(FormatText("SURVIVAL TIME: %.02f", (float)framesCounter/60), 10, 10, 20, WHITE);
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+    //----------------------------------------------------------------------------------
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/floppy.c

@@ -0,0 +1,246 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: floppy
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_TUBES 100
+#define FLOPPY_RADIUS 24
+#define TUBES_WIDTH 80
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct Floppy {
+    Vector2 position;
+    int radius;
+    Color color;
+} Floppy;
+
+typedef struct Tubes {
+    Rectangle rec;
+    Color color;
+    bool active;
+} Tubes;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+static int score;
+static int hiScore = 0;
+
+static Floppy floppy;
+static Tubes tubes[MAX_TUBES*2];
+static Vector2 tubesPos[MAX_TUBES];
+static int tubesSpeedX;
+static bool superfx;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: floppy");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    floppy.radius = FLOPPY_RADIUS;
+    floppy.position = (Vector2){80, screenHeight/2 - floppy.radius};
+    tubesSpeedX = 2;
+
+    for (int i = 0; i < MAX_TUBES; i++)
+    {
+        tubesPos[i].x = 400 + 280*i;
+        tubesPos[i].y = -GetRandomValue(0, 120);
+    }
+
+    for (int i = 0; i < MAX_TUBES*2; i += 2)
+    {
+        tubes[i].rec.x = tubesPos[i/2].x;
+        tubes[i].rec.y = tubesPos[i/2].y;
+        tubes[i].rec.width = TUBES_WIDTH;
+        tubes[i].rec.height = 255;
+
+        tubes[i+1].rec.x = tubesPos[i/2].x;
+        tubes[i+1].rec.y = 600 + tubesPos[i/2].y - 255;
+        tubes[i+1].rec.width = TUBES_WIDTH;
+        tubes[i+1].rec.height = 255;
+
+        tubes[i/2].active = true;
+    }
+
+    score = 0;
+
+    gameOver = false;
+    superfx = false;
+    pause = false;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            for (int i = 0; i < MAX_TUBES; i++) tubesPos[i].x -= tubesSpeedX;
+
+            for (int i = 0; i < MAX_TUBES*2; i += 2)
+            {
+                tubes[i].rec.x = tubesPos[i/2].x;
+                tubes[i+1].rec.x = tubesPos[i/2].x;
+            }
+
+            if (IsKeyDown(KEY_SPACE) && !gameOver) floppy.position.y -= 3;
+            else floppy.position.y += 1;
+
+            // Check Collisions
+            for (int i = 0; i < MAX_TUBES*2; i++)
+            {
+                if (CheckCollisionCircleRec(floppy.position, floppy.radius, tubes[i].rec))
+                {
+                    gameOver = true;
+                    pause = false;
+                }
+                else if ((tubesPos[i/2].x < floppy.position.x) && tubes[i/2].active && !gameOver)
+                {
+                    score += 100;
+                    tubes[i/2].active = false;
+
+                    superfx = true;
+
+                    if (score > hiScore) hiScore = score;
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (!gameOver) 
+        {
+            DrawCircle(floppy.position.x, floppy.position.y, floppy.radius, BLUE);
+
+            // Draw tubes
+            for (int i = 0; i < MAX_TUBES; i++)
+            {
+                DrawRectangle(tubes[i*2].rec.x, tubes[i*2].rec.y, tubes[i*2].rec.width, tubes[i*2].rec.height, RED);
+                DrawRectangle(tubes[i*2 + 1].rec.x, tubes[i*2 + 1].rec.y, tubes[i*2 + 1].rec.width, tubes[i*2 + 1].rec.height, RED);
+            }
+            
+            // Draw flashing fx (one frame only)
+            if (superfx)
+            {
+                DrawRectangle(0, 0, screenWidth, screenHeight, GOLD);
+                superfx = false;
+            }
+
+            DrawText(FormatText("%04i", score), 20, 20, 40, PINK);
+            DrawText(FormatText("HI-SCORE: %04i", hiScore), 20, 70, 20, VIOLET);
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/gold_fever.c

@@ -0,0 +1,293 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: gold fever
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct Player {
+    Vector2 position;
+    int radius;
+    Vector2 speed;
+    Color color;
+} Player;
+
+typedef struct Enemy {
+    Vector2 position;
+    int radius;
+    int radiusBounds;
+    Vector2 speed;
+    bool moveRight;
+    Color colorBounds;
+    Color color;
+} Enemy;
+
+typedef struct Points {
+    Vector2 position;
+    int radius;
+    int value;
+    bool active;
+    Color color;
+} Points;
+
+typedef struct Exit {
+    Rectangle rec;
+    bool active;
+    bool save;
+    Color color;
+} Exit;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+static int score;
+static int hiScore = 0;
+
+static Player player;
+static Enemy enemy;
+static Points points;
+static Exit exit;
+static bool follow;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+
+    InitWindow(screenWidth, screenHeight, "sample game: gold fever");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    pause = false;
+    score = 0;
+
+    player.position = (Vector2){50, 50};
+    player.radius = 20;
+    player.speed = (Vector2){5, 5};
+    player.color = DARKGRAY;
+
+    enemy.position = (Vector2){screenWidth - 50, screenHeight/2};
+    enemy.radius = 20;
+    enemy.radiusBounds = 150;
+    enemy.speed = (Vector2){3, 3};
+    enemy.moveRight = true;
+    enemy.color = MAROON;
+    enemy.colorBounds = RED;
+    follow = false;
+
+    points.radius = 10;
+    points.position = (Vector2){GetRandomValue(points.radius, screenWidth - points.radius), GetRandomValue(points.radius, screenHeight - points.radius)};
+    points.value = 100;
+    points.active = true;
+    points.color = GOLD;
+
+    exit.rec.width = 50;
+    exit.rec.height = 50;
+    exit.rec.x = GetRandomValue(0, screenWidth - exit.rec.width);
+    exit.rec.y = GetRandomValue(0, screenHeight - exit.rec.height);
+    exit.active = false;
+    exit.save = false;
+    exit.color = PINK;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            //Control player
+            if (IsKeyDown(KEY_RIGHT)) player.position.x += player.speed.x;
+            if (IsKeyDown(KEY_LEFT)) player.position.x -= player.speed.x;
+            if (IsKeyDown(KEY_UP)) player.position.y -= player.speed.y;
+            if (IsKeyDown(KEY_DOWN)) player.position.y += player.speed.y;
+
+            //wall behaviour player
+            if (player.position.x - player.radius <= 0) player.position.x = player.radius;
+            if (player.position.x + player.radius >= screenWidth) player.position.x = screenWidth - player.radius;
+            if (player.position.y - player.radius <= 0) player.position.y = player.radius;
+            if (player.position.y + player.radius >= screenHeight) player.position.y = screenHeight - player.radius;
+
+            //IA Enemy
+            if ( (follow || CheckCollisionCircles(player.position, player.radius, enemy.position, enemy.radiusBounds)) && !exit.save)
+            {
+                if (player.position.x > enemy.position.x) enemy.position.x += enemy.speed.x;
+                if (player.position.x < enemy.position.x) enemy.position.x -= enemy.speed.x;
+
+                if (player.position.y > enemy.position.y) enemy.position.y += enemy.speed.y;
+                if (player.position.y < enemy.position.y) enemy.position.y -= enemy.speed.y;
+            }
+            else
+            {
+                if (enemy.moveRight) enemy.position.x += enemy.speed.x;
+                else enemy.position.x -= enemy.speed.x;
+            }
+
+            //wall behaviour enemy
+            if (enemy.position.x - enemy.radius <= 0) enemy.moveRight = true;
+            if (enemy.position.x + enemy.radius >= screenWidth) enemy.moveRight = false;
+
+            if (enemy.position.x - enemy.radius <= 0) enemy.position.x = enemy.radius;
+            if (enemy.position.x + enemy.radius >= screenWidth) enemy.position.x = screenWidth - enemy.radius;
+            if (enemy.position.y - enemy.radius <= 0) enemy.position.y = enemy.radius;
+            if (enemy.position.y + enemy.radius >= screenHeight) enemy.position.y = screenHeight - enemy.radius;
+
+            //Collisions
+            if (CheckCollisionCircles(player.position, player.radius, points.position, points.radius) && points.active)
+            {
+                follow = true;
+                points.active = false;
+                exit.active = true;
+            }
+
+            if (CheckCollisionCircles(player.position, player.radius, enemy.position, enemy.radius) && !exit.save)
+            {
+                gameOver = true;
+                
+                if (hiScore < score) hiScore = score;
+            }
+
+            if (CheckCollisionCircleRec(player.position, player.radius, exit.rec))
+            {
+               follow = false;
+               
+               if (!points.active)
+               {
+                    score += points.value;
+                    points.active = true;
+                    enemy.speed.x += 0.5;
+                    enemy.speed.y += 0.5;
+                    points.position = (Vector2){GetRandomValue(points.radius, screenWidth - points.radius), GetRandomValue(points.radius, screenHeight - points.radius)};
+               }
+               
+               exit.save = true;
+            }
+            else exit.save = false;
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+    
+        ClearBackground(RAYWHITE);
+    
+        if (!gameOver)
+        {
+            if (follow) ClearBackground(RED);
+
+            DrawCircleLines(enemy.position.x, enemy.position.y, enemy.radiusBounds, enemy.colorBounds);
+            DrawCircleV(enemy.position, enemy.radius, enemy.color);
+            
+            DrawCircleV(player.position, player.radius, player.color);
+            DrawCircleV(points.position, points.radius, points.color);
+            
+            if (exit.active) DrawRectangleRec(exit.rec, exit.color);
+
+            DrawText(FormatText("SCORE: %04i", score), 10, 10, 20, GRAY);
+            DrawText(FormatText("HI-SCORE: %04i", hiScore), 300, 10, 20, GRAY);
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/gorilas.c

@@ -0,0 +1,571 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: gorilas
+*
+*   Sample game Marc Palau and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_BUILDINGS                    15
+#define MAX_EXPLOSIONS                  200
+#define MAX_PLAYERS                       2
+
+#define BUILDING_RELATIVE_ERROR          30        // Building size random range %
+#define BUILDING_MIN_RELATIVE_HEIGHT     20        // Minimum height in % of the screenHeight
+#define BUILDING_MAX_RELATIVE_HEIGHT     60        // Maximum height in % of the screenHeight
+#define BUILDING_MIN_GRAYSCALE_COLOR    120        // Minimum gray color for the buildings
+#define BUILDING_MAX_GRAYSCALE_COLOR    200        // Maximum gray color for the buildings
+
+#define MIN_PLAYER_POSITION               5        // Minimum x position %
+#define MAX_PLAYER_POSITION              20        // Maximum x position %
+
+#define GRAVITY                       9.81f
+#define DELTA_FPS                        60
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct Player {
+    Vector2 position;
+    Vector2 size;
+
+    Vector2 aimingPoint;
+    int aimingAngle;
+    int aimingPower;
+
+    Vector2 previousPoint;
+    int previousAngle;
+    int previousPower;
+
+    Vector2 impactPoint;
+
+    bool isLeftTeam;                // This player belongs to the left or to the right team
+    bool isPlayer;                  // If is a player or an AI
+    bool isAlive;
+} Player;
+
+typedef struct Building {
+    Rectangle rectangle;
+    Color color;
+} Building;
+
+typedef struct Explosion {
+    Vector2 position;
+    int radius;
+    bool active;
+} Explosion;
+
+typedef struct Ball {
+    Vector2 position;
+    Vector2 speed;
+    int radius;
+    bool active;
+} Ball;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static bool gameOver = false;
+static bool pause = false;
+
+static Player player[MAX_PLAYERS];
+static Building building[MAX_BUILDINGS];
+static Explosion explosion[MAX_EXPLOSIONS];
+static Ball ball;
+
+static int playerTurn = 0;
+static bool ballOnAir = false;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+// Additional module functions
+static void InitBuildings(void);
+static void InitPlayers(void);
+static bool UpdatePlayer(int playerTurn);
+static bool UpdateBall(int playerTurn);
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: gorilas");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    // Init shoot
+    ball.radius = 10;
+    ballOnAir = false;
+    ball.active = false;
+
+    InitBuildings();
+    InitPlayers();
+    
+    // Init explosions
+    for (int i = 0; i < MAX_EXPLOSIONS; i++)
+    {
+        explosion[i].position = (Vector2){ 0.0f, 0.0f };
+        explosion[i].radius = 30;
+        explosion[i].active = false;
+    }
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            if (!ballOnAir) ballOnAir = UpdatePlayer(playerTurn); // If we are aiming
+            else
+            {
+                if (UpdateBall(playerTurn))                       // If collision
+                {
+                    // Game over logic
+                    bool leftTeamAlive = false;
+                    bool rightTeamAlive = false;
+
+                    for (int i = 0; i < MAX_PLAYERS; i++)
+                    {
+                        if (player[i].isAlive)
+                        {
+                            if (player[i].isLeftTeam) leftTeamAlive = true;
+                            if (!player[i].isLeftTeam) rightTeamAlive = true;
+                        }
+                    }
+                    
+                    if (leftTeamAlive && rightTeamAlive)
+                    {
+                        ballOnAir = false;
+                        ball.active = false;
+
+                        playerTurn++;
+
+                        if (playerTurn == MAX_PLAYERS) playerTurn = 0;
+                    }
+                    else
+                    {
+                        gameOver = true;
+                        
+                        // if (leftTeamAlive) left team wins
+                        // if (rightTeamAlive) right team wins
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (!gameOver)
+        {
+            // Draw buildings
+            for (int i = 0; i < MAX_BUILDINGS; i++) DrawRectangleRec(building[i].rectangle, building[i].color);
+
+            // Draw explosions
+            for (int i = 0; i < MAX_EXPLOSIONS; i++)
+            {
+                if (explosion[i].active) DrawCircle(explosion[i].position.x, explosion[i].position.y, explosion[i].radius, RAYWHITE);
+            }
+            
+            // Draw players
+            for (int i = 0; i < MAX_PLAYERS; i++)
+            {
+                if (player[i].isAlive)
+                {
+                    if (player[i].isLeftTeam) DrawRectangle(player[i].position.x - player[i].size.x/2, player[i].position.y - player[i].size.y/2,
+                                                             player[i].size.x, player[i].size.y, BLUE);
+                    else DrawRectangle(player[i].position.x - player[i].size.x/2, player[i].position.y - player[i].size.y/2,
+                                                             player[i].size.x, player[i].size.y, RED);
+                }
+            }
+
+            // Draw ball
+            if (ball.active) DrawCircle(ball.position.x, ball.position.y, ball.radius, MAROON);
+
+            // Draw the angle and the power of the aim, and the previous ones
+            if (!ballOnAir)
+            {
+                // Draw shot information
+                /*
+                if (player[playerTurn].isLeftTeam)
+                {
+                    DrawText(FormatText("Previous Point %i, %i", (int)player[playerTurn].previousPoint.x, (int)player[playerTurn].previousPoint.y), 20, 20, 20, DARKBLUE);
+                    DrawText(FormatText("Previous Angle %i", player[playerTurn].previousAngle), 20, 50, 20, DARKBLUE);
+                    DrawText(FormatText("Previous Power %i", player[playerTurn].previousPower), 20, 80, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Point %i, %i", (int)player[playerTurn].aimingPoint.x, (int)player[playerTurn].aimingPoint.y), 20, 110, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Angle %i", player[playerTurn].aimingAngle), 20, 140, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Power %i", player[playerTurn].aimingPower), 20, 170, 20, DARKBLUE);
+                }
+                else
+                {
+                    DrawText(FormatText("Previous Point %i, %i", (int)player[playerTurn].previousPoint.x, (int)player[playerTurn].previousPoint.y), screenWidth*3/4, 20, 20, DARKBLUE);
+                    DrawText(FormatText("Previous Angle %i", player[playerTurn].previousAngle), screenWidth*3/4, 50, 20, DARKBLUE);
+                    DrawText(FormatText("Previous Power %i", player[playerTurn].previousPower), screenWidth*3/4, 80, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Point %i, %i", (int)player[playerTurn].aimingPoint.x, (int)player[playerTurn].aimingPoint.y), screenWidth*3/4, 110, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Angle %i", player[playerTurn].aimingAngle), screenWidth*3/4, 140, 20, DARKBLUE);
+                    DrawText(FormatText("Aiming Power %i", player[playerTurn].aimingPower), screenWidth*3/4, 170, 20, DARKBLUE);
+                }
+                */
+                
+                // Draw aim
+                if (player[playerTurn].isLeftTeam)
+                {
+                    // Previous aiming
+                    DrawTriangle((Vector2){ player[playerTurn].position.x - player[playerTurn].size.x/4, player[playerTurn].position.y - player[playerTurn].size.y/4 },
+                                 (Vector2){ player[playerTurn].position.x + player[playerTurn].size.x/4, player[playerTurn].position.y + player[playerTurn].size.y/4 },
+                                 player[playerTurn].previousPoint, GRAY);
+
+                    // Actual aiming
+                    DrawTriangle((Vector2){ player[playerTurn].position.x - player[playerTurn].size.x/4, player[playerTurn].position.y - player[playerTurn].size.y/4 },
+                                 (Vector2){ player[playerTurn].position.x + player[playerTurn].size.x/4, player[playerTurn].position.y + player[playerTurn].size.y/4 },
+                                 player[playerTurn].aimingPoint, DARKBLUE);
+                }
+                else
+                {
+                    // Previous aiming
+                    DrawTriangle((Vector2){ player[playerTurn].position.x - player[playerTurn].size.x/4, player[playerTurn].position.y + player[playerTurn].size.y/4 },
+                                 (Vector2){ player[playerTurn].position.x + player[playerTurn].size.x/4, player[playerTurn].position.y - player[playerTurn].size.y/4 },
+                                 player[playerTurn].previousPoint, GRAY);
+
+                    // Actual aiming
+                    DrawTriangle((Vector2){ player[playerTurn].position.x - player[playerTurn].size.x/4, player[playerTurn].position.y + player[playerTurn].size.y/4 },
+                                 (Vector2){ player[playerTurn].position.x + player[playerTurn].size.x/4, player[playerTurn].position.y - player[playerTurn].size.y/4 },
+                                 player[playerTurn].aimingPoint, MAROON);
+                }
+            }
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}
+
+//--------------------------------------------------------------------------------------
+// Additional module functions
+//--------------------------------------------------------------------------------------
+static void InitBuildings(void)
+{
+    // Horizontal generation
+    int currentWidth = 0;
+
+    // We make sure the absolute error randomly generated for each building, has as a minimum value the screenWidth.
+    // This way all the screen will be filled with buildings. Each building will have a different, random width.
+
+    float relativeWidth = 100/(100 - BUILDING_RELATIVE_ERROR);
+    float buildingWidthMean = (screenWidth*relativeWidth/MAX_BUILDINGS) + 1;        // We add one to make sure we will cover the whole screen.
+
+    // Vertical generation
+    int currentHeighth = 0;
+    int grayLevel;
+
+    // Creation
+    for (int i = 0; i < MAX_BUILDINGS; i++)
+    {
+        // Horizontal
+        building[i].rectangle.x = currentWidth;
+        building[i].rectangle.width = GetRandomValue(buildingWidthMean*(100 - BUILDING_RELATIVE_ERROR/2)/100 + 1, buildingWidthMean*(100 + BUILDING_RELATIVE_ERROR)/100);
+
+        currentWidth += building[i].rectangle.width;
+
+        // Vertical
+        currentHeighth = GetRandomValue(BUILDING_MIN_RELATIVE_HEIGHT, BUILDING_MAX_RELATIVE_HEIGHT);
+        building[i].rectangle.y = screenHeight - (screenHeight*currentHeighth/100);
+        building[i].rectangle.height = screenHeight*currentHeighth/100 + 1;
+
+        // Color
+        grayLevel = GetRandomValue(BUILDING_MIN_GRAYSCALE_COLOR, BUILDING_MAX_GRAYSCALE_COLOR);
+        building[i].color = (Color){ grayLevel, grayLevel, grayLevel, 255 };
+    }
+}
+
+static void InitPlayers(void)
+{
+    for (int i = 0; i < MAX_PLAYERS; i++)
+    {
+        player[i].isAlive = true;
+
+        // Decide the team of this player
+        if (i % 2 == 0) player[i].isLeftTeam = true;
+        else player[i].isLeftTeam = false;
+
+        // Now there is no AI
+        player[i].isPlayer = true;
+
+        // Set size, by default by now
+        player[i].size = (Vector2){ 40, 40 };
+
+        // Set position
+        if (player[i].isLeftTeam) player[i].position.x = GetRandomValue(screenWidth*MIN_PLAYER_POSITION/100, screenWidth*MAX_PLAYER_POSITION/100);
+        else player[i].position.x = screenWidth - GetRandomValue(screenWidth*MIN_PLAYER_POSITION/100, screenWidth*MAX_PLAYER_POSITION/100);
+
+        for (int j = 0; j < MAX_BUILDINGS; j++)
+        {
+            if (building[j].rectangle.x > player[i].position.x)
+            {
+                // Set the player in the center of the building
+                player[i].position.x = building[j-1].rectangle.x + building[j-1].rectangle.width/2;
+                // Set the player at the top of the building
+                player[i].position.y = building[j-1].rectangle.y - player[i].size.y/2;
+                break;
+            }
+        }
+
+        // Set statistics to 0
+        player[i].aimingPoint = player[i].position;
+        player[i].previousAngle = 0;
+        player[i].previousPower = 0;
+        player[i].previousPoint = player[i].position;
+        player[i].aimingAngle = 0;
+        player[i].aimingPower = 0;
+
+        player[i].impactPoint = (Vector2){ -100, -100 };
+    }
+}
+
+static bool UpdatePlayer(int playerTurn)
+{
+    // If we are aiming at the firing quadrant, we calculate the angle
+    if (GetMousePosition().y <= player[playerTurn].position.y)
+    {
+        // Left team
+        if (player[playerTurn].isLeftTeam && GetMousePosition().x >= player[playerTurn].position.x)
+        {
+            // Distance (calculating the fire power)
+            player[playerTurn].aimingPower = sqrt(pow(player[playerTurn].position.x - GetMousePosition().x, 2) + pow(player[playerTurn].position.y - GetMousePosition().y, 2));
+            // Calculates the angle via arcsin
+            player[playerTurn].aimingAngle = asin((player[playerTurn].position.y - GetMousePosition().y)/player[playerTurn].aimingPower)*RAD2DEG;
+            // Point of the screen we are aiming at
+            player[playerTurn].aimingPoint = GetMousePosition();
+
+            // Ball fired
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+            {
+                player[playerTurn].previousPoint = player[playerTurn].aimingPoint;
+                player[playerTurn].previousPower = player[playerTurn].aimingPower;
+                player[playerTurn].previousAngle = player[playerTurn].aimingAngle;
+                ball.position = player[playerTurn].position;
+
+                return true;
+            }
+        }
+        // Right team
+        else if (!player[playerTurn].isLeftTeam && GetMousePosition().x <= player[playerTurn].position.x)
+        {
+            // Distance (calculating the fire power)
+            player[playerTurn].aimingPower = sqrt(pow(player[playerTurn].position.x - GetMousePosition().x, 2) + pow(player[playerTurn].position.y - GetMousePosition().y, 2));
+            // Calculates the angle via arcsin
+            player[playerTurn].aimingAngle = asin((player[playerTurn].position.y - GetMousePosition().y)/player[playerTurn].aimingPower)*RAD2DEG;
+            // Point of the screen we are aiming at
+            player[playerTurn].aimingPoint = GetMousePosition();
+
+            // Ball fired
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+            {
+                player[playerTurn].previousPoint = player[playerTurn].aimingPoint;
+                player[playerTurn].previousPower = player[playerTurn].aimingPower;
+                player[playerTurn].previousAngle = player[playerTurn].aimingAngle;
+                ball.position = player[playerTurn].position;
+
+                return true;
+            }
+        }
+        else
+        {
+            player[playerTurn].aimingPoint = player[playerTurn].position;
+            player[playerTurn].aimingPower = 0;
+            player[playerTurn].aimingAngle = 0;
+        }
+    }
+    else
+    {
+        player[playerTurn].aimingPoint = player[playerTurn].position;
+        player[playerTurn].aimingPower = 0;
+        player[playerTurn].aimingAngle = 0;
+    }
+
+    return false;
+}
+
+static bool UpdateBall(int playerTurn)
+{
+    static int explosionNumber = 0;
+
+    // Activate ball
+    if (!ball.active)
+    {
+        if (player[playerTurn].isLeftTeam)
+        {
+            ball.speed.x = cos(player[playerTurn].previousAngle*DEG2RAD)*player[playerTurn].previousPower*3/DELTA_FPS;
+            ball.speed.y = -sin(player[playerTurn].previousAngle*DEG2RAD)*player[playerTurn].previousPower*3/DELTA_FPS;
+            ball.active = true;
+        }
+        else
+        {
+            ball.speed.x = -cos(player[playerTurn].previousAngle*DEG2RAD)*player[playerTurn].previousPower*3/DELTA_FPS;
+            ball.speed.y = -sin(player[playerTurn].previousAngle*DEG2RAD)*player[playerTurn].previousPower*3/DELTA_FPS;
+            ball.active = true;
+        }
+    }
+
+    ball.position.x += ball.speed.x;
+    ball.position.y += ball.speed.y;
+    ball.speed.y += GRAVITY/DELTA_FPS;
+
+    // Collision
+    if (ball.position.x + ball.radius < 0) return true;
+    else if (ball.position.x - ball.radius > screenWidth) return true;
+    else
+    {
+        // Player collision
+        for (int i = 0; i < MAX_PLAYERS; i++)
+        {
+            if (CheckCollisionCircleRec(ball.position, ball.radius,  (Rectangle){ player[i].position.x - player[i].size.x/2, player[i].position.y - player[i].size.y/2,
+                                                                                  player[i].size.x, player[i].size.y }))
+            {
+                // We can't hit ourselves
+                if (i == playerTurn) return false;
+                else
+                {
+                    // We set the impact point
+                    player[playerTurn].impactPoint.x = ball.position.x;
+                    player[playerTurn].impactPoint.y = ball.position.y + ball.radius;
+
+                    // We destroy the player
+                    player[i].isAlive = false;
+                    return true;
+                }
+            }
+        }
+
+        // Building collision
+        // NOTE: We only check building collision if we are not inside an explosion
+        for (int i = 0; i < MAX_BUILDINGS; i++)
+        {
+            if (CheckCollisionCircles(ball.position, ball.radius, explosion[i].position, explosion[i].radius - ball.radius))
+            {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < MAX_BUILDINGS; i++)
+        {
+            if (CheckCollisionCircleRec(ball.position, ball.radius, building[i].rectangle))
+            {
+                // We set the impact point
+                player[playerTurn].impactPoint.x = ball.position.x;
+                player[playerTurn].impactPoint.y = ball.position.y + ball.radius;
+
+                // We create an explosion
+                explosion[explosionNumber].position = player[playerTurn].impactPoint;
+                explosion[explosionNumber].active = true;
+                explosionNumber++;
+
+                return true;
+            }
+        }
+    }
+
+    return false;
+}

games/samples/missile_commander.c

@@ -0,0 +1,539 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: missile commander
+*
+*   Sample game Marc Palau and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_MISSILES                100
+#define MAX_INTERCEPTORS            30
+#define MAX_EXPLOSIONS              100
+#define LAUNCHERS_AMOUNT            3           // Not a variable, should not be changed
+#define BUILDINGS_AMOUNT            6           // Not a variable, should not be changed
+
+#define LAUNCHER_SIZE               80
+#define BUILDING_SIZE               60
+#define EXPLOSION_RADIUS            40
+
+#define MISSILE_SPEED               1
+#define MISSILE_LAUNCH_FRAMES       80
+#define INTERCEPTOR_SPEED           10
+#define EXPLOSION_INCREASE_TIME     90          // In frames
+#define EXPLOSION_TOTAL_TIME        210         // In frames
+
+#define EXPLOSION_COLOR             (Color){ 125, 125, 125, 125 }
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct Missile {
+    Vector2 origin;
+    Vector2 position;
+    Vector2 objective;
+    Vector2 speed;
+
+    bool active;
+} Missile;
+
+typedef struct Interceptor {
+    Vector2 origin;
+    Vector2 position;
+    Vector2 objective;
+    Vector2 speed;
+
+    bool active;
+} Interceptor;
+
+typedef struct Explosion {
+    Vector2 position;
+    float radiusMultiplier;
+    int frame;
+    bool active;
+} Explosion;
+
+typedef struct Launcher {
+    Vector2 position;
+    bool active;
+} Launcher;
+
+typedef struct Building {
+    Vector2 position;
+    bool active;
+} Building;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter = 0;
+static bool gameOver = false;
+static bool pause = false;
+static int score = 0;
+
+static Missile missile[MAX_MISSILES];
+static Interceptor interceptor[MAX_INTERCEPTORS];
+static Explosion explosion[MAX_EXPLOSIONS];
+static Launcher launcher[LAUNCHERS_AMOUNT];
+static Building building[BUILDINGS_AMOUNT];
+static int explosionIndex = 0;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+// Additional module functions
+static void UpdateOutgoingFire();
+static void UpdateIncomingFire();
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: missile commander");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//--------------------------------------------------------------------------------------
+// Game Module Functions Definition
+//--------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    // Initialize missiles
+    for (int i = 0; i < MAX_MISSILES; i++)
+    {
+        missile[i].origin = (Vector2){ 0, 0 };
+        missile[i].speed = (Vector2){ 0, 0 };
+        missile[i].position = (Vector2){ 0, 0 };
+
+        missile[i].active = false;
+    }
+    
+    // Initialize interceptors
+    for (int i = 0; i < MAX_INTERCEPTORS; i++)
+    {
+        interceptor[i].origin = (Vector2){ 0, 0 };
+        interceptor[i].speed = (Vector2){ 0, 0 };
+        interceptor[i].position = (Vector2){ 0, 0 };
+
+        interceptor[i].active = false;
+    }
+    
+    // Initialize explosions
+    for (int i = 0; i < MAX_EXPLOSIONS; i++)
+    {
+        explosion[i].position = (Vector2){ 0, 0 };
+        explosion[i].frame = 0;
+        explosion[i].active = false;
+    }
+    
+    // Initialize buildings and launchers
+    int sparcing = screenWidth/(LAUNCHERS_AMOUNT + BUILDINGS_AMOUNT + 1);
+
+    // Buildings and launchers placing
+    launcher[0].position = (Vector2){ 1*sparcing, screenHeight - LAUNCHER_SIZE/2 };
+    building[0].position = (Vector2){ 2*sparcing, screenHeight - BUILDING_SIZE/2 };
+    building[1].position = (Vector2){ 3*sparcing, screenHeight - BUILDING_SIZE/2 };
+    building[2].position = (Vector2){ 4*sparcing, screenHeight - BUILDING_SIZE/2 };
+    launcher[1].position = (Vector2){ 5*sparcing, screenHeight - LAUNCHER_SIZE/2 };
+    building[3].position = (Vector2){ 6*sparcing, screenHeight - BUILDING_SIZE/2 };
+    building[4].position = (Vector2){ 7*sparcing, screenHeight - BUILDING_SIZE/2 };
+    building[5].position = (Vector2){ 8*sparcing, screenHeight - BUILDING_SIZE/2 };
+    launcher[2].position = (Vector2){ 9*sparcing, screenHeight - LAUNCHER_SIZE/2 };
+
+    // Buildings and launchers activation
+    for (int i = 0; i < LAUNCHERS_AMOUNT; i++) launcher[i].active = true;
+    for (int i = 0; i < BUILDINGS_AMOUNT; i++) building[i].active = true;
+
+    // Initialize game variables
+    score = 0;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            framesCounter++;
+
+            static 
+            float distance;
+
+            // Interceptors update
+            for (int i = 0; i < MAX_INTERCEPTORS; i++)
+            {
+                if (interceptor[i].active)
+                {
+                    // Update position
+                    interceptor[i].position.x += interceptor[i].speed.x;
+                    interceptor[i].position.y += interceptor[i].speed.y;
+
+                    // Distance to objective
+                    distance = sqrt( pow(interceptor[i].position.x - interceptor[i].objective.x, 2) +
+                                     pow(interceptor[i].position.y - interceptor[i].objective.y, 2));
+
+                    if (distance < INTERCEPTOR_SPEED)
+                    {
+                        // Interceptor dissapears
+                        interceptor[i].active = false;
+
+                        // Explosion
+                        explosion[explosionIndex].position = interceptor[i].position;
+                        explosion[explosionIndex].active = true;
+                        explosion[explosionIndex].frame = 0;
+                        explosionIndex++;
+                        if (explosionIndex == MAX_EXPLOSIONS) explosionIndex = 0;
+
+                        break;
+                    }
+                }
+            }
+
+            // Missiles update
+            for (int i = 0; i < MAX_MISSILES; i++)
+            {
+                if (missile[i].active)
+                {
+                    // Update position
+                    missile[i].position.x += missile[i].speed.x;
+                    missile[i].position.y += missile[i].speed.y;
+
+                    // Collision and missile out of bounds
+                    if (missile[i].position.y > screenHeight) missile[i].active = false;
+                    else
+                    {
+                        // CHeck collision with launchers
+                        for (int j = 0; j < LAUNCHERS_AMOUNT; j++)
+                        {
+                            if (launcher[j].active)
+                            {
+                                if (CheckCollisionPointRec(missile[i].position,  (Rectangle){ launcher[j].position.x - LAUNCHER_SIZE/2, launcher[j].position.y - LAUNCHER_SIZE/2,
+                                                                                            LAUNCHER_SIZE, LAUNCHER_SIZE }))
+                                {
+                                    // Missile dissapears
+                                    missile[i].active = false;
+
+                                    // Explosion and destroy building
+                                    launcher[j].active = false;
+
+                                    explosion[explosionIndex].position = missile[i].position;
+                                    explosion[explosionIndex].active = true;
+                                    explosion[explosionIndex].frame = 0;
+                                    explosionIndex++;
+                                    if (explosionIndex == MAX_EXPLOSIONS) explosionIndex = 0;
+
+                                    break;
+                                }
+                            }
+                        }
+
+                        // CHeck collision with buildings
+                        for (int j = 0; j < BUILDINGS_AMOUNT; j++)
+                        {
+                            if (building[j].active)
+                            {
+                                if (CheckCollisionPointRec(missile[i].position,  (Rectangle){ building[j].position.x - BUILDING_SIZE/2, building[j].position.y - BUILDING_SIZE/2,
+                                                                                            BUILDING_SIZE, BUILDING_SIZE }))
+                                {
+                                    // Missile dissapears
+                                    missile[i].active = false;
+
+                                    // Explosion and destroy building
+                                    building[j].active = false;
+
+                                    explosion[explosionIndex].position = missile[i].position;
+                                    explosion[explosionIndex].active = true;
+                                    explosion[explosionIndex].frame = 0;
+                                    explosionIndex++;
+                                    if (explosionIndex == MAX_EXPLOSIONS) explosionIndex = 0;
+
+                                    break;
+                                }
+                            }
+                        }
+
+                        // CHeck collision with explosions
+                        for (int j = 0; j < MAX_EXPLOSIONS; j++)
+                        {
+                            if (explosion[j].active)
+                            {
+                                if (CheckCollisionPointCircle(missile[i].position, explosion[j].position, EXPLOSION_RADIUS*explosion[j].radiusMultiplier))
+                                {
+                                    // Missile dissapears and we earn 100 points
+                                    missile[i].active = false;
+                                    score += 100;
+
+                                    explosion[explosionIndex].position = missile[i].position;
+                                    explosion[explosionIndex].active = true;
+                                    explosion[explosionIndex].frame = 0;
+                                    explosionIndex++;
+                                    if (explosionIndex == MAX_EXPLOSIONS) explosionIndex = 0;
+
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Explosions update
+            for (int i = 0; i < MAX_EXPLOSIONS; i++)
+            {
+                if (explosion[i].active)
+                {
+                    explosion[i].frame++;
+
+                    if (explosion[i].frame <= EXPLOSION_INCREASE_TIME) explosion[i].radiusMultiplier = explosion[i].frame/(float)EXPLOSION_INCREASE_TIME;
+                    else if (explosion[i].frame <= EXPLOSION_TOTAL_TIME) explosion[i].radiusMultiplier = 1 - (explosion[i].frame - (float)EXPLOSION_INCREASE_TIME)/(float)EXPLOSION_TOTAL_TIME;
+                    else
+                    {
+                        explosion[i].frame = 0;
+                        explosion[i].active = false;
+                    }
+                }
+            }
+
+            // Fire logic
+            UpdateOutgoingFire();
+            UpdateIncomingFire();
+
+            // Game over logic
+            int checker = 0;
+
+            for (int i = 0; i < LAUNCHERS_AMOUNT; i++)
+            {
+                if (!launcher[i].active) checker++;
+                if (checker == LAUNCHERS_AMOUNT) gameOver = true;
+            }
+
+            checker = 0;
+            for (int i = 0; i < BUILDINGS_AMOUNT; i++)
+            {
+                if (!building[i].active) checker++;
+                if (checker == BUILDINGS_AMOUNT) gameOver = true;
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (!gameOver)
+        {
+            // Draw missiles
+            for (int i = 0; i < MAX_MISSILES; i++)
+            {
+                if (missile[i].active)
+                {
+                    DrawLine(missile[i].origin.x, missile[i].origin.y, missile[i].position.x, missile[i].position.y, RED);
+
+                    if (framesCounter % 16 < 8) DrawCircle(missile[i].position.x, missile[i].position.y, 3, YELLOW);
+                }
+            }
+            
+            // Draw interceptors
+            for (int i = 0; i < MAX_INTERCEPTORS; i++)
+            {
+                if (interceptor[i].active)
+                {
+                    DrawLine(interceptor[i].origin.x, interceptor[i].origin.y, interceptor[i].position.x, interceptor[i].position.y, GREEN);
+
+                    if (framesCounter % 16 < 8) DrawCircle(interceptor[i].position.x, interceptor[i].position.y, 3, BLUE);
+                }
+            }
+            
+            // Draw explosions
+            for (int i = 0; i < MAX_EXPLOSIONS; i++)
+            {
+                if (explosion[i].active) DrawCircle(explosion[i].position.x, explosion[i].position.y, EXPLOSION_RADIUS*explosion[i].radiusMultiplier, EXPLOSION_COLOR);
+            }
+
+            // Draw buildings and launchers
+            for (int i = 0; i < LAUNCHERS_AMOUNT; i++)
+            {
+                if (launcher[i].active) DrawRectangle(launcher[i].position.x - LAUNCHER_SIZE/2, launcher[i].position.y - LAUNCHER_SIZE/2, LAUNCHER_SIZE, LAUNCHER_SIZE, GRAY);
+            }
+
+            for (int i = 0; i < BUILDINGS_AMOUNT; i++)
+            {
+                if (building[i].active) DrawRectangle(building[i].position.x - BUILDING_SIZE/2, building[i].position.y - BUILDING_SIZE/2, BUILDING_SIZE, BUILDING_SIZE, LIGHTGRAY);
+            }
+
+            // Draw score
+            DrawText(FormatText("SCORE %4i", score), 20, 20, 40, LIGHTGRAY);
+            
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}
+
+//--------------------------------------------------------------------------------------
+// Additional module functions
+//--------------------------------------------------------------------------------------
+static void UpdateOutgoingFire()
+{
+    static int interceptorNumber = 0;
+    int launcherShooting = 0;
+
+    if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) launcherShooting = 1;
+    if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) launcherShooting = 2;
+    if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) launcherShooting = 3;
+
+    if (launcherShooting > 0 && launcher[launcherShooting - 1].active)
+    {
+        float module;
+        float sideX;
+        float sideY;
+
+        // Activate the interceptor
+        interceptor[interceptorNumber].active = true;
+
+        // Assign start position
+        interceptor[interceptorNumber].origin = launcher[launcherShooting - 1].position;
+        interceptor[interceptorNumber].position = interceptor[interceptorNumber].origin;
+        interceptor[interceptorNumber].objective = GetMousePosition();
+
+        // Calculate speed
+        module = sqrt( pow(interceptor[interceptorNumber].objective.x - interceptor[interceptorNumber].origin.x, 2) +
+                       pow(interceptor[interceptorNumber].objective.y - interceptor[interceptorNumber].origin.y, 2));
+
+        sideX = (interceptor[interceptorNumber].objective.x - interceptor[interceptorNumber].origin.x)*INTERCEPTOR_SPEED/module;
+        sideY = (interceptor[interceptorNumber].objective.y - interceptor[interceptorNumber].origin.y)*INTERCEPTOR_SPEED/module;
+
+        interceptor[interceptorNumber].speed = (Vector2){ sideX, sideY };
+
+        // Update
+        interceptorNumber++;
+        if (interceptorNumber == MAX_INTERCEPTORS) interceptorNumber = 0;
+    }
+}
+
+static void UpdateIncomingFire()
+{
+    static int missileIndex = 0;
+
+    // Launch missile
+    if (framesCounter % MISSILE_LAUNCH_FRAMES == 0)
+    {
+        float module;
+        float sideX;
+        float sideY;
+
+        // Activate the missile
+        missile[missileIndex].active = true;
+
+        // Assign start position
+        missile[missileIndex].origin = (Vector2){ GetRandomValue(20, screenWidth - 20), -10 };
+        missile[missileIndex].position = missile[missileIndex].origin;
+        missile[missileIndex].objective = (Vector2){ GetRandomValue(20, screenWidth - 20), screenHeight + 10 };
+
+        // Calculate speed
+        module = sqrt( pow(missile[missileIndex].objective.x - missile[missileIndex].origin.x, 2) +
+                       pow(missile[missileIndex].objective.y - missile[missileIndex].origin.y, 2));
+
+        sideX = (missile[missileIndex].objective.x - missile[missileIndex].origin.x)*MISSILE_SPEED/module;
+        sideY = (missile[missileIndex].objective.y - missile[missileIndex].origin.y)*MISSILE_SPEED/module;
+
+        missile[missileIndex].speed = (Vector2){ sideX, sideY };
+
+        // Update
+        missileIndex++;
+        if (missileIndex == MAX_MISSILES) missileIndex = 0;
+    }
+}

games/samples/pang.c

@@ -0,0 +1,692 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: pang
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define MAX_SPEED           5
+#define METEORS_SPEED       2
+#define NUM_SHOOTS          1
+#define NUM_BIG_METEORS     2
+#define NUM_MEDIUM_METEORS  4
+#define NUM_SMALL_METEORS   8
+#define SHIP_BASE_SIZE      20.0f
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+typedef struct Player {
+    Vector2 position;
+    Vector2 speed;
+    float rotation;
+    Vector3 collider;
+    Color color;
+} Player;
+
+typedef struct Shoot {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    float rotation;
+    int lifeSpawn;
+    bool active;
+    Color color;
+} Shoot;
+
+typedef struct BigMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    int points;
+    bool active;
+    Color color;
+} BigMeteor;
+
+typedef struct MediumMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    int points;
+    bool active;
+    Color color;
+} MediumMeteor;
+
+typedef struct SmallMeteor {
+    Vector2 position;
+    Vector2 speed;
+    float radius;
+    int points;
+    bool active;
+    Color color;
+} SmallMeteor;
+
+typedef struct Points {
+    char letter;
+    Vector2 position;
+    int value;
+    Color color;
+    float alpha;
+} Points;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+static int score;
+
+static Player player;
+static Shoot shoot[NUM_SHOOTS];
+static BigMeteor bigMeteor[NUM_BIG_METEORS];
+static MediumMeteor mediumMeteor[NUM_MEDIUM_METEORS];
+static SmallMeteor smallMeteor[NUM_SMALL_METEORS];
+static Points points[5];
+
+// NOTE: Defined triangle is isosceles with common angles of 70 degrees.
+static float shipHeight;
+static float gravity;
+
+static int countMediumMeteors;
+static int countSmallMeteors;
+static int meteorsDestroyed;
+static Vector2 linePosition;
+
+static bool victory;
+static bool lose;
+static bool awake;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+static void InitShoot(Shoot shoot);
+static void DrawSpaceship(Vector2 position, float rotation, Color color);
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    InitWindow(screenWidth, screenHeight, "sample game: pang");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+static void InitGame(void)
+{
+    int posx, posy;
+    int velx = 0;
+    int vely = 0;
+    
+    framesCounter = 0;
+    gameOver = false;
+    pause = false;
+    score = 0;
+    
+    victory = false;
+    lose = false;
+    awake = true;
+    gravity = 0.25f;
+
+    linePosition = (Vector2){ 0.0f , 0.0f };
+    shipHeight = (SHIP_BASE_SIZE/2)/tanf(20*DEG2RAD);
+
+    // Initialization player
+    player.position = (Vector2){ screenWidth/2, screenHeight };
+    player.speed = (Vector2){ MAX_SPEED, MAX_SPEED };
+    player.rotation = 0;
+    player.collider = (Vector3){ player.position.x, player.position.y - shipHeight/2.0f, 12.0f };
+    player.color = LIGHTGRAY;
+
+    meteorsDestroyed = 0;
+
+    // Initialize shoots
+    for (int i = 0; i < NUM_SHOOTS; i++)
+    {
+        shoot[i].position = (Vector2){ 0, 0 };
+        shoot[i].speed = (Vector2){ 0, 0 };
+        shoot[i].radius = 2;
+        shoot[i].active = false;
+        shoot[i].lifeSpawn = 0;
+        shoot[i].color = WHITE;
+    }
+
+    // Initialize big meteors
+    for (int i = 0; i < NUM_BIG_METEORS; i++)
+    {
+        bigMeteor[i].radius = 40.0f;
+        posx = GetRandomValue(0 + bigMeteor[i].radius, screenWidth - bigMeteor[i].radius);
+        posy = GetRandomValue(0 + bigMeteor[i].radius, screenHeight/2);
+
+        bigMeteor[i].position = (Vector2){ posx, posy };
+
+        while ((velx == 0) || (vely == 0))
+        {
+            velx = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+            vely = GetRandomValue(-METEORS_SPEED, METEORS_SPEED);
+        }
+
+        bigMeteor[i].speed = (Vector2){ velx, vely };
+        bigMeteor[i].points = 200;
+        bigMeteor[i].active = true;
+        bigMeteor[i].color = BLUE;
+    }
+
+    // Initialize medium meteors
+    for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+    {
+        mediumMeteor[i].position = (Vector2){-100, -100};
+        mediumMeteor[i].speed = (Vector2){0,0};
+        mediumMeteor[i].radius = 20.0f;
+        mediumMeteor[i].points = 100;
+        mediumMeteor[i].active = false;
+        mediumMeteor[i].color = BLUE;
+    }
+
+    // Initialize small meteors
+    for (int i = 0; i < NUM_SMALL_METEORS; i++)
+    {
+        smallMeteor[i].position = (Vector2){ -100, -100 };
+        smallMeteor[i].speed = (Vector2){ 0, 0 };
+        smallMeteor[i].radius = 10.0f;
+        smallMeteor[i].points = 50;
+        smallMeteor[i].active = false;
+        smallMeteor[i].color = BLUE;
+    }
+
+    // Initialize animated points
+    for (int i = 0; i < 5; i++)
+    {
+        points[i].position = (Vector2){ 0, 0 };
+        points[i].value = 0;
+        points[i].alpha = 0.0f;
+    }
+
+    countMediumMeteors = 0;
+    countSmallMeteors = 0;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            if (awake)
+            {
+                // Player logic
+                if (IsKeyDown(KEY_LEFT))  player.position.x -= player.speed.x;
+                if (IsKeyDown(KEY_RIGHT))  player.position.x += player.speed.x;
+
+                // Wall behaviour for player
+                if (player.position.x + SHIP_BASE_SIZE/2 > screenWidth) player.position.x = screenWidth - SHIP_BASE_SIZE/2;
+                else if (player.position.x - SHIP_BASE_SIZE/2 < 0) player.position.x = 0 + SHIP_BASE_SIZE/2;
+
+                 // Activation of shoot
+                if (IsKeyPressed(KEY_SPACE))
+                {
+                    for (int i = 0; i < NUM_SHOOTS; i++)
+                    {
+                        if (!shoot[i].active)
+                        {
+                            shoot[i].position = (Vector2){ player.position.x, player.position.y - shipHeight };
+                            linePosition = (Vector2){ player.position.x, player.position.y};
+                            shoot[i].active = true;
+                            shoot[i].speed.y = MAX_SPEED;
+                            break;
+                        }
+                    }
+                }
+
+                // Shoot life timer
+                for (int i = 0; i < NUM_SHOOTS; i++)
+                {
+                    if (shoot[i].active) shoot[i].lifeSpawn++;
+                }
+
+                // Shot logic
+                for (int i = 0; i < NUM_SHOOTS; i++)
+                {
+                    if (shoot[i].active)
+                    {
+                        // Movement
+                        shoot[i].position.y -= shoot[i].speed.y;
+
+                        // Wall behaviour for shoot
+                        if (shoot[i].position.x > screenWidth + shoot[i].radius)
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                        }
+                        else if (shoot[i].position.x < 0 - shoot[i].radius)
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                        }
+                        
+                        if (shoot[i].position.y > screenHeight + shoot[i].radius)
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                        }
+                        else if (shoot[i].position.y < 0 - shoot[i].radius)
+                        {
+                            shoot[i].active = false;
+                            shoot[i].lifeSpawn = 0;
+                        }
+
+                        // Life of shoot
+                        if (shoot[i].lifeSpawn >= 120)
+                        {
+                            shoot[i].position = (Vector2){0, 0};
+                            shoot[i].speed = (Vector2){0, 0};
+                            shoot[i].lifeSpawn = 0;
+                            shoot[i].active = false;
+                        }
+                    }
+                }
+
+                // Player collision with meteors
+                player.collider = (Vector3){player.position.x, player.position.y - shipHeight/2, 12};
+
+                for (int i = 0; i < NUM_BIG_METEORS; i++)
+                {
+                    if (CheckCollisionCircles((Vector2){ player.collider.x, player.collider.y }, player.collider.z, bigMeteor[i].position, bigMeteor[i].radius) && bigMeteor[i].active)
+                    {
+                        gameOver = true;
+                    }
+                }
+
+                for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+                {
+                    if (CheckCollisionCircles((Vector2){ player.collider.x, player.collider.y }, player.collider.z, mediumMeteor[i].position, mediumMeteor[i].radius) && mediumMeteor[i].active)
+                    {
+                        gameOver = true;
+                    }
+                }
+
+                for (int i = 0; i < NUM_SMALL_METEORS; i++)
+                {
+                    if (CheckCollisionCircles((Vector2){ player.collider.x, player.collider.y }, player.collider.z, smallMeteor[i].position, smallMeteor[i].radius) && smallMeteor[i].active)
+                    {
+                        gameOver = true;
+                    }
+                }
+
+                // Meteor logic
+                for (int i = 0; i < NUM_BIG_METEORS; i++)
+                {
+                    if (bigMeteor[i].active)
+                    {
+                        // movement
+                        bigMeteor[i].position.x += bigMeteor[i].speed.x;
+                        bigMeteor[i].position.y += bigMeteor[i].speed.y;
+
+                        // wall behaviour
+                        if (((bigMeteor[i].position.x + bigMeteor[i].radius) >= screenWidth) || ((bigMeteor[i].position.x - bigMeteor[i].radius) <= 0)) bigMeteor[i].speed.x *= -1;
+                        if ((bigMeteor[i].position.y - bigMeteor[i].radius) <= 0) bigMeteor[i].speed.y *= -1.5;
+                        
+                        if ((bigMeteor[i].position.y + bigMeteor[i].radius) >= screenHeight)
+                        {
+                            bigMeteor[i].speed.y *= -1;
+                            bigMeteor[i].position.y = screenHeight - bigMeteor[i].radius;
+                        }
+
+                        bigMeteor[i].speed.y += gravity;
+                    }
+                }
+
+                for (int i = 0; i < NUM_MEDIUM_METEORS; i++)
+                {
+                    if (mediumMeteor[i].active)
+                    {
+                        // Movement logic
+                        mediumMeteor[i].position.x += mediumMeteor[i].speed.x;
+                        mediumMeteor[i].position.y += mediumMeteor[i].speed.y;
+
+                        // Wall behaviour
+                        if (mediumMeteor[i].position.x + mediumMeteor[i].radius >= screenWidth || mediumMeteor[i].position.x - mediumMeteor[i].radius <= 0) mediumMeteor[i].speed.x *= -1;
+                        if (mediumMeteor[i].position.y - mediumMeteor[i].radius <= 0) mediumMeteor[i].speed.y *= -1;
+                        if (mediumMeteor[i].position.y + mediumMeteor[i].radius >= screenHeight)
+                        {
+                            mediumMeteor[i].speed.y *= -1;
+                            mediumMeteor[i].position.y = screenHeight - mediumMeteor[i].radius;
+                        }
+
+                        mediumMeteor[i].speed.y += gravity + 0.12f;
+                    }
+                }
+
+                for (int i = 0; i < NUM_SMALL_METEORS; i++)
+                {
+                    if (smallMeteor[i].active)
+                    {
+                        // movement
+                        smallMeteor[i].position.x += smallMeteor[i].speed.x;
+                        smallMeteor[i].position.y += smallMeteor[i].speed.y;
+
+                        // wall behaviour
+                        if (smallMeteor[i].position.x + smallMeteor[i].radius >= screenWidth || smallMeteor[i].position.x - smallMeteor[i].radius <= 0) smallMeteor[i].speed.x *= -1;
+                        if (smallMeteor[i].position.y - smallMeteor[i].radius <= 0) smallMeteor[i].speed.y *= -1;
+                        if (smallMeteor[i].position.y + smallMeteor[i].radius >= screenHeight)
+                        {
+                            smallMeteor[i].speed.y *= -1;
+                            smallMeteor[i].position.y = screenHeight - smallMeteor[i].radius;
+                        }
+
+                        smallMeteor[i].speed.y += gravity + 0.25f;
+                    }
+                }
+
+                // Collision behaviour
+                for (int i = 0; i < NUM_SHOOTS; i++)
+                {
+                    if ((shoot[i].active))
+                    {
+                        for (int a = 0; a < NUM_BIG_METEORS; a++)
+                        {
+                            if (bigMeteor[a].active && (bigMeteor[a].position.x - bigMeteor[a].radius <= linePosition.x && bigMeteor[a].position.x + bigMeteor[a].radius >= linePosition.x)
+                                && (bigMeteor[a].position.y + bigMeteor[a].radius >= shoot[i].position.y))
+                            {
+                                shoot[i].active = false;
+                                shoot[i].lifeSpawn = 0;
+                                bigMeteor[a].active = false;
+                                meteorsDestroyed++;
+                                score +=  bigMeteor[a].points;
+
+                                for (int z = 0; z < 5; z++)
+                                {
+                                    if (points[z].alpha == 0.0f)
+                                    {
+                                        points[z].position = bigMeteor[a].position;
+                                        points[z].value = bigMeteor[a].points;
+                                        points[z].color = RED;
+                                        points[z].alpha = 1.0f;
+                                        z = 5;
+                                    }
+                                }
+
+                                for (int j = 0; j < 2; j ++)
+                                {
+                                    if ((countMediumMeteors%2) == 0)
+                                    {
+                                        mediumMeteor[countMediumMeteors].position = (Vector2){bigMeteor[a].position.x, bigMeteor[a].position.y};
+                                        mediumMeteor[countMediumMeteors].speed = (Vector2){METEORS_SPEED*-1, METEORS_SPEED};
+                                    }
+                                    else
+                                    {
+                                        mediumMeteor[countMediumMeteors].position = (Vector2){bigMeteor[a].position.x, bigMeteor[a].position.y};
+                                        mediumMeteor[countMediumMeteors].speed = (Vector2){METEORS_SPEED, METEORS_SPEED};
+                                    }
+
+                                    mediumMeteor[countMediumMeteors].active = true;
+                                    countMediumMeteors ++;
+                                }
+
+                                bigMeteor[a].color = RED;
+                                a = NUM_BIG_METEORS;
+                            }
+                        }
+                    }
+
+                    if ((shoot[i].active))
+                    {
+                        for (int b = 0; b < NUM_MEDIUM_METEORS; b++)
+                        {
+                            if (mediumMeteor[b].active && (mediumMeteor[b].position.x - mediumMeteor[b].radius <= linePosition.x && mediumMeteor[b].position.x + mediumMeteor[b].radius >= linePosition.x)
+                                && (mediumMeteor[b].position.y + mediumMeteor[b].radius >= shoot[i].position.y))
+                            {
+                                shoot[i].active = false;
+                                shoot[i].lifeSpawn = 0;
+                                mediumMeteor[b].active = false;
+                                meteorsDestroyed++;
+                                score +=  mediumMeteor[b].points;
+
+                                for (int z = 0; z < 5; z++)
+                                {
+                                    if (points[z].alpha == 0.0f)
+                                    {
+                                        points[z].position = mediumMeteor[b].position;
+                                        points[z].value = mediumMeteor[b].points;
+                                        points[z].color = GREEN;
+                                        points[z].alpha = 1.0f;
+                                        z = 5;
+                                    }
+                                }
+
+                                for (int j = 0; j < 2; j ++)
+                                {
+                                     if (countSmallMeteors%2 == 0)
+                                    {
+                                        smallMeteor[countSmallMeteors].position = (Vector2){mediumMeteor[b].position.x, mediumMeteor[b].position.y};
+                                        smallMeteor[countSmallMeteors].speed = (Vector2){METEORS_SPEED*-1, METEORS_SPEED*-1};
+                                    }
+                                    else
+                                    {
+                                        smallMeteor[countSmallMeteors].position = (Vector2){mediumMeteor[b].position.x, mediumMeteor[b].position.y};
+                                        smallMeteor[countSmallMeteors].speed = (Vector2){METEORS_SPEED, METEORS_SPEED*-1};
+                                    }
+
+                                    smallMeteor[countSmallMeteors].active = true;
+                                    countSmallMeteors ++;
+                                }
+                                mediumMeteor[b].color = GREEN;
+                                b = NUM_MEDIUM_METEORS;
+                            }
+                        }
+                    }
+
+                    if ((shoot[i].active))
+                    {
+                        for (int c = 0; c < NUM_SMALL_METEORS; c++)
+                        {
+                            if (smallMeteor[c].active && (smallMeteor[c].position.x - smallMeteor[c].radius <= linePosition.x && smallMeteor[c].position.x + smallMeteor[c].radius >= linePosition.x)
+                                && (smallMeteor[c].position.y + smallMeteor[c].radius >= shoot[i].position.y))
+                            {
+                                shoot[i].active = false;
+                                shoot[i].lifeSpawn = 0;
+                                smallMeteor[c].active = false;
+                                meteorsDestroyed++;
+                                smallMeteor[c].color = YELLOW;
+                                score +=  smallMeteor[c].points;
+
+                                for (int z = 0; z < 5; z++)
+                                {
+                                    if (points[z].alpha == 0.0f)
+                                    {
+                                        points[z].position = smallMeteor[c].position;
+                                        points[z].value = smallMeteor[c].points;
+                                        points[z].color = YELLOW;
+                                        points[z].alpha = 1.0f;
+                                        z = 5;
+                                    }
+                                }
+
+                                c = NUM_SMALL_METEORS;
+                            }
+                        }
+                    }
+                }
+
+                for (int z = 0; z < 5; z++)
+                {
+                    if (points[z].alpha > 0.0f)
+                    {
+                        points[z].position.y -= 2;
+                        points[z].alpha -= 0.02f;
+                    }
+                    
+                    if (points[z].alpha < 0.0f) points[z].alpha = 0.0f;
+                }
+                
+                if (meteorsDestroyed == (NUM_BIG_METEORS + NUM_MEDIUM_METEORS + NUM_SMALL_METEORS)) victory = true;
+            }
+            else
+            {
+                framesCounter++;
+                if (framesCounter%180 == 0) awake = false;
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(DARKGRAY);
+        
+        if (!gameOver)
+        {
+            // Draw player
+            Vector2 v1 = { player.position.x + sinf(player.rotation*DEG2RAD)*(shipHeight), player.position.y - cosf(player.rotation*DEG2RAD)*(shipHeight) };
+            Vector2 v2 = { player.position.x - cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y - sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+            Vector2 v3 = { player.position.x + cosf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2), player.position.y + sinf(player.rotation*DEG2RAD)*(SHIP_BASE_SIZE/2) };
+            DrawTriangleLines(v1, v2, v3, player.color);
+
+            // Draw meteor
+            for (int i = 0;i < NUM_BIG_METEORS; i++)
+            {
+                if (bigMeteor[i].active) DrawCircleV(bigMeteor[i].position, bigMeteor[i].radius, bigMeteor[i].color);
+                else
+                {
+                    DrawCircleV(bigMeteor[i].position, bigMeteor[i].radius, Fade(bigMeteor[i].color, 0.25f));
+                    //DrawText(FormatText("%i", bigMeteor[i].points), bigMeteor[i].position.x  - MeasureText("200", 20)/2, bigMeteor[i].position.y - 10, 20, Fade(WHITE, 0.25f));
+                }
+            }
+
+            for (int i = 0;i < NUM_MEDIUM_METEORS; i++)
+            {
+                if (mediumMeteor[i].active) DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, mediumMeteor[i].color);
+                else
+                {
+                    DrawCircleV(mediumMeteor[i].position, mediumMeteor[i].radius, Fade(mediumMeteor[i].color, 0.25f));
+                    //DrawText(FormatText("%i", mediumMeteor[i].points), mediumMeteor[i].position.x  - MeasureText("100", 20)/2, mediumMeteor[i].position.y - 10, 20, Fade(WHITE, 0.25f));
+                }
+            }
+
+            for (int i = 0;i < NUM_SMALL_METEORS; i++)
+            {
+                if (smallMeteor[i].active) DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, smallMeteor[i].color);
+                else
+                {
+                    DrawCircleV(smallMeteor[i].position, smallMeteor[i].radius, Fade(smallMeteor[i].color, 0.25f));
+                    //DrawText(FormatText("%i", smallMeteor[i].points), smallMeteor[i].position.x - MeasureText("50", 10)/2, smallMeteor[i].position.y - 5, 10, Fade(WHITE, 0.25f));
+                }
+            }
+
+            // Draw shoot
+
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active) DrawLine(linePosition.x, linePosition.y, shoot[i].position.x, shoot[i].position.y, RED);
+            }
+
+            for (int z = 0; z < 5; z++)
+            {
+                if (points[z].alpha > 0.0f)
+                {
+                    DrawText(FormatText("+%i", points[z].value), points[z].position.x, points[z].position.y, 20, Fade(points[z].color, points[z].alpha));
+                }
+            }
+
+            // Draw Text
+            DrawText(FormatText("SCORE: %i", score), 10, 10, 20, LIGHTGRAY);
+            
+            if (victory) DrawText("VICTORY", screenWidth/2 - MeasureText("VICTORY", 40)/2, screenHeight/2 - 40, 40, LIGHTGRAY);
+            
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, LIGHTGRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, LIGHTGRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/snake.c

@@ -0,0 +1,293 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: snake
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define SNAKE_LENGTH   256
+#define SQUARE_SIZE     31
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct Snake {
+    Vector2 position;
+    Vector2 size;
+    Vector2 speed;
+    Color color;
+} Snake;
+
+typedef struct Food {
+    Vector2 position;
+    Vector2 size;
+    bool active;
+    Color color;
+} Food;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+
+static Food fruit;
+static Snake snake[SNAKE_LENGTH];
+static Vector2 snakePosition[SNAKE_LENGTH];
+static bool allowMove;
+static Vector2 offset;
+static int counterTail;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: snake");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    framesCounter = 0;
+    gameOver = false;
+    pause = false;
+    
+    counterTail = 1;
+    allowMove = false;
+
+    offset.x = screenWidth%SQUARE_SIZE;
+    offset.y = screenHeight%SQUARE_SIZE;
+
+    for (int i = 0; i < SNAKE_LENGTH; i++)
+    {
+        snake[i].position = (Vector2){ offset.x/2, offset.y/2 };
+        snake[i].size = (Vector2){ SQUARE_SIZE, SQUARE_SIZE };
+        snake[i].speed = (Vector2){ SQUARE_SIZE, 0 };
+
+        if (i == 0) snake[i].color = DARKBLUE;
+        else snake[i].color = BLUE;
+    }
+
+    for (int i = 0; i < SNAKE_LENGTH; i++)
+    {
+        snakePosition[i] = (Vector2){ 0.0f, 0.0f };
+    }
+
+    fruit.size = (Vector2){ SQUARE_SIZE, SQUARE_SIZE };
+    fruit.color = SKYBLUE;
+    fruit.active = false;
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+        
+        if (!pause)
+        {
+            // control
+            if (IsKeyPressed(KEY_RIGHT) && (snake[0].speed.x == 0) && allowMove)
+            {
+                snake[0].speed = (Vector2){ SQUARE_SIZE, 0 };
+                allowMove = false;
+            }
+            if (IsKeyPressed(KEY_LEFT) && (snake[0].speed.x == 0) && allowMove)
+            {
+                snake[0].speed = (Vector2){ -SQUARE_SIZE, 0 };
+                allowMove = false;
+            }
+            if (IsKeyPressed(KEY_UP) && (snake[0].speed.y == 0) && allowMove)
+            {
+                snake[0].speed = (Vector2){ 0, -SQUARE_SIZE };
+                allowMove = false;
+            }
+            if (IsKeyPressed(KEY_DOWN) && (snake[0].speed.y == 0) && allowMove)
+            {
+                snake[0].speed = (Vector2){ 0, SQUARE_SIZE };
+                allowMove = false;
+            }
+
+            // movement
+            for (int i = 0; i < counterTail; i++) snakePosition[i] = snake[i].position;
+
+            if ((framesCounter%5) == 0)
+            {
+                for (int i = 0; i < counterTail; i++)
+                {
+                    if (i == 0)
+                    {
+                        snake[0].position.x += snake[0].speed.x;
+                        snake[0].position.y += snake[0].speed.y;
+                        allowMove = true;
+                    }
+                    else snake[i].position = snakePosition[i-1];
+                }
+            }
+
+            // wall behaviour
+            if (((snake[0].position.x) > (screenWidth - offset.x)) || 
+                ((snake[0].position.y) > (screenHeight - offset.y)) ||
+                (snake[0].position.x < 0) || (snake[0].position.y < 0))
+            {
+                gameOver = true;
+            }
+
+            // collision with yourself
+            for (int i = 1; i < counterTail; i++)
+            {
+                if ((snake[0].position.x == snake[i].position.x) && (snake[0].position.y == snake[i].position.y)) gameOver = true;
+            }
+
+            // TODO: review logic: fruit.position calculation
+            if (!fruit.active)
+            {
+                fruit.active = true;
+                fruit.position = (Vector2){ GetRandomValue(0, (screenWidth/SQUARE_SIZE) - 1)*SQUARE_SIZE + offset.x/2, GetRandomValue(0, (screenHeight/SQUARE_SIZE) - 1)*SQUARE_SIZE + offset.y/2 };
+
+                for (int i = 0; i < counterTail; i++)
+                {
+                       while ((fruit.position.x == snake[i].position.x) && (fruit.position.y == snake[i].position.y))
+                       {
+                           fruit.position = (Vector2){ GetRandomValue(0, (screenWidth/SQUARE_SIZE) - 1)*SQUARE_SIZE, GetRandomValue(0, (screenHeight/SQUARE_SIZE) - 1)*SQUARE_SIZE };
+                           i = 0;
+                       }
+                }
+            }
+
+            // collision
+            if (CheckCollisionRecs((Rectangle){(int)snake[0].position.x, (int)snake[0].position.y, (int)snake[0].size.x, (int)snake[0].size.y},
+                                   (Rectangle){(int)fruit.position.x, (int)fruit.position.y, (int)fruit.size.x, (int)fruit.size.y}))
+            {
+                snake[counterTail].position = snakePosition[counterTail - 1];
+                counterTail += 1;
+                fruit.active = false;
+            }
+
+            framesCounter++;
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+        
+        if (!gameOver)
+        {
+            // Draw grid lines
+            for (int i = 0; i < screenWidth/SQUARE_SIZE + 1; i++)
+            {
+                DrawLineV((Vector2){SQUARE_SIZE*i + offset.x/2, offset.y/2}, (Vector2){SQUARE_SIZE*i + offset.x/2, screenHeight - offset.y/2}, LIGHTGRAY);
+            }
+
+            for (int i = 0; i < screenHeight/SQUARE_SIZE + 1; i++)
+            {
+                DrawLineV((Vector2){offset.x/2, SQUARE_SIZE*i + offset.y/2}, (Vector2){screenWidth - offset.x/2, SQUARE_SIZE*i + offset.y/2}, LIGHTGRAY);
+            }
+
+            // Draw snake
+            for (int i = 0; i < counterTail; i++) DrawRectangleV(snake[i].position, snake[i].size, snake[i].color);
+
+            // Draw fruit to pick
+            DrawRectangleV(fruit.position, fruit.size, fruit.color);
+
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/space_invaders.c

@@ -0,0 +1,407 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: space invaders
+*
+*   Sample game developed by Ian Eito, Albert Martos and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define NUM_SHOOTS 50
+#define NUM_MAX_ENEMIES 50
+#define FIRST_WAVE 10
+#define SECOND_WAVE 20
+#define THIRD_WAVE 50
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef enum { FIRST = 0, SECOND, THIRD } enemyWave;
+
+typedef struct Player{
+    Rectangle rec;
+    Vector2 speed;
+    Color color;
+} Player;
+
+typedef struct Enemy{
+    Rectangle rec;
+    Vector2 speed;
+    bool active;
+    Color color;
+} Enemy;
+
+typedef struct Shoot{
+    Rectangle rec;
+    Vector2 speed;
+    bool active;
+    Color color;
+} Shoot;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 450;
+
+static int framesCounter;
+static bool gameOver;
+static bool pause;
+static int score;
+static bool victory;
+
+static Player player;
+static Enemy enemy[NUM_MAX_ENEMIES];
+static Shoot shoot[NUM_SHOOTS];
+static enemyWave wave;
+
+static int shootRate;
+static float alpha;
+
+static int activeEnemies;
+static int enemiesKill;
+static bool smooth;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: space invaders");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//------------------------------------------------------------------------------------
+// Module Functions Definitions (local)
+//------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    // Initialize game variables
+    shootRate = 0;
+    pause = false;
+    gameOver = false;
+    victory = false;
+    smooth = false;
+    wave = FIRST;
+    activeEnemies = FIRST_WAVE;
+    enemiesKill = 0;
+    score = 0;
+    alpha = 0;
+
+    // Initialize player
+    player.rec.x =  20;
+    player.rec.y = 50;
+    player.rec.width = 10;
+    player.rec.height = 10;
+    player.speed.x = 5;
+    player.speed.y = 5;
+    player.color = BLACK;
+
+    // Initialize enemies
+    for (int i = 0; i < NUM_MAX_ENEMIES; i++)
+    {
+        enemy[i].rec.width = 10;
+        enemy[i].rec.height = 10;
+        enemy[i].rec.x = GetRandomValue(screenWidth, screenWidth + 1000);
+        enemy[i].rec.y = GetRandomValue(0, screenHeight - enemy[i].rec.height);
+        enemy[i].speed.x = 5;
+        enemy[i].speed.y = 5;
+        enemy[i].active = true;
+        enemy[i].color = DARKGRAY;
+    }
+
+    // Initialize shoots
+    for (int i = 0; i < NUM_SHOOTS; i++)
+    {
+        shoot[i].rec.x = player.rec.x;
+        shoot[i].rec.y = player.rec.y + player.rec.height/4;
+        shoot[i].rec.width = 10;
+        shoot[i].rec.height = 5;
+        shoot[i].speed.x = 7;
+        shoot[i].speed.y = 0;
+        shoot[i].active = false;
+        shoot[i].color = WHITE;
+    }
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            switch (wave)
+            {
+                case FIRST:
+                {
+                    if (!smooth)
+                    {
+                        alpha += 0.02f;
+                        
+                        if (alpha >= 1.0f) smooth = true;
+                    }
+                    
+                    if (smooth) alpha -= 0.02f;
+                    
+                    if (enemiesKill == activeEnemies)
+                    {
+                        enemiesKill = 0;
+
+                        for (int i = 0; i < activeEnemies; i++)
+                        {
+                            if (!enemy[i].active) enemy[i].active = true;
+                        }
+                        
+                        activeEnemies = SECOND_WAVE;
+                        wave = SECOND;
+                        smooth = false;
+                        alpha = 0.0f;
+                    }
+                } break;
+                case SECOND:
+                {
+                    if (!smooth)
+                    {
+                        alpha += 0.02f;
+                        
+                        if (alpha >= 1.0f) smooth = true;
+                    }
+                    
+                    if (smooth) alpha -= 0.02f;
+                    
+                    if (enemiesKill == activeEnemies)
+                    {
+                        enemiesKill = 0;
+
+                        for (int i = 0; i < activeEnemies; i++)
+                        {
+                            if (!enemy[i].active) enemy[i].active = true;
+                        }
+                        
+                        activeEnemies = THIRD_WAVE;
+                        wave = THIRD;
+                        smooth = false;
+                        alpha = 0.0f;
+                    }
+                } break;
+                case THIRD:
+                {
+                    if (!smooth)
+                    {
+                        alpha += 0.02f;
+                        
+                        if (alpha >= 1.0f) smooth = true;
+                    }
+                    
+                    if (smooth) alpha -= 0.02f;
+                    
+                    if (enemiesKill == activeEnemies) victory = true;
+                        
+                } break;
+                default: break;
+            }
+
+            // Player movement
+            if (IsKeyDown(KEY_RIGHT)) player.rec.x += player.speed.x;
+            if (IsKeyDown(KEY_LEFT)) player.rec.x -= player.speed.x;
+            if (IsKeyDown(KEY_UP)) player.rec.y -= player.speed.y;
+            if (IsKeyDown(KEY_DOWN)) player.rec.y += player.speed.y;
+
+            // Player collision with enemy
+            for (int i = 0; i < activeEnemies; i++)
+            {
+                if (CheckCollisionRecs(player.rec, enemy[i].rec)) gameOver = true;
+            }
+
+             // Enemy behaviour
+            for (int i = 0; i < activeEnemies; i++)
+            {
+                if (enemy[i].active)
+                {
+                    enemy[i].rec.x -= enemy[i].speed.x;
+
+                    if (enemy[i].rec.x < 0)
+                    {
+                        enemy[i].rec.x = GetRandomValue(screenWidth, screenWidth + 1000);
+                        enemy[i].rec.y = GetRandomValue(0, screenHeight - enemy[i].rec.height);
+                    }
+                }
+            }
+
+            // Wall behaviour
+            if (player.rec.x <= 0) player.rec.x = 0;
+            if (player.rec.x + player.rec.width >= screenWidth) player.rec.x = screenWidth - player.rec.width;
+            if (player.rec.y <= 0) player.rec.y = 0;
+            if (player.rec.y + player.rec.height >= screenHeight) player.rec.y = screenHeight - player.rec.height;
+
+            //Shoot initialization
+            if (IsKeyDown(KEY_SPACE))
+            {
+                shootRate += 5;
+
+                for (int i = 0; i < NUM_SHOOTS; i++)
+                {
+                    if (!shoot[i].active && shootRate%20 == 0)
+                    {
+                        shoot[i].rec.x = player.rec.x;
+                        shoot[i].rec.y = player.rec.y + player.rec.height/4;
+                        shoot[i].active = true;
+                        break;
+                    }
+                }
+            }
+
+            // Shoot logic
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active)
+                {
+                    // Movement
+                    shoot[i].rec.x += shoot[i].speed.x;
+
+                    // Collision with enemy
+                    for (int j = 0; j < activeEnemies; j++)
+                    {
+                        if (enemy[j].active)
+                        {
+                           if (CheckCollisionRecs(shoot[i].rec, enemy[j].rec))
+                            {
+                                shoot[i].active = false;
+                                enemy[j].active = false;
+                                enemy[j].rec.x = GetRandomValue(screenWidth, screenWidth + 1000);
+                                enemy[j].rec.y = GetRandomValue(0, screenHeight - enemy[j].rec.height);
+                                shootRate = 0;
+                                enemiesKill++;
+                                score += 100;
+                            }
+                            
+                            if (shoot[i].rec.x + shoot[i].rec.width >= screenWidth)
+                            {
+                                shoot[i].active = false;
+                                shootRate = 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(LIGHTGRAY);
+        
+        if (!gameOver)
+        {
+            DrawRectangleRec(player.rec, player.color);
+
+            if (wave == FIRST) DrawText("FIRST WAVE", screenWidth/2 - MeasureText("FIRST WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha));
+            else if (wave == SECOND) DrawText("SECOND WAVE", screenWidth/2 - MeasureText("SECOND WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha));
+            else if (wave == THIRD) DrawText("THIRD WAVE", screenWidth/2 - MeasureText("THIRD WAVE", 40)/2, screenHeight/2 - 40, 40, Fade(BLACK, alpha));
+            
+            for (int i = 0; i < activeEnemies; i++)
+            {
+                if (enemy[i].active) DrawRectangleRec(enemy[i].rec, enemy[i].color);
+            }
+
+            for (int i = 0; i < NUM_SHOOTS; i++)
+            {
+                if (shoot[i].active) DrawRectangleRec(shoot[i].rec, shoot[i].color);
+            }
+            
+            DrawText(FormatText("%04i", score), 20, 20, 40, DARKGRAY);
+        
+            if (victory) DrawText("YOU WIN", screenWidth/2 - MeasureText("YOU WIN", 40)/2, screenHeight/2 - 40, 40, BLACK);
+        
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}

games/samples/tetris.c

@@ -0,0 +1,835 @@
+/*******************************************************************************************
+*
+*   raylib - sample game: tetris
+*
+*   Sample game Marc Palau and Ramon Santamaria
+*
+*   This game has been created using raylib v1.3 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Some Defines
+//----------------------------------------------------------------------------------
+#define SQUARE_SIZE             30
+
+#define GRID_HORIZONTAL_SIZE    12
+#define GRID_VERTICAL_SIZE      20
+
+#define LATERAL_SPEED           10
+#define TURNING_SPEED           12
+#define FAST_FALL_AWAIT_COUNTER 30
+
+#define FADING_TIME             33
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef enum GridSquare { EMPTY, MOVING, FULL, BLOCK, FADING } GridSquare;
+
+//------------------------------------------------------------------------------------
+// Global Variables Declaration
+//------------------------------------------------------------------------------------
+static int screenWidth = 800;
+static int screenHeight = 620;
+
+static bool gameOver = false;
+static bool pause = false;
+
+// Matrices
+static GridSquare grid [GRID_HORIZONTAL_SIZE][GRID_VERTICAL_SIZE];
+static GridSquare piece [4][4];
+static GridSquare incomingPiece [4][4];
+
+// Theese variables keep track of the active piece position
+static int piecePositionX = 0;
+static int piecePositionY = 0;
+
+// Game parameters
+static Color fadingColor;
+//static int fallingSpeed;           // In frames
+
+static bool beginPlay = true;      // This var is only true at the begining of the game, used for the first matrix creations
+static bool pieceActive = false;
+static bool detection = false;
+static bool lineToDelete = false;
+
+// Statistics
+static int level = 1;
+static int lines = 0;
+
+// Counters
+static int gravityMovementCounter = 0;
+static int lateralMovementCounter = 0;
+static int turnMovementCounter = 0;
+static int fastFallMovementCounter = 0;
+
+static int fadeLineCounter = 0;
+
+// Based on level
+static int gravitySpeed = 30;
+
+//------------------------------------------------------------------------------------
+// Module Functions Declaration (local)
+//------------------------------------------------------------------------------------
+static void InitGame(void);         // Initialize game
+static void UpdateGame(void);       // Update game (one frame)
+static void DrawGame(void);         // Draw game (one frame)
+static void UnloadGame(void);       // Unload game
+static void UpdateDrawFrame(void);  // Update and Draw (one frame)
+
+// Additional module functions
+static bool Createpiece();
+static void GetRandompiece();
+static void ResolveFallingMovement();
+static bool ResolveLateralMovement();
+static bool ResolveTurnMovement();
+static void CheckDetection();
+static void CheckCompletition();
+static void DeleteCompleteLines();
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "sample game: tetris");
+
+    InitGame();
+
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateGame();
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        DrawGame();
+        //----------------------------------------------------------------------------------
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadGame();         // Unload loaded data (textures, sounds, models...)
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//--------------------------------------------------------------------------------------
+// Game Module Functions Definition
+//--------------------------------------------------------------------------------------
+
+// Initialize game variables
+void InitGame(void)
+{
+    // Initialize game statistics
+    level = 1;
+    lines = 0;
+
+    fadingColor = GRAY;
+
+    piecePositionX = 0;
+    piecePositionY = 0;
+
+    pause = false;
+
+    beginPlay = true;
+    pieceActive = false;
+    detection = false;
+    lineToDelete = false;
+
+    // Counters
+    gravityMovementCounter = 0;
+    lateralMovementCounter = 0;
+    turnMovementCounter = 0;
+    fastFallMovementCounter = 0;
+
+    fadeLineCounter = 0;
+    gravitySpeed = 30;
+
+    // Initialize grid matrices
+    for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
+	{
+		for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
+		{
+            if ((j == GRID_VERTICAL_SIZE - 1) || (i == 0) || (i == GRID_HORIZONTAL_SIZE - 1)) grid[i][j] = BLOCK;
+            else grid[i][j] = EMPTY;
+		}
+	}
+
+    // Initialize incoming piece matrices
+    for (int i = 0; i < 4; i++)
+	{
+		for (int j = 0; j< 4; j++)
+		{
+			incomingPiece[i][j] = EMPTY;
+		}
+	}
+}
+
+// Update game (one frame)
+void UpdateGame(void)
+{
+    if (!gameOver)
+    {
+        if (IsKeyPressed('P')) pause = !pause;
+
+        if (!pause)
+        {
+            if (!lineToDelete)
+            {
+                if (!pieceActive)
+                {
+                    // Get another piece
+                    pieceActive = Createpiece();
+
+                    // We leave a little time before starting the fast falling down
+                    fastFallMovementCounter = 0;
+                }
+                else    // Piece falling
+                {
+                    // Counters update
+                    fastFallMovementCounter++;
+                    gravityMovementCounter++;
+                    lateralMovementCounter++;
+                    turnMovementCounter++;
+
+                    // We make sure to move if we've pressed the key this frame
+                    if (IsKeyPressed(KEY_LEFT) || IsKeyPressed(KEY_RIGHT)) lateralMovementCounter = LATERAL_SPEED;
+                    if (IsKeyPressed(KEY_UP)) turnMovementCounter = TURNING_SPEED;
+
+                    // Fall down
+                    if (IsKeyDown(KEY_DOWN) && (fastFallMovementCounter >= FAST_FALL_AWAIT_COUNTER))
+                    {
+                        // We make sure the piece is going to fall this frame
+                        gravityMovementCounter += gravitySpeed;
+                    }
+                    
+                    if (gravityMovementCounter >= gravitySpeed)
+                    {
+                        // Basic falling movement
+                        CheckDetection(&detection);
+
+                        // Check if the piece has collided with another piece or with the boundings
+                        ResolveFallingMovement(&detection, &pieceActive);
+
+                        // Check if we fullfilled a line and if so, erase the line and pull down the the lines above
+                        CheckCompletition(&lineToDelete);
+
+                        gravityMovementCounter = 0;
+                    }
+                    
+                    // Move laterally at player's will
+                    if (lateralMovementCounter >= LATERAL_SPEED)
+                    {
+                        // Update the lateral movement and if success, reset the lateral counter
+                        if (!ResolveLateralMovement()) lateralMovementCounter = 0;
+                    }
+                    
+                    // Turn the piece at player's will
+                    if (turnMovementCounter >= TURNING_SPEED)
+                    {
+                        // Update the turning movement and reset the turning counter
+                        if (ResolveTurnMovement()) turnMovementCounter = 0;
+                    }
+                }
+
+                // Game over logic
+                for (int j = 0; j < 2; j++)
+                {
+                    for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+                    {
+                        if (grid[i][j] == FULL)
+                        {
+                            gameOver = true;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // Animation when deleting lines
+                fadeLineCounter++;
+
+                if (fadeLineCounter%8 < 4) fadingColor = MAROON;
+                else fadingColor = GRAY;
+
+                if (fadeLineCounter >= FADING_TIME)
+                {
+                    DeleteCompleteLines();
+                    fadeLineCounter = 0;
+                    lineToDelete = false;
+                }
+            }
+        }
+    }
+    else
+    {
+        if (IsKeyPressed(KEY_ENTER))
+        {
+            InitGame();
+            gameOver = false;
+        }
+    }
+}
+
+// Draw game (one frame)
+void DrawGame(void)
+{
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (!gameOver)
+        {
+            // Draw gameplay area
+            Vector2 offset;
+            offset.x = screenWidth/2 - (GRID_HORIZONTAL_SIZE*SQUARE_SIZE/2);
+            offset.y = screenHeight/2 - ((GRID_VERTICAL_SIZE - 1)*SQUARE_SIZE/2) + SQUARE_SIZE*2;
+
+            offset.y -= 60;     // NOTE: Harcoded position!
+
+            int controller = offset.x;
+
+            for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
+            {
+                for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
+                {
+                    // Draw each square of the grid
+                    if (grid[i][j] == EMPTY)
+                    {
+                        DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
+                        DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        offset.x += SQUARE_SIZE;
+                    }
+                    else if (grid[i][j] == FULL)
+                    {
+                        DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
+                        offset.x += SQUARE_SIZE;
+                    }
+                    else if (grid[i][j] == MOVING)
+                    {
+                        DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, DARKGRAY);
+                        offset.x += SQUARE_SIZE;
+                    }
+                    else if (grid[i][j] == BLOCK)
+                    {
+                        DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, LIGHTGRAY);
+                        offset.x += SQUARE_SIZE;
+                    }
+                    else if (grid[i][j] == FADING)
+                    {
+                        DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, fadingColor);
+                        offset.x += SQUARE_SIZE;
+                    }
+                }
+
+                offset.x = controller;
+                offset.y += SQUARE_SIZE;
+            }
+            
+            // Draw incoming piece
+            //offset.x = screenWidth/2 - (4*SQUARE_SIZE/2);
+            //offset.y = (screenHeight/2 - ((GRID_VERTICAL_SIZE - 1)*SQUARE_SIZE/2)) - (3*SQUARE_SIZE);
+
+            // NOTE: Harcoded positions for the demo!
+            offset.x = 850;
+            offset.y = 75;
+
+            int controler = offset.x;
+            
+            for (int j = 0; j < 4; j++)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    if (incomingPiece[i][j] == EMPTY)
+                    {
+                        DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
+                        DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
+                        offset.x += SQUARE_SIZE;
+                    }
+                    else if (incomingPiece[i][j] == MOVING)
+                    {
+                        DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
+                        offset.x += SQUARE_SIZE;
+                    }
+                }
+
+                offset.x = controler;
+                offset.y += SQUARE_SIZE;
+            }
+            
+            if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+        }
+        else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+
+    EndDrawing();
+}
+
+// Unload game variables
+void UnloadGame(void)
+{
+    // TODO: Unload all dynamic loaded data (textures, sounds, models...)
+}
+
+// Update and Draw (one frame)
+void UpdateDrawFrame(void)
+{
+    UpdateGame();
+    DrawGame();
+}
+
+//--------------------------------------------------------------------------------------
+// Additional module functions
+//--------------------------------------------------------------------------------------
+static bool Createpiece()
+{
+    piecePositionX = (int)((GRID_HORIZONTAL_SIZE - 4)/2);
+    piecePositionY = 0;
+
+    // If the game is starting and you are going to create the first piece, we create an extra one
+	if (beginPlay)
+	{
+        GetRandompiece();
+        beginPlay = false;
+	}
+	
+    // We assign the incoming piece to the actual piece
+    for (int i = 0; i < 4; i++)
+	{
+		for (int j = 0; j< 4; j++)
+		{
+			piece[i][j] = incomingPiece[i][j];
+		}
+	}
+	
+    // We assign a random piece to the incoming one
+	GetRandompiece();
+
+    // Assign the piece to the grid
+    for (int i = piecePositionX; i < piecePositionX + 4; i++)
+	{
+		for (int j = 0; j < 4; j++)
+		{
+			if (piece[i - (int)piecePositionX][j] == MOVING) grid[i][j] = MOVING;
+		}
+	}
+
+	return true;
+}
+
+static void GetRandompiece()
+{
+    srand(time(NULL));
+    int random = rand() % 7;
+
+    for (int i = 0; i < 4; i++)
+	{
+		for (int j = 0; j < 4; j++)
+		{
+			incomingPiece[i][j] = EMPTY;
+		}
+	}
+
+    switch(random)
+	{
+        case 0:	{	incomingPiece[1][1] = MOVING;   incomingPiece[2][1] = MOVING;	incomingPiece[1][2] = MOVING;	incomingPiece[2][2] = MOVING;	}	break;	//Cube
+        case 1:	{	incomingPiece[1][0] = MOVING;	incomingPiece[1][1] = MOVING;	incomingPiece[1][2] = MOVING;	incomingPiece[2][2] = MOVING;	}	break;	//L
+        case 2:	{	incomingPiece[1][2] = MOVING;	incomingPiece[2][0] = MOVING;	incomingPiece[2][1] = MOVING;	incomingPiece[2][2] = MOVING;	}	break;	//L inversa
+        case 3:	{	incomingPiece[0][1] = MOVING;	incomingPiece[1][1] = MOVING;	incomingPiece[2][1] = MOVING;	incomingPiece[3][1] = MOVING;	}	break;	//Recta
+        case 4:	{	incomingPiece[1][0] = MOVING;	incomingPiece[1][1] = MOVING;	incomingPiece[1][2] = MOVING;	incomingPiece[2][1] = MOVING;	}	break;	//Creu tallada
+        case 5: {	incomingPiece[1][1] = MOVING;	incomingPiece[2][1] = MOVING; 	incomingPiece[2][2] = MOVING;	incomingPiece[3][2] = MOVING;	}	break;	//S
+        case 6: {	incomingPiece[1][2] = MOVING;	incomingPiece[2][2] = MOVING; 	incomingPiece[2][1] = MOVING;	incomingPiece[3][1] = MOVING;	}	break;	//S inversa
+    }
+}
+
+static void ResolveFallingMovement(bool *detection, bool *pieceActive)
+{
+    // If we finished moving this piece, we stop it
+    if (*detection)
+	{
+        for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+		{
+			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+			{
+				if (grid[i][j] == MOVING)
+				{
+					grid[i][j] = FULL;
+					*detection = false;
+					*pieceActive = false;
+				}
+			}
+		}
+	}
+    // We move down the piece
+	else
+	{
+        for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+		{
+			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+			{
+				if (grid[i][j] == MOVING)
+				{
+					grid[i][j+1] = MOVING;
+					grid[i][j] = EMPTY;
+				}
+			}
+		}
+        piecePositionY++;
+    }
+}
+
+static bool ResolveLateralMovement()
+{
+    bool collision = false;
+
+    // Move left
+	if (IsKeyDown(KEY_LEFT))
+	{
+        // Check if is possible to move to left
+		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+		{
+			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+			{
+				if (grid[i][j] == MOVING)
+				{
+                    // Check if we are touching the left wall or we have a full square at the left
+					if ((i-1 == 0) || (grid[i-1][j] == FULL)) collision = true;
+				}
+			}
+		}
+        // If able, move left
+		if (!collision)
+		{
+			for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+			{
+				for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)             // We check the matrix from left to right
+				{
+                    // Move everything to the left
+					if (grid[i][j] == MOVING)
+					{
+						grid[i-1][j] = MOVING;
+						grid[i][j] = EMPTY;
+					}
+				}
+			}
+
+            piecePositionX--;
+		}
+	}
+
+    // Move right
+	else if (IsKeyDown(KEY_RIGHT))
+	{
+        // Check if is possible to move to right
+		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+		{
+			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+			{
+				if (grid[i][j] == MOVING)
+				{
+                    // Check if we are touching the right wall or we have a full square at the right
+					if ((i+1 == GRID_HORIZONTAL_SIZE - 1) || (grid[i+1][j] == FULL))
+                    {
+                        collision = true;
+
+                    }
+				}
+			}
+		}
+        // If able move right
+		if (!collision)
+		{
+			for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+			{
+				for (int i = GRID_HORIZONTAL_SIZE - 1; i >= 1; i--)             // We check the matrix from right to left
+				{
+                    // Move everything to the right
+					if (grid[i][j] == MOVING)
+					{
+						grid[i+1][j] = MOVING;
+						grid[i][j] = EMPTY;
+					}
+				}
+			}
+
+            piecePositionX++;
+		}
+	}
+
+    return collision;
+}
+
+static bool ResolveTurnMovement()
+{
+    // Input for turning the piece
+    if (IsKeyDown(KEY_UP))
+	{
+		int aux;
+		bool checker = false;
+
+        // Check all turning possibilities
+		if ((grid[piecePositionX + 3][piecePositionY] == MOVING) &&
+            (grid[piecePositionX][piecePositionY] != EMPTY) &&
+            (grid[piecePositionX][piecePositionY] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 3][piecePositionY + 3] == MOVING) &&
+            (grid[piecePositionX + 3][piecePositionY] != EMPTY) &&
+            (grid[piecePositionX + 3][piecePositionY] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX][piecePositionY + 3] == MOVING) &&
+            (grid[piecePositionX + 3][piecePositionY + 3] != EMPTY) &&
+            (grid[piecePositionX + 3][piecePositionY + 3] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX][piecePositionY] == MOVING) &&
+            (grid[piecePositionX][piecePositionY + 3] != EMPTY) &&
+            (grid[piecePositionX][piecePositionY + 3] != MOVING))
+        {	
+            checker = true;
+        }
+
+
+		if ((grid[piecePositionX + 1][piecePositionY] == MOVING) &&
+            (grid[piecePositionX][piecePositionY + 2] != EMPTY) &&
+            (grid[piecePositionX][piecePositionY + 2] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 3][piecePositionY + 1] == MOVING) &&
+            (grid[piecePositionX + 1][piecePositionY] != EMPTY) &&
+            (grid[piecePositionX + 1][piecePositionY] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 2][piecePositionY + 3] == MOVING) &&
+            (grid[piecePositionX + 3][piecePositionY + 1] != EMPTY) &&
+            (grid[piecePositionX + 3][piecePositionY + 1] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX][piecePositionY + 2] == MOVING) &&
+            (grid[piecePositionX + 2][piecePositionY + 3] != EMPTY) &&
+            (grid[piecePositionX + 2][piecePositionY + 3] != MOVING))
+        {	
+            checker = true;
+        }
+
+
+		if ((grid[piecePositionX + 2][piecePositionY] == MOVING) &&
+            (grid[piecePositionX][piecePositionY + 1] != EMPTY) &&
+            (grid[piecePositionX][piecePositionY + 1] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 3][piecePositionY + 2] == MOVING) &&
+            (grid[piecePositionX + 2][piecePositionY] != EMPTY) &&
+            (grid[piecePositionX + 2][piecePositionY] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 1][piecePositionY + 3] == MOVING) &&
+            (grid[piecePositionX + 3][piecePositionY + 2] != EMPTY) &&
+            (grid[piecePositionX + 3][piecePositionY + 2] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX][piecePositionY + 1] == MOVING) &&
+            (grid[piecePositionX + 1][piecePositionY + 3] != EMPTY) &&
+            (grid[piecePositionX + 1][piecePositionY + 3] != MOVING))
+        {	
+            checker = true;
+        }
+
+		if ((grid[piecePositionX + 1][piecePositionY + 1] == MOVING) &&
+            (grid[piecePositionX + 1][piecePositionY + 2] != EMPTY) &&
+            (grid[piecePositionX + 1][piecePositionY + 2] != MOVING))
+        {	
+            checker = true;
+        }
+        
+		if ((grid[piecePositionX + 2][piecePositionY + 1] == MOVING) &&
+            (grid[piecePositionX + 1][piecePositionY + 1] != EMPTY) &&
+            (grid[piecePositionX + 1][piecePositionY + 1] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 2][piecePositionY + 2] == MOVING) &&
+            (grid[piecePositionX + 2][piecePositionY + 1] != EMPTY) &&
+            (grid[piecePositionX + 2][piecePositionY + 1] != MOVING))
+        {	
+            checker = true;
+        }
+		if ((grid[piecePositionX + 1][piecePositionY + 2] == MOVING) &&
+            (grid[piecePositionX + 2][piecePositionY + 2] != EMPTY) &&
+            (grid[piecePositionX + 2][piecePositionY + 2] != MOVING))
+        {	
+            checker = true;
+        }
+
+		if (!checker)
+		{
+			aux = piece[0][0];
+			piece[0][0] = piece[3][0];
+			piece[3][0] = piece[3][3];
+			piece[3][3] = piece[0][3];
+			piece[0][3] = aux;
+
+			aux = piece[1][0];
+			piece[1][0] = piece[3][1];
+			piece[3][1] = piece[2][3];
+			piece[2][3] = piece[0][2];
+			piece[0][2] = aux;
+
+			aux = piece[2][0];
+			piece[2][0] = piece[3][2];
+			piece[3][2] = piece[1][3];
+			piece[1][3] = piece[0][1];
+			piece[0][1] = aux;
+
+			aux = piece[1][1];
+			piece[1][1] = piece[2][1];
+			piece[2][1] = piece[2][2];
+			piece[2][2] = piece[1][2];
+			piece[1][2] = aux;
+		}
+
+		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+		{
+			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+			{
+				if (grid[i][j] == MOVING)
+				{
+					grid[i][j] = EMPTY;
+				}
+			}
+		}
+
+		for (int i = piecePositionX; i < piecePositionX + 4; i++)
+		{
+			for (int j = piecePositionY; j < piecePositionY + 4; j++)
+			{
+				if (piece[i - piecePositionX][j - piecePositionY] == MOVING)
+				{
+					grid[i][j] = MOVING;
+				}
+			}
+		}
+        return true;
+	}
+
+    return false;
+}
+
+static void CheckDetection(bool *detection)
+{
+    for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+	{
+		for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+		{
+			if ((grid[i][j] == MOVING) && ((grid[i][j+1] == FULL) || (grid[i][j+1] == BLOCK))) *detection = true;
+		}
+	}
+}
+
+static void CheckCompletition(bool *lineToDelete)
+{
+    int calculator;
+
+	for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+	{
+		calculator = 0;
+		for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+		{
+            // Count each square of the line
+			if (grid[i][j] == FULL)
+			{
+				calculator++;
+			}
+
+            // Check if we completed the whole line
+			if (calculator == GRID_HORIZONTAL_SIZE - 2)
+			{
+                *lineToDelete = true;
+                calculator = 0;
+				// points++;
+
+                // Mark the completed line
+				for (int z = 1; z < GRID_HORIZONTAL_SIZE - 1; z++)
+				{
+					grid[z][j] = FADING;
+				}
+			}
+		}
+	}
+}
+
+static void DeleteCompleteLines()
+{
+    // erase the completed line
+    for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
+    {
+        while (grid[1][j] == FADING)
+        {
+            for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
+            {
+                grid[i][j] = EMPTY;
+            }
+            for (int j2 = j-1; j2 >= 0; j2--)
+            {
+                for (int i2 = 1; i2 < GRID_HORIZONTAL_SIZE - 1; i2++)
+                {
+                    if (grid[i2][j2] == FULL)
+                    {
+                        grid[i2][j2+1] = FULL;
+                        grid[i2][j2] = EMPTY;
+                    }
+                    else if (grid[i2][j2] == FADING)
+                    {
+                        grid[i2][j2+1] = FADING;
+                        grid[i2][j2] = EMPTY;
+                    }
+                }
+            }
+        }
+    }
+}