2011-07-26 5 views
1

나는 OpenGL에서 간단한 벽돌 브레이커 게임을 작성했다. 공은 다음을 사용하여 그려진 2D 서클입니다.Brick Breaker 도움. 서클, 패들, 어색한 튀김

for (float angle = 0; angle < (10); angle+=0.01) 
{ 
    glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS)); 
} 

게임이 전체 화면으로 변경되면 왜곡됩니다. RADIUS는 0.025로 정의됩니다. 외륜 운동을 부드럽게 만드는 데 도움이 필요합니다. 또한 게임을 몇 번하면 공이 패들에 닿을 때 가장 왼쪽으로 향해서 특정 높이로 상승한 다음 다시 튀어 나옵니다. 전체 코드 : 당신이 당신의 윈도우의 화면 비율을 계산하지만 당신은 그것을 사용하지 않는 :

#include <GL/openglut.h> 
#include <stdarg.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <cmath> 
#define RADIUS 0.025 
#define SPEED 0.001 
int WIDTH = 900; 
int HEIGHT = 650; 
int RATIO = WIDTH/HEIGHT; 
bool show[5][10]; 
float x_brick[4][9]; 
float y_brick[4][9]; 
float P_XPOS = 0; 
float P_YPOS = -0.8; 
bool phit_center = false , phit_corner = false; 
bool game_over = false; 
bool RIGHT = 1,LEFT = 0,UP = 1,DOWN = 0; 
bool started = false; 
float x_pos = 0,y_pos = -0.75; 
bool hit = false; 
int lives = 3; 
using namespace std; 
void b_draw() 
{ 
     glColor3f(1.0,0.0,0.0); 
     glBegin(GL_QUADS); 
     for(int a = 0; a < 9; a++) 
     { 
       for(int b = 0; b < 4; b++) 
       { 
         if(show[b][a] == 1) 
         { 
            glVertex2f(x_brick[b][a],y_brick[b][a]); 
            glVertex2f(x_brick[b][a],y_brick[b][a] - 0.10); 
            glVertex2f(x_brick[b][a]+0.2,y_brick[b][a] - 0.10); 
            glVertex2f(x_brick[b][a]+0.2,y_brick[b][a]); 
         } 
       } 
     } 
     glEnd(); 
} 
void c_draw() 
{ 
    glColor3f(0.0,0.0,0.0); 
    glBegin(GL_TRIANGLE_FAN); 
    glVertex2f(x_pos,y_pos); 
    for (float angle = 0; angle < (10); angle+=0.01) 
    { 
     glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS)); 
    } 
    glEnd(); 
} 
bool b_hit() 
{ 
    hit = false; 
    int flag = 1; 
    for(int a = 0; a < 10; a++) 
    { 
      for(int b =0; b < 4; b++) 
      { 
        if(x_pos >= x_brick[b][a] && x_pos <= x_brick[b][a] + 0.2) 
        { 
           if(y_pos <= y_brick[b][a] && y_pos >= y_brick[b][a] - 0.1) 
           { 
             if(show[b][a] == 1) 
             { 
                show[b][a] = 0; 
                flag = 0; 
                hit = true; 
                break; 
             } 
           } 
        } 
      } 
      if(flag == 0) 
        break; 
    } 
    return hit; 
} 
bool crashed() 
{ 
    if(y_pos < P_YPOS - 0.05) 
       return true; 
    else return false;; 
} 
void p_hit() 
{ 
    phit_corner = false; 
    phit_center = false; 
    if(x_pos <= P_XPOS + 0.13 && x_pos >= P_XPOS - 0.13) 
    { 
       if(y_pos <= P_YPOS) 
       { 
         phit_center = true; 
       } 
    } 
    else if((x_pos >= P_XPOS + 0.13 && x_pos <= P_XPOS + 0.2) || (x_pos <= P_XPOS - 0.13 && x_pos >= P_XPOS - 0.2)) 
    { 
       if(y_pos <= P_YPOS) 
       { 
         phit_corner = true; 
       } 
    } 
} 
void c_move() 
{ 
     if(UP && RIGHT) 
     { 
      x_pos += (SPEED); 
      y_pos += (SPEED);  
     } 
     if(UP && LEFT) 
     { 
      x_pos -= (SPEED); 
      y_pos += (SPEED); 
     } 
     if(DOWN && RIGHT) 
     { 
       x_pos += (SPEED); 
       y_pos -= (SPEED); 
     } 
     if(DOWN && LEFT) 
     { 
       x_pos -= (SPEED); 
       y_pos -= (SPEED); 
     } 
     b_hit(); 
     if(x_pos >= (RATIO-RADIUS)) 
     { 
       RIGHT = 0; 
       LEFT = 1; 
     } 
     else if(x_pos <= (-RATIO+RADIUS)) 
     { 
      RIGHT = 1; 
      LEFT = 0; 
     } 
     if(y_pos >= (RATIO-RADIUS) || hit) 
     { 
        UP = 0; 
        DOWN = 1; 
     } 
     else if(y_pos <= (-RATIO+RADIUS) || hit) 
     { 
      UP = 1; 
      DOWN = 0; 
     } 
     p_hit(); 
     if(phit_center) 
     { 
        DOWN = 0; 
        UP = 1; 
     } 
     if(phit_corner) 
     { 
        if(LEFT) 
        { 
          LEFT = 0; 
          RIGHT = 1; 
        } 
        else 
        { 
         RIGHT = 0; 
         LEFT = 1; 
        } 
        UP = 1; 
        DOWN = 0; 
     } 
} 
void p_draw() 
{ 
    glColor3f(0.0,0.0,0.0); 
    glBegin(GL_QUADS); 
         glVertex2f(P_XPOS-0.2,P_YPOS); 
         glVertex2f(P_XPOS+0.2,P_YPOS); 
         glVertex2f(P_XPOS+0.2,P_YPOS-0.05); 
         glVertex2f(P_XPOS-0.2,P_YPOS-0.05); 
    glEnd(); 
} 

