Instituto:
Pedro Ochoa Osorto
Asignatura:
Programación
Catedrático:
Oscar Anaccímedes Gómez Ruiz.
Integrantes:
Bety Elizabeth Cruz. Eily Rosita Reyes. Yesica Yamileth Ríos. Antonio Floran Andes. Hermes Andrés Maldonado.
Trabajo:
Exposición de un Juego en C++.
Juego:
Galaga.
San Antonio del Norte, la PAZ.
INTRODUCCION
En el presente informe
damos a conocer la historia del juego de Galaga, su funcionamiento y al mismo
tiempo su código fuente que contiene el mismo.
Galaga: Es un juego mata
marcianos creado en 1981 por la empresa NAMCO (NAMCO es una empresa
desarrolladora de software fundada el 1 de junio de 1955 en TOKIO JAPON.
v Dar a conocer y explicar el juego de Galaga, en que
consiste, su historia etc.
v Conocer más a fondo cada uno de sus códigos.
v Dar a conocer y explicar nuestro diagrama de flujo.
v Explicar cómo está organizado el código fuente.
MARCO TEORICO
Juego de Galaga
Galaga es juego mata
marcianos creado en 1981 por la empresa Namco.
Fue diseñado cm el
sucesor del Galaxian.
Fecha de estreno
inicial:.1981
Serie: Galaxian
Plataformas: Árcade,
Nintendo, Entertainmnt System.
Desarrolladores: Namco,
Majesco Entertainment, Namco Networks
Distribuidores: Namco,
Atari, Bandai Namco Games.
Game: videojuego de un jugador,
videojuego multijugador
Objetivo del juego
El jugador controla una
nave que debe enfrentarse contra un enjambre de marcianos que le atacaran
disparando
Asteroides cuando inicia
el juego, los marcianos no parecen haciendo piruetas para después tomar un
lugar en una información.
Cada tres vidas el
jugador podrá participar en un “challengin” donde deberá disparar a muchos
marcianos.
Si hablamos de juego
marciano de toda la vida los más clásicos el nombre de Galaga es una que
inevitablemente
llega a nuestra cabeza,
este SHOOTER de plano fijado creado por: NANCO triunfo desde el momento en el
que se comercializo en el año 1981 en los árcades de todo el mundo siendo la
escuela de galaxiano.
Otro tipo de gran fama
cuando comenzamos a jugar ponemos el control de una nave que se encuentra
afincada en el fin de la pantalla y desde la cual disparamos a los enemigos
quienes vienen hacia nosotros con intención hostil.
La particularidad y
principal diferencia con su entrega precedente es que al comenzar la partida la
pantalla no está directamente llena de marcianos si no que estos van
apareciendo en dirección recta para que intentemos acabar con ellos sin
permitir que se repliegue lo que supondría una mayor dificultad.
La pantalla solo se
termina una vez hemos logrado acabar con todos los enemigos del nivel para cual
necesitaremos echar mano de toda nuestra habilidad y de la mayor precisión
posible en lo relacionado con acertar a los enemigos incluso cuando se acercan
los marcianos hacia nosotros de una manera continua hacia la partida a medida
que derrotamos marcianos.
Como es habitual en las
secuelas Galaga incorpora un buen surtido de novedades en corporación a su
entrega precedente lo que permite disfrutar de más carteristas de interés, por
ejemplo: los podemos encontrar con niveles de desafío que se dan cita entre las
pantallas una serie de enemigos que atacan con malas intenciones por la
pantalla para que acabemos con todos y recibamos una bonificación especial.
Galaga también cuenta con
una particularidad curiosa las naves enemigas pueden eliminarlos.
Si conseguimos derrotar
al enemigo que mataremos la recuperaremos y la uniremos de la nave principal
para tener doble fuerza de ataque.
A lo largo del tiempo
Galaga ha tenido tanta popularidad que ha llegado a multitud de plataformas y sistemas
de video juegos.
Tras su árcade original
lo hemos visto en consola ordenadores maquinas portátiles de LCD he incluso
actual mente
En dispositivos móviles del
tipo del IPHONE es un clásico entre los clásicos y un juego de naves que no
pasa de moda
El cual sigue todavía
sirviendo a los desarrolladores actuales.
Para en tender como se
deben hacer ciertas cosas a la hora de crear títulos del genero exitoso.
Es por otro lado, un buen
reflejo de lo que suponía el rico mercado de los árcades en los años 80, algo
que ha terminado pasando a mejor vida debido a la caída en desgracia de este
tipo de máquinas ahora solo disponibles en algunos países.
NAMCO
Fecha de estreno inicial
1981, serie Galaxian plataformas: Arcada, Nintendo, entertainment system, Wii,
más.
Desarrolladores: Namco,
majesco, entertainment namco net Works.
Distribuidores: Namco,
Atari, Bandai: Namco games, Mus.
Director ejecutivo: hitoshi,
hitoshi, hagiwara.
En el año 2004 la empresa
gano 1600 millones de dólares el negocio principal DE LA EMPRESA y el
desarrollo de distribución de máquina recreativa, video juego para el hogar,
video consolas contenido para la televisión y servicio móvil.
También trabaja en otras
líneas de negocio en todo el mundo.
En el 2005 se unió con
BANDAY una de las mayores jugueteras de JAPON y también productoras de video
juego formando el HOLDING, NAMCO BANDAY HOLDING para afrontar mejor las
dificultades y costos para programar para la nueva generación de consola.
Video juego destacados
Esto es únicamente un
pequeño listado destacado de los juegos más famosos desarrollados por NAMCO a lo
largo de su historia no intenta ser extensivo si no señalar juegos importantes
en la historia de la empresa:
v PACMAN (1980)
v MSI PACMAN
v ACE KAPAT
v BATEN KAITOS
v GALAXIAN (1979)
v GALAGA (1979)
v DIG GUG (1982)
v XEVIOUS
v MACROSS
v METROCROSS
v PENNY RACERS
v RIDGE CALIBUR (1993)
v SOUL CALIBUR (1998)
v STARFOX: ASSAULT
v TALES OF PHATASIA
v TALES OF SYMPHONI
MANUAL TECNICO DE PROGRAMACION
#include<stdio.h>
#include<windows.h>
#include<conio.h>
#include<stdlib.h>
#include<list>
using namespace std;
#define ARRIBA 72
#define IZQUIERDA 75
#define DERECHA 77
#define ABAJO 80
void gotoxy(int x, int y){
HANDLE
hCon;
hCon =
GetStdHandle(STD_OUTPUT_HANDLE);
COORD dwPos;
dwPos.X
= x;
dwPos.Y
= y;
SetConsoleCursorPosition(hCon,
dwPos);
}
class NAVE{
int
x,y;
int
corazones;
int
vidas;
public:
NAVE(int
_x, int _y, int
_corazones, int _vidas):
x(_x),y(_y),corazones(_corazones),vidas(_vidas){}
int X(){ return x;
}
int Y(){ return y; }
int VID(){ return
vidas;}
void COR(){ corazones--; }
void pintar();
void borrar();
void mover();
void pintar_corazones();
void morir();
};
void NAVE::pintar(){
gotoxy(x,y); printf(" %c",30);
gotoxy(x,y+1); printf(" %c%c%c",40,207,41);
gotoxy(x,y+2); printf("%c%c %c%c",30,190,190,30);
}
void NAVE::borrar(){
gotoxy(x,y); printf(" ");
gotoxy(x,y+1); printf("
");
gotoxy(x,y+2); printf("
");
}
void NAVE::mover(){
if(kbhit()){
char tecla = getch();
borrar();
if(tecla ==
IZQUIERDA && x>3) x--;
if(tecla ==
DERECHA && x+6 <77) x++;
if(tecla ==
ARRIBA && y > 4) y--;
if(tecla ==
ABAJO && y+3 <33) y++;
if(tecla == 'e')corazones--;
pintar();
pintar_corazones();
}
}
void ocultarcursor(){
HANDLE hCon;
hCon = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO cci;
cci.dwSize = 100;
cci.bVisible = FALSE;
SetConsoleCursorInfo(hCon,&cci);
}
void pintar_limites(){
for(int i = 2;
i<78; i++){
gotoxy(i,3);
printf("%c",205);
gotoxy(i,33);printf("%c",205);
}
for(int i =4; i<33
; i++){
gotoxy(2,i);
printf("%c",186);
gotoxy(77,i);
printf("%c",186);
}
gotoxy(2,3);
printf("%c",201);
gotoxy(2,33);
printf("%c",200);
gotoxy(77,3);
printf("%c",187);
gotoxy(77,33); printf("%c",188);
}
void NAVE::pintar_corazones(){
gotoxy(50,2); printf("vidas%d",vidas);
gotoxy(64,2); printf("salud");
gotoxy(70,2);
printf("
");
for(int i=0;
i<corazones; i++){
gotoxy(70+i,2);
printf("%c",3);
}
}
void NAVE::morir(){
if(corazones==0){
borrar();
gotoxy(x,y); printf(" **
");
gotoxy(x,y+1); printf(" **** ");
gotoxy(x,y+2); printf(" ** ");
Sleep(200);
borrar();
gotoxy(x,y); printf(" *
** *");
gotoxy(x,y+1); printf(" **** ");
gotoxy(x,y+2); printf(" * ** *");
Sleep(200);
borrar();
vidas--;
corazones =3;
pintar_corazones();
pintar();
}
}
class AST{
int
x,y;
public:
AST(int _x, int
_y):x(_x),y(_y){}
void
pintar();
void
mover();
void choque(NAVE &N);
int X(){ return x;}
int Y(){ return y;}
};
void AST::pintar(){
gotoxy(x,y);
printf("%c",184);
}
void AST::mover(){
gotoxy(x,y); printf(" ");
y++;
if(y>32){
x = rand()%71 + 4;
y = 4;
}
pintar();
}
void AST::choque(NAVE &N){
if(
x>=N.X() && x< N.X()+6 && y>+N.Y() && y<=
N.Y()+2)
{
N.COR();
N.borrar();
N.pintar();
N.pintar_corazones();
x = rand()%71 + 4;
y = 4;
}
}
class BALA{
int
x, y;
public:
BALA(int _x,int _y):
x(_x),y(_y){}
int X(){ return x;}
int Y(){return y;}
void mover();
bool fuera();
};
void BALA::mover(){
gotoxy(x,y);
printf(" ");
if(y > 4) y--;
gotoxy(x,y);
printf("*");
}
bool BALA::fuera(){
if(y == 4) return true;
return false;
}
int main(){
ocultarcursor();
pintar_limites();
NAVE
N(37,30,3,3);
N.pintar();
N.pintar_corazones();
list<AST*> A;
list<AST*>::iterator itA;
for(int i=0;
i<5; i++){
A.push_back(new AST(rand()%75 + 3, rand()%5 +4));
}
list<BALA*> B;
list<BALA*>::iterator it;
bool game_over = false;
int puntos = 0;
while(!game_over){
gotoxy(4,2);
printf("puntos %d",puntos);
if(kbhit())
{
char tecla = getch();
if(tecla == 'a')
B.push_back(new BALA(N.X() + 2, N.Y() - 1));
}
for(it = B.begin(); it !=B.end(); it++)
{
(*it)->mover();
if((*it)->fuera()){
gotoxy((*it)->X(), (*it)->Y());
printf(" ");
delete(*it);
it = B.erase(it);
}
}
for(itA = A.begin(); itA !=A.end(); itA++){
(*itA)->mover();
(*itA)->choque(N);
}
for(itA = A.begin(); itA != A.end(); itA++){
for(it = B.begin(); it != B.end(); it++){
if((*itA)->X() == (*it)->X() && (
(*itA)->Y()+1 == (*it)->Y() || (*itA)->Y() == (*it)->Y() )){
gotoxy((*it)->X(),(*it)->Y());
printf(" ");
delete(*it);
it
= B.erase(it);
A.push_back(new AST(rand()%75 +3, 4));
gotoxy((*itA)->X(),(*itA)->Y()); printf("
");
delete(*itA);
itA
=A.erase(itA)
puntos+=5;
}
}
}
if(N.VID() == 0) game_over = true;
N.morir();
N.mover();
Sleep(30);
}
printf("you are
lose");
return 0;
}
MANUAL DE USUARIO
Con la tecla DERECHA: esquiva ala derecha con la tecla
ABAJO: se mueve hacia abajo y con la tecla ARRIBA: se mueve hacia arriba con la
tecla A dispara
El juego tiene 3 vidas, cada una de las vidas esta
complementada por 3 corazones cuando los asteroides caen sobre la nave se van perdido
corazones, alos 3 corazones pierde una vida y al perder las tres vidas el juego
finaliza.
La función GOTOXI: es
una función de las librerías de borlan que se encuentra en la librería
coniunh.h
Gotoxi mueve el cursor de la ventana de texto a la posición
según las coordenadas especificadas por los argumentos X E Y, si las
coordenadas no son válidas Z entonces la llamada a la función GOTOXI es
ignorada. Los argumentos no pueden ser O y normalmente en los programas de
consolas las dimensiones de las pantallas son 80 caracteres, horizontales por
25 líneas verticales
#INCLUDE<STDIO.H>: quiere
decir “estándar input and output” que traducido es “ENTRADA Y SALIDA ESTANDAR”
INCLUDE<STDIO.H>: Es para
incluir una librería de tiempo estándar. se incluye la librería stdio.h para
usar la siguiente función, printf, scanf, gets, putts, tapen, close, White,
read, spritf, sscanf, fprinf, fscanf entre muchas funciones.
#INCLUDE<WINDOWS.H>: Contiene
todas las declaraciones de las funciones de la biblioteca Windows API (Interfaz
de programación de aplicaciones de Windows y en ingles Windows aplicación
programming interface) permite que una aplicación corra bajo un determinado
sistema operativo y algunas de las funciones de APPI: Depuración y manejo de errores,
manejo de memoria manejo de energía almacenamiento etc.
Todas las macro utilizadas por los programadores de
aplicaciones para Windows y las estructuras de datos utilizadas en gran
cantidad de funciones y sub sistemas
#INCLUDE<LIST.H>: Permite
implementar listas doble mente enlazadas fácil mente
USING MANESPACE: Contiene una de cloración del espacio del nombre.
también cuando se declara using manes pace podemos evitar estar escribiendo std:
cout o std: cin, etc. En nuestro código. Facilita la escritura del código al
momento de usarlas entidades de las librerías estándares
#INCLUDE>CONIO.H>: Es una
biblioteca de manejo de entrada y salida de datos, es posible que algunas de las
funciones que incluye no funciones correctamente. Las funciones más usadas de
esta son: getch (), clrscr (), gotoxi () y glosario tex color ()
VOID: Significa que no devuelve
ningún valor. Cuando se utiliza para una lista de parámetros de una función
void especifica que la función no tiene ningún parámetro, cuando se utiliza en
la declaración de un puntero void especifica que el puntero es universal
CLASS EN C++: Es una secuencia de
estructuras en el estilo de C con algunas ventajas cencías per muy potentes
WHILE: Sirve cuando un argumento sea
verdad.
HANDLE: En programación de computadora
se conoce como HANDLE aun tipo particular de punteros “INTELIGENTES “los
handles son utilizados cuando un programa hace referencia a bloques de memoria
u objetos controlados por otros sistemas tales como: Una base de datos o un
sistema operativo.
Mientras un puntero literalmente contiene la dirección en
la memoria de algún objeto un handles es una referencia abstracta y controlada
de manera independiente por el sistema permitiendo que la referencia pueda ser
reubicada en la memoria por el sistema sin invalidar el handles.
CICLO FOR: son los que conocemos
como estructuras de control de flujo.
En este informe
concluimos con el juego de Galaga dando a conocer sus funcionamientos
código fuente y la historia en general, de cómo fue organizado.
BIBLIOGRAFIA
No hay comentarios:
Publicar un comentario