Tarea 4 Ajedrez con G - Edgar

#include <windows.h>
#include <C:\GLUT\include\GL\glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#define PI 3.1415926535897932384626433832795

/** Descripcion: Tablero de Ajedrez sobre fondo azul, donde se mueve por las casillas
 *  la letra G de Google.
 *
 * Autores:
 *  Edgar Villa Miguel.
 * Fecha de creacion: 18/02/17
 * Revisiones: ---
 *  programa.
 * Fecha de ultima actualizacion: 20/02/17
 */

int ancho = 734, alto = 734; // alto y ancho para la ventana
int tableroBlanco = 296; // tamaño del tablero blanco
int cuadroNegro = 37; // tamaño de un cuadrito negro del tablero
int xG = ancho/2 - cuadroNegro; // coordenada x para mover G
int yG = alto/2 + cuadroNegro; // coordenada y para mover G
int bnG = 1; // variable para cambiar fonode de G, 1 significa blanco, 0 negro
int confirmaCambia = 1; // bandera que ayuda a cambiar de manera correcta los colores para G
float dx,dy;

/**
 * Traza circulos acorde a los parámetros recibidos
 * @param cx Coordenada x donde se ubicará el centro del circulo
 * @param cy Coordenada y donde se ubicará el centro del circulo
 * @param radio Medida que tendrá de radio el circulor
 * @param r Color rojo de un RGB de 0.0 a 1.0
 * @param g Color verde de un RGB de 0.0 a 1.0lor
 * @param b Color azul de un RGB de 0.0 a 1.0
 * @param a1 Inicio del trazo del circulo en radianes
 * @param a2 Fin del trazo del circulo en radianes
 */
void circulo( float cx, float cy, float radio, float r,
    float g, float b, float a1, float a2 )
{
    // glEnable( GL_LINE_SMOOTH );
    glBegin( GL_POLYGON );
    glColor3f(r,g,b);
    glVertex2f(cx,cy);
    for( float i = a1; i<= a2; i+=0.01 )
    {
        dx = radio*cos(i) + cx;
        dy= radio*sin(i) + cy;
        glVertex2f(dx,dy);
    }
    glEnd();
}

void cuadro( float lado, float r, float g, float b)
{
    glColor3f(r,g,b);
    glBegin(GL_POLYGON );
    glVertex2f(lado, lado);
    glVertex2f(-lado, lado);
    glVertex2f(-lado, -lado);
    glVertex2f(lado, -lado);
    glEnd();

}

void logoG( int bn ) // b(blanco) = 1, n(negro) = 0
{
    glPointSize(10); // el valor es el tamaño del punto que tendrá en pixeles
    glColor3f(0, 0, 1.0); // RGB B = 1, Blue

    circulo( 0.0, 0.0, 40, 0.917647, 0.262745, 0.207843, 0.872664626, 2.617993878 ); // Rojo
    circulo( 0.0, 0.0, 40, 0.984313, 0.737254, 0.019607, 2.60, 3.665191429 ); // Amarillo
    circulo( 0.0, 0.0, 40, 0.203921, 0.658823, 0.325490, 3.66, 5.410520681 ); // Verde
    circulo( 0.0, 0.0, 40, 0.258823, 0.521568, 0.956862, 5.4, 6.5 ); // Azul
    if( bn == 1 )
        circulo( 0.0, 0.0, 23, 1.0, 1.0, 1.0, 0, 2*PI ); // Blanco
    else
        circulo( 0.0, 0.0, 23, 0.0, 0.0, 0.0, 0, 2*PI ); // Blanco

    glBegin( GL_POLYGON ); // Rectangulo azul
    glColor3f( 0.258823, 0.521568, 0.956862 ); // Azul
    glVertex2i(0,8);
    glVertex2i(0,-7);
    glVertex2i(39,-7);
    glVertex2i(39,8);

    glEnd();
}

void cuadritoNegro( int x, int y)
{
    // sino se pone push y pop Matriz solo se pintaría un cuadro que se esta movimiento n...
    // ... veces que se llame esta función
    glPushMatrix();
        glTranslatef( x, y, 0);//traslada
        cuadro( cuadroNegro, 0.0, 0.0, 0.0 ); // cuadros pequeños de color negro para el tablero
    glPopMatrix();
}