void BallLoop() 
{ 
    glClearColor(1.0,1.0,1.0,0); 
    glDisable(GL_DEPTH_TEST); 
    glClear(GL_COLOR_BUFFER_BIT); 
    glMatrixMode (GL_MODELVIEW); 
    glLoadIdentity(); 
    c_draw(); 
    b_draw(); 
    p_draw(); 
    glFlush(); 
    if(started) 
       c_move(); 
    if(crashed()) 
    {   
       x_pos = 0; 
       y_pos = -0.7; 
       started = 0; 
       UP = 1; 
       RIGHT = 1; 
       DOWN = 0; 
       LEFT = 0; 
    } 

    glutSwapBuffers(); 
    glutPostRedisplay(); 
} 
void user_input(unsigned char key, int x, int y) 
{ 
    if(key == 13) 
    started = true; 
} 
void ArrowKeys(int key, int x, int y) 
{ 
    if(key==GLUT_KEY_LEFT && P_XPOS >= -0.8) 
     for(float a = 0; a < 0.05; a+= 0.001) 
     { 
             P_XPOS -=0.003; 
             BallLoop(); 
     } 
    if(key==GLUT_KEY_RIGHT && P_XPOS <= 0.8) 
    { 
          for(float a = 0; a < 0.05; a+= 0.001) 
          { 
             P_XPOS +=0.003; 
             BallLoop(); 
          } 
    } 
} 
void set_xy() 
{ 
    for(int a = 0; a < 5; a++) 
    { 
      for(int b = 0; b < 10; b++) 
      { 
        show[a][b] = 1; 
      } 
    } 
    int c = 0; 
    for(float a = -0.94; c <= 8; a+=0.21) 
    {   

       for(int b = 0; b <= 5; b++) 
       { 
         x_brick[b][c] = a; 

       } 
       c++; 
    } 
    int d = 0; 
    for(float s = 0.99; d <= 3; s-=0.11) 
    { 
       for(int r = 0; r < 9; r++) 
       { 
         y_brick[d][r] = s; 
       } 
       d++; 
    } 
} 
void changeSize(int w, int h) 
{ 

    if(h == 0) 
     h = 1; 
    RATIO = w/h; 
    float ratio = 1.0* w/h; 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    glViewport(0, 0, w, h); 
    glMatrixMode(GL_MODELVIEW); 
    BallLoop(); 
} 
int main(int argc, char **argv) 
{ 
    set_xy(); 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); 
    glutInitWindowPosition(0,0); 
    glutInitWindowSize(WIDTH,HEIGHT);      
    glutCreateWindow("Brick Breaker - By Viraj"); 
    glutReshapeFunc(changeSize); 
    glutDisplayFunc(BallLoop); 
    glutKeyboardFunc(user_input); 
    glutSpecialFunc(ArrowKeys); 
    glutMainLoop(); 
    return 0; 
} 
+1

