Juegos en C

FACULTAD DE INGENIERIA CIVIL, ARQUITECTURA Y URBANISMO
ESCUELA PROFESIONAL DE CIENCIAS FISICO MATEMATICAS
JUEGOS EN C++
I. OBJETIVOS:
 Aprender a crear un espacio de trabajo.

 Conocimiento de juegos en c++.
II. LENGUAJE DE PROGRAMACIÓN DE C++:
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención

de su creación fue extender al lenguaje de programación C mecanismos que permiten la
manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados
a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los

paradigmas de programación estructurada y programación orientada a objetos. Por esto se
suele decir que el C++ es un lenguaje de programación multiparadigma.
Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría
de los fabricantes de compiladores más modernos. Existen también algunos intérpretes,
tales como ROOT.
Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear

nuevos tipos que se comporten como tipos fundamentales.
El nombre "C++" fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue
utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre
"C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que
C++ es una extensión de C.
C++ es un lenguaje de programación orientado a objetos que toma la base del lenguaje C y
le agrega la capacidad de abstraer tipos como en Smalltalk.
La intención de su creación fue el extender al exitoso lenguaje de programación C con

mecanismos que permitieran la manipulación de objetos. En ese sentido, desde el punto de
vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido (¿por? fusionar
con el siguiente).
Si aprenden C++ bien serán parte de una comunidad de “elite” dentro de lo programadores
incluso podrán ganar mucho dinero creando software de bajo nivel, desde los cuales se
sustentarán sistemas mucho más complejos. Pero, nuevamente, los voy a traer hasta nuestra
realidad: establecer una base para crear nuestros futuros videojuegos. Ahora que nombre
esto de "crear una base para nuestros futuros vieojuegos" les paso a explicar la ventaja más
excitante de programar orientado al objeto. Si nosotros creamos un diseño relativamente
bueno que sustente a nuestro videojuego podremos en un futuro seguir ocupando estas
"clases" de objeto (ya veremos este concepto), es decir, no tendremos que invertar la rueda
de nuevo (un error frecuente en un programador). Otra característica de C++ es que ofrece
la robustez de nuestro diseño mediante la ocultación de información, es decir, no todas las
personas que ocupen nuestro código podrán acceder a todo el código. Por ejemplo, no
podrán acceder a las estructuras que guardan la información en un tipo de dato lista,
podremos restringir el acceso del programador que ocupará nuestras clases a las funciones
canónicas insertar, eliminar o borrar un elemento.
C++ (y C) es el lenguaje más utilizado para crear videojuegos a nivel profesional. Así
que si queremos ser "profesionales", hay que conocer C++. C++ es un lenguaje muy
potente y muy flexible, pero también bastante difícil de aprender. Además, C++ no
incorpora funciones "nativas" (o sea, que pertenezcan al propio lenguaje en sí) para la
gestión de gráficos ni multimedia, por lo que si nos decidiéramos por usar este lenguaje
tendríamos que echar mano de alguna librería gráfica disponible y aprender a utilizarla.
III. COMPILADORES DE C++

Hay muchos compiladores para el lenguaje C++ en todos los sistemas operativos (todos),
porque casi todos los sistemas operativos están hechos en C o C++. Sin embargo, solo
algunos de ellos se pueden usar conjuntamente con Allegro en su versión más reciente
(3.9.35) algunos de ellos son Djgpp, Visual C++, Watcom y Borland C++. puedes ver todos
los compiladores que soporta Allegro. Yo personalmente me voy ha basar en el compilador
Djgpp ya que es gratuito y tiene una comunidad grande de personas que lo ocupan, además
de que se basa en el compilador de Unix, es decir, puedo pasar compilar fácilmente un
programa hecho en Djgpp en Unix y por consecuencia en Linux. Djgpp también trata de
estar siempre acorde con la estandarización ANSI. El código fuente trataré de que sea
compatible con todos los siguientes compiladores: GCC Unís, Visual C++ y Djgpp.
IV. HISTORIA DE LOS VIDEOJUEGOS
En 1 958 William Higginbotham creó, sirviéndose de un programa para el cálculo de

