U2 Creación de patrones (Tiro parabólico)

Instituto Tecnológico de Acapulco

Materia: Graficación

Profesor: Javier Sánchez Padilla

Equipo 4:

• Luis Leonel de Jesús Islas Rivas

20321076

• Oscar Rubén Romero Terrazas

18320979

Fecha: 05/04/2022

Grupo: IS1
Creación de patrones

Objetivos

El objetivo principal de este código es el siguiente:

1. A través de las teclas izquierda y derecha poder controlar la dirección hacia donde será

disparado Mario, y al mismo tiempo, que el cañón se incline hacia este tal ángulo.

2. Con las teclas Z y X controlar la velocidad (potencia) del disparo, y así poder elegir el

impulso que Mario obtendrá.

3. Al momento de presionar la tecla F, Mario debe salir disparado hacia la dirección del

cañón. Si Mario toca al enemigo, se mostrará en la pantalla que el jugador ganó y el

enemigo se destruirá. Si no, se dará la opción de si el jugador quiere volver a intentarlo.

4. Al momento de que Mario toca a el villano, este cambiara a otro patrón simulando una

explosión dando a entender que el enemigo fue destruido.

5. También en la parte superior derecha se encuentra una barra que medirá la velocidad del

disparo, y también una línea como guía para mostrar con mejor precisión hacia donde

será disparado Mario.

6. El enemigo tiene un movimiento aleatorio. Al toparse con las orillas, este rebotará. Al

momento de tocar a Mario, cambiará de patrón y se detendrá.

2
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

Código

// hecho por Luis Leonel de Jesús Islas Rivas y Oscar Rubén Romero Terrazas:D

#include <windows.h>

#include <cstdlib>

#include <iostream>

#include <gl\glut.h>

#include <cmath>

#include<time.h>

#include <math.h>

using namespace std;

bool gameover=false;

bool reintentar=false;

int malocara=0;

bool ganaste=false;

float PosX, PosY, incy, incx;

////////////////// cuadro

int limite=2;

float x=0;

float y=0;

float lado= 150.0;

bool disparo=false;

////////////////// enemigo

bool DD=true;

bool D=true;

float x_primae=3500.0;

float y_primae=3000.0;

float dirx=-3.0;

float diry=-3.0;

float ladoe= 150.0;

bool echocax=false;

bool echocay=false;

///////////////// flecha

const float pi=3.1415927;

3
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

int x_rf=1, y_rf=1; // Puntos iniciales pivote origen de rotacion

int xf=2000,yf=0; // Puntos de ubicacion del objeto

float x_primaf, y_primaf; // Puntos destino al final de la rotacion

double ang_rotac=1,grados=0; // Angulo de rotacion y angulo inicia

////////////////Velocidad

float porcentaje=0;

float barra=0;

//////////////////////////////////////////////////////////CAÑON

float v1x=-100.0, v1y=-100.0; // Vertices del cuadrado

float v2x=-100.0, v2y=100.0;

float v3x=500.0, v3y=100.0;

float v4x=500.0, v4y=-100.0;

float x_prima, y_prima; // Puntos destino al final de la rotacion

double cang_rotac=0.01; // Angulo de rotacion y angulo inicial

int x_r=0, y_r=0; // Ubicacion del pivote

unsigned char PackMan[ ] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFC, 0x00, 0x00, 0x0F, 0xFC, 0x00,

0x00, 0x30, 0x03, 0x00, 0x00, 0x3C, 0x03, 0x00, 0x00, 0xC2, 0x0F, 0xC0, 0x00, 0xC1, 0x0F, 0xC0,

0x00, 0xC0, 0xF3, 0xC0, 0x00, 0xFF, 0xF3, 0xC0, 0x03, 0x00, 0xFF, 0xC0, 0x03, 0x00, 0xFF, 0xC0,

0x03, 0x00, 0xF0, 0xC0, 0x03, 0x00, 0xF0, 0xC0, 0x00, 0xC3, 0xC3, 0x00, 0x00, 0xC3, 0xFF, 0x00,