이야,이 체크 아웃 : 당신이 아래로 버튼을 누르면 축이 너무 기하 급수적 증가가 http://unity3d.com/support/documentation/ScriptReference/Input.GetAxis.html 갑자기 다시 올라가면, 당신의 외륜이 그다지 움직이지 않습니다. – holgac

답변

4

많은 사람들이 잘못 작성된 자습서에 코드를 적용하기 때문에 이러한 종류의 문제에 부딪 힙니다. 한 가지 중요한 실수는 변형 핸들러에서 프로젝션 행렬 설정을 수행하는 것입니다. 어떤 심각한 OpenGL 응용 프로그램에서든 게임을 포함하여 게임을 렌더링하는 동안 여러 번 HUD, 미니 맵, GUI 요소 등을 위해 프로젝션을 전환합니다.

대신 디스플레이 처리기에서 프로젝션을 설정해야합니다. 또한 투영 행렬을 전혀 놓치지 않았으므로 뷰포트 만 설정 했으므로 닫을 수는 있지만 충분하지는 않습니다. 나는 디스플레이 핸들러 Ball_Loop 부르지 만 아니라, 여기에 내가 수정 줄 방법은없는 것 :

void BallLoop() 
{ 
    const int win_width = glutGet(GLUT_WINDOW_WIDTH); 
    const int win_height = glutGet(GLUT_WINDOW_HEIGHT); 
    const float win_aspect = (float)win_width/(float)win_height; 

    glClearColor(1.0,1.0,1.0,0); 
    glDisable(GL_DEPTH_TEST); 
    glClear(GL_COLOR_BUFFER_BIT); 

    glViewport(0, 0, win_width, win_height); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    glOrtho(-aspect, aspect, -1, 1, -1, 1); /* those ortho limits should match your game logic */ 

    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
    c_draw(); 
    b_draw(); 
    p_draw(); 
    glFlush(); 
    if(started) 
       c_move(); 
    if(crashed()) 
    {   
       x_pos = 0; 
       y_pos = -0.7; 
       started = 0; 
       UP = 1; 
       RIGHT = 1; 
       DOWN = 0; 
       LEFT = 0; 
    } 

    glutSwapBuffers(); 
    glutPostRedisplay(); 
} 

편집완전히 고정 및 재생 brickbreaker.cc 소스 코드

#include <GL/glut.h> 
#include <stdarg.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <cmath> 

using namespace std; 

#define RADIUS 0.025 

#define RATIO (4./3.) 

bool show[5][10]; 
float x_brick[4][9]; 
float y_brick[4][9]; 

float paddle_x = 0; 
float paddle_y = -0.8; 
float paddle_speed = 0; 
const float PaddleSpeedFactor = 3.; 

bool phit_center = false , phit_corner = false; 
bool game_over = false; 

float speed_x = 0.; 
float speed_y = 0.; 

float x_pos = 0,y_pos = -0.75; 
int lives = 3; 

float T_last_frame = 0.; 

void draw_bricks() 
{ 
     glColor3f(1.0,0.0,0.0); 
     glBegin(GL_QUADS); 
     for(int a = 0; a < 9; a++) 
     { 
       for(int b = 0; b < 4; b++) 
       { 
         if(show[b][a] == 1) 
         { 
            glVertex2f(x_brick[b][a],y_brick[b][a]); 
            glVertex2f(x_brick[b][a],y_brick[b][a] - 0.10); 
            glVertex2f(x_brick[b][a]+0.2,y_brick[b][a] - 0.10); 
            glVertex2f(x_brick[b][a]+0.2,y_brick[b][a]); 
         } 
       } 
     } 
     glEnd(); 
} 