trayectorias y un osciloscopio, Tennis for Two (tenis para dos): un simulador de tenis de
mesa para entretenimiento de los visitantes de la exposición Brookhaven National
Laboratory. Este videojuego fue el primero en permitir el juego entre dos jugadores
humanos. Cuatro años más tarde Steve Russell, un estudiante del Instituto de Tecnología de
Massachussets, dedicó seis meses a crear un juego para computadora usando gráficos
vectoriales: Spacewar. En este juego, dos jugadores controlaban la dirección y la velocidad
de dos naves espaciales que luchaban entre ellas. El videojuego funcionaba sobre un PDP-1
y fue el primero en tener un cierto éxito, aunque apenas fue conocido fuera del ámbito
universitario.
En 1 966 Ralph Baer empezó a desarrollar junto a Albert Maricon y Ted Dabney, un
proyecto de videojuego llamado Fox and Hounds dando inicio al videojuego doméstico.
Este proyecto evolucionaría hasta convertirse en la Magnavox Odyssey, el primer sistema
doméstico de videojuegos lanzado en 1 972 que se conectaba a la televisión y que permitía
jugar a varios juegos pregrabados.
Un hito importante en el inicio de los videojuegos tuvo lugar en 1 971 cuando Nolan
Bushnell comenzó a comercializar Computer Space, una versión de Space War,
aunque otra versión recreativa de Space War como fue Galaxy War puede que se le
adelantara a principios de los 70 en el campus de la universidad de Standford.
La ascensión de los videojuegos llegó con la máquina recreativa Pong que es
considerada la versión comercial del juego Tennis for Two de Higginbotham. El
sistema fue diseñado por Al Alcom para Nolan Bushnell en la recién fundada Atari.
El juego se presentó en 1 972 y fue la piedra angular del videojuego como industria.
Durante los años siguientes se implantaron numerosos avances técnicos en los videojuegos
(destacando los microprocesadores y los chips de memoria). Aparecieron en los salones
recreativos juegos como Space Invaders (Taito) o Asteroids (Atari).
V. SIMPLE DIRECTMEDIA LAYER

SDL (Simple DirectMedia Layer), es una API creada por Sam Lantinga de Locky Games
para el desarrollo de videojuegos, demos, emuladores, reproductores y más, algo de lo que
te permite hacer SDL es establecer un modo de video y utilizar la memoria de video o de
sistema para trabajar con gráficos, que en términos de SDL se conocen como superficies
(Surfaces), te permite el manejo o detección de eventos para saber si se movió el mouse o
se presionó alguna tecla del teclado, etc., te permite trabajar o manipular sonido en tus
programas, manejo de la unidad de CD-ROM, manejo de hilos, temporizadores, además de

ofrecernos lo anterior esta API es multiplataforma ya que se puede hacer desarrollos para
SO (sistemas operativo) Windows, Linux, MacOS, entre otros y además de esto también la
podemos utilizar en muchos lenguajes de programación como Perl, C, C++, PHP, entre
otros y otro punto a favor más es que está bajo licencia LPGL (licencia publica general
menor) o sea que tu aplicación creada con SDL no necesita ser de código abierto, pero
hombre todo es conocimiento y como tal deberíamos aportar con algo.
Simple DirectMedia Layer es una biblioteca de desarrollo multiplataforma diseñada para

proporcionar acceso de bajo nivel a hardware de audio, teclado, mouse, joystick y gráficos
a través de OpenGL y Direct3D. Es utilizado por el software de reproducción de video,
emuladores y juegos populares, incluido el galardonado catálogo de Valve y muchos juegos
de Humble Bundle .
SDL es oficialmente compatible con Windows, Mac OS X, Linux, iOS y Android. El

soporte para otras plataformas se puede encontrar en el código fuente.
SDL está escrito en C, funciona de forma nativa con C ++, y hay enlaces disponibles para
varios otros idiomas, incluidos C # y Python.
SDL 2.0 se distribuye bajo la licencia zlib . Esta licencia le permite utilizar SDL libremente
en cualquier software.
Se han desarrollado una serie de bibliotecas adicionales que complementan las

funcionalidades y capacidades de la biblioteca base.
 SDL Mixer: Extiende las capacidades de SDL para la gestión y uso de sonido y
música en aplicaciones y juegos. Es compatible con formatos de sonido como
Wave, MP3 y OGG, y formatos de música como MOD, S3M, IT y XM.
 SDL Image: Extiende notablemente las capacidades para trabajar con diferentes
formatos de imagen. Los formatos compatibles son los siguientes: BMP, JPEG,
TIFF, PNG, PNM, PCX, XPM, LBM, GIF, y TGA,
 SDL Net: Proporciona funciones y tipos de dato multiplataforma para programar
aplicaciones que trabajen con redes.
 SDL RTF: Posibilita el abrir para leer en aplicaciones SDL archivos de texto usando
el formato Rich Text Format RTF.
 SDL TTF: Permite usar tipografías TrueType en aplicaciones SDL.
VI. OTRAS LIBRERÍAS
 Allegro: esta librería también es desarrollada en C como SDL, Allegro

