Instituto Politcnico Nacional

Escuela Superior de Ingeniera Mecnica y Electrnica

Ingeniera en Comunicaciones y Electrnica

Gloria Stephan Adame Celis

Edna Lucia Antonio de la Cruz
Luis Fernando Miranda Cenobio

2CM18

Programacin Orientada a
Objetos

Proyecto Parcial 2

PROYECTO PARCIAL 2
INTRODUCCION

Este proyecto forma parte de una serie de conocimientos adquiridos en las clases impartidas en el
segundo departamental en los siguientes programas hacemos uso de los conocimientos
mencionados . En el desarrollo de un proyecto informatico uno de los aspectos mas importantes es la
eleccion del lenguaje ms apropiado para su implementacin y las herramientas a utilizar. Existe
mltiples herrmamientas informaticas y multiples lenguajes de programacion dependiendo del area
de estudio. El lenguaje propuesto por la maestra ha sido el lenguaje C++, y el compilador es Dev +
+, una vez que tenemos el lenguaje, se ha de recabar informacin sobre las herramientas disponibles
y hacer uso de ellas.

OBJETIVOS

Los objetivos que pretendemos alcanzar y conseguir :

Implementar
Implementar
Implementar
Implementar
Implementar
Implementar

clases
estructuras
herencias
herencias multiples
Juego didactico
Reportes

Si logramos alcanzar todos los objetivos, abremos hecho uso de los conocimientos enseados en
clase con la finalidad de hacer un proyecto final.
MARCO TEORICO

QU ES UNA CLASE?
Una clase est formada por miembros que son los atributos y mtodos. Donde los atributos
representan las caractersticas relevantes del objeto o concepto descrito, mientras que los mtodos
representan las acciones u operaciones permitidas para almacenar o manipular los datos.
Una variable de tipo clase o una instancia de la clase se llama objeto. Donde un objeto contiene
datos es decir atributos y comportamiento es decir mtodos.
Estos objetos se crean mediante la ejecucin o como comnmente se dice el objeto se crea en
tiempo de ejecucin.
NIVELES DE SEGURIDAD DE UNA CLASE.
En una clase se manejan tres tipos de seguridad que son:

Privada: (private)
Publica: (public)
Protegida: (protected)

CATEGORIAS DE SEGURIDAD PARA C++.

Privada: los miembros definidos en esta seccin solo se pueden acceder por miembros de la misma
clase. La privacidad permite garantizar la proteccin de los atributos definidos en esta seccin,
generalmente en esta seccin se utiliza para definir los atributos y en algunos casos mtodos de la
clase.
Publica: en esta seccin se definen los atributos y mtodos que estarn disponibles para cualquier
cliente. A dems se permite la interaccin para que otros objetos del tipo de la clase puedan
manipular los atributos y mtodos sin tener que conocer la estructura interna del objeto.
Protegida: en esta seccin se definen los atributos y mtodos que se comparten con otras clases
derivadas.
Sintaxis:

Definicin de una clase en c++.

ESTRUCTURAS.
Una estructura es un tipo compuesto definido por el usuario. Se componen de campos o miembros
que pueden ser de diferentes tipos: int, float, char, arreglos, apuntador, etc
En c++ una estructura es igual que una clase salvo que por default sus miembros son public de
forma predeterminada.
Las estructuras son tipos de datos adicionales, que se pueden construir analizando elementos de
otros tipos e incluso con otras estructuras, ejemplos:
struct Persona.
Palabra Reservada Tipo de la estructura o nombre de nuevo tipo de datos.
Una estructura se considera como otro tipo de dato abstracto [TDA]. Donde cada uno de los
elementos de datos individuales es una entidad en s mismo, que se conoce como un campo de datos
forman una sola unidad que se denomina estructura.

CMO INSTANCIAR UNA ESTRUCTURA?

nombre_Estructura

variable.