void ball_draw() 
{ 
    glColor3f(0.0,0.0,0.0); 
    glBegin(GL_TRIANGLE_FAN); 
    glVertex2f(x_pos,y_pos); 
    for (float angle = 0; angle < (10); angle+=0.01) 
    { 
     glVertex2f((x_pos + sin(angle) * RADIUS), (y_pos + (cos(angle)) * RADIUS)); 
    } 
    glEnd(); 
} 

bool brick_hit() 
{ 
    bool hit = false; 
    int flag = 1; 
    for(int a = 0; a < 10; a++) 
    { 
      for(int b =0; b < 4; b++) 
      { 
        if(x_pos >= x_brick[b][a] && x_pos <= x_brick[b][a] + 0.2) 
        { 
           if(y_pos <= y_brick[b][a] && y_pos >= y_brick[b][a] - 0.1) 
           { 
             if(show[b][a] == 1) 
             { 
                show[b][a] = 0; 
                flag = 0; 
                hit = true; 
                break; 
             } 
           } 
        } 
      } 
      if(flag == 0) 
        break; 
    } 
    return hit; 
} 

bool crashed() 
{ 
    if(y_pos < paddle_y - 0.05) 
       return true; 

    return false; 
} 

void paddle_hit() 
{ 
    phit_corner = false; 
    phit_center = false; 
    if(x_pos <= paddle_x + 0.13 && x_pos >= paddle_x - 0.13) 
    { 
       if(y_pos <= paddle_y) 
       { 
         phit_center = true; 
       } 
    } 
    else if((x_pos >= paddle_x + 0.13 && x_pos <= paddle_x + 0.2) || 
        (x_pos <= paddle_x - 0.13 && x_pos >= paddle_x - 0.2)) 
    { 
       if(y_pos <= paddle_y) 
       { 
         phit_corner = true; 
       } 
    } 
} 

void paddle_move(float dT) 
{ 

    if(paddle_x < RATIO && paddle_x > -RATIO) 
     paddle_x += paddle_speed * PaddleSpeedFactor * dT; 

     if(paddle_x > 0.95) { 
     paddle_x = 0.95; 
     paddle_speed = 0.; 
    } 

     if(paddle_x < -0.95) { 
     paddle_x = -0.95; 
     paddle_speed = 0.; 
    } 

    paddle_speed *= (1. - 0.05); 
    if(fabs(paddle_speed) < 0.01) 
     paddle_speed = 0.; 
} 

void ball_move(float dT) 
{ 
     x_pos += speed_x * dT; 
     y_pos += speed_y * dT; 

     if(brick_hit()) { 
     speed_y *= -1; 
     } 

     if(x_pos >= (RATIO-RADIUS) || x_pos <= (-RATIO+RADIUS)) 
     { 
     speed_x *= -1; 
     } 

     if(y_pos >= (1.-RADIUS)) 
     { 
     speed_y = -1; 
     } 

     paddle_hit(); 
     if(phit_center) 
     { 
     speed_y = 1; 
     } 
     if(phit_corner) 
     { 
     speed_x *= -1; 
     speed_y = 1; 
     } 
} 

void paddle_draw() 
{ 
    glColor3f(0.0,0.0,0.0); 
    glBegin(GL_QUADS); 
         glVertex2f(paddle_x - 0.2, paddle_y); 
         glVertex2f(paddle_x + 0.2, paddle_y); 
         glVertex2f(paddle_x + 0.2, paddle_y - 0.05); 
         glVertex2f(paddle_x - 0.2, paddle_y - 0.05); 
    glEnd(); 
} 

void step_game() 
{ 
    paddle_move(T_last_frame); 
    ball_move(T_last_frame); 

    if(crashed()) 
    { 
    speed_x = 0; 
    speed_y = 0; 
     x_pos = 0; 
     y_pos = -0.7; 
     paddle_speed = 0; 
     paddle_x = 0; 
    } 

    glutPostRedisplay(); 
} 

void launch_ball() 
{ 
    speed_y = 1.; 
    speed_x = 1.; 
} 

void user_input(unsigned char key, int x, int y) 
{ 
    if(key == 13) 
     launch_ball(); 
} 

void ArrowKeys(int key, int x, int y) 
{ 
    if(key==GLUT_KEY_LEFT) 
     paddle_speed = -1.; 

    if(key==GLUT_KEY_RIGHT) 
     paddle_speed = +1.; 
} 

void set_xy() 
{ 
    for(int a = 0; a < 5; a++) 
    { 
      for(int b = 0; b < 10; b++) 
      { 
        show[a][b] = 1; 
      } 
    } 
    int c = 0; 
    for(float a = -0.94; c <= 8; a+=0.21) 
    {   

       for(int b = 0; b <= 5; b++) 
       { 
         x_brick[b][c] = a; 

       } 
       c++; 
    } 
    int d = 0; 
    for(float s = 0.99; d <= 3; s-=0.11) 
    { 
       for(int r = 0; r < 9; r++) 
       { 
         y_brick[d][r] = s; 
       } 
       d++; 
    } 
} 

void display() 
{ 
    const int win_width = glutGet(GLUT_WINDOW_WIDTH); 
    const int win_height = glutGet(GLUT_WINDOW_HEIGHT); 
    const float win_aspect = (float)win_width/(float)win_height; 

    glViewport(0, 0, win_width, win_height); 

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    if(win_aspect > RATIO) { 
     glOrtho(-win_aspect, win_aspect, -1., 1., -1., 1.); 
    } else { 
     glOrtho(-RATIO, RATIO, -RATIO/win_aspect, RATIO/win_aspect, -1., 1.); 
    } 

    glMatrixMode(GL_MODELVIEW); 

    glClearColor(0., 0., 1., 1.); 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

     glBegin(GL_QUADS); 
     glColor3f(1,1,1); 
     glVertex2f(-RATIO, -1); 
     glVertex2f(RATIO, -1); 
     glVertex2f(RATIO, 1); 
     glVertex2f(-RATIO, 1); 
     glEnd(); 

    draw_bricks(); 
    paddle_draw(); 
    ball_draw(); 

    glutSwapBuffers(); 

     // GLUT doesn't offer cross plattform timing 
     // assume 60Hz refresh rate 
     T_last_frame = 1./60.; 
} 

int main(int argc, char **argv) 
{ 
    set_xy(); 

    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); 

    glutInitWindowPosition(0,0); 
    glutInitWindowSize(800, 600); 

    glutCreateWindow("Brick Breaker - By Viraj"); 
    glutDisplayFunc(display); 

    glutKeyboardFunc(user_input); 
    glutSpecialFunc(ArrowKeys); 

    glutIdleFunc(step_game); 

    glutMainLoop(); 

    return 0; 
} 

편집 2 그리고 단지 완성도를 위해, 여기에 부드러운 움직임를 들어 GLFW 버전

#include <GL/glfw.h> 

#include <stdlib.h> 
#include <math.h> 

using namespace std; 

#define RADIUS 0.025 

#define RATIO (4./3.) 

bool show[5][10]; 
float x_brick[4][9]; 
float y_brick[4][9]; 

const float SpeedFactor = 10.; 

float paddle_x = 0; 
float paddle_y = -0.8; 
float paddle_speed = 0; 
const float PaddleSpeedFactor = 3.; 

bool phit_center = false, phit_corner = false; 
bool game_over = false; 

float speed_x = 0.; 
float speed_y = 0.; 

float x_pos; 
float y_pos; 
int lifes = 0; 

void draw_bricks() 
{ 
    glColor3f(1.0, 0.0, 0.0); 
    glBegin(GL_QUADS); 
    for (int a = 0; a < 9; a++) { 
     for (int b = 0; b < 4; b++) { 
      if (show[b][a] == 1) { 
       glVertex2f(x_brick[b][a], y_brick[b][a]); 
       glVertex2f(x_brick[b][a], y_brick[b][a] - 0.10); 
       glVertex2f(x_brick[b][a] + 0.2, 
         y_brick[b][a] - 0.10); 
       glVertex2f(x_brick[b][a] + 0.2, y_brick[b][a]); 
      } 
     } 
    } 
    glEnd(); 
} 

void ball_draw() 
{ 
    glColor3f(0.0, 0.0, 0.0); 
    glBegin(GL_TRIANGLE_FAN); 
    glVertex2f(x_pos, y_pos); 
    for (float angle = 0; angle < (10); angle += 0.01) { 
     glVertex2f((x_pos + sin(angle) * RADIUS), 
       (y_pos + (cos(angle)) * RADIUS)); 
    } 
    glEnd(); 
} 