es diseñada para el desarrollo de videojuegos, es parecida a SDL, pero
difieren en mucho, mi experiencia se basa en la instalación para el IDE
DevC++, pues es solamente bajar el paquete para el IDE e instalarla con
el gestor de paquetes de DevC++, creo que tengo un poco más de
experiencia en esta librería que utilizando SDL, he probado algunos
juegos que han hecho con la librería allegro y me han parecido geniales a
pesar de que solamente son demos.
 OpenGL (Open Graphics Library): Es una API grafica

multiplataforma creada por Silicon Graphics, esta solamente se basa en
el aspecto grafico de una aplicación, las otras son la librería GLU
(OpenGL Utility Library) una librería de utilidades, GLX (OpenGL
Extension to the X Windows Systems) para interactuar con sistemas de
ventanas X Windows. Esta
librería nos facilita la creación de videojuegos en 3D, tengo muy poca

experiencia manejando esta librería, solamente he hecho un simple
ejemplo, pero promete mucho.
 DirectX: Es una API multimedia creada por Microsoft, que consta

básicamente de cuarto partes Direct3d para gráficos, DirectSound y
DirectMusic para los sonidos y DirectInput para el control del teclado,
Mouse, etc., esta también no sirve para crear juegos es espacios 3D pero
solamente se utiliza en SO Windows, tengo poca experiencia en esta,
solamente he realizado un sencillo ejemplo, pero es realmente potente.
VII. ¿QUÉ NECESITO PARA MI VIDEO JUEGO?

Primero lo primero, y esto es la idea de lo que quieres convertir en un juego, tu idea por
simple que sea es la fuente de tu poder, las cosas sencillas los las que mejor funcionan,
o, nunca te divertiste con pac-man todavía da batalla, como segundo y esto es tu
gasolina para ver realizado tu proyecto es tener las ganas y la convicción de que si se
puede, después de esto debes preguntarte según tu idea, en qué clase de videojuego se
enmarca tu idea, existen muchos tipos de juegos yo creo que ni los conos todos,
solamente me baso en los básicos, a continuación describo algunos.
ARCADE: Pac-Man, Tetris, etc.
RPG: como el famoso Final Fantasy, mucha acción, aventura y estrategia, este género
es el que ha consumido mayor parte de mi tiempo, algo triste, pero no los puedo dejar.
SIMULACIÓN: como los juegos de Fórmula 1, los de aviones como EagleOne, el

reconocido Ned for Speed.
SIDESCROLLERS: como SuperTux, el viejo pero divertido Mario Bross, Naruto

Ninja Council de GBA.
JUEGOS DE ESTRATEGIA: estos juegos son como los de Age of Empires,

Wesnhost, Civ, etc, al parecer lo más importante de este tipo es la programación de la
inteligencia artificial, ya que realmente este es el fuerte que atrae a los jugadores de este
género, por otra parte, según los teóricos dicen que no se necesita muchos efectos y
calida en gráficos para el desarrollo de este tipo de juegos, pero como la comida, lo
primero es la impresión. Shooter’s: Estos son los famosos juegos de primera persona
(DOOM, Quake, no se cual más, etc.) o los de tercera persona (Max Payne, Super
Mario 64, Tomb Raider, etc.), en este tipo de juegos si se necesitan gráficos de buena
calidad, personalmente me gustan más los juegos en tercera persona.
DEPORTE: FIFA 2006 y de más, los de baloncesto, los de tenis como virtual tenis,
realmente no sé si es un género aparte me queda difícil definirlo dentro de alguno de los
anteriores.
Después de esto se necesitan habilidades como por ejemplo, saber programar en algún
lenguaje como C++
VIII. EJEMPLO DE JUEGOS CREADOS EN C++

Aunque espero que durante las etapas anteriores hayas tenido imaginación y empezaras a
crear tus propios juegos en modo consola tales como ahorcados, adivina el número, hundir
la flota, etc. Ha llegado la parte de empezar con aplicaciones gráficas. Aquí uno debe elegir
qué camino tomar. Para los videojuegos el camino sería aprender a usar una biblioteca 2D.
Muchos se desilusionan en este punto nueva mente porque ellos quieren hacer super juegos
3D que compitan con el último juego de moda, pero primero se debe aprender a caminar
para después correr. Aprender cómo se trabaja en un proyecto de videojuego y con
bibliotecas externas, aprender a usar imágenes y conceptos de programación gráfica.
Existen varias bibliotecas gráficas con las que empezar, pero mi recomendación es SDL,
tiene bastante reputación en el mundo de los videojuegos 2D, es simple y existe mucha
documentación. En este apartado es cuando es más difícil encontrar documentación en
español, pero existe un gran trabajo en español en forma de wiki perfecto para comenzar en
este maravilloso mundo.
Esto estupendo tutorial no se limita a mostrat y explicar las características de SDL, sino que
trata de explicar el buen uso de la misma y finalmente tiene el desarrollo de un videojuego
paso a paso. Totalmente recomendada para iniciarse con gráficos.
Estos son algunos ejemplos de juegos y con sus códigos y su sintaxis.
 JUEGO SNAKE EN C++