Un registro es una variable declarada por un nuevo tipo de dato definida por una estructura.
La palabra reservada struct introduce la definicin de la estructura. El identificador tiempo es la
etiqueta de la estructura que da nombre a la definicin de la estructura y se utiliza para declarar las
variables del tipo de la estructura. En este ejemplo el nuevo tipo de dato es llamado Persona.
Los nombres declarados entre las llaves de la definicin de la estructura son los miembros de la
estructura se le llama dato miembro o campo.

Caractersticas:

Los miembros de la misma estructura deben tener nombres nicos, pero dos estructuras
diferentes pueden contener miembros con el mismo nombre sin conflicto alguno.
La definicin de estructura termina con un (;).
La definicin de persona tiene tres miembros de tipo entero.//
Los miembros de la estructura pueden ser de cualquier tipo.
Una estructura no puede contener una instancia de s mismo.

DIFERENCIAS CON RESPECTO A UNA CLASE.

En struct, si no se indica nada, sus miembros son pblicos.

En class si no se indica nada, sus miembros son privados.
Las estructuras son tipos de valor.
Una estructura no puede declarar un constructor de instancia sin parmetros.
Una estructura no puede declarar un destructor.

La asignacin de una variable de un tipo estructura crea una copia del valor que se asigne.

HERENCIA.
La herencia permite compartir atributos y mtodos entre clases y clases derivadas (subclases).
Heredan atributos y mtodos de las clases superiores que reciben el nombre de sper-clase (clase
base).

DEFINICIN DE APUNTADOR.
Cuando se declara una variable, el compilador reserva un espacio de memoria para ella y asocia el
nombre de esta a la direccin de memoria desde donde comienzan los datos de esa variable. Las
direcciones de memoria se suelen describir como nmeros en hexadecimal.
Un apuntador es una variable cuyo valor es la direccin de memoria de otra variable. Se dice que un
apuntador apunta a la variable cuyo valor se almacena a partir de la direccin de memoria que
contiene el apuntador. Por ejemplo, si un apuntador p almacena la direccin de una variable x, se
dice que p apunta a x.
Son variables que se usan para almacenar direcciones de memoria, los operadores que se usan son:

& operador de direccin es decir la direccin de.

* operador de indireccin es decir contenido de lo que apunta.
Referenciacin.

La referenciacin es la
obtencin
de
la
direccin de una variable. En C y C++ esto se hace a travs del operador (&), aplicado a la variable
a la cual se desea saber su direccin. Ntese que se trata de un operador unario. Ejemplo:

Este cdigo imprime un valor del estilo 0x4fffd34. Este valor puede variar durante cada ejecucin
del programa, debido a que el programa puede reservar distintos espacios de memoria durante cada
ejecucin.
Declaracin de un apuntador.
Para declarar un apuntador se especifica el tipo de dato al que apunta, el operador (*), y el nombre
del apuntador. La sintaxis es la siguiente:
<Tipo de dato apuntado> *<nombre de apuntador>.

Asignacin dinmica de memoria.

Los programas pueden crear variables globales o locales. Las variables declaradas globales en sus
programas se almacenan en posiciones fijas de memoria, en la zona conocida como segmento de
datos del programa, y todas las funciones pueden utilizar estas variables. Las variables locales se
almacenan en la pila (stack) y existen solo mientras estn activas las funciones donde estn
declaradas. En ambos casos el espacio de almacenamiento se reserva en el momento de la
compilacin del programa. Tambin es posible reservar y utilizar memoria dinmicamente, tomada
de la zona de memoria llamada montculo (heap) o almacn libre. En C estn disponibles varias
funciones que permiten realizar reservar y liberar memoria, pero C++ adems provee un mtodo
ms fcil y seguro de hacerlo.
Asignacin dinmica de memoria al estilo de C++.
Para asignar memoria dinmicamente en C++ se utilizan los operadores new y delate. El operador
new reserva memoria para un tipo de datos especfico y retorna su direccin, o retorna NULL en caso
de no haber conseguido suficiente memoria; y el operador delete permite liberar la memoria
reservada a travs de un apuntador. La sintaxis de ambos operadores es como sigue:
Para reservar y liberar un solo bloque:
<Apuntador> = new <tipo de dato> delete <apuntador>
Para reservar y liberar varios bloques (un arreglo):
<Apuntador>= new <tipo de datos> [<nmero de bloques>] delete [] <apuntador
El tipo del apuntador especificado del lado izquierdo del operador new debe coincidir con el tipo
especificado del lado derecho. De no ser as, se produce un error de compilacin