void key(unsigned char c, int x, int y)
{
    int siAvanzo = 0; // verifica si se puede avanzar la G para entonces cambiar de color a G

    if ( c == 27 )
        exit(0);

    // mueve G una posición a la izquierda al presionar 'a' o 'A'
    if ( (c == 'a' || c == 'A') && xG > 181 )
    {
        xG = xG - 74;
        siAvanzo = 1;
    }
    // mueva G una posición a la derecha al presionar 'd' o 'D'
    if ( (c =='d' || c == 'D') && xG < 625 )
    {
        xG = xG + 74;
        siAvanzo = 1;
    }

    // mueve G una posición hacia abajo al presionar 's' o'S'
    if ( (c =='s' || c == 'S') && yG > 109 )
    {
        yG = yG - 74;
        siAvanzo = 1;
    }
    // mueve G una posición hacia arriba al presionar 'w' o 'W'
    if ( (c =='w' || c == 'W') && yG < 624 )
    {
        yG = yG + 74;
        siAvanzo = 1;
    }

    if( siAvanzo == 1 ) // si G avanza entonces cambia de color, su fondo
    {
        if( confirmaCambia == 0 )
        {
            bnG = 0; // negro

            // si bnG es negro, se permite cambiar a blanco en el sig movimiento de G
            confirmaCambia = 1;
        }
        else
            bnG = 1; // blanco
    }

    glutPostRedisplay();
}

void display(void){
    int i, j; // contador de for

    if( bnG == 1 ) // si bnG es blanco, se permite cambiar a negro en el sig movimiento de G
        confirmaCambia = 0;

    glClear( GL_COLOR_BUFFER_BIT ); // limpia, libera el buffer

    // Tablero parte blanca
    /*************************************************************/
    glPushMatrix();
        glTranslatef( ancho/2-1, alto/2+1, 0);//traslada
        cuadro( 296, 1.0, 1.0, 1.0 ); // color blanco del tablero
    glPopMatrix();
    /*************************************************************/


    int x, y; // coordenadas donde se traladarán los cuadritos negros
    // Tablero
    /*************************************************************/
    x = 70 + cuadroNegro + 2*cuadroNegro; // cuadroNegro es la mitad de un lado del cuadrito
    y = alto - (70 + cuadroNegro);

        for ( i = 0; i < 8; ++i ) // recorre las filas o renglones
        {
            for( j = 0; j < 4; j++ ) // recorre las columnas de las filas
            {
                cuadritoNegro( x, y); // dibuja cada cuadrito negro
                x = x + 2*(2*cuadroNegro); // 2 por un lado completo de un cuadrito
            }

            y = y - 2*cuadroNegro; // cuadroNegro es la mitad de un lado del cuadrito
            if( i%2 != 0 )
                x = 70 + cuadroNegro + 2*cuadroNegro; // cuadroNegro es la mitad de un lado del cuadrito
            else
                x = 70 + cuadroNegro; // cuadroNegro es la mitad de un lado del cuadrito
        }
    /*************************************************************/



    // movimientos de G a través del tablero
    /** ------------------------------------------------------- **/
    glPushMatrix();
        glTranslatef( xG, yG, 0);//traslada
        glScalef( 0.76, 0.76, 1.0 ); // para escalar reduciendo el logo de la G
        logoG(bnG); // trae el logo de la letra G de Google
    glPopMatrix();
    /** ------------------------------------------------------- **/

    glFlush(); // libera memoria
}

int main(int argc, char** argv){
    glutInit(&argc, argv); // Inicializa la libreria GLUT
    // glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );
    glutInitWindowSize( ancho, alto ); // Inicializa el tamaño de la ventana
    glutInitWindowPosition(10,50); // posicion de la ventana
    glutCreateWindow("Tablero de Ajedrez con G"); // crea la ventana

    glClearColor( 2.0/255.0, 75.0/255.0, 123.0/255.0, 0); // establece el color de fondo de la ventana
    gluOrtho2D( 0, ancho, 0, alto );

    // glutDisplayFunc(display); Aqui le indicamos a GLUT que la rutina
    // utilizada como Display sera la llama display. Este tipo de rutinas se
    // ejecuta una vez por ciclo de programa, y será la que realice
    // todas las operaciones gráficas (render).

    //  glutDisplayFunc(display);

    // ciclo de la aplicación
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutMainLoop();
    return 0;

    return 0;
}