#include <windows.h>
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#define ARRIBA 72
#define IZQUIERDA 75
#define DERECHA 77
#define ABAJO 80
#define ESC 27
int cuerpo[200][2];
int n = 1, tam = 10, dir = 3;
int x = 10, y = 12;
int xc = 30, yc = 15;
int velocidad = 60;
char tecla;
void gotoxy(int x, int y)

{
HANDLE hCon;
COORD dwPos;
dwPos.X = x;
dwPos.Y = y;
hCon = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hCon,dwPos);
}
void OcultaCursor() {
CONSOLE_CURSOR_INFO cci = {100, FALSE};
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
}
void pintar(){
for(int i=2; i < 78; i++){
gotoxy (i, 3); printf ("%c", 205);
gotoxy(i, 23); printf ("%c", 205);
}
for(int v=4; v < 23; v++){
gotoxy (2,v); printf ("%c", 186);
gotoxy(77,v); printf ("%c", 186);
}
gotoxy (2,3); printf ("%c", 201);
gotoxy (2,23); printf ("%c", 200);
gotoxy (77,3); printf ("%c", 187);
gotoxy(77,23); printf ("%c", 188);
}
void guardar_posicion(){
cuerpo[n][0] = x;
cuerpo[n][1] = y;
n++;
if(n == tam) n = 1;
}
void dibujar_cuerpo(){
for(int i = 1; i < tam; i++){
gotoxy(cuerpo[i][0] , cuerpo[i][1]); printf("*");
}
}
void borrar_cuerpo(){
gotoxy(cuerpo[n][0] , cuerpo[n][1]); printf(" ");
}
void teclear(){
if(kbhit()){
tecla = getch();
switch(tecla){
case ARRIBA : if(dir != 2) dir = 1; break;
case ABAJO : if(dir != 1) dir = 2; break;
case DERECHA : if(dir != 4) dir = 3; break;
case IZQUIERDA : if(dir != 3) dir = 4; break;
}
}
}
void comida()
{
if(x == xc && y == yc)
{
xc = (rand() % 73) + 4;
yc = (rand() % 19) + 4;
tam++;
gotoxy(xc, yc); printf("%c", 4);
}
}
bool game_over()
{
if(y == 3 || y == 23 || x == 2 || x == 77) return false;
for(int j = tam - 1; j > 0; j--){
if(cuerpo[j][0] == x && cuerpo[j][1] == y)
return false;
}
return true;
}
int main()
{
OcultaCursor();
pintar();
gotoxy(xc, yc); printf("%c", 4);
while(tecla != ESC && game_over())

{
borrar_cuerpo();
guardar_posicion();
dibujar_cuerpo();
comida();
teclear();
teclear();
if(dir == 1) y--;
if(dir == 2) y++;
if(dir == 3) x++;
if(dir == 4) x--;
Sleep(velocidad);
}
pintar();
return 0;
}
 JUEGO DE PACMAN
#include <windows.h>
#include <iostream>
#include <conio.h>
#include <stdio.h>
#define ARRIBA 72
#define IZQUIERDA 75
#define DERECHA 77
#define ABAJO 80
#define ESC 27
#define ENTER 13
int backcolor=0;
int dir = 0;
int x=39,y=22;
int anteriorpx,anteriorpy;
char tecla;
long int puntos = -5;

int vidas = 3;
void setCColor( int color)

{
static HANDLE hConsole;
hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
SetConsoleTextAttribute( hConsole, color | (backcolor * 0x10 + 0x100) );

}
int color[7] = {
0x009,
0x00E,
0x00C,
0x002,
0x00B,
0x005,
0x00F
};
void gotoxy(int x, int y)