DESARROLLO
CODIGO 1:
//programa de registros
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <climits>
#include <vector>
using namespace std;

class Articulo {
public:
string referencia;
string nombre;
int existente;
int compra;
int venta;

Articulo() {}
bool operator==(const Articulo &articulo) const{
return this==&articulo || this->referencia==articulo.referencia;
}
bool operator<(const Articulo &articulo) const{
return this->referencia<articulo.referencia;
}
Articulo& operator=(const Articulo &articulo){
if (this!=&articulo){
this->referencia = articulo.referencia;

this->nombre = articulo.nombre;
this->existente = articulo.existente;
this->compra = articulo.compra;
this->venta = articulo.venta;
}
return *this;
}

//imprimir en pantalla
static void imprimir (Articulo &articulo, int *contador){
cout << " referencia

: " << articulo.referencia.c_str() << endl;

cout << " nombre

: " << articulo.nombre.c_str() << endl;

cout << " cantidad existente: " << articulo.existente << endl;
cout << " precio de compra : " << articulo.compra << endl;
cout << " precio de venta : " << articulo.venta << endl;
cout << endl;

(*contador)++;
}
//imprimir en archivo
static void imprimir_en_archivo (Articulo &articulo, ostream *archivo){
*archivo << articulo.referencia.c_str() << "\t";
*archivo << articulo.nombre.c_str() << "\t";
*archivo << articulo.existente << "\t";
*archivo << articulo.compra << "\t";
*archivo << articulo.venta << endl;;

}
};
//funciones
string leer_cadena (const char *mensaje);

int

leer_entero (const char *mensaje, int menor, int mayor);

bool leer_campo

(istream &archivo, char *campo, char delimitador);

template <class T> T* vector_buscar (vector<T> &arreglo, const T &dato);

template <class T> void vector_quitar (vector<T> &arreglo, T &dato);
template <class T> void quick_sort

(vector<T> &arreglo, int inicio=0, int fin=-1);