0x00, 0x3C, 0x00, 0xC0, 0x00, 0x3C, 0x00, 0xC0, 0x00, 0xF0, 0x3F, 0xF0, 0x00, 0xF0, 0x3F, 0xF0,

0x03, 0x0F, 0x0C, 0x0C, 0x03, 0x0F, 0x0C, 0x0C, 0x03, 0x27, 0x30, 0x0C, 0x03, 0x0F, 0x30, 0x0C,

0x00, 0xFC, 0x33, 0xF0, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0xC0, 0x00, 0x0C,

0x00, 0x30, 0x00, 0xF0, 0x00, 0x30, 0x00, 0xF0, 0x00, 0x0F, 0xFF, 0x00, 0x00, 0x0F, 0xFF, 0x00

};

unsigned char Malo[ ] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x60, 0x00,

0x01, 0x80, 0x60, 0x00, 0x00, 0x73, 0x80, 0x00, 0x00, 0x73, 0x80, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x01, 0xAA, 0xE0, 0x00, 0x01, 0xD5, 0x60, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x01, 0x1E, 0x20, 0x00,

0x0F, 0x1E, 0x3C, 0x00, 0x3F, 0x1E, 0x3F, 0x00, 0x31, 0xFF, 0xE3, 0x00, 0x31, 0xFF, 0xE3, 0x00,

0x30, 0xFF, 0xC3, 0x00, 0x2C, 0x33, 0x0D, 0x00, 0x0F, 0xB3, 0x7C, 0x00, 0x0F, 0xB3, 0x7C, 0x00,

0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x60, 0x00, 0x01, 0x80, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00

};

unsigned char Malo2[ ] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

4
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x01, 0x80, 0x60, 0x00,

0x01, 0x80, 0x60, 0x00, 0x00, 0x73, 0x80, 0x00, 0x00, 0x73, 0x80, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x01, 0xD5, 0x60, 0x00, 0x01, 0xAA, 0xE0, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x3F, 0x1E, 0x3E, 0x00,

0x31, 0x1E, 0x23, 0x00, 0x31, 0x1E, 0x23, 0x00, 0x31, 0xFF, 0xE3, 0x00, 0x21, 0xFF, 0xE1, 0x00,

0x00, 0xFF, 0xC0, 0x00, 0x1C, 0x33, 0x0E, 0x00, 0x0F, 0xB3, 0x7C, 0x00, 0x1F, 0xB3, 0x7E, 0x00,

0x00, 0x12, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00

};

unsigned char Malo3[ ] = {0x0C, 0xFF, 0xFF, 0xF0, 0x0C, 0xFF, 0xFF, 0xF0, 0x0C, 0xFF, 0xFF, 0xF0, 0x0C, 0xFF, 0xFF, 0xF0,

0x3C, 0xFF, 0xFF, 0xF0, 0x3C, 0xFF, 0xFF, 0xF0, 0x0F, 0x3F, 0xFF, 0xF0, 0x0F, 0x3F, 0xFF, 0xF0,

0x0F, 0x33, 0xF3, 0xC0, 0x0F, 0x33, 0xF3, 0xC0, 0x3F, 0x00, 0xF3, 0xF0, 0x3F, 0x00, 0xF3, 0xF0,

0x03, 0x00, 0x33, 0xC0, 0x03, 0x00, 0x33, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0,

0x00, 0xFF, 0xF3, 0x30, 0x00, 0xFF, 0xF3, 0x30, 0x00, 0xC3, 0xCC, 0x00, 0x06, 0xC3, 0xCC, 0x00,

0x06, 0xC3, 0xCC, 0x00, 0x00, 0xC3, 0xCC, 0x00, 0x00, 0xC0, 0xC3, 0x30, 0x00, 0xC0, 0xC3, 0x30,

0x03, 0x30, 0xCC, 0x00, 0x03, 0x30, 0xCC, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

unsigned char Malo4[ ] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x02, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x02, 0x0C, 0x10, 0x00, 0x01, 0x8C, 0x60, 0x00,

0x01, 0x80, 0x60, 0x00, 0x00, 0x73, 0x80, 0x00, 0x00, 0x73, 0x80, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x01, 0xD5, 0x60, 0x00, 0x0F, 0xAA, 0xFC, 0x00, 0x3F, 0xFF, 0xFF, 0x00, 0x31, 0x5E, 0xA3, 0x00,

0x31, 0x5E, 0xA3, 0x00, 0x31, 0x5E, 0xA3, 0x00, 0x21, 0xFF, 0xE1, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x02, 0xFF, 0xD0, 0x00, 0x1C, 0x33, 0x0E, 0x00, 0x0F, 0xB3, 0x7C, 0x00, 0x1F, 0xB3, 0x7E, 0x00,

0x00, 0x12, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x02, 0xC0, 0xD0, 0x00, 0x01, 0x00, 0x20, 0x00

};