bool brick_hit() 
{ 
    for (int a = 0; a < 10; a++) { 
     for (int b = 0; b < 4; b++) { 
      if (x_pos >= x_brick[b][a] 
       && x_pos <= x_brick[b][a] + 0.2) { 
       if (y_pos <= y_brick[b][a] 
        && y_pos >= y_brick[b][a] - 0.1) { 
        if (show[b][a] == 1) { 
         show[b][a] = 0; 
         return true; 
        } 
       } 
      } 
     } 
    } 
    return false; 
} 

bool crashed() 
{ 
    if (y_pos < paddle_y - 0.05) 
     return true; 

    return false; 
} 

void paddle_hit() 
{ 
    phit_corner = false; 
    phit_center = false; 
    if (x_pos <= paddle_x + 0.13 && x_pos >= paddle_x - 0.13) { 
     if (y_pos <= paddle_y) { 
      phit_center = true; 
     } 
    } else if ((x_pos >= paddle_x + 0.13 && x_pos <= paddle_x + 0.2) || 
      (x_pos <= paddle_x - 0.13 && x_pos >= paddle_x - 0.2)) { 
     if (y_pos <= paddle_y) { 
      phit_corner = true; 
     } 
    } 
} 

void paddle_move(float dT) 
{ 

    if (paddle_x < RATIO && paddle_x > -RATIO) 
     paddle_x += paddle_speed * PaddleSpeedFactor * dT; 

    if (paddle_x > 1.) { 
     paddle_x = 1.; 
     paddle_speed = 0.; 
    } 

    if (paddle_x < -1.) { 
     paddle_x = -1.; 
     paddle_speed = 0.; 
    } 
} 

void ball_move(float dT) 
{ 
    x_pos += speed_x * dT; 
    y_pos += speed_y * dT; 

    if (brick_hit()) { 
     speed_y *= -1; 
    } 

     if (x_pos >= (RATIO - RADIUS) || x_pos <= (-RATIO + RADIUS)) { 
     speed_x *= -1; 
    } 

    if (y_pos >= (1. - RADIUS)) { 
     speed_y = -1; 
    } 

    paddle_hit(); 
    if (phit_center) { 
     speed_y = 1; 
    } 
    if (phit_corner) { 
     speed_x *= -1; 
     speed_y = 1; 
    } 
} 

void paddle_draw() 
{ 
    glColor3f(0.0, 0.0, 0.0); 
    glBegin(GL_QUADS); 
    glVertex2f(paddle_x - 0.2, paddle_y); 
    glVertex2f(paddle_x + 0.2, paddle_y); 
    glVertex2f(paddle_x + 0.2, paddle_y - 0.05); 
    glVertex2f(paddle_x - 0.2, paddle_y - 0.05); 
    glEnd(); 
} 

void reset_game() 
{ 
    lifes = 3; 
    speed_x = 0; 
    speed_y = 0; 
    x_pos = 0; 
    y_pos = -0.7; 
    paddle_speed = 0; 
    paddle_x = 0; 
} 

void step_game(float dT) 
{ 
    if(!lifes) 
     return; 

    paddle_move(dT * SpeedFactor); 
    ball_move(dT * SpeedFactor); 

    if (crashed()) { 
     lifes--; 
     speed_x = 0; 
     speed_y = 0; 
     x_pos = 0; 
     y_pos = -0.7; 
    } 
} 

void launch_ball() 
{ 
    if(!lifes) 
     return; 

    speed_y = 1.; 
    speed_x = 1.; 
} 

void keyboard(int key, int action) 
{ 
    switch(key) 
    { 
    case GLFW_KEY_ENTER: 
     launch_ball(); 
     break; 

    case GLFW_KEY_ESC: 
     reset_game(); 
     break; 

    case GLFW_KEY_LEFT: 
     switch(action) { 
     case GLFW_PRESS: 
      paddle_speed = -1.; 
      break; 

     case GLFW_RELEASE: 
      paddle_speed = 0; 
      break; 
     } break; 

    case GLFW_KEY_RIGHT: 
     switch(action) { 
     case GLFW_PRESS: 
      paddle_speed = 1.; 
      break; 

     case GLFW_RELEASE: 
      paddle_speed = 0; 
      break; 
     } break; 
    } 
} 

void set_xy() 
{ 
    for (int a = 0; a < 5; a++) { 
     for (int b = 0; b < 10; b++) { 
      show[a][b] = 1; 
     } 
    } 
    int c = 0; 
    for (float a = -0.94; c <= 8; a += 0.21) { 

     for (int b = 0; b <= 5; b++) { 
      x_brick[b][c] = a; 

     } 
     c++; 
    } 
    int d = 0; 
    for (float s = 0.99; d <= 3; s -= 0.11) { 
     for (int r = 0; r < 9; r++) { 
      y_brick[d][r] = s; 
     } 
     d++; 
    } 
} 

float display() 
{ 
    int win_width; 
    int win_height; 
    glfwGetWindowSize(&win_width, &win_height); 
    const float win_aspect = (float)win_width/(float)win_height; 

    glfwSetTime(0.); 

    glViewport(0, 0, win_width, win_height); 

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    if (win_aspect > RATIO) { 
     glOrtho(-win_aspect, win_aspect, -1., 1., -1., 1.); 
    } else { 
     glOrtho(-RATIO, RATIO, -RATIO/win_aspect, RATIO/win_aspect, 
      -1., 1.); 
    } 

    glMatrixMode(GL_MODELVIEW); 

    glClearColor(0., 0., 1., 1.); 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glBegin(GL_QUADS); 
    glColor3f(1, 1, 1); 
    glVertex2f(-RATIO, -1); 
    glVertex2f(RATIO, -1); 
    glVertex2f(RATIO, 1); 
    glVertex2f(-RATIO, 1); 
    glEnd(); 

    draw_bricks(); 
    paddle_draw(); 

    ball_draw(); 

    glfwSwapBuffers(); 
    return glfwGetTime(); 
} 

int main(int argc, char **argv) 
{ 
    set_xy(); 

    if(GL_FALSE == glfwInit()) 
     return -1; 

    if(GL_FALSE == glfwOpenWindow(800, 600, 8, 8, 8, 8, 0, 0, GLFW_WINDOW)) 
     return -2; 

    glfwSetWindowTitle("Viraj's Brick Breaker - GLFW version by datenwolf"); 
    glfwSetKeyCallback(keyboard); 

    reset_game(); 

    while(glfwGetWindowParam(GLFW_OPENED)) { 
     glfwPollEvents(); 
     float const dT = display(); 
     step_game(dT); 
    } 

    glfwTerminate(); 

    return 0; 
} 
+0

저기서 고마워. :) 그러나 그것은 약간 변덕스럽고 느린 노를 고치지 않습니다. – viraj

+0

@viraj : 패배스럽고 느린 패들이 입력 관리에 문제가됩니다. 당신이 디스플레이 기능에서 게임 로직을 부분적으로하고있는 것처럼 보입니다. 그것을하기에 이상적인 곳이 아닙니다. 게임 로직을 유휴 함수에 배치하고 입력 콜백을 사용하여 입력 플래그를 설정하고 (어느 키가 눌려 졌는지, 눌려지지 않은 마우스 버튼 등, 마우스 이동 핸들러는 이동 이벤트를 누적해야 함) 해당 입력 플래그를 적용합니다 게임 상태. 또한 프레임을 렌더링하고 표시하는 데 걸리는 시간을 측정하고이를 사용하여 게임 시간을 앞당길 수 있습니다. 본질적으로 렌더링과 게임 로직을 혼합해서는 안됩니다. – datenwolf

+0

또한, 아래쪽에 3 개의 하트를 렌더링하고 싶습니다. 방정식을 사용하여 점을 그리거나 하트 모양을 그립니다. 나는 그것을 디플레이 기능에 넣었지만, 매우 느려지 게 만듭니다. 기능 : mod (x) -sqrt (1-x * x); mod (x) + sqrt (1-x * x); – viraj

0

내가 당신의 왜곡이 changeSize (...) 기능 때문이라고 생각합니다. 이 스 니펫을 훔친 코드를 살펴 보겠습니다.

전체 화면 모드로 전환 할 때 화면의 해상도를 변경합니까? 그렇게하면 픽셀이 더 이상 정사각형이 아닐 가능성이 높으므로 화면의 실제 종횡비가 필요합니다.