/*La mansión del terror
programación de videojuegos con SDL*/

//abrimos librerias

#include <SDL/SDL.h>


//definicion de estructura de datos
#define HUESO 1
#define LLAVE 2
#define ESCALERA 3
#define PERRO 4

// Estructuras de datos para los objetos
struct objeto {
int estado; // Estado del objeto
char desc1[80]; // Descripción para estado 1
char desc2[80]; // Descripción para estado 2
int hab; // Habitación en la que se encuentra
int lotengo; // Indica si tengo este objeto en mi inventario
} objetos[5];
// Estructura de datos para las habitaciónes
struct habitacion {
char desc[255];
int norte;
int sur;
int este;
int oeste;
} habitaciones[10];
       
int main(){
     /*inicialización de estructura de datos*/
     
     //inicialización de objetos
     // hueso
objetos[HUESO].estado=1;
strcpy(objetos[HUESO].desc1,"un hueso");
strcpy(objetos[HUESO].desc2,"un hueso");
objetos[HUESO].hab=2;
objetos[HUESO].lotengo=0;
// llave
objetos[LLAVE].estado=1;
strcpy(objetos[LLAVE].desc1,"una llave sobre la lampara");
strcpy(objetos[LLAVE].desc2,"una llave sobre la lampara");
objetos[LLAVE].hab=3;
objetos[LLAVE].lotengo=0;
// escalera
objetos[ESCALERA].estado=1;
strcpy(objetos[ESCALERA].desc1,"una escalera");
strcpy(objetos[ESCALERA].desc2,"una escalera");
objetos[ESCALERA].hab=9;
objetos[ESCALERA].lotengo=0;
// perro
objetos[PERRO].estado=1;
strcpy(objetos[PERRO].desc1,"un perro rabioso");
strcpy(objetos[PERRO].desc2,"un perro comiendose un hueso");
objetos[PERRO].hab=9;
objetos[PERRO].lotengo=0;
     
     /*datos del mapa*/
// Habitación 1
strcpy(habitaciones[1].desc,"Estas en una pequeña habitación pintada de blanco. Junto a tipuedes ver una cama y una mesita de noche.");
habitaciones[1].norte=0;
habitaciones[1].sur=4;
habitaciones[1].este=0;
habitaciones[1].oeste=0;
// Habitación 2
strcpy(habitaciones[2].desc,"Estas en una habitación pintada de verde. Junto a ti puedes veruna cama y una mesita de noche.");
habitaciones[2].norte=0;
habitaciones[2].sur=5;
habitaciones[2].este=0;
habitaciones[2].oeste=0;
// Habitación 3
strcpy(habitaciones[3].desc,"Estas en el salón de la casa. Puedes ver una gran mesa rodeadade sillas.");
habitaciones[3].norte=0;
habitaciones[3].sur=6;
habitaciones[3].este=0;
habitaciones[3].oeste=0;
// Habitación 4
strcpy(habitaciones[4].desc,"Estas en el pasillo.");
habitaciones[4].norte=1;
habitaciones[4].sur=7;
habitaciones[4].este=5;
habitaciones[4].oeste=0;
     // Habitación 5
strcpy(habitaciones[5].desc,"Estas en el pasillo.");
habitaciones[5].norte=2;
habitaciones[5].sur=8;
habitaciones[5].este=6;
habitaciones[5].oeste=4;
// Habitación 6
strcpy(habitaciones[6].desc,"Estas en el pasillo.");
habitaciones[6].norte=3;
habitaciones[6].sur=9;
habitaciones[6].este=0;
habitaciones[6].oeste=5;
// Habitación 7
strcpy(habitaciones[7].desc,"Estas en el típico servicio, con sus típicas piezas.");
habitaciones[7].norte=4;
habitaciones[7].sur=0;
habitaciones[7].este=0;
habitaciones[7].oeste=0;
// Habitación 8
strcpy(habitaciones[8].desc,"Estas en la entrada de la casa. Puedes ver la puerta cerrada.");
habitaciones[8].norte=5;
habitaciones[8].sur=0;
habitaciones[8].este=0;
habitaciones[8].oeste=0;
// Habitación 9
strcpy(habitaciones[9].desc,"Estas en la cocina.");
habitaciones[9].norte=6;
habitaciones[9].sur=0;
habitaciones[9].este=0;
habitaciones[9].oeste=0;
/***
Inicialización del estado de juego.
***/
// variable que indica la habitación en la que estamos
int habitacionActual = 1;
// variable que indica cuantos objetos hay
int nobjetos = 4;
/***
game loop
***/
char verbo[30], nombre[30];
int i, accion;
int done = 0;
while (!done) {
// Mostramos información de la habitación.
// Descripción
printf("\n\n%s",habitaciones[habitacionActual].desc);
// Mostramos si hay algun objeto
for (i=1 ; i<=nobjetos ; i++) {
if (objetos[i].hab == habitacionActual) {
printf("\nTambien puedes ver ");
// mostramos la descripción del objeto según su estado
if (objetos[i].estado == 1) {
printf("%s",objetos[i].desc1);
} else {
printf("%s",objetos[i].desc2);
}
}
}
// Mostramos las posibles salidas
printf("\nPuedes ir dirección ");
if (habitaciones[habitacionActual].norte != 0)
printf ("Norte ");
if (habitaciones[habitacionActual].sur != 0)
printf ("Sur ");
if (habitaciones[habitacionActual].este != 0)
printf ("Este ");
if (habitaciones[habitacionActual].oeste != 0)
printf ("Oeste ");
// Leemos la entrada del jugador
printf("\n>>> ");
scanf("%s%s",verbo,nombre);
// Procesamos la entrada del jugador
// coger
if (!strcmp(verbo,"coger")) {
accion = 0;
// Hueso
if (!strcmp(nombre,"hueso") && objetos[HUESO].hab == habitacionActual) {
accion = 1;
objetos[HUESO].hab=0;
objetos[HUESO].lotengo=1;
printf("\nHas cogido el hueso.");
}
// Llave
if (!strcmp(nombre,"llave") && objetos[LLAVE].hab == habitacionActual) {
accion = 1;
// para coger la llave necesitamos la escalera
if (objetos[ESCALERA].lotengo == 1) {
objetos[LLAVE].hab=0;
objetos[LLAVE].lotengo=1;
printf("\nTras subirte a la escalera, alcanzas la llave.");
} else {
printf("\nNo alcanzo la llave. Está demasiado alta.");
}
}
// Escaleras
if (!strcmp(nombre,"escalera") && objetos[ESCALERA].hab == habitacionActual) {
accion = 1;
if (objetos[PERRO].estado == 2) {
objetos[ESCALERA].hab=0;
objetos[ESCALERA].lotengo=1;
printf("\nHas cogido las escaleras.");
} else {
printf("\nEl perro gruñe y ladra y no te deja cogerlo.");
}
}
if (accion == 0)
printf("\nNo puedes hacer eso.");
}
// dar
if (!strcmp(verbo,"dar")) {
accion = 0;
// Hueso
if (!strcmp(nombre,"hueso") && objetos[HUESO].lotengo == 1 && objetos[PERRO].hab ==
habitacionActual) {
accion = 1;
objetos[HUESO].lotengo=0;
objetos[PERRO].estado=2;
printf("\nEl perro coge el hueso y se retira a comerselo tranquilamente.");
}
if (accion == 0)
printf("\nNo puedes hacer eso.");
}
// usar
if (!strcmp(verbo,"usar")) {
accion = 0;
// Hueso
if (!strcmp(nombre,"llave") && objetos[LLAVE].lotengo == 1 && habitacionActual == 8) {
accion = 1;
printf("\nENHORABUENA!!! Has escapado de la mansión del terror.");
done = 1;
}
if (accion == 0)
printf("\nNo puedes hacer eso.");
}
// ir
if (!strcmp(verbo,"ir")) {
accion = 0;
// norte
if (!strcmp(nombre,"norte") && habitaciones[habitacionActual].norte != 0) {
accion = 1;
habitacionActual=habitaciones[habitacionActual].norte;
}
// sur
if (!strcmp(nombre,"sur") && habitaciones[habitacionActual].sur != 0) {
accion = 1;
habitacionActual=habitaciones[habitacionActual].sur;
}
// este
if (!strcmp(nombre,"este") && habitaciones[habitacionActual].este != 0) {
accion = 1;
habitacionActual=habitaciones[habitacionActual].este;
}
// oeste
if (!strcmp(nombre,"oeste") && habitaciones[habitacionActual].oeste != 0) {
accion = 1;
habitacionActual=habitaciones[habitacionActual].oeste;
}

if (accion == 0)
printf("\nNo puedes hacer eso.");
}
}

return 0;
 }

#include <stdlib.h>
#include <SDL/SDL.h>
 
 int main(int argc, char *argv[])
{
 SDL_Surface *screen;
 SDL_Surface *fondo;
 SDL_Surface *protagonista;
 SDL_Rect destino;
int i, j;
int xProt = 320, yProt= 400;
int terminado = 0;
SDL_Event suceso;
Uint8* teclas;


 /* Tratamos de inicializar la biblioteca SDL (important posar-ho)*/
 if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
printf("No se pudo inicializar SDL: %s\n", SDL_GetError());
exit(1);
}/*SDL_INIT_VIDEO
   SDL_INIT_AUDIO
   SDL_INIT_TIMER
   SDL_INIT_CDROM
   SDL_INIT_JOYSTICK
   SDL_INIT_EVERYTHING*/
   /*per afegir-ne mes al costat de cada nom es separa per un
   |
   que es posa apretant "Alt Gr" + 1**/

 /* Preparamos las imagenes a mostrar */
 fondo = SDL_LoadBMP("fondo.bmp");
protagonista = SDL_LoadBMP("fondo3.bmp");

 /* Si todo ha ido bien, hacemos algo:
entrar a modo grafico y cambiar el título de la ventana */
screen = SDL_SetVideoMode( 640, 480, 16, SDL_HWSURFACE );
 if(screen == NULL) {
 printf( "Error al entrar a modo grafico: %s\n", SDL_GetError() );
SDL_Quit();
return -1;/*SDL_SWSURFACE--->Crear la superficie de video en la memoria principal
            SDL_HWSURFACE--->Crea la superficie en la memoria de vídeo
            SDL_ASYNCBLIT--->Modo de blit asíncrono. Mejora el rendimientoen 
                             máquinas con más de un procesador, unque puede 
                             disminuir en máquinas con una sólo procesador
            SDL_ANYFORMAT--->Fuerza el uso de los bpp de la surface actual. 
                             Hay que usarlo cuando queramos crear la superficie 
                             en una ventana
            SDL_HWPALETTE--->Da a SDL acceso exclusivo a la paleta de color
            SDL_DOUBLEBUF--->Sólo válido con SDL_HWSURFACE. Permite el uso de 
                             doble buffer
            SDL_FULLSCREEN-->Intenta poner el modo a pantalla completa
            SDL_OPENGL------>Crea un contexto OpenGL en la superficie
            SDL_OPENGLBLIT-->Igual que el anterior, pero permite que SDL haga el
                             render 2D
            SDL_RESIZABLE--->Crea un ventana que puede cambiar de tamaño
            SDL_NOFRAME----->Crea una ventana pero sin borde*/
            
            /*per afegir-ne mes al costat de cada nom es separa per un
            |
            que es posa apretant "Alt Gr" + 1*/
   }

 /* Titulo de la ventana */
SDL_WM_SetCaption( "programa de procva!" , "Hola mundo" );

/* Parte repetitiva: hasta que se elija terminar */
 while(terminado == 0) {

 /* Dibujamos la imagen de fondo */
 /* Como tiene 207 x 211 pixeles, la repetimos varias veces */
for (i=0; i<3; i++)
for (j=0; j<3; j++) {
destino.x=207*i;
 destino.y=211*j;
SDL_BlitSurface(fondo, NULL, screen, &destino);
  }

/* Dibujamos el protagonista */
destino.x=xProt;
  destino.y=yProt;
  SDL_BlitSurface(protagonista, NULL, screen, &destino);

      /* Actualizamos la pantalla */
    SDL_Flip(screen);

     /* Miramos si hay algun suceso pendiente,
       entre ellos, peticion de abandonar el programa
         (pulsar la X de la ventana) o tecla ESC */
    while (SDL_PollEvent(&suceso)) {
        if (suceso.type == SDL_QUIT)    terminado = 1;
          if (suceso.type == SDL_KEYDOWN)
           if (suceso.key.keysym.sym == SDLK_ESCAPE)  terminado = 1;
        }

        /* Vemos el estado indivudal de las demas teclas */
      teclas = SDL_GetKeyState(NULL);
         if (teclas[SDLK_UP]) { yProt -= 2; }
  if (teclas[SDLK_DOWN]) { yProt += 2; }
       if (teclas[SDLK_LEFT]) { xProt -= 3; }
     if (teclas[SDLK_RIGHT]) { xProt += 3; }
 
    /* Y esperamos 50 ms antes de repetir */
        SDL_Delay( 50 );
}
 
 /* Finalmente, preparamos para salir */
  SDL_Quit();
   return 0;
 }

#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
/* se incluye SDL_image.h para los metodos de
carga de imagenes */
#include <SDL/SDL_image.h>
/* metodo que permite cargar imagenes y las devuelve
como SDL_Surface */
SDL_Surface* cargarImagen(char *nombreArchivo)
{
/* SDL tiene metodos para cargar cada tipo de imagen
BMP,PCX,JPG,GIF,etc. pero este metodo (IMG_Load())
automaticamente carga imagenes sin preguntar el tipo*/
SDL_Surface *image = IMG_Load(nombreArchivo);
return image;
}
/* metodo que permite dibujar una *imagen previamente cargada
(con cargarImagen()), y dibujarla en una superficie dada
(en este caso *screen), en la posicion (x,y)*/
void dibujaImagen(SDL_Surface *screen, SDL_Surface *imagen, int x, int y)
{
/* se crea un rectangulo */
SDL_Rect rect;
/* se le asigna donde empieza en x el rectangulo */
rect.x=x;
/* se le asigna donde empieza en y el rectangulo */
rect.y=y;
/* se pega la imagen sobre screen de acuerdo a
la posicion del rectangulo */
SDL_BlitSurface(imagen, 0, screen, &rect);
}
int main(int argc, char *argv[])
{
SDL_Surface* screen;
if (SDL_Init(SDL_INIT_VIDEO)<0)
{
printf("Error al iniciar SDL:: %s",SDL_GetError());
return -1;
}
screen = SDL_SetVideoMode(640,480,16,SDL_HWSURFACE|SDL_RESIZABLE);
if (!screen)
{
printf("Error al iniciar el contexto SDL:: %s",SDL_GetError());
return -1;
}
SDL_WM_SetCaption(":: Carga de imagen con SDL ::",NULL);
/* llamamos al metodo para que cargue la imagen "foto.jpg" */
SDL_Surface* img = cargarImagen("foto.jpg");
/* preguntamos si realmente se cargo la imagen */
if (!img)
{
/* si nose cargo, salimos del programa */
printf("No se pudo cargar la imagen: %s",SDL_GetError());
return -1;
}
/* llamamos al otro metodo para que dibuje la imagen (*img)
sobre nuestra superficie buffer (*screen), en la posicion
100,100
*/
dibujaImagen(screen, img, 100, 100);
/* Este metodo tomara todos los cambios que se han hecho sobre
la superficie buffer(*screen), y las desplegara por pantalla
*/
SDL_Flip(screen);
SDL_Delay(5000);
return 1;
}

#include <stdio.h> 
#include <stdlib.h> 
#include <ctype.h> 
#include <conio.h> 

int main(void) 
{ 
   int ch; 
    
   do { 
      ch = getch(); 
      
      switch (ch){ 
             
      case 'a': 
         puts("opcion 1"); 
         getch();
         
         break; 
      case 'd': 
         puts("opcion 2"); 
         getch();
         break; 
         
      case 's': 
         puts("opcion 3"); 
         getch();
         break; 
         
      case 'w': 
         puts("opcion 4"); 
         getch();
         break; 
         
      default: 
         puts("Tecla no valida!"); 
         break; 
      } 
   }while (toupper(ch) != 'S'); 
    
   return EXIT_SUCCESS; 
}

# include <conio.h>

 int main ()
 {
   _cprintf ("1. diferentes obras para la consola de E / S, baja: \n");
   _getch ();
   _cprintf ("2. data:. \n");
   _getch ();
   _cprintf ("3. va hacia abajo y atrás:.\n");
   _getch ();
    return 0;
 }

 _cprintf ("1. diferentes obras para la consola de E / S, baja: \n");
   _getch ();

_cprintf ("2. data:. \n");
   _getch ();

_cprintf ("2. data:. \n");
   _getch ();

_cprintf ("3. va hacia abajo y atrás:.\n");
   _getch ();

_cprintf ("1. diferentes obras para la consola de E / S, baja: \n");
   _getch ();

_cprintf ("3. va hacia abajo y atrás:.\n");
   _getch ();

tecla=getch();

//Añadir
system("color a0");

//Añadir
system("color 0");