{
HANDLE hCon;
COORD dwPos;
dwPos.X = x;
dwPos.Y = y;
hCon = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hCon,dwPos);
}
char mapa[50][100] = {
" ",
" AXXXXXXXXXXXXXXXXXXXB
AXXXXXXXXXXXXXXXXXXXB",
" Y___________________Y Y___________________Y",
" Y_AXXXXXB_AXXXXXXXB_Y
Y_AXXXXXXXB_AXXXXXB_Y",
" Y_Y Y_Y Y_Y Y_Y Y_Y Y_Y",
"
Y_DXXXXXC_DXXXXXXXC_DXC_DXXXXXXXC_DXXXXXC_Y",
" Y________|_________|___|_________|________Y",
"
Y_AXXXXXB_AXB_AXXXXXXXXXXXXXB_AXB_AXXXXXB_Y",
" Y_DXXXXXC_Y Y_DXXXXB AXXXXC_Y Y_DXXXXXC_Y",

" Y_________Y Y______Y Y______Y Y_________Y",
" DXXXXXXXB_Y DXXXXB_Y Y_AXXXXC Y_AXXXXXXXC",
" Y_Y AXXXXC_DXXXC_DXXXXB Y_Y ",
" Y_Y Y_________________Y Y_Y ",
" XXXXXXXXC_DXC_AXXXXXX
XXXXXXB_DXC_DXXXXXXXX",
" _________|____Y * Y____|_________",
"
XXXXXXXXB_AXB_DXXXXXXXXXXXXXC_AXB_AXXXXXXXX",
" Y_Y Y_________________Y Y_Y ",
" Y_Y Y_AXXXXXXXXXXXXXB_Y Y_Y ",
" AXXXXXXXC_DXC_DXXXXB
AXXXXC_DXC_DXXXXXXXB",
" Y________|_________Y Y_________|________Y",
" Y_AXXXXXB_AXXXXXXB_Y Y_AXXXXXXB_AXXXXXB_Y",
" Y_DXXXB Y_DXXXXXXC_DXXXC_DXXXXXXC_Y
AXXXC_Y",
" Y_____Y Y_________|_____|_________Y Y_____Y",
" DXXXB_Y Y_AXB_AXXXXXXXXXXXXXB_AXB_Y
Y_AXXXC",
" AXXXC_DXC_Y Y_DXXXXB AXXXXC_Y Y_DXC_DXXXB",
" Y_________Y Y______Y Y______Y Y_________Y",
" Y_AXXXXXXXC DXXXXB_Y Y_AXXXXC DXXXXXXXB_Y",
"
Y_DXXXXXXXXXXXXXXC_DXXXC_DXXXXXXXXXXXXXXC_Y",
" Y_________________|_____|_________________Y",
"
DXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXC",
};
void pintar_mapa()
{
for(int i = 0 ; i < 78 ; i++){
for(int j = 0 ; j < 30 ; j++){
gotoxy(i,j);
if(mapa[j][i] == 'X') {setCColor(color[0]);printf("%c",205);}

if(mapa[j][i] == '_') {setCColor(color[1]); printf("%c",250);}
else if(mapa[j][i] == 'Y') {setCColor(color[0]);printf("%c",186);}
else if(mapa[j][i] == 'A') {setCColor(color[0]);printf("%c",201);}
else if(mapa[j][i] == 'B') {setCColor(color[0]);printf("%c",187);}
else if(mapa[j][i] == 'C') {setCColor(color[0]);printf("%c",188);}
else if(mapa[j][i] == 'D') {setCColor(color[0]);printf("%c",200);}
}
}
}
void pacman(int x , int y){

setCColor(color[1]);
gotoxy(x,y); printf("%c",2);
}
void borrar_pacman(int x, int y){

gotoxy(x,y); printf(" ");
if(mapa[y][x] == '_'){ mapa[y][x] = ' '; puntos += 5;}
}
void teclear(){
if(kbhit()){
tecla = getch();
switch(tecla){
case ARRIBA:
dir = 0;
break;
case ABAJO:
dir = 1;
break;
case DERECHA:
dir = 2;
break;
case IZQUIERDA:
dir = 3;
break;
class fantasma{
int fdir;
int _x, _y;
int col;
public:
fantasma(int x , int y , int color);
void dibujar_fantasma() const;

void borrar_fantasma() const;
void mover_fantasma();
void choque_pacman();
};
fantasma::fantasma(int x , int y, int color){
_x = x;
_y = y;
col = color;
fdir = rand()%4;
}
void fantasma::dibujar_fantasma() const{
setCColor(color[col]);
gotoxy(_x,_y); printf("%c",6);
}
void fantasma::borrar_fantasma() const{
gotoxy(_x,_y); printf(" ");

}
void fantasma::choque_pacman(){
if(y == _y && x == _x || (fdir == 0 && dir == 1 || fdir == 1 && dir == 0
||fdir == 2 && dir == 3 || fdir == 3 && dir == 2 )&&(_y == anteriorpy && _x
== anteriorpx)){
x = 39;
y = 22;
dir = 4;
vidas--;
}
}
void fantasma::mover_fantasma(){
borrar_fantasma();
choque_pacman();
int bolx=_x,boly=_y;
if(mapa[_y][_x] == '|'){
fdir = rand()%4;
}
if(mapa[_y][_x] == '*'){
fdir = 0;
}
if(fdir == 2){
if(mapa[_y][_x+1] != 'X' && mapa[_y][_x+1] != 'A' && mapa[_y][_x+1] !
= 'Y' &&
mapa[_y][_x+1] != 'B' && mapa[_y][_x+1] != 'C' && mapa[_y][_x+1] !=
'D') _x++;
else fdir = rand()%4;
}
if(fdir == 3){
if(mapa[_y][_x-1] != 'X' && mapa[_y][_x-1] != 'A' && mapa[_y][_x-1] !=
'Y' &&
mapa[_y][_x-1] != 'B' && mapa[_y][_x-1] != 'C' && mapa[_y][_x-1] !=
'D') _x--;
}
if(fdir == 0){
if(mapa[_y-1][_x] != 'X' && mapa[_y-1][_x] != 'A' && mapa[_y-1][_x] !=
'Y' &&
mapa[_y-1][_x] != 'B' && mapa[_y-1][_x] != 'C' && mapa[_y-1][_x] !=

'D') _y--;
}
if(fdir == 1){
if(mapa[_y+1][_x] != 'X' && mapa[_y+1][_x] != 'A' && mapa[_y+1][_x] !
= 'Y' &&
mapa[_y+1][_x] != 'B' && mapa[_y+1][_x] != 'C' && mapa[_y+1][_x] !=
'D') _y++;
}
if(mapa[boly][bolx] == '_') {setCColor(color[1]);

gotoxy(bolx,boly);printf("%c",250);}
// rutina atajo
if(_x <= 17) _x = 61;
else if(_x >= 62) _x = 18;
dibujar_fantasma();
}
void marcador(){
gotoxy(5,4); printf("PUNTOS");
gotoxy(5,6); printf(" ");
gotoxy(5,6); printf("%ld",puntos);
gotoxy(5,25); printf("VIDAS");
for(int i = 0 ; i <= vidas ; i++){
gotoxy(5,i+27);printf(" ");
}
for(int i = 0 ; i < vidas ; i++){
gotoxy(5,i+27);printf("%c",2);
}
gotoxy(70,27);printf("%c",169);
}
int main(){
fantasma A(41,14,2);
fantasma B(43,14,3);
fantasma C(40,14,4);
fantasma D(39,14,5);
pintar_mapa();
while(vidas > 0 && puntos < 1950){

marcador();
borrar_pacman(x,y);
anteriorpx = x; anteriorpy = y;
teclear();
if(dir == 0 && mapa[y-1][x] != 'X' && mapa[y-1][x] != 'A' && mapa[y-1]

[x] != 'Y' &&
mapa[y-1][x] != 'B' && mapa[y-1][x] != 'C' && mapa[y-1][x] != 'D')
y--;
else if(dir == 1 && mapa[y+1][x] != 'X' && mapa[y+1][x] != 'A' &&
mapa[y+1][x] != 'Y' &&
mapa[y+1][x] != 'B' && mapa[y+1][x] != 'C' && mapa[y+1][x] != 'D')

y++;
pacman(x,y);
Sleep(55);
borrar_pacman(x,y);
B.choque_pacman();
C.choque_pacman();
D.choque_pacman();
A.choque_pacman();
anteriorpx = x; anteriorpy = y;
teclear();
if(dir == 2 && mapa[y][x+1] != 'X' && mapa[y][x+1] != 'A' && mapa[y]
[x+1] != 'Y' &&
mapa[y][x+1] != 'B' && mapa[y][x+1] != 'C' && mapa[y][x+1] != 'D')
x++;
else if(dir == 3 && mapa[y][x-1] != 'X' && mapa[y][x-1] != 'A' && mapa[y]
[x-1] != 'Y' &&
mapa[y][x-1] != 'B' && mapa[y][x-1] != 'C' && mapa[y][x-1] != 'D')
x--;
A.mover_fantasma();
B.mover_fantasma();
C.mover_fantasma();
D.mover_fantasma();
pacman(x,y);
Sleep(55);
if(x < 17) {
borrar_pacman(x,y);
x = 61;
}
else if(x > 62){
borrar_pacman(x,y);
x= 18;
}
}
for(int i = 0 ; i <= vidas ; i++){
gotoxy(5,i+27);printf(" ");
system("pause>NULL");
return 0;
}
 JUEGO DE GATO
#include<iostream.h>
char gato[3][3];
bool bandera=true;
//===PROTOTIPOS===
void imprimegato();
void cambiaturno(char &t);
void introduce(char t, char corden);
short evalua(char t);
main()
{
imprimegato();
char t='X';
char posicion;
while(bandera==true)
{
cout<<"Es el turno de "<<t<<" introduzca posicion: ";
cin>>posicion;
posicion=toupper(posicion);
introduce(t,posicion);
// comprueba(turno);
evalua(t);
cambiaturno(t);
imprimegato();
}
system("pause");
}//fin main
//====INTRODUCE=====
void introduce(char t, char corden)
{
switch(corden)
{
case 'A':
if(gato[0][0]!='X' && gato[0][0]!='O')
{
gato[0][0]=t;
// cambiaturno(t);
}
else{cout<<"\n=Posicion ocupada=\n";}
break;
case 'B':
if(gato[0][1]!='X' && gato[0][1]!='O')
{
gato[0][1]=t;
// cambiaturno(t);
}
break;
case 'C':
if(gato[0][2]!='X' && gato[0][2]!='O')
{
gato[0][2]=t;
// cambiaturno(t);
}
break;
case 'D':
if(gato[1][0]!='X' && gato[1][0]!='O')
{
gato[1][0]=t;
// cambiaturno(t);
}
break;
case 'E':
if(gato[1][1]!='X' && gato[1][1]!='O')
{
gato[1][1]=t;
// cambiaturno(t);
}
break;
case 'F':
if(gato[1][2]!='X' && gato[1][2]!='O')
{
gato[1][2]=t;
// cambiaturno(t);
}
break;
case 'G':
if(gato[2][0]!='X' && gato[2][0]!='O')
{
gato[2][0]=t;
// cambiaturno(t);
}
break;
case 'H':
if(gato[2][1]!='X' && gato[2][1]!='O')
{
gato[2][1]=t;
// cambiaturno(t);
}
break;
case 'I':
if(gato[2][2]!='X' && gato[2][2]!='O')
{
gato[2][2]=t;
// cambiaturno(t);
}
break;
default:
cout<<"\nIntroduzca una posicion valida.\n";
}//fin switch
}//fin introduce
//====CAMBIATURNO===
void cambiaturno(char &t)
{
if (t=='X'){t='O';}
else{t='X';}
//cout<<t
//return t;
}//fin cambiaturno
//=======IMPRIMEGATO=====
void imprimegato()
{
cout<<"\n ######GATO#######\n\n";
cout<<"\t"<<gato[0][0]<<" | "<<gato[0][1]<<" | "<<gato[0][2]<<" a|b|

c"<<endl
cout<<"\t----------"<<" -----------\n";
cout<<"\t"<<gato[1][0]<<" | "<<gato[1][1]<<" | "<<gato[1][2]<<" d|e|
f"<<endl
cout<<"\t----------"<<" -----------\n";
cout<<"\t"<<gato[2][0]<<" | "<<gato[2][1]<<" | "<<gato[2][2]<<" g|h|
i"<<endl
cout<<"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
}//fin imrpimegato
short evalua(char t)
{
cout<<t
short px=0;
short po=0;
short evaluacion=0;
cout<<"\n[0][i]\n";
for(short i=0;i<3i++)
{
if(((gato[0][i]=='X')||gato[0][i]=='\0')&&((gato[1][i]=='X')||gato[1]
[i]=='\0')&&((gato[2][i]=='X')||gato[2][i]=='\0'))
{px++;}
if(gato[0][0]=='O'||gato[0][1]=='O'||gato[0][2]=='O'||gato[1][0]=='O'||gato[1]
[1]=='O'||gato[1][2]=='O'||gato[2][0]=='O'||gato[2][1]=='O'||gato[2][2]=='O')
{
if(((gato[0][i]=='O')||gato[0][i]=='\0')&&((gato[1][i]=='O')||gato[1]
[i]=='\0')&&((gato[2][i]=='O')||gato[2][i]=='\0'))
{po++;}
}
//else {po++;}
cout<<"\npo="<<po
cout<<"\npx="<<px
for(short i=0;i<3i++)
{
if(((gato[i][0]=='X')||gato[i][0]=='\0')&&((gato[i][1]=='X')||gato[i]
[1]=='\0')&&((gato[i][2]=='X')||gato[i][2]=='\0'))
{px++;}
{
if(((gato[i][0]=='O')||gato[i][0]=='\0')&&((gato[i][1]=='O')||gato[i]
[1]=='\0')&&((gato[i][2]=='O')||gato[i][2]=='\0'))
{po++;}
}
//else{po++;}
cout<<"\npo="<<po
cout<<"\npx="<<px
}//fin for
//Diagonales
cout<<"\ndiagonales\n";
if(((gato[0][0]=='X')||gato[0][0]=='\0')&&((gato[1][1]=='X')||gato[1]
[1]=='\0')&&((gato[2][2]=='X')||gato[2][2]=='\0'))
{px++;}
{
if(((gato[0][0]=='O')||gato[0][0]=='\0')&&((gato[1][1]=='O')||gato[1]
[1]=='\0')&&((gato[2][2]=='O')||gato[2][2]=='\0'))
{po++;}
}
//else{po++;}cout<<"\n1.diagonal\n";
cout<<"\npo="<<po
cout<<"\npx="<<px
if(((gato[2][0]=='X')||gato[2][0]=='\0')&&((gato[1][1]=='X')||gato[1]
[1]=='\0')&&((gato[0][2]=='X')||gato[0][2]=='\0'))
{px++;}
{
if(((gato[2][0]=='O')||gato[2][0]=='\0')&&((gato[1][1]=='O')||gato[1]
[1]=='\0')&&((gato[0][2]=='O')||gato[0][2]=='\0'))
{po++;}
}
//else{po++;}cout<<"\n2.diagonal\n";
cout<<"\npo="<<po
cout<<"\npx="<<px
if (t=='X'){evaluacion=px-po;}
else{evaluacion=po-px;}
cout<<"\n\nfinales";
cout<<"\npo="<<po
cout<<"\npx="<<px
//return evaluacion;
cout<<"\n\nEvaluacion es: "<<evaluacion<<endl
}//fin evalua

Juegos en C

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Juegos en C

Cargado por

Copyright:

Formatos disponibles

FACULTAD DE INGENIERIA CIVIL, ARQUITECTURA Y URBANISMO

ESCUELA PROFESIONAL DE CIENCIAS FISICO MATEMATICAS

 Aprender a crear un espacio de trabajo.

II. LENGUAJE DE PROGRAMACIÓN DE C++:

C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención

Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los

Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear

La intención de su creación fue el extender al exitoso lenguaje de programación C con

III. COMPILADORES DE C++

IV. HISTORIA DE LOS VIDEOJUEGOS

En 1 958 William Higginbotham creó, sirviéndose de un programa para el cálculo de

V. SIMPLE DIRECTMEDIA LAYER

programas, manejo de la unidad de CD-ROM, manejo de hilos, temporizadores, además de

Simple DirectMedia Layer es una biblioteca de desarrollo multiplataforma diseñada para

SDL es oficialmente compatible con Windows, Mac OS X, Linux, iOS y Android. El

Se han desarrollado una serie de bibliotecas adicionales que complementan las

VI. OTRAS LIBRERÍAS

 Allegro: esta librería también es desarrollada en C como SDL, Allegro

 OpenGL (Open Graphics Library): Es una API grafica

librería nos facilita la creación de videojuegos en 3D, tengo muy poca

 DirectX: Es una API multimedia creada por Microsoft, que consta

VII. ¿QUÉ NECESITO PARA MI VIDEO JUEGO?

ARCADE: Pac-Man, Tetris, etc.

SIMULACIÓN: como los juegos de Fórmula 1, los de aviones como EagleOne, el

SIDESCROLLERS: como SuperTux, el viejo pero divertido Mario Bross, Naruto

JUEGOS DE ESTRATEGIA: estos juegos son como los de Age of Empires,

VIII. EJEMPLO DE JUEGOS CREADOS EN C++

Estos son algunos ejemplos de juegos y con sus códigos y su sintaxis.

 JUEGO SNAKE EN C++

void gotoxy(int x, int y)

while(tecla != ESC && game_over())

long int puntos = -5;

void setCColor( int color)

hConsole = GetStdHandle( STD_OUTPUT_HANDLE );

SetConsoleTextAttribute( hConsole, color | (backcolor * 0x10 + 0x100) );

void gotoxy(int x, int y)

" Y_DXXXXXC_Y Y_DXXXXB AXXXXC_Y Y_DXXXXXC_Y",

if(mapa[j][i] == 'X') {setCColor(color[0]);printf("%c",205);}

void pacman(int x , int y){

void borrar_pacman(int x, int y){

void dibujar_fantasma() const;

gotoxy(_x,_y); printf(" ");

mapa[_y-1][_x] != 'B' && mapa[_y-1][_x] != 'C' && mapa[_y-1][_x] !=

if(mapa[boly][bolx] == '_') {setCColor(color[1]);

while(vidas > 0 && puntos < 1950){

if(dir == 0 && mapa[y-1][x] != 'X' && mapa[y-1][x] != 'A' && mapa[y-1]

mapa[y+1][x] != 'B' && mapa[y+1][x] != 'C' && mapa[y+1][x] != 'D')

cout<<"\t"<<gato[0][0]<<" | "<<gato[0][1]<<" | "<<gato[0][2]<<" a|b|

También podría gustarte