Pong

#include <GL/glut.h>
#include<iostream>
#include<ctime>
#include<sstream>
using namespace std;

// Game state
int width=800, height=600;      // Window params
enum { MENU, GAME, END };
int gamestate = MENU;           // Game state
bool keyStates[256] = { 0 };    // Key presses
int score1=0, score2=0;         // Scores of 2 players
int winScore=10;                // Score to win

// Board params
float board1x=20,  board2x=770;
float board1y=450, board2y=450;
float boardWidth=10, boardHeight=100;

// Ball params
bool   ballUp    = true;
bool   ballRight = true;
float ballSpeed = 0.2;
float ballCurSpeed = ballSpeed; //Speed just after hitting a board (fn of distance from center) Max value = 2*ballSpeed
float ballSize = 10;
float ballX = board1x + boardWidth;
float ballY = board1y - boardHeight/2;

// Misc params
time_t start;
int timePassed;
string self("by Max");
string text("Press RETURN to start");
string ins1("Player 1 - keys Q,A");
string ins2("Player 2 - keys P,L");
string rule("First to score 10 wins!");
string win1("Player 1 wins!");
string win2("Player 2 wins!");
string playagain("Play again (RETURN)");
string reset("Reset (Spacebar)");

void wait(int);             // Delay
void ball();                // Draws ball
void ballOperations();      // Moves ball
void board(float,float);  // Draws boards
void cube();                // Draws cube
void drawTitle();           // Draws menu
void init();
void keyOperations();
void display();
void keyboardDown();
void keyboardUp();
void idle();

void wait(int sec) {
    clock_t end = clock() + sec * CLOCKS_PER_SEC;
    while( clock() < end ) {}
}

void resetState() {
    ballUp = true;
    ballRight = true;
    ballSpeed = 0.2;
    ballCurSpeed = ballSpeed;
    ballSize = 10;
    ballX = board1x + boardWidth;
    ballY = board1y - boardHeight/2;
    score1=0;
    score2=0;
}

void ball() {
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex2d(ballX,ballY);
        glVertex2d(ballX+ballSize,ballY);
        glVertex2d(ballX+ballSize,ballY-ballSize);
        glVertex2d(ballX,ballY-ballSize);
    glEnd();
}

void board(float boardx, float boardy) {
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex2d(boardx,boardy);
        glVertex2d(boardx+boardWidth,boardy);
        glVertex2d(boardx+boardWidth,boardy-boardHeight);
        glVertex2d(boardx,boardy-boardHeight);
    glEnd();
}

void ballOperations() {
    // Player 1 miss
    if(ballX < 0) {
        score2++;
        ballCurSpeed = ballSpeed;
        if(score2==winScore) {
            gamestate = END;
            return;
        }
        ballX = board1x + boardWidth;
        ballY = board1y - boardHeight/2;
        ballRight = true;
        display();
        wait(1);
    }

    // Player 2 miss
    if(ballX > 800) {
        score1++;
        ballCurSpeed = ballSpeed;
        if(score1==winScore) {
            gamestate = END;
            return;
        }
        ballX = board2x - boardWidth;
        ballY = board2y - boardHeight/2;
        ballRight = false;
        display();
        wait(1);
    }

    // Board-ball collision
    if(ballX < board1x+boardWidth && ballY-ballSize < board1y && ballY > board1y-100) {
        ballRight = !ballRight;
        ballCurSpeed = ballSpeed + ballSpeed * abs( board1y-(boardHeight/2)-ballY ) / (boardHeight/2) ;
        ballX += ballCurSpeed;      // Just to be safe after a collision
    }
    if(ballX+ballSize > board2x   && ballY-ballSize < board2y && ballY > board2y-100) {
        ballRight = !ballRight;
        ballCurSpeed = ballSpeed + ballSpeed * abs( board2y-(boardHeight/2)-ballY ) / (boardHeight/2) ;
        ballX -= ballCurSpeed;      // Just to be safe after a collision
    }

    // Top-bottom collison detection
    if(ballY > height)                      //collide top
        ballUp = !ballUp;
    if(ballY < ballSize)                    //collide bottom
        ballUp = !ballUp;

    // Code to move the ball
    if(ballRight)
            ballX += ballCurSpeed;
    else
            ballX -= ballCurSpeed;

    if(ballUp)
            ballY += ballCurSpeed;
    else
            ballY -= ballCurSpeed;
}

void cube(int x, int y) {
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex2d(x,y);
        glVertex2d(x,y+20);
        glVertex2d(x+20,y+20);
        glVertex2d(x+20,y);
    glEnd();
}