int main(){
system ("color 4F");
Articulo *dato, articulo;
vector<Articulo> arreglo;
int i, n, opcion, contador=0;
char campo[255], ruta[] = "Lista_Articulos.txt"; //nombre del archivo .txt a crear en carpeta para
almacenamiento de informacin
ifstream entrada (ruta);
if (entrada!=NULL){
while (leer_campo (entrada, campo, '\t')){
articulo.referencia = campo;
leer_campo (entrada, campo, '\t');
articulo.nombre = campo;
leer_campo (entrada, campo, '\t');
articulo.existente = atoi (campo);
leer_campo (entrada, campo, '\t');
articulo.compra = atoi (campo);
leer_campo (entrada, campo, '\n');
articulo.venta = atoi (campo);
arreglo.push_back (articulo);
}
entrada.close();
}
do {
system ("cls");

//menu en pantalla
cout << "\n\t\t\t ****Programa para registrar articulos****\n\n"<< endl <<"\t\t\t\t **** MENU
PRINCIPAL ****\n" << endl << "\t\t\t1. Ingresar nuevo registro"
<< endl << "\t\t\t2. Consultar registro existente"
<< endl << "\t\t\t3. Modificar registro existente" << endl << "\t\t\t4. Eliminar Registro
existente" << endl
<< "\t\t\t5. Ordenar registros existentes" << endl << "\t\t\t6. Editar registros existente"
<< endl <<"\t\t\t7. Guardar registros y Salir del sistema"
<< endl << "\n\n\nNota: Para guardar los registros es necesario al final seleccionar la
opcion: " << endl;
opcion = leer_entero ("\nSeleccione una opcion:", 1, 7);
cout << endl;
//condicionales
// opcion 2: consulta de registros
//aparece "no existen registros" cuando el archivo credo esta vaio
if (arreglo.empty() && opcion!=1 && opcion!=7){
cout << endl << " No existen registros." << endl << endl;
system (" pause");
continue;
}

// ingreso de articulo
if (opcion<5){
articulo.referencia = leer_cadena (" Ingrese la referencia del articulo: ");
dato = vector_buscar (arreglo, articulo);
if (dato!=NULL)
Articulo::imprimir (*dato, &contador);
}
//busca el articulo en archivo para ver si esta creado
//sino, continua con el ingreso de datos
if (dato!=NULL && opcion==1)
cout << endl << " Registro Existente.";

else if (dato==NULL && opcion>=2 && opcion<=4)

cout << endl << " No se encontro Registro.";
else switch (opcion){
case 1:
articulo.nombre = leer_cadena (" Nombre del articulo: "); //permite ingreso de letras y
nombres
articulo.existente = leer_entero (" Ingrese cantidad existente: ", 0, INT_MAX); //ingreso de
enteros
articulo.compra = leer_entero (" Ingrese precio de compra: ", 0, INT_MAX); //ingreso de
enteros
articulo.venta = leer_entero (" Ingrese precio de venta: ", 0, INT_MAX); //ingreso de
enteros
arreglo.push_back (articulo);
cout << endl << " Registro agregado correctamente.";
break;
case 3:
//modificar campos ya guardados en archivo
cout << "\n\t\t\t ****Menu de modificacion de campos****\n" << endl;
cout << "\t\t\t1.- Nombre del articulo" << endl;
cout << "\t\t\t2.- Cantidad existente" << endl;
cout << "\t\t\t3.- Precio de compra" << endl;
cout << "\t\t\t4.- Precio de venta" << endl;
switch (leer_entero ("\n Seleccione un numero de campo a modificar: ", 1, 4)){
case 1:
dato->nombre = leer_cadena (" Ingrese el nombre del articulo: ");
break;
case 2:
dato->existente = leer_entero (" Ingrese cantidad existente; ", 0, INT_MAX);
break;
case 3:
dato->compra = leer_entero (" Ingrese precio de compra: ", 0, INT_MAX);
break;
case 4:

dato->venta = leer_entero (" Ingrese precio de venta: ", 0, INT_MAX);

break;
}
cout << endl << " Registro actualizado correctamente."; // informa que los datos se
registraron en archivo
break;
case 4:
vector_quitar (arreglo, *dato); //informa que el registro del articulo fue aliminado
cout << endl << " Registro borrado correctamente.";
break;
case 5:
quick_sort (arreglo); //indica que los datos en archivo fueron ordenados
cout << endl << " Registros ordenados correctamente.";
break;
case 6:
n = arreglo.size();
contador = 0;
for (i=0; i<n; i++) //suma los registros en el archivo
Articulo::imprimir (arreglo[i], &contador);
cout << " Total de registros: " << contador << ".";
break;
}
if (opcion<7 && opcion>=1){
cout << endl << endl;
system (" pause");
}
} while (opcion!=7);
ofstream salida (ruta);
if (salida!=NULL){
n = arreglo.size();
for (i=0; i<n; i++)

Articulo::imprimir_en_archivo (arreglo[i], &salida);

salida.close();
}
return EXIT_SUCCESS;
}
//vectos para busqueda de informacion ya registrada en archivo
template <class T>
T* vector_buscar (vector<T> &arreglo, const T &dato){
int i, n=arreglo.size();
for (i=0; i<n; i++)
if (dato==arreglo[i])
return &arreglo[i];
return NULL;
}
//vector para elminar datos registrados
template <class T>
void vector_quitar (vector<T> &arreglo, T &dato){
int i, n=arreglo.size();
for (i=0; i<n; i++)
if (dato==arreglo[i])

arreglo.erase (arreglo.begin()+i);
return;
}
}
//vector que valida numeros negativos
template <class T>
void quick_sort (vector<T> &arreglo, int inicio, int fin){
int menor = inicio, mayor;
if (fin==-1)
fin = arreglo.size()-1;
mayor = fin;

T pivote;
if (fin>inicio){
for (pivote=arreglo[(inicio+fin)/2]; menor<=mayor;){
for (; menor<fin && arreglo[menor]<pivote; menor++);
for (; mayor>inicio && pivote<arreglo[mayor]; mayor--);
if (menor<=mayor){
pivote = arreglo[menor];
arreglo[menor] = arreglo[mayor];
arreglo[mayor] = pivote;
menor++;
mayor--;
}
}
if (inicio<mayor)
quick_sort (arreglo, inicio, mayor);
if (menor<fin)
quick_sort (arreglo, menor, fin);
}
}
// valida cualquier caracter
string leer_cadena (const char *mensaje){
char cadena[255];
cout << mensaje << "";
cin.getline (cadena, sizeof (cadena));
char *salto = strchr (cadena, '\n');
if (salto!=NULL)
*salto = '\0';
string str(cadena);
return str;
}
//valida solo enteros