unsigned char Malo5[ ] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x02, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x02, 0x0C, 0x10, 0x00, 0x01, 0x8C, 0x60, 0x00,

0x01, 0x92, 0x60, 0x00, 0x00, 0x73, 0x80, 0x00, 0x00, 0x73, 0x80, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x31, 0xAA, 0xE3, 0x00, 0x3F, 0xD5, 0x7F, 0x00, 0x3F, 0xFF, 0xFF, 0x00, 0x31, 0x1E, 0x23, 0x00,

0x21, 0x5E, 0xA1, 0x00, 0x01, 0x1E, 0x20, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x01, 0xFF, 0xE0, 0x00,

0x02, 0xFF, 0xD0, 0x00, 0x1C, 0x33, 0x0E, 0x00, 0x0F, 0xB3, 0x7C, 0x00, 0x1F, 0xB3, 0x7E, 0x00,

0x20, 0x52, 0x81, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x02, 0xC0, 0xD0, 0x00, 0x01, 0x00, 0x20, 0x00

5
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

};

void DibujaTexto(int PosX, int PosY,char *string)

{ glRasterPos2f(PosX,PosY);

while (*string) // Muestra letra por letra

glutBitmapCharacter (GLUT_BITMAP_9_BY_15, *string++);

void teclas( unsigned char key, int PosX, int PosY )

{ switch ( key ) {

case 'f': cout<<"El usuario oprimio flecha f "<<disparo<<endl;

disparo=true;

break;

case 'x': cout<<"El usuario oprimio flecha x "<<porcentaje<<endl;

porcentaje+=1; if(porcentaje>100){porcentaje=100;}

break;

case 'z': cout<<"El usuario oprimio flecha Z "<<porcentaje<<endl;

porcentaje-=1; if(porcentaje<0){porcentaje=0;}

break;

case 'y': cout<<"El usuario oprimio flecha Y "<<porcentaje<<endl;

if(reintentar=true){disparo=false; reintentar=false;}

break;

case 'n': cout<<"El usuario oprimio flecha N "<<porcentaje<<endl;

if(reintentar=true){gameover=true; reintentar=false;}

break;

}}

void RotarCuadro(void)

glColor3f (1.0, 1.0, 1.0 );

glBegin(GL_QUADS);

glVertex2f(v1x,v1y);

glVertex2f(v2x,v2y);

6
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

glVertex2f(v3x,v3y);

glVertex2f(v4x,v4y);

glEnd();

// El calculo de los vertices atuaran en el siguientee ciclo de OpenGL para dibujar

// el cuadrado ahora con las nuevas ubicaciones

// Calcula vertice 1

void teclas_especiales( int key, int PosX, int PosY )

{ switch ( key ) {

case GLUT_KEY_LEFT: cout<<"El usuario oprimio flecha derecha x="<<endl;

x_primaf=x_rf+(xf-x_rf)*cos(pi*ang_rotac/180)-(yf-y_rf)*sin(pi*ang_rotac/180);

y_primaf=y_rf+(yf-y_rf)*cos(pi*ang_rotac/180)+(xf-x_rf)*sin(pi*ang_rotac/180);

grados+=1;

if (grados>=90) { grados=0; x_primaf=2000.0; y_primaf=0.0;}

xf=x_primaf; yf=y_primaf;

x_prima=x_r+(v1x-x_r)*cos(pi*ang_rotac/180)-(v1y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v1y-y_r)*cos(pi*ang_rotac/180)+(v1x-x_r)*sin(pi*ang_rotac/180);

v1x=x_prima; v1y=y_prima;

// Calcula vertice 2

x_prima=x_r+(v2x-x_r)*cos(pi*ang_rotac/180)-(v2y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v2y-y_r)*cos(pi*ang_rotac/180)+(v2x-x_r)*sin(pi*ang_rotac/180);

v2x=x_prima; v2y=y_prima;

// Calcula vertice 3

x_prima=x_r+(v3x-x_r)*cos(pi*ang_rotac/180)-(v3y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v3y-y_r)*cos(pi*ang_rotac/180)+(v3x-x_r)*sin(pi*ang_rotac/180);

v3x=x_prima; v3y=y_prima;

// Calcula vertice 4

x_prima=x_r+(v4x-x_r)*cos(pi*ang_rotac/180)-(v4y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v4y-y_r)*cos(pi*ang_rotac/180)+(v4x-x_r)*sin(pi*ang_rotac/180);

v4x=x_prima; v4y=y_prima;

cout<<v1x<<" "<<v1y<<" "<<v2x<<" "<<v2y<<" "<<v3x<<" "<<v3y<<" "<<v4x<<" "<<v4y<<endl;

if(grados==0) {v1x=-100; v1y=-100; v2x=-100; v2y=100; v3x=500; v3y=100; v4x=500; v4y=-100;}

7
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

break;

case GLUT_KEY_RIGHT: cout<<"El usuario oprimio flecha izquierda x="<<grados<<endl;

x_primaf=x_rf+(xf-x_rf)*cos(pi*ang_rotac/180)+(yf-y_rf)*sin(pi*ang_rotac/180);

y_primaf=y_rf+(yf-y_rf)*cos(pi*ang_rotac/180)-(xf-x_rf)*sin(pi*ang_rotac/180);

grados-=1;

if (grados<=0) { grados=90; x_primaf=0.0; y_primaf=2000.0;}

xf=x_primaf; yf=y_primaf;

x_prima=x_r+(v1x-x_r)*cos(pi*ang_rotac/180)+(v1y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v1y-y_r)*cos(pi*ang_rotac/180)-(v1x-x_r)*sin(pi*ang_rotac/180);

v1x=x_prima; v1y=y_prima;

// Calcula vertice 2

x_prima=x_r+(v2x-x_r)*cos(pi*ang_rotac/180)+(v2y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v2y-y_r)*cos(pi*ang_rotac/180)-(v2x-x_r)*sin(pi*ang_rotac/180);

v2x=x_prima; v2y=y_prima;

// Calcula vertice 3

x_prima=x_r+(v3x-x_r)*cos(pi*ang_rotac/180)+(v3y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v3y-y_r)*cos(pi*ang_rotac/180)-(v3x-x_r)*sin(pi*ang_rotac/180);

v3x=x_prima; v3y=y_prima;

// Calcula vertice 4

x_prima=x_r+(v4x-x_r)*cos(pi*ang_rotac/180)+(v4y-y_r)*sin(pi*ang_rotac/180);

y_prima=y_r+(v4y-y_r)*cos(pi*ang_rotac/180)-(v4x-x_r)*sin(pi*ang_rotac/180);

v4x=x_prima; v4y=y_prima;

if(grados==90) {v1x=100; v1y=-100; v2x=-100; v2y=-100; v3x=-100; v3y=500; v4x=100; v4y=500;}

break;}}

void Inicializa(void)

{ glClearColor (0.0, 0.0, 0.0, 0.0); // Color de la ventana

glMatrixMode (GL_PROJECTION); // Parametros de proyeccion (calcula los rangos)

gluOrtho2D (0.0, 4000.0, 0.0, 3500.0); } // indica el rango de eje

//gluOrtho2D (0.0, 800.0, 0.0, 600.0); } // indica el rango de eje

void ChecaColisiones()

{ float xcentro_cuadro, ycentro_cuadro, xcentro_otro, ycentro_otro;

8
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

unsigned int distX, distY,distancia_zero;

xcentro_cuadro=(x+lado)/2; // obtiene el centro en x

//se saca con el vertice izquierdo inferior mas la mitad del tamaño

ycentro_cuadro=(y+lado)/2;

//lo mismo pero con Y

xcentro_otro=(x_primae+ladoe)/2; //obtiene centro

ycentro_otro=(y_primae+ladoe)/2; //obtiene centro

distX=xcentro_cuadro-xcentro_otro; //saca la distancia entre un cuadro y otro

distY=ycentro_cuadro-ycentro_otro;

distancia_zero=(lado+ladoe)/2;

if (distX<=distancia_zero && distY<=distancia_zero)

{ ganaste=true;}

void Velocidad(void){

if(gameover==false){

barra=porcentaje*5;

glColor3f(1.0,1.0,1.0);

glBegin(GL_LINES);

glVertex2f (3400,3400);

glVertex2f (3900,3400);

glVertex2f (3900,3400);

glVertex2f (3900,3300);

glVertex2f (3900,3300);

glVertex2f (3400,3300);

glVertex2f (3400,3300);

glVertex2f (3400,3400);

glEnd();

glBegin(GL_QUADS);

glVertex2f (3400,3400);

9
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

glVertex2f (3400+barra,3400);

glVertex2f (3400+barra,3300);

glVertex2f (3400,3300);

glEnd();

void Animacion(void){

glClear (GL_COLOR_BUFFER_BIT);

if(gameover==true){

glColor3f(1.0,0.0,0.0); DibujaTexto(1700,1750.0,"PERDISTE :c ");

} else{

glColor3f(1.0,1.0,1.0); DibujaTexto(2800.0,3300.0,"Velocidad");

if(reintentar==true && gameover==false){glColor3f(1.0,1.0,1.0); DibujaTexto(1700.0,1800.0,"Reintentar?");}

if(reintentar==true && gameover==false){glColor3f(1.0,1.0,1.0); DibujaTexto(1950.0,1700.0,"y/n");}

////////////////////////////////////////////////////////////TEXTO

if(disparo==false){

glColor3f(1.0,1.0,1.0); DibujaTexto(300.0,1750.0,"Instrucciones: Mueve las flechas para ajustar el angulo y");

glColor3f(1.0,1.0,1.0); DibujaTexto(500.0,1650.0,"apuntar al enemigo. Ajusta la velocidad con Z y X.");

glColor3f(1.0,1.0,1.0); DibujaTexto(1300.0,1450.0,"Dispara con la tecla F");

if(ganaste==true){

glColor3f(0.0,1.0,0.0); DibujaTexto(1800,1750.0,"¡GANASTE!");

////////////////////////////////////////////////////////////////

float xx, yy;

if(disparo==false){xx=x; yy=y;}else{xx=x-20; yy=y-25;}

if(disparo==true){glColor3f(1.0,1.0,1.0); glRasterPos2i(xx,yy); glBitmap(32,32,0.0,0.0,0.0,0.0,PackMan);}

if(ganaste==false)

{malocara+=1;

if(malocara==0){glColor3f(1.0,1.0,1.0); glRasterPos2i(x_primae,y_primae); glBitmap(32,32,0.0,0.0,0.0,0.0,Malo);}

10
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

if(malocara==1){glColor3f(1.0,1.0,1.0); glRasterPos2i(x_primae,y_primae); glBitmap(32,32,0.0,0.0,0.0,0.0,Malo2);}

if(malocara==1){malocara=0;}

else

glColor3f(1.0,0.0,0.0); glRasterPos2i(x_primae,y_primae); glBitmap(32,32,0.0,0.0,0.0,0.0,Malo3);

////////////////////////////////////////////////////////////////////

void FormasBasicas(void)

{ glClear (GL_COLOR_BUFFER_BIT);

if(disparo==false){

///////////////////////////////////////////////////////////Enemigo

int limite=5;srand(time(NULL));

if(echocax==false){x_primae+=(rand()%limite)*-1;}

if(echocax==true){x_primae+=(rand()%limite)*1;}

if(echocay==false){y_primae+=(rand()%limite)*-1;}

if(echocay==true){y_primae+=(rand()%limite)*1;}

if(y_primae>3500-ladoe){echocay=false;}

if(y_primae<0){echocay=true;}

if(x_primae>4000-ladoe){echocax=false;}

if(x_primae<0){echocax=true;}

glBegin(GL_QUADS);

glVertex2f (x_primae,y_primae);

glVertex2f (x_primae,y_primae+ladoe);

glVertex2f (x_primae+ladoe,y_primae+ladoe);

glVertex2f (x_primae+ladoe,y_primae);

11
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

glEnd();

Animacion();

Velocidad();

x=0; y=0;

////////////////////////////////////////////LINEA

glColor3f (0.0, 0.0, 0.0 );

//x_primaf=x_rf+(xf-x_rf)*cos(pi*ang_rotac/180)-(yf-y_rf)*sin(pi*ang_rotac/180);

//y_primaf=y_rf+(yf-y_rf)*cos(pi*ang_rotac/180)+(xf-x_rf)*sin(pi*ang_rotac/180);

//cout<<grados<<endl;

glColor3f(1.0,1.0,1.0);

glBegin(GL_LINES);

glVertex2f(0.0,0.0);

glVertex2f(x_primaf,y_primaf);

glEnd();

RotarCuadro();

glutPostRedisplay();

glFlush();

else{

///////////////////////////////////cuadro

glBegin(GL_QUADS);

glVertex2f (x,y);

glVertex2f (x,y+lado);

glVertex2f (x+lado,y+lado);

glVertex2f (x+lado,y);

glEnd();

///////////////////////////////////enemigo

if(ganaste==false){

int limite=5;srand(time(NULL));

12
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

if(echocax==false){x_primae+=(rand()%limite)*-1;}

if(echocax==true){x_primae+=(rand()%limite)*1;}

if(echocay==false){y_primae+=(rand()%limite)*-1;}

if(echocay==true){y_primae+=(rand()%limite)*1;}

if(y_primae>3500-ladoe){echocay=false;}

if(y_primae<0){echocay=true;}

if(x_primae>4000-ladoe){echocax=false;}

if(x_primae<0){echocax=true;}

glBegin(GL_QUADS);

glVertex2f (x_primae,y_primae);

glVertex2f (x_primae,y_primae+ladoe);

glVertex2f (x_primae+ladoe,y_primae+ladoe);

glVertex2f (x_primae+ladoe,y_primae);

glEnd();

///////////////////////////////////formula parametro

float v =100+(porcentaje*2.5);

float g = 9.8;

float pi=3.1416;

float a = grados;

float p1 = (x*tan(a*pi/180.0));

float p3 = (g*(x*x));

float p4 = (2*(v*v)*((cos(a*pi/180.0))*(cos(a*pi/180.0))));

if (disparo==true)

{y=((p1-(p3/p4)));

x=x+11.40;}

if (a>=40){x=x-0.5;}

if (a>=50){x=x-1;}

if (a>=60){x=x-2;}

if (a>=70){x=x-3;}

if (a>=80){x=x-3;}

if (a>=90){x=x-3;}

13
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

cout<<y<<endl;

ChecaColisiones();

if(y<0 && ganaste==false){reintentar=true;}

Animacion();

Velocidad();

glutPostRedisplay();

glFlush(); // Procesa la rutina tan rápido // como sea posible

void SegmentoDeLinea(void) {

int main(int argc, char *argv[])

{ glutInit(&argc, argv); // Inicializa glut

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB ); // Establece el modo de //visualizacion

glutInitWindowPosition (250, 100); //Definir rango donde se establece la ventana

glutInitWindowSize (600, 500); // Establece alto y ancho de la // ventana

glutCreateWindow ("Un Ejemplo de un programa en OpenGL"); //titulo de la ventana

Inicializa();

{glutDisplayFunc(FormasBasicas);}

if(disparo==true){glutDisplayFunc(SegmentoDeLinea);}

glutSpecialFunc(teclas_especiales); //se agrga una funcion para teclas especiales

glutKeyboardFunc(teclas);

srand(time(NULL));

glutMainLoop();// ciclo infinito

system("PAUSE");

return EXIT_SUCCESS; }

14
U2 Creación de patrones (Tiro parabólico)
Creación de patrones

Resultado final

15
U2 Creación de patrones (Tiro parabólico)