void drawTitle() {
    // Dirty way to draw "PONG"
    cube(200,500); cube(220,500); cube(240,500); cube(260,500); cube(260,480); cube(260,460); cube(240,460); cube(220,460);
    cube(200,460); cube(200,480); cube(200,460); cube(200,440); cube(200,420);

    cube(300,500); cube(320,500); cube(340,500); cube(360,500); cube(300,480); cube(300,460); cube(300,440); cube(300,420);
    cube(360,480); cube(360,460); cube(360,440); cube(360,420); cube(300,420); cube(320,420); cube(340,420); cube(360,420);

    cube(400,500); cube(400,480); cube(400,460); cube(400,440); cube(400,420); cube(420,480); cube(440,460); cube(460,440);
    cube(480,500); cube(480,480); cube(480,460); cube(480,440); cube(480,420);

    cube(520,500); cube(540,500); cube(560,500); cube(580,500); cube(520,480); cube(520,460); cube(520,440); cube(520,420);
    cube(540,420); cube(560,420); cube(580,420); cube(580,440); cube(580,460); cube(560,460);

    // "by Max"
    glRasterPos2f(550,400);
        for(int i=0 ; i<self.length() ; i++)
            glutBitmapCharacter(GLUT_BITMAP_8_BY_13, self.at(i));
}

void init (void) {
    glClearColor (0,0,0,0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0,width,0,height);
}

void keyOperations() {
    // 13=RETURN, 27=ESC
    if(keyStates[13] && gamestate == MENU) {
        resetState();
        gamestate = GAME;
    }
    if(keyStates[27] && gamestate == MENU)
        exit(0);

    if(keyStates[32] && gamestate == GAME)
        gamestate = MENU;

    if(keyStates[32] && gamestate == END) {
        resetState();
        gamestate = MENU;
    }

    if(keyStates[13] && gamestate == END) {
        resetState();
        gamestate = GAME;
    }

    //Move boards
    if(keyStates['q'])
        if(board1y < 600)
            board1y+=0.3;

    if(keyStates['a'])
        if(board1y > 100)
            board1y-=0.3;
    if(keyStates['p'])
        if(board2y < 600)
            board2y+=0.3;

    if(keyStates['l'])
        if(board2y > 100)
            board2y-=0.3;
}

void display (void) {
    glClear(GL_COLOR_BUFFER_BIT);

    keyOperations();

    switch(gamestate) {
        case MENU:
            // Draw menu
            drawTitle();

            glRasterPos2f(300,300);
                for(int i=0 ; i<ins1.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ins1.at(i));

            glRasterPos2f(300,250);
                for(int i=0 ; i<ins2.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, ins2.at(i));

            glRasterPos2f(300,200);
                for(int i=0 ; i<rule.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, rule.at(i));

            // Blink
            if(timePassed % 2 == 0) {
                glRasterPos2f(290,100);
                for(int i=0 ; i<text.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, text.at(i));
            }

        break;

        case GAME:
            ballOperations();           // Move ball
            ball();                     // Draw ball
            board(board1x, board1y);    // Draw boards
            board(board2x, board2y);

            glBegin(GL_LINES);          // Center line
                glVertex2i(400,0);
                glVertex2i(400,600);
            glEnd();

            // Draw score
            {
                string number;
                stringstream conv1;
                conv1<<score1;
                number = conv1.str();
                glRasterPos2f(330,550);
                for(int i=0 ; i<number.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, number.at(i));

                stringstream conv2;
                conv2<<score2;
                number = conv2.str();
                glRasterPos2f(450,550);
                for(int i=0 ; i<number.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, number.at(i));
            }
        break;

        case END:
            // Draw winner
            if(score1 == winScore) {
                glRasterPos2f(50,400);
                for(int i=0 ; i<win1.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, win1.at(i));
            }
            else {
                glRasterPos2f(550,400);
                for(int i=0 ; i<win2.length() ; i++)
                    glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, win2.at(i));
            }

            // Draw options
            glRasterPos2f(300,200);
            for(int i=0 ; i<playagain.length() ; i++)
                glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, playagain.at(i));

            glRasterPos2f(300,100);
            for(int i=0 ; i<reset.length() ; i++)
                glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, reset.at(i));

        break;
    }

    glFlush();
}

void keyboardDown(unsigned char key, int x, int y) {
    keyStates[key] = true;
}

void keyboardUp(unsigned char key, int x, int y) {
    keyStates[key] = false;
}

void idle() {
    display();
    timePassed = static_cast<int>(clock()-start)/CLOCKS_PER_SEC;
}

int main (int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize(width, height);
    glutInitWindowPosition (0, 0);
    glutCreateWindow("Pong by Max");

    init();
    glutDisplayFunc(display);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboardDown);
    glutKeyboardUpFunc(keyboardUp);
    start = clock();
    glutMainLoop();
    return 0;
}