int leer_entero (const char *mensaje, int menor, int mayor){

int entero;
do {
cout << mensaje << " ";
cin >> entero;
cin.get();
if (entero<menor || entero>mayor)
cout << " Numero no valido." << endl;
} while (entero<menor || entero>mayor);
return entero;
}
//valida campos en archivo
bool leer_campo (istream &archivo, char *cadena, char delimitador){
archivo.getline (cadena, 255, delimitador);
if (archivo.eof())
return false;
char *tab = strchr (cadena, delimitador);
if (tab!=NULL)
*tab = '\0';
return true;
}

CODIGO 2:
//cilindro

{
cout << "Ingresa el punto x: ";

#include<iostream>

cin >> X;

#include<math.h>

cout << "Ingresa el punto y: ";

#include<cmath>

cin >> Y;
cout << endl;
}

using namespace std;

void Punto::Imprimir(void)
class Punto

cout <<"Punto ("<< X << ", " << Y << " )"
<< endl;

private:
double X,Y;

}
//**********************************************
***************

public:
Punto(double x=0,double y=0);

class Circulo

void Leer(void);

void Imprimir(void);
};

Punto::Punto(double x, double y):X(x),Y(y)

{}

private:
double R;

public:
Circulo(double r=1);
void Leer(void);

void Punto::Leer(void)

double CalP(void);

double CalD(void);

return (M_PI * pow(R,2));

double CalA(void);

void Imprimir(void);

void Circulo::Imprimir(void)
{

};

// Punto::Imprimir();

Circulo::Circulo(double r):R(r)

cout <<" Diametro: " << CalD() << endl

<<" Perimetro: " << CalP() << endl

<<" Area: " << CalA() << endl;

void Circulo::Leer(void)

//**********************************************
********

{
//Punto::Leer();
cout <<" Cual es el Radio del circulo?: ";

class Cilindro:public Circulo, public Punto

{
private:

cin >> R;

double H;
}
public:
double Circulo::CalP(void)

Cilindro(double x=0, double y=0, double

r=1,double h=1);

void Leer(void);
return(2*M_PI*R);

double CalAl(void);
double CalAt(void);

double CalV(void);

double Circulo::CalD(void)

void Imprimir(void);

};
return(R * 2);

}
double Circulo::CalA(void)
{

Cilindro::Cilindro(double x, double y, double

r,double h):Circulo(r),H(h),Punto(x,y)
{
}

void Cilindro:: Leer(void)

Punto::Imprimir();

Circulo::Imprimir();
Punto::Leer();
Circulo::Leer();

cout <<"Area Lateral: " << CalAl() << endl

cout << "Cual es la altura del cilindro?: ";

<<"Area Total: " << CalAt() << endl

cin >> H;

<<"Volumen: " << CalV() <<endl;

cout <<endl;
}

