scroll-game

Простой скролл эффект

#include <iostream>

#include <cmath>

#include "glut.h"

#include <time.h>

#include <sys/timeb.h>

using namespace std;

float xmax =10;

float xmin =0;

float ymax =10;

float ymin =0;

static float alfa=0;

static int k=1;

static int start=0;

char buffer[10];

int nTimeStart;

float xr, yr;

int rost=1;

bool UpClick=true;

static float _x=3;

static float _y=3;

// Define bitmasks for mouse status, we assume mice have less than 17 buttons

#define MB_LEFT   0

#define MB_MIDDLE 1

#define MB_RIGHT  2

#define LMB_PRESSED (1<<0)

#define MMB_PRESSED (1<<1)

#define RMB_PRESSED (1<<2)

#define LMB_CLICKED (1<<16)

#define MMB_CLICKED (1<<17)

#define RMB_CLICKED (1<<18)

#define MB_PRESSED(state, button) 1<<(button)

#define MB_CLICKED(state, button) 1<<(button)+16)

#define MB_MASK_PRESSED 0x0000ffffL

#define MB_MASK_CLICKED 0xffff0000L

short int mouse_status = 0;

int goRight = 1;

int goLeft = 1;

int goUp= 1;

bool game=1;

static float scaleText=0.90f;

void delay( float sec )

{

    clock_t end = clock() + sec * CLK_TCK;

    while( clock() < end );

}

int GetMilliCount()

{

    // Something like GetTickCount but portable

    // It rolls over every ~ 12.1 days (0x100000/24/60/60)

    // Use GetMilliSpan to correct for rollover

    timeb tb;

    ftime( &tb );

    int nCount = tb.millitm + (tb.time & 0xfffff) * 1000;

    return nCount;

}

int GetMilliSpan( int nTimeStart )

{

    int nSpan = GetMilliCount() - nTimeStart;

    if ( nSpan < 0 )

        nSpan += 0x100000 * 1000;

    return nSpan;

}

//функция для отображения текста

void drawString (char *s)

{

    for (int i = 0; i < strlen (s); i++)

        glutBitmapCharacter (GLUT_BITMAP_TIMES_ROMAN_24, s[i]);

}

void drawChar(char c)

{

    //glScalef(scaleText,scaleText,scaleText);

    glutBitmapCharacter (GLUT_BITMAP_TIMES_ROMAN_24, c);

}

void init()

{

    glClearColor(1.0,1.0, 1.0, 0.0);

    gluOrtho2D(xmin, xmax, ymin, ymax);

    xr = rand()%5+5;

    yr = rand()%8;

}

void AnimateText(char *s, float x, float y)

{

    for (int i = 0; i < strlen (s); i++)   

    {

        glPushMatrix();

        glTranslatef(x,y,0);

        glRasterPos2f( -2+i/2., 0.1*sin(2.5*alfa+0.5*k*i)  );

        //glRotatef(1,0,0,1);

        drawChar(s[i]);

        glPopMatrix();

    }

}

void peshka(int x, int y, int color=0)

{

    if (color==1)    glColor3f(1,1,1);

    else glColor3f(0,0,0);

    glPushMatrix();

    glTranslatef(x,y,0);

    glBegin(GL_QUADS);

    glVertex2f(0.1,0.9);

    glVertex2f(0.9,0.9);

    glVertex2f(0.9,0.1);

    glVertex2f(0.1,0.1);

    glEnd();

    glLineWidth(2);

    if (color==0)    glColor3f(1,1,1);

    else glColor3f(0,0,0);

    glBegin(GL_LINE_LOOP);

    glVertex2f(0.1,0.9);

    glVertex2f(0.9,0.9);

    glVertex2f(0.9,0.1);

    glVertex2f(0.1,0.1);

    glEnd();

    glPopMatrix();

    glLineWidth(1);

}

void board()

{       

    glColor3f(0,0,0);

    glBegin(GL_QUADS);

    for(int x=0;x<8;x+=2)

        for(int y=0;y<8;y+=2)

        {

            glVertex2i(x,y);

            glVertex2i(x,y+1);

            glVertex2i(x+1,y+1);

            glVertex2i(x+1,y);

            glVertex2i(x+1,y+1);

            glVertex2i(x+1,y+2);

            glVertex2i(x+2,y+2);

            glVertex2i(x+2,y+1);

        }

        /*

        for(int x=-1;x<8;x+=2)

        for(int y=-1;y<8;y+=2)

        {

        glColor3f(rand()%100/100., rand()%100/100., rand()%100/100.);

        glVertex2i(x,y);

        glVertex2i(x,y+1);

        glVertex2i(x+1,y+1);

        glVertex2i(x+1,y);

        glVertex2i(x+1,y+1);

        glVertex2i(x+1,y+2);

        glVertex2i(x+2,y+2);

        glVertex2i(x+2,y+1);

        }*/

        /*

        for(int x=0;x<8;x+=1)

        for(int y=0;y<8;y+=1)

        {

        glColor3f(rand()%100/100., rand()%100/100., rand()%100/100.);

        glVertex2i(x,y);

        glVertex2i(x,y+1);

        glVertex2i(x+1,y+1);

        glVertex2i(x+1,y);

        }*/

        glEnd();

        glLineWidth(4);

        glColor3f(0.714, 0.4284, 0.18144);

        glBegin(GL_LINE_LOOP);

        glVertex2i(0,0);

        glVertex2i(0,8);

        glVertex2i(8,8);

        glVertex2i(8,0);

        glEnd();   

        glLineWidth(1);

        //glRasterPos2f(0,0);

        //fi = -fabs( (cy*l)/glutGet(GLUT_WINDOW_HEIGHT)-l/2);

        //drawString (gcvt ( fi , 5, buffer)  )

        for(int y=0;y<8;y+=1)

        {

            glRasterPos2f(-0.3,y+0.35);

            drawString (gcvt ( y+1 , 1, buffer)  );

            glRasterPos2f(8.15,y+0.35);

            drawString (gcvt ( y+1 , 1, buffer)  );

        }

        for(int x=0;x<8;x+=1)

        {

            glRasterPos2f(x+0.35,-0.35);

            drawChar (x+97);

            glRasterPos2f(x+0.35,8.1);

            //glRotatef(1,0,0,1);

            //glPushMatrix();

            drawChar (x+97);

            //glPopMatrix();

        }

}

void draw()

{

    glClear( GL_COLOR_BUFFER_BIT  );

    glColor3f(0.15, 0.5, 0.85);

    glBegin(GL_QUADS);

        glVertex2f(xmin,ymin);

        glVertex2f(xmin,ymax);

        glVertex2f(xmax,ymax);

        glVertex2f(xmax,ymin);

    glEnd();

    glColor3f(0.5, 0.1, 0.95);

    for (float x=xmin;x<=xmax;x+=0.7)

    for (float y=ymin;y<=ymax;y+=0.7)

    {

        glPushMatrix();

        glTranslatef(x,y,0);

        glutSolidSphere(0.35,24,24);

        glPopMatrix();

    }

    glPushMatrix();

    glTranslatef(_x,_y,0);

    glColor3f(1,0,0);

    glutSolidSphere(0.3,12,12);

    glPopMatrix();   

    glColor3f(0, 1, 0);

    glBegin(GL_QUADS);

    glVertex2f(xr,10);

    glVertex2f(xr+1,10);

    glVertex2f(xr+1,yr);

    glVertex2f(xr,yr);

    glVertex2f(xr,yr-1);

    glVertex2f(xr+1,yr-1);

    glVertex2f(xr+1,0);

    glVertex2f(xr,0);

    glEnd();

    /*

    //горизонтальная сетка

    glColor3f(1.0, 1.0, 0.0);

    glBegin(GL_LINES);

    for (float x=xmin;x<=xmax;x+=xmax/10)

    { 

        glVertex2f(x, ymax);

        glVertex2f(x, ymin);

    }

    //вертикальная сетка

    for (float y=ymin;y<=ymax;y+=ymax/10)

    { 

        glVertex2f(xmax, y);

        glVertex2f(xmin, y);

    }

    glEnd();

    */

    glColor3f(1, 0, 0);

    if (!game)

    //if ( GetMilliSpan( nTimeStart )/1000 < 2 )

    {

        //glPushMatrix();

        //glScalef(scaleText,scaleText,1);

        AnimateText("GAME OVER", _x,5);

        //glPopMatrix();

    }

    glFlush();

    glutSwapBuffers();

}

void animate()

{

    nTimeStart = GetMilliCount();

    static float lastTime=0;

    float time = glutGet(GLUT_ELAPSED_TIME)/50.0;// /1000 = количество секунд = 1 с

    //alfa+=k*(time-lastTime);

    xr-=0.1;

    if (xr+1<=xmin){

        xr = xmax;

        yr = rand()%8;

    }

    system("CLS");

    cout<<xmax<<" "<<xr<<endl;

    if (game)

        _x+=0.1*(time-lastTime);

    if (goLeft==-1 && game)

        _x-=0.1*(time-lastTime);

    if (goUp==-1&& _y<ymax  && game)

        _y+=0.5*(time-lastTime);

    if (goUp==1 && game)

    {

        if (_y>0)

            _y-=0.5*(time-lastTime);

        //if (_x>8 && _x<10)

            //_y-=0.5*(time-lastTime);

    }

/*

    if(mouse_status & MB_CLICKED(MB_LEFT)) {

        if (_y>0 && game)

            _y-=0.5*(time-lastTime);

            mouse_status &= ~MB_MASK_CLICKED;

    }*/

    //if (_x>8 && _x<10 && _y<= 0)

    //    game=false;

    alfa+=0.05;

    UpClick=false;

    if (game)

    {

        if (_x>5 )

        {

            xmin=_x-5;

            xmax=_x+5;

        }

        glLoadIdentity();

        if (_x<5) gluOrtho2D(0, 10, 0, 10);

        else      gluOrtho2D(xmin, xmax, ymin, ymax);

    }

    //glTranslatef(-_x, 0, 0.0);

    lastTime = time;

    glutPostRedisplay();

}

void mouse(int button,int state,int x,int y)

{

    int b=0;

    switch(button)

    {

    case GLUT_LEFT_BUTTON:

        //nTimeStart = GetMilliCount();

        if (state == GLUT_DOWN) {

            goLeft = -1;

        }

        else  {// state = GLUT_DOWN

            goLeft = 1;

        }

        break;

    case GLUT_RIGHT_BUTTON:

        if (state == GLUT_DOWN) {

            goRight = -1;

        }

        else  {// state = GLUT_DOWN

            goRight = 1;

        }

        break;

    case GLUT_MIDDLE_BUTTON:

        if (state ==  GLUT_DOWN) {

            goUp = -1;

            //UpClick=false;

        }

        else  {// state = GLUT_DOWN

            goUp = 1;

        }

        if (!game)exit(0);

        break;

    default: break;

    }

}

void onMouseButton(int button, int state, int x, int y)

{

    int b;

    switch(button) {

    case GLUT_LEFT_BUTTON:   b=MB_LEFT;   break;

    case GLUT_MIDDLE_BUTTON: b=MB_MIDDLE; break;

    case GLUT_RIGHT_BUTTON:  b=MB_RIGHT;  break;

    }

    if(mouse_status & MB_PRESSED(b,0) && GLUT_UP == state) {

        //mouse_status |= MB_CLICKED(b,0);

    }

    if( !(mouse_status & MB_PRESSED(b,0)) && GLUT_DOWN == state) {

        //mouse_status = (mouse_status & ~(0L | MB_CLICKED(b,0))) | MB_PRESSED(b,0);

    }

    glutPostRedisplay();

}

void main(int argc, char **argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);

    glutInitWindowPosition(glutGet (GLUT_SCREEN_WIDTH)/4, glutGet (GLUT_SCREEN_HEIGHT)/4);

    glutInitWindowSize(600, 600);

    glutCreateWindow("SCROLL");

    init();

    glutDisplayFunc(draw);

    glutIdleFunc(animate);

    glutMouseFunc(mouse);

    glutMainLoop();

}