double Cilindro::CalAl(void)

int main (void)

{
return (H*CalP());

Cilindro Cili;

double Cilindro:: CalAt(void)

Cili.Leer();

Cili.Imprimir();
return (CalAl() + 2*CalA());
system("pause");

}
double Cilindro ::CalV(void)

return 1;

{
return (CalA() * H);
}

void Cilindro::Imprimir(void)
{

CODIGO 3:

//librerias

int Num_vidas = 3;

#include <windows.h>

int Corazones = 3;

#include <iostream>

//cordenadas avion y asteroides

#include <conio.h>

int ix = 40;

#include <stdio.h>

int iy = 19;

//definir teclas

int y = 8;

#define IZQUIERDA 75

int x = 12;

#define DERECHA 77

int yy = 12;
int xx = 17;

//dibujos exposion y nave

int x1 = 58;

char avion_l1[]={' ',' ',' ', '*',' ',' ',' ',0};

int y1 = 6;

char avion_l2[]={' ',' ','*', '*','*',' ',' ',0};

int x2 = 70;

char avion_l3[]={' ','*',' ', '*',' ','*',' ',0};

int y2 = 9;
int i,v;

char explocion_l1[]={' ',' ','*','*',' ',' ',' ',0};

int dd=0;

char explocion_l2[]={' ','*','*','*','*',' ',' ',0};

bool disparo = false;

char explocion_l3[]={' ',' ','*','*',' ',' ',' ',0};

//tiempo de nivel
int repeticion = 0;

char explocion_r1[]={'*',' ','*','*',' ','*',' ',0};

int nivel = 1;

char explocion_r2[]={' ','*','*','*','*',' ',' ',0};

bool condicion = false;

char explocion_r3[]={'*',' ','*','*',' ','*',' ',0};

int xb;

//borrar lineas de avion

char borrar_avion[]={' ',' ',' ',' ',' ',' ',' ',0};

// funcion donde nos situa la pantalla

void gotoxy (int x, int y)

gotoxy (ix,iy); puts (explocion_l1);

HANDLE hCon;

gotoxy (ix,iy+1); puts (explocion_l2);

COORD dwPos;

gotoxy (ix,iy+2); puts (explocion_l3);

dwPos.X = x;
dwPos.Y = y;

Sleep (380);

hCon =
GetStdHandle(STD_OUTPUT_HANDLE);

gotoxy (ix,iy); puts (explocion_r1);

SetConsoleCursorPosition(hCon,dwPos);

gotoxy (ix,iy+1); puts (explocion_r2);

gotoxy (ix,iy+2); puts (explocion_r3);

//funcion vidas
void vidas (int vi)

Sleep (380);

{
gotoxy(2,1);

gotoxy (ix,iy); puts (avion_l1);

printf ("VIDAS %d",vi);

gotoxy (ix,iy+1); puts (avion_l2);

gotoxy (ix,iy+2); puts (avion_l3);

}

void Barra_salud (int n)

{

//funcion jugar
gotoxy (72,1); printf (" ");
gotoxy (73,1); printf (" ");
gotoxy (74,1); printf (" ");

void jugar (void)

{
if (!disparo)xb=ix;
gotoxy (xb+3,iy+dd);printf ("*");

for (v=0; v<n;v++)

{

//rutina asteroides
gotoxy (x,y); printf ("%c",2);

gotoxy (72+v,1);
printf ("%c",3);
}

gotoxy (xx,yy); printf ("%c",2);

gotoxy (x1,y1); printf ("%c",2);
gotoxy (x2,y2); printf ("%c",2);

}
//funcion nave que explote

Sleep (70);

void Explocion (void)

{

gotoxy (x,y); printf (" ");

gotoxy (xx,yy); printf (" ");

y1=4;

gotoxy (x1,y1); printf (" ");

x1=(rand ()%70)+6;

gotoxy (x2,y2); printf (" ");

gotoxy (xb+3,iy+dd);printf (" ");

if (y2>20|| x2 == xb+3 && iy+dd <= y2)

//rutina disparo

if (disparo == true) dd--;

y2=4;

if (iy+dd <5)

x2=(rand ()%70)+6;

}
dd=0;

//rutina para mover avion

disparo = false;

if (kbhit())

// rutina asterioides

unsigned char tecla = getch ();

if (y>20 || x == xb+3 && iy+dd <= y)

switch (tecla)

{
y=4;

case IZQUIERDA:

x=(rand () %70)+6;

if (ix>4)

if (y == 4)

gotoxy (ix,iy);puts
condicion = false;

(borrar_avion);
gotoxy (ix,iy+1);puts
(borrar_avion);

gotoxy (ix,iy+2);puts
(borrar_avion);

if (yy>20 || xx == xb+3 && iy+dd <= yy)

ix-=2;

{
yy=4;
xx=(rand ()%70)+6;

gotoxy (ix,iy);puts
(avion_l1);

gotoxy (ix,iy+1);puts
(avion_l2);

if (y1>20|| x1 == xb+3 && iy+dd <= y1)

{

gotoxy (ix,iy+2);puts
(avion_l3);

Barra_salud (Corazones);

break;

printf ("\a");
}

case DERECHA:
if (ix<70)

gotoxy (ix,iy); puts (avion_l1);

gotoxy (ix,iy+1); puts (avion_l2);

gotoxy (ix,iy);puts

gotoxy (ix,iy+2); puts (avion_l3);

(borrar_avion);
gotoxy (ix,iy+1);puts
(borrar_avion);
gotoxy (ix,iy+2);puts

if (!Corazones)
{

(borrar_avion);

Num_vidas --;
vidas (Num_vidas);
ix+=2;

Explocion ();
Corazones = 3;

gotoxy (ix,iy); puts

Barra_salud (Corazones);

(avion_l1);
gotoxy (ix,iy+1); puts

(avion_l2);
gotoxy (ix,iy+2); puts
(avion_l3);
}
break;

//rutina para cambio de nivel

if (!condicion)
{
repeticion ++;

case 'd':
disparo = true;
break;
}//fin switch
}//fin if

condicion = true;
}
if (repeticion == 4)
{
nivel ++;

//ritina para los golpes de los asteroides

if ((x>ix && x<ix+6 && y==iy-1)||(xx>ix
&& xx<ix + 6 && yy == iy-1)||(x1>ix &&
x<ix+6 && y1==iy-1)||(x2>ix && x2<ix + 6
&& y2 == iy-1))
{
Corazones --;

gotoxy (35,1); printf ("NIVEL

%i",nivel);

gotoxy (ix,iy); puts (borrar_avion);

gotoxy (ix,iy+1); puts
(borrar_avion);

gotoxy (ix,iy+2); puts

(borrar_avion);

gotoxy (35,1); printf ("GAME OVER", nivel);

Sleep (200);
getch ();

iy -= 2;

gotoxy (ix,iy); puts (avion_l1);

gotoxy (ix,iy+1); puts (avion_l2);
gotoxy (ix,iy+2); puts (avion_l3);
repeticion = 0;
}

y++;
yy++;
y1++;
y2++;

int main ()
{
vidas (Num_vidas);
Barra_salud (Corazones);
gotoxy (35,1); printf ("NIVEL %i", nivel);

gotoxy (ix,iy); puts (avion_l1);

gotoxy (ix,iy+1); puts (avion_l2);
gotoxy (ix,iy+2); puts (avion_l3);
while (Num_vidas>0)
{
jugar ();
}

//funcion jugar