API tools faq
paste
Advertisement
alvaro_93

main.c

alvaro_93
Jun 22nd, 2015
295
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 36.63 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * File:   main.c
  3.  * Author: owner
  4.  *
  5.  * Created on 12 de junio de 2015, 12:52 AM
  6.  */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include<conio.h>
  11. #include <windows.h>  
  12. #include "juego.h"
  13.  
  14. #define N 38
  15. #define E 20
  16. #define Factor 2//factor para calcular la cantidad de enemigos
  17. #define MAX 30
  18.  
  19.  
  20. /*
  21.   *                  PROCEDIMIENTOS DE ALVARO
  22. Estos procedimientos fueron creados por Alvaro, asi que no es perra de nadie
  23. */
  24.  
  25.  
  26. void cargarMonstruosGen(TObject arrMonst [MAX]){
  27.    
  28.     FILE* archivo;
  29.    
  30.     char name[30];//le asigno una capacidad maxima a name
  31.     int health,atack,defense,speed,i;
  32.     i=0;//inicializo contador
  33.    
  34.     archivo=fopen("monstruos.txt","r");//abro el archivo que usare
  35.     if (archivo!=NULL)
  36.         while (fscanf(archivo, "%s %d %d %d %d", name, &health,&atack,&defense,&speed) == 5){   //leo cada registro
  37.             crearMonstruo(&arrMonst[i], name,health,atack, defense, speed);                      // uso el procedimiento creado por Neil
  38.             //notese que envio el elemtno objeto del arreglo con ampersan para que el procedimiento
  39.             //reciba un puntero a tipo objeto
  40.             i++;//incremento el contador para seguir recorriendo el arreglo
  41.                  
  42.         }    
  43.            
  44.    
  45.    
  46. }
  47.  
  48. void cargarPocionesGen(TObject arrPociones[MAX]){
  49.     FILE* archivo;
  50.    
  51.     char name[30];//le asigno una capacidad maxima a name
  52.     int peso,consumible,i;
  53.     i=0;//inicializo contador
  54.    
  55.     archivo=fopen("pociones.txt","r");//abro el archivo que usare
  56.     if (archivo!=NULL)
  57.         while (fscanf(archivo, "%s %d %d", name, &peso,&consumible) == 3){//leo cada registro
  58.             crearConsumible(&arrPociones[i],name,peso,consumible);// uso el procedimiento creado por Neil
  59.             //notese que envio el elemtno objeto del arreglo con ampersan para que el procedimiento
  60.             //reciba un puntero a tipo objeto
  61.             i++;//incremento el contador para seguir recorriendo el arreglo
  62.                  
  63.         }    
  64. }
  65.  
  66. void cargarArmasGen(TObject arrArmas[MAX]){
  67.    
  68.     FILE* archivo;
  69.    
  70.     char name[30];          //le asigno una capacidad maxima a name
  71.     int peso,atack,defense,speed,i;
  72.     i=0;//inicializo contador
  73.    
  74.     archivo=fopen("armas.txt","r");//abro el archivo que usare
  75.     if (archivo!=NULL)
  76.         while (fscanf(archivo, "%s %d %d %d %d", name, &peso,&atack,&defense,&speed) == 5){//leo cada registro
  77.             crearArma(&arrArmas[i],name,peso,atack,defense,speed);
  78. /*
  79.             uso el procedimiento creado por Neil
  80.             notese que envio el elemetno objeto del arreglo con ampersan para que el procedimiento
  81.             reciba un puntero a tipo objeto
  82. */
  83.             i++;//incremento el contador para seguir recorriendo el arreglo
  84.                  
  85.         }        
  86. }    
  87. /////////////////////////////FIN DE PROCEDIMIENTOS DE ALVARO/////////////////////////////////
  88.  
  89.  
  90.  void gotoxy(int x,int y){  
  91.       HANDLE hcon;  
  92.       hcon = GetStdHandle(STD_OUTPUT_HANDLE);  
  93.       COORD dwPos;  
  94.       dwPos.X = x;  
  95.       dwPos.Y= y;  
  96.       SetConsoleCursorPosition(hcon,dwPos);  
  97.  }
  98.  
  99.  void actualizarItem(TObject *hero){  //actualiza todos los items (armas) que el heroe tiene equipado
  100.   TNodo *ptrnodo;                      //degrada las armas para que se vuelvan inservibles
  101.      ptrnodo = hero->hero->cinturon->head; //apunta al primer nodo del cinturon
  102.      int i;
  103.      for(i = 1;i <= hero->hero->cinturon->max; i++){
  104.          if(ptrnodo->elemento != NULL && ptrnodo->elemento->id == 1){   //solo cuando es un arma y el elemnto no es null
  105.              if(ptrnodo->elemento->arma->atack > 0){
  106.                  ptrnodo->elemento->arma->atack = ptrnodo->elemento->arma->atack -3;
  107.              } else ptrnodo->elemento->arma->atack = 0;
  108.              if(ptrnodo->elemento->arma->defense > 0){
  109.                  ptrnodo->elemento->arma->defense = ptrnodo->elemento->arma->defense -3;
  110.              } else ptrnodo->elemento->arma->defense = 0;
  111.              if(ptrnodo->elemento->arma->speed > 0){
  112.                  ptrnodo->elemento->arma->speed = ptrnodo->elemento->arma->speed -3;
  113.              } else ptrnodo->elemento->arma->speed = 0;          
  114.             ptrnodo = ptrnodo->sig; //avanza al siguiente nodo
  115.          }else ptrnodo = ptrnodo->sig;
  116.          
  117.      }  
  118.  }
  119.  
  120.  void actualizarHeroe(TObject *hero){ //segun lo que lleve el heroe se actualiza los stats del heroe
  121.      TNodo *ptrnodo;
  122.      ptrnodo = hero->hero->cinturon->head; //apunta al primer nodo del cinturon
  123.      int i;
  124.      for(i = 1;i <= hero->hero->cinturon->max; i++){
  125.          if(ptrnodo->elemento != NULL && ptrnodo->elemento->id == 1){   //solo cuando es un arma y el elemnto no es null
  126.             hero->hero->atack = hero->hero->atack + ptrnodo->elemento->arma->atack;
  127.             hero->hero->defense = hero->hero->defense + ptrnodo->elemento->arma->defense;
  128.             hero->hero->speed = hero->hero->speed + ptrnodo->elemento->arma->speed;
  129.             ptrnodo = ptrnodo->sig; //avanza al siguiente nodo
  130.          } else ptrnodo = ptrnodo->sig;
  131.      }
  132.  }
  133.  
  134.  
  135.  void refrescarHeroe(TObject *hero){ //se actulaiza el heroe a su condicion original sin items
  136.      TNodo *ptrnodo;
  137.      ptrnodo = hero->hero->cinturon->head; //apunta al primer nodo del cinturon
  138.      int i;
  139.      for(i = 1;i <= hero->hero->cinturon->max; i++){
  140.          if(ptrnodo->elemento != NULL && ptrnodo->elemento->id == 1){   //solo cuando es un arma y el elemnto no es null
  141.             hero->hero->atack = hero->hero->atack - ptrnodo->elemento->arma->atack;
  142.             hero->hero->defense = hero->hero->defense - ptrnodo->elemento->arma->defense;
  143.             hero->hero->speed = hero->hero->speed - ptrnodo->elemento->arma->speed;
  144.             ptrnodo = ptrnodo->sig; //avanza al siguiente nodo
  145.          } else ptrnodo = ptrnodo->sig;
  146.      }
  147.  } //hace lo contrario a actualizarHeroe
  148.  
  149.  int usarPocion (TObject *hero, TItem *pocion){ //usa la pocion y destruye el item, recibe un item sacado con desapilar item o quitarcinturon
  150.     if (pocion->id == 2){  //verifica si de verdad es una pocion
  151.         hero->hero->health = hero->hero->health + pocion->consumible->consumible;
  152.         if(hero->hero->health > hero->hero->healthMax) hero->hero->health = hero->hero->healthMax;
  153.         TObject *poc = malloc(sizeof(TObject));
  154.         poc->item = pocion;
  155.         eliminarItem(poc); //esto fue estupidamente redundante
  156.         free(poc);
  157.         return 1; //tuvo exito
  158.     }else{
  159.         return 0; //no es una pocion
  160.     }  
  161.  }
  162.  
  163.  
  164. void moverHeroe(int i,int j){//estos deben ser pasado como punteros a enteros
  165.    
  166.    
  167.     //cambio de movimiento
  168.         //cabeza
  169.         gotoxy(i,j);
  170.         printf("%c",254);
  171.         //brazos
  172.         gotoxy(i-1,j+1);
  173.         printf("%c",200);
  174.         gotoxy(i,j+1);
  175.         printf("%c",177);
  176.         gotoxy(i+1,j+1);
  177.         printf("%c",188);
  178.         //piernas
  179.         gotoxy(i,j+2);
  180.         printf("%c",186);
  181.        
  182.     //elimianr el anterior
  183.         i=i-4;
  184.        
  185.         //cabeza
  186.         gotoxy(i,j);
  187.         printf(" ");
  188.         //brazos
  189.         gotoxy(i-1,j+1);
  190.         printf(" ");
  191.         gotoxy(i,j+1);
  192.         printf(" ");
  193.         gotoxy(i+1,j+1);
  194.         printf(" ");
  195.         //piernas
  196.         gotoxy(i,j+2);
  197.         printf(" ");
  198.    
  199. }
  200.  
  201. void entrarMenu(TObject *hero){
  202.     int opc = 0;
  203.     char c;
  204.    
  205.      printf(" /////////////////////MENU/////////////////////   \n");
  206.     while (opc != 1){
  207.         printf("¿que deseas hacer?  \n"  );
  208.         printf("1. usar a la mochila  \n"  );
  209.         printf("2. usar cinturon  \n"  );
  210.         printf("3. EXIT  \n"  );
  211.         c = getch();
  212.         if(c == '1'){ //cambio de pantalla
  213.             char c1 = '5';
  214.             while(c1 != 3){
  215.                 printf(" /////////////////////MENU/////////////////////   \n");
  216.                 printf("¿que quieres hacer con la mochila?  \n"  );
  217.                 printf("1. mover objeto al cinturon  \n"  );
  218.                 printf("2. eliminar objeto de mochila \n");
  219.                 printf("3. volver al menu anterior \n");
  220.                 c1 = getch(); // si c1 = 3 termina
  221.                 if(c1 == '1'){ //actualiza la pantalla
  222.  
  223.                     int pos = 11;
  224.                     int verif = 2;
  225.                     TItem *ptrItem;
  226.                     ptrItem = desapilarItem(hero->hero->mochila);
  227.                     while (verif!=1 && pos != 0){                      
  228.                         printf(" /////////////////////MENU/////////////////////   \n");
  229.                         printf("¿en que posicion del cinturon quieres guardar el item? \n");
  230.                         printf("ingrese cero para volver... \n");
  231.                         scanf("%d",&pos);
  232.                         verif = agregarCinturon(hero->hero->cinturon,ptrItem, pos);
  233.                         if(verif==0 && pos != 0)printf("no es posible agregar en este espacio \n");
  234.                         if( pos == 0)apilarItem(hero->hero->mochila, ptrItem); //para cuando no se hace nada
  235.                     }
  236.                     if(verif == 1 || pos == 0) c1='3'; // para salir
  237.                    
  238.                 }
  239.                 if(c1 == '2'){ //actualiza la pantalla
  240.                     TItem *ptrItem;
  241.                     TObject *ptrObj;
  242.                     ptrItem = desapilarItem(hero->hero->mochila);
  243.                     if(ptrItem!=NULL){
  244.                         ptrObj->id = 3;
  245.                         ptrObj->hero= NULL;
  246.                         ptrObj->monstruo = NULL;
  247.                         ptrObj->item = ptrItem;
  248.                         eliminarItem(ptrObj);
  249.                     }
  250.                     if (ptrItem==NULL) printf("no hay nada que eliminar");
  251.                     else  printf("se elimino el item!!");
  252.                     c1='3';
  253.                 }
  254.             }    
  255.         }
  256.         if(c == '2'){//actuaizar pantalla
  257.             char c2 = '6';
  258.             while(c2 != '5'){
  259.                 printf(" /////////////////////MENU/////////////////////   \n");
  260.                 printf("¿que quieres hacer en el cinturon?  \n"  );
  261.                 printf("1. mover objeto a otro espacio en el cintron \n"  );
  262.                 printf("2. guardar item a la mochila \n");
  263.                 printf("3. eliminar del cinturon \n");
  264.                 printf("4. usar pocion desde cinturon \n");
  265.                 printf("5. volver al menu anterior... \n");
  266.                 c2 = getch();
  267.                 if(c2=='1'){ ///actualizar pantalla
  268.                     int pos1;    
  269.                     int pos2;
  270.                     while(1){
  271.                         printf(" /////////////////////MENU/////////////////////   \n");
  272.                         printf("para salir ingrese cero \n"  );                        
  273.                         printf("Ingrese posicion del item que quiere mover  \n"  );
  274.                         scanf("%d",&pos1);
  275.                         if(pos1==0)break;
  276.                         printf("Ingrese la posicion destino  \n"  );
  277.                         scanf("%d",&pos2);
  278.                         if(pos2==0)break;
  279.                         TItem *ptrItem;
  280.                         ptrItem = quitarCinturon(hero->hero->cinturon, pos1);              
  281.                         int verif = agregarCinturon(hero->hero->cinturon,ptrItem,pos2) ;
  282.                         if(verif == 0){
  283.                             agregarCinturon(hero->hero->cinturon,ptrItem,pos1) ;
  284.                             printf("Ingrese posiciones validas, puede que no estes considerando la capacidad \n");
  285.                             //borrar la pantalla
  286.                         }
  287.                         else {                            
  288.                             break;
  289.                         }
  290.                     }///borrar pantalla actual
  291.                     (c2='5');              
  292.                 }
  293.                 if(c2=='2'){ //actualizar pantalla
  294.                     while(1){
  295.                         printf(" /////////////////////MENU/////////////////////   \n");
  296.                         printf("para salir ingrese cero \n" );
  297.                         printf("ingrese la posicion del item a guardar en la mochila \n"  );
  298.                         TItem *ptrItem;
  299.                         int pos1;
  300.                         scanf("%d",&pos1);
  301.                         if(pos1==0)break;
  302.                         ptrItem = quitarCinturon(hero->hero->cinturon, pos1);
  303.                         if(ptrItem != NULL){
  304.                             apilarItem(hero->hero->mochila, ptrItem);
  305.                             //actualizar pantalla
  306.                             printf("movido exitosamente \n");
  307.                             //borrar pantalla
  308.                             break;
  309.                         }else{//actializar pantalla
  310.                             agregarCinturon(hero->hero->cinturon,ptrItem,pos1);
  311.                             printf("ingresa una posicion correcta mierda!! \n");
  312.                         }
  313.                     }
  314.                     (c2='5');
  315.                 }
  316.                 if(c2=='3'){ //actualizar pantalla
  317.                     while(1){
  318.                         printf(" /////////////////////MENU/////////////////////   \n");
  319.                         printf("para salir ingrese cero \n" );
  320.                         printf("Ingrese la posicion del item que quiere eliminar  \n" );
  321.                         TItem *ptrItem;
  322.                         int pos1;
  323.                         scanf("%d",&pos1);
  324.                         if(pos1==0)break;
  325.                         ptrItem = quitarCinturon(hero->hero->cinturon, pos1);
  326.                         if(ptrItem != NULL){ //actualizar pantalla
  327.                             TObject *ptrObj;
  328.                             ptrObj->id = 3;
  329.                             ptrObj->hero= NULL;
  330.                             ptrObj->monstruo = NULL;
  331.                             ptrObj->item = ptrItem;
  332.                             eliminarItem(ptrObj);
  333.                             printf("se elimino correctamente \n");                            
  334.                             break;
  335.                             //borrar pantalla
  336.                         }else{
  337.                             agregarCinturon(hero->hero->cinturon,ptrItem,pos1);
  338.                             printf("aqui no hay nada, ingresa de nuevo la posicion \n");
  339.                         }
  340.                     }
  341.                     (c2='5');
  342.                 }
  343.                 if(c2=='4'){ //actualizar pantalla
  344.                     while(1){
  345.                         printf(" /////////////////////MENU/////////////////////   \n");
  346.                         printf("para salir ingrese cero \n" );
  347.                         printf("Ingrese la posicion de la pocion en el cinturon  \n" );
  348.                         TItem *ptrItem;
  349.                         int pos1;
  350.                         scanf("%d",&pos1);
  351.                         if(pos1==0)break;
  352.                         ptrItem = quitarCinturon(hero->hero->cinturon, pos1);
  353.                         if(ptrItem != NULL && ptrItem->id == 2){ //si es una pocion
  354.                             //actualizar pantalla
  355.                             usarPocion (hero, ptrItem);
  356.                             printf("a que eso te sienta bien \n");
  357.                             //borrar pantalla
  358.                             break;
  359.                            
  360.                         }else{
  361.                             //actualizar pantalla
  362.                             agregarCinturon(hero->hero->cinturon,ptrItem,pos1);
  363.                             printf("eso no es un pocion!! \n");
  364.                             //borrar pantalla
  365.                         }
  366.                     }
  367.                 }
  368.                
  369.             }
  370.         }
  371.        
  372.         if(c == 3) opc = 1; //sale del menu
  373.     }
  374.      
  375. }
  376.  
  377.  
  378.  void pintar(char nombre[],int nivel,int *animacion){
  379.      int i;
  380.      gotoxy(0,0);
  381.      printf("                                 JUEGO DE AVENTURA \n");
  382.      printf("Nombre del Jugador: %s",nombre);                        
  383.      printf("                                   Nivel :%d\n",nivel);
  384.          
  385.      //Lineas horizontales
  386.      for (i=2;i<78;i++){
  387.          gotoxy(i,3);
  388.          printf("%c",205);
  389.          gotoxy(i,23);
  390.          printf("%c",205);
  391.      }
  392.      //Lineas Verticales
  393.      for (i=4;i<23;i++){
  394.          gotoxy(2,i);
  395.          printf("%c",186);
  396.          gotoxy(77,i);
  397.          printf("%c",186);
  398.      }
  399.      
  400.      //Esquinas
  401.      gotoxy(2,3); printf("%c",201);
  402.      gotoxy(2,23); printf("%c",200);
  403.      gotoxy(77,3); printf("%c",187);
  404.      gotoxy(77,23); printf("%c",188);
  405.      
  406.      
  407.      //Pasto
  408.      for (i=3;i<77;i++){
  409.          gotoxy(i,21);
  410.          printf("%c",176);
  411.          gotoxy(i,22);
  412.          printf("%c",177);
  413.      }
  414.      
  415.      //Nubes
  416.      int n; i=7;
  417.      for (n=20;n<26;n++){
  418.              gotoxy(n,i);
  419.              printf("%c",64);
  420.              gotoxy(n,i+1);
  421.              printf("%c",64);
  422.              gotoxy(n,i+2);
  423.              printf("%c",64);
  424.                        
  425.       }
  426.      
  427.      for (n=20+20;n<26+20;n++){
  428.              gotoxy(n,i);
  429.              printf("%c",64);
  430.              gotoxy(n,i+1);
  431.              printf("%c",64);
  432.              gotoxy(n,i+2);
  433.              printf("%c",64);
  434.                        
  435.       }
  436.      //arbol
  437.      int k,a;
  438.      if (*animacion==0){
  439.      
  440.      
  441.         for (k=60;k<67;k++){
  442.          gotoxy(k,15);
  443.          printf("%c",177);
  444.          gotoxy(k,16);
  445.          printf("%c",177);
  446.          gotoxy(k,17);
  447.          printf("%c",177);
  448.          if (k==62 || k==63 || k==64){
  449.              gotoxy(k,18);
  450.              printf("%c",186);
  451.              gotoxy(k,19);
  452.              printf("%c",186);
  453.              gotoxy(k,20);
  454.              printf("%c",186);
  455.          }
  456.          
  457.         }
  458.      }else if ((*animacion)<3){
  459.          srand(time(NULL));//randomize
  460.          int arbol=176,tronco=179;
  461.          for(a=0;a<=(*animacion);a++){
  462.             for (k=60-a*10;k<67-a*10;k++){
  463.                 gotoxy(k,15);
  464.                 printf("%c",arbol);//178,177,176
  465.                 gotoxy(k,16);
  466.                 printf("%c",arbol);
  467.                 gotoxy(k,17);
  468.                 printf("%c",arbol);
  469.                 if (k==(62-a*10) || k==(63-a*10) || k==(64-a*10)){
  470.                 gotoxy(k,18);
  471.                 printf("%c",tronco);//186,240,169,179
  472.                 gotoxy(k,19);
  473.                 printf("%c",tronco);
  474.                 gotoxy(k,20);
  475.                 printf("%c",tronco);
  476.                 }
  477.                
  478.             }
  479.             int t[4]={240,169,179,186};
  480.             int r=rand() % 4;
  481.             tronco=t[r];
  482.             if (arbol==178 ) arbol=176;
  483.                 else arbol++;
  484.         }  
  485.          /*if (*animacion!=0)
  486.            (*animacion)=0;*/
  487.      } else if ((*animacion)>=3 && (*animacion)<5 ){
  488.          int t=16,p,b=30,g;
  489.            //cueva
  490.          for (g=0;g<2;g++){
  491.             int cont=1;
  492.             gotoxy(b,t);
  493.             printf("%c",176);
  494.             for (p=t;p<22;p++){
  495.                 gotoxy(b-cont,p);
  496.                 printf("%c",176);
  497.                 gotoxy(b+cont,p);
  498.                 printf("%c",176);
  499.                 cont++;
  500.             }
  501.             b=b+40;
  502.          }
  503.          //arbol
  504.          for (k=50;k<57;k++){
  505.          gotoxy(k,15);
  506.          printf("%c",177);
  507.          gotoxy(k,16);
  508.          printf("%c",177);
  509.          gotoxy(k,17);
  510.          printf("%c",177);
  511.          if (k==52 || k==53 || k==54){
  512.              gotoxy(k,18);
  513.              printf("%c",186);
  514.              gotoxy(k,19);
  515.              printf("%c",186);
  516.              gotoxy(k,20);
  517.              printf("%c",186);
  518.          }
  519.          
  520.      }
  521.          
  522.      }
  523.      else if (*animacion==5){
  524.          (*animacion)=0;
  525.             //aves
  526.                 //203,40,41
  527.          gotoxy (60,6);
  528.          printf("%c",157);
  529.          gotoxy(54,10);
  530.          printf("%c",157);
  531.          gotoxy(68,8);
  532.          printf("%c",157);
  533.          gotoxy(60,15);
  534.          printf("%c",157);
  535.          gotoxy(60,12);
  536.          printf("%c",157);
  537.          gotoxy(55,14);
  538.          printf("%c",157);
  539.          gotoxy(65,13);
  540.          printf("%c",157);
  541.          
  542.      }
  543. }
  544.  
  545. void eliminarMapa(TObject mapa[E]){
  546.      int i;
  547.      for (i=0;i<E;i++){
  548.          free(mapa[i].hero);
  549.          free(mapa[i].item);
  550.          free(mapa[i].monstruo);
  551.      }
  552.  }
  553.  
  554.  
  555.  
  556.  
  557.  ///colocarObjeto soporta cualquier arreglo por lo que se tiene que colocar bien los arreglos correspondiente al objeto
  558.  
  559.  int colocarObjeto(TObject *objeto,int nivel,TObject arr[]){ /// desde el arreglo cargado desde
  560.      //los archivos se seleccinan aleatoriamente dependiendo el nivel
  561.      int lmtInf, lmtSup ;
  562.      int random;
  563.      if(objeto->id != 0) return 0; //esta lleno el espacio y no se puede agregar nada
  564.      
  565.      lmtInf = (nivel-2)*3;  
  566.      if (lmtInf < 0) {
  567.          lmtInf = 0;
  568.          lmtSup = 2;
  569.      } else  lmtSup = lmtInf + 5;  /// se selecciona en nivel 1 del 0 al 3, nivel 2 del 0 a 5
  570.       // nivel 3 del 3 al 8 , nivel 4 del 6 a 11 , nivel 5 del 9 a 14
  571.      
  572.      random = lmtInf + (rand() % (lmtSup - lmtInf));
  573.      
  574.      objeto = arr[random];
  575.      return 1;
  576.      
  577.  }
  578.  
  579.  void crearMapasAleatorios(TObject mapaxnivel[E],int nivel,char heroe[],TObject* Hero ){
  580.     srand(time(NULL));//randomize
  581.     int e,p,o,pos;//enemigos y posiciones
  582.     TObject *mapa[E] = malloc((E+1)*sizeof(TObject));//E cantidad de espacios en el mapa, creando un mapa con punteros a objetos en cada posicion
  583.    
  584.      int i;
  585.      for(i=0;i<E;i++){
  586.          if (i==0) {
  587.              crearHeroe(Hero,heroe);//El heroe debe estar en el primer bloque //correguir
  588.              mapa[i]= Hero;
  589.          }else {
  590.          mapa[i]->id=0; //cada parte del mapa lo inicializamos como vacio
  591.          mapa[i]->hero=NULL;
  592.          mapa[i]->item=NULL;
  593.          mapa[i]->monstruo=NULL;
  594.          }        
  595.      }
  596.      
  597.      /// soporta solo hasta 5 niveles
  598.      //Cantidad de enemigos
  599.      e=(rand() % 2*Factor) + 2*nivel; // aumentar ratio de aparcion
  600.      
  601.      //Posiones
  602.      p =  (10 - nivel) + (rand() % Factor) ;  //disminuye el ratio de aparicion ,
  603.      //colocar enemigos
  604.      // cantidad de armas
  605.      o = (10 - nivel) - (rand() % 2*Factor);
  606.      
  607.                 ////////////////////////////////
  608.      TObject arrMonst[MAX];
  609.      cargarMonstruosGen(arrMonst);
  610.      
  611.      
  612.      int j=0; int verif;
  613.      while (j<e){//aqui coloco a los mounstruos en el mapa
  614.         pos= (rand() % (E-2) ) + 2 ;
  615.        
  616.        
  617.         verif = colocarObjeto(mapa[pos],nivel,arrMonst); // si existe lo carga a mapa[pos]]
  618.        
  619.         if(verif==1)j++; //si verif 0 entonces no se coloco satisfactoriamente y se vuelve a ha
  620.                     // invocar el mismo bucle
  621.      }
  622.      
  623.      j=0;
  624.      //colocar posiones
  625.      
  626.      TObject arrPociones[MAX];//Anderson puso esto porque me salia error
  627.      cargarPocionesGen(arrPociones);
  628.      while (j<p){// coloco las pociones en el mapa
  629.         pos= (rand() % (E-2) ) + 2 ;
  630.         verif = colocarObjeto(mapa[pos],nivel,arrPociones);//sacar del archivo
  631.         if(verif==1)j++;
  632.      }
  633.      // agregamos items
  634.      TObject arrArmas[MAX];//Anderson puso esto porque me salia error
  635.      cargarArmasGen(arrArmas);
  636.      while (j<o){//coloca las armas en el mapa
  637.         pos= (rand() % (E-2) ) + 2 ;
  638.         verif = colocarObjeto(mapa[pos],nivel,arrArmas);//sacar del archivo
  639.         if(verif==1)j++;
  640.      }
  641.      
  642.      
  643.      //generamos el mapa
  644.      i=0;
  645.      for (i=0;i<E;i++){
  646.          mapaxnivel[i].id = mapa[i]->id;
  647.          mapaxnivel[i].hero = mapa[i]->hero;
  648.          mapaxnivel[i].item = mapa[i]->item;
  649.          mapaxnivel[i].monstruo = mapa[i]->monstruo;
  650.      }
  651.  }
  652.  
  653. void estoEsGuerra(THero* hero,TMonst* mons,int* est ){
  654.     int turno,pos;
  655.     int opcAcc;
  656.     int opcPoci;
  657.     TItem* item;
  658.     char C;
  659.     //graficamos los dibujitos del heroe y el moustruo
  660.     // graficaCabecera(hero,mons);//grafica la vida de los contrincates y sus demas skills
  661.     if (hero->speed > mons->speed)
  662.         turno=0;//pares para que ataque heroe
  663.     else
  664.         turno=1;//impares para que ataque monstruo
  665.     //habra un menu en el que te saldran las opciones
  666.     while(hero->health > 0 && mons->health>0 ){
  667.        
  668.         if (turno % 2==0){
  669.             //colocar el MENU de seleccion entre atacar y curarse
  670.             printf("Selecciones que accion toma");
  671.             C=getch();                    
  672.  
  673.             if (C=='1'){//eligio atacar
  674.                 //degenera la vida del monstruo
  675.                 mons->health=( mons->health )-((hero->atack - mons->defense)*(hero->atack >= mons->defense)+5*(hero->atack < mons->defense));
  676.                         //actualiza graficamente la vida del monstruo
  677.             }
  678.             else if (C=='2'){//elijo seleccionar item
  679.                 //siempre tendremos la leyenda disponible para visualizar los numeros al que corresponden ciertas pociones
  680.                 printf("Seleccione la pocion que necesite");//esto ira en el cuadro de texto
  681.                 C=getch();
  682.                 //limpiar el cuadro de texto
  683.                 pos=int(C-48);
  684.                
  685.                 while(1){
  686.                     item=quitarCinturon(hero->cinturon, pos);//quitamos al item de la correa
  687.                     if (item==NULL || item->id==1)
  688.                         printf("No seas pendejo, elije una pocion por favor");
  689.                     else{
  690.                         //limpiar cuadro de texto
  691.                         break;
  692.                     }
  693.                 }
  694.                 usarPocion (TObject *hero, TItem *item);// con esto actualizamos al heroe, enviamos un item que es de tipo pocion
  695.                
  696.                            
  697.             }    
  698.            
  699.         }
  700.         else{
  701.              hero->health=( hero->health )-((mons->atack - hero->defense)*(mons->atack >= hero->defense)+5*(mons->atack < hero->defense));
  702.            
  703.            
  704.         };
  705.         turno++;
  706.        
  707.        
  708.     }
  709.     if (hero->health==0)//pierde la guerra
  710.         //en el cuadro de mensaje colocamos has muerto
  711.         *est=0;
  712.     else{//aca gana la guerra
  713.         //en el cuadro de mensaje colocamos has ganado
  714.         refrescarHeroe(hero);
  715.         actualizarItem(hero);
  716.         actualizarHeroe(hero);
  717.     }
  718.     //en el cuadro de mensaje colocamos "presiona enter"
  719.     C=getch;
  720.     if (C==13){
  721.         //borra el cuadro de mensaje
  722.        
  723.         break;// solo hemos colocado esto temporalmente para queno haya error
  724.        
  725.        
  726.        
  727.     }
  728.        
  729. }
  730. void recogerItems(TObject* hero,TObject* objectnew){
  731.     char C;
  732.    
  733.     //gotoxy a pantalla de mensaje de texto
  734.     printf("Has encontrado un item, que perra que eres!!!");
  735.     if (objectnew->item->id==1){
  736.         printf("(Es un arma)");
  737.         printf("Caracteristicas:\n");
  738.         printf("Nombre: ",objectnew->item->name);
  739.         printf("Peso: ",objectnew->item->peso);
  740.         printf("Ataque:",objectnew->item->arma->atack);
  741.         printf("Defensa:",objectnew->item->arma->defense);
  742.         printf("Velocidad:",objectnew->item->arma->speed);
  743.  
  744.     }
  745.  
  746.     else{
  747.         printf("(Es una pocion)");
  748.         printf("Caracteristicas:\n");
  749.         printf("Nombre: ",objectnew->item->name);
  750.         printf("Peso: ",objectnew->item->peso);
  751.         printf("Curabilidad:",objectnew->item->consumible->consumible);
  752.  
  753.     }
  754.  
  755.     printf("\n\n\n");    
  756.    
  757.     while(1){
  758.             //imprime esto debajo de las caracteristicas de item encontrado
  759.         printf("Opciones:");
  760.         printf("1. Guardar\n");
  761.         printf("2. Salir \n");
  762.         C=getch();
  763.         if (C=='1'){
  764.             //borra lo escrito en pantalla de texto a partir de Opciones
  765.             printf("Elegir lugar en el que se va a guardar:\n");
  766.             printf("1. Mochila\n");
  767.             printf("2. Correa\n");
  768.             printf("3. Volver\n");
  769.  
  770.             C=getch();
  771.  
  772.             if (C=='1'){
  773.                 void apilarItem(hero->hero->mochila, objectnew.item);
  774.                 //borro todo
  775.                 printf("El item %s fue guardado en la mochila",objectnew.item->name);
  776.                 printf("\nPresiona Enter para volver al juego");
  777.                 C=getch();
  778.                 if (C==13){
  779.                     //borra el cuadro de mensajes
  780.                     //regresa a la pantalla principal del juego
  781.  
  782.                 }
  783.  
  784.             }
  785.             else if (C=='2'){
  786.                 int pos;
  787.                 //borro la pantalla de mensaje de texto apartir de Elegir en el lugar que se va a guardar
  788.                 printf("Ingrese la posicion de la mochila a la que desee ingresar");
  789.                 scanf("%d",&pos);
  790.                 while(1){
  791.                     if (agregarCinturon(hero->hero->cinturon,objectnew->item,pos )){
  792.                     objectnew->id=0;
  793.                     objectnew->NULL;
  794.                     break;
  795.  
  796.                     }
  797.                     else
  798.                         printf("Ingrese una nueva posicion:");scanf("%d",&pos);
  799.  
  800.                 }
  801.                 printf("El item %s fue guardado en la correa",objectnew.item->name);
  802.                 printf("\nPresiona Enter para volver al juego");
  803.                 C=getch();
  804.                 if (C==13){
  805.                     //borra el cuadro de mensajes
  806.                     //regresa a la pantalla principal del juego
  807.  
  808.                 }
  809.  
  810.  
  811.             }
  812.             else if (C=='3'){
  813.                 //borra el mensaje actual desde "Elegir lugar en el que se va a guardar"
  814.  
  815.             }
  816.  
  817.            
  818.         }
  819.         else if (C=='2'){
  820.             //borramos al item de la posicion
  821.             objectnew->id=0;
  822.             objectnew->NULL;
  823.             //borra el cuadro de mensajes
  824.             //regresa a la pantalla principal del juego
  825.             break;
  826.  
  827.         }
  828.    
  829.        
  830.     }
  831.  
  832.    
  833.        
  834.    
  835.     // cuando encontramos un item, lo comunicamos por medio del cuadro de texto
  836.                 // ahi generamos un menu en el cuadro de texto como lo siguiente:
  837.                 ///////////Has encontrado un item, que perra que eres!!!/////////////
  838.                 //Imprimir caracteristicas de item encontrado
  839.                 //Opciones:
  840.                 //1.Guardar
  841.                 //2.Salir
  842.                 //Si elige Guardar, borra la pantalla del cuadro de texto, y escribe a donde lo quiere guardar:
  843.                 //1.1 En la mochila
  844.                 //1.2 En la correa        
  845.                 //Si se guarda en la mochila lo hace altoque y elimina la pantalla de menu y manda un mensaje de objeto guardado
  846.                 //Si se guarda en la correa, te manda en la pantalla un texto "Ingrese posicion a guardar
  847.                 //si no se puede guardar te volvera a salir "ingrese la posicion a la que desee guardar"
  848.                 //1.3 Volver al menu anterior, borra lo que este en cuadro de texto y escribe el menu anterior gracias al While
  849.                 //Si elige salir borra lo que este en el cuadro de texto
  850.                 //elige entre tres opciones para cargar en la mochila, en la correa o no hacer nada
  851.                 // en caso de que no quiera hacer nada se tendra que eliminar el item de esa posicion
  852.                 //para que podamos colorcar el puntero al heroe que pisara esa nueva posicion
  853.                 //y se prepara para simplemente pisar ese lugar donde estaba el item, borrando el item de la posicion
  854.    
  855.                
  856.    
  857.    
  858. }
  859.  
  860. int main(int argc, char** argv) {
  861. /*
  862.  Debemos tomar en cuenta que por cada ves que salgamos de batallas o salgamos de modos de seleccion de mochila debemos
  863.  * volver a representar el mapa donde se quedo, ademas contaremos con un area de cuadro de texto que brindara
  864.  * informacion oportuna de acuerdo a lo que esta sucediendo
  865. */
  866.    
  867.     TObject mapa[E];// es un arreglo de estructuras tipo objetos con maximo E
  868.     int r;
  869.     for (r=0;r<E;r++){//aca empieza a reservar espacio para los apuntadores de cada elemento del arreglo ya que pueden ir cualquiera de los 3
  870.         mapa[r].hero=malloc(sizeof(THero));
  871.         mapa[r].item=malloc(sizeof(TItem));
  872.         mapa[r].monstruo=malloc(sizeof(TMonst));
  873.     }
  874.     TObject *Hero = malloc(sizeof(TObject));
  875.     char C;
  876.     char nombre[N];
  877.     int i=4,j=18,nivel=1;//comenzamos en el nivel 1
  878.     int animacion=0;//Le da animacion al campo
  879.     printf("Ingrese el nombre del jugador :");
  880.     gets(nombre);//obtenemos el nombre
  881.     system("cls");
  882.     //pintar(nombre,nivel);
  883.     gotoxy(i,j);
  884.     moverHeroe(i,j);
  885.     int estadoJuego=1; //1 vivo 0 muerto
  886.     int mov=0;//movimiento del arreglo a medida que el jugador se mueve
  887.     crearMapasAleatorios(mapa,nivel,nombre,Hero);//iniciamos el juego
  888.     pintar(nombre,nivel,&animacion);
  889.     while (estadoJuego){
  890.         //pintar(nombre,nivel,&animacion); //se nota un poco la impresion pero no debria notarse
  891.         C = getch();
  892.         //system("cls");
  893.         if (C==77){//DERECHA
  894.             mov++;
  895.             i=i+4;//para moverse mas
  896.            //hemos movido el mu;equito a la nueva posicion a la que entraria, pero aun no hemos hecho la modificacion
  897.            // a nivel de punteros, eso esta bien!!!
  898.             if (i<76){
  899.             gotoxy(i,j);
  900.             moverHeroe(i,j);
  901.             }else {
  902.             animacion++;    
  903.             gotoxy(4,j);
  904.             moverHeroe(4,j);
  905.             i=4;
  906.            
  907.             /*gotoxy(75,j);
  908.             moverHeroe(75,j);
  909.             i=75;*/
  910.             }
  911.           if (mov != E){  
  912.             if (mapa[mov].id==0){//vaci0
  913.                 estadoJuego=1;//no hace nada
  914.                 C=getch();
  915.                 if (C==32)
  916.                     entrarMenu(Hero);
  917.                
  918.             }else if (mapa[mov].id==2){//Enemigo
  919.                 //Manda mensaje a la pantalla auxiliar que empezara el dududuelo,se usa gotoxy
  920.                
  921.                 estoEsGuerra(Hero,mapa[mov].monstruo,&estadoJuego);
  922.                 eliminarMonstruo(mapa[mov]);// elimino al monstruo del mapa
  923.                
  924.                 // aqui volvemos a mostrar el mapa
  925.                
  926.             }else if (mapa[mov].id==3){//Consumible o Arma
  927.                
  928.  
  929.                 recogerItems(Hero,&mapa[mov]);
  930.                
  931.             }
  932.            
  933.             if (estadoJuego){//Si continua y todavia no pierde
  934.                 mapa[mov].id=mapa[mov-1].id;//Nos movemos
  935.                 mapa[mov].hero=mapa[mov-1].hero;
  936. /*
  937.  *             Creo que estos 2 no deberian estarse moviendo
  938.                 mapa[mov].item=mapa[mov-1].item;
  939.                 mapa[mov].monstruo=mapa[mov-1].monstruo;
  940. */              //anteriormente solo estaba el heroe por lo que solo ponemos en nulo lo anterior    
  941.                 mapa[mov-1].id=0;//el casillero anterior queda vacio
  942.                 mapa[mov-1].hero=NULL;
  943.             //
  944.             }else{
  945.                 //eliminarMapa(mapa);
  946.                 system("cls");
  947.                 gotoxy(36,12);
  948.                 printf("GAME OVER\n");
  949.                 gotoxy(36,15);
  950.                 printf("Deseas jugar de nuevo ? (S/N)");
  951.                 char g=getchar();
  952.                 if (g=='s' || g=='S'){
  953.                     estadoJuego=1;
  954.                     nivel=1;
  955.                     mov=0;
  956.                 }else {
  957.                     estadoJuego=0;//fin del juego
  958.                 }
  959.             }
  960.           }else {
  961.               estadoJuego=1;
  962.               nivel++;
  963.              
  964.               //eliminarMapa(mapa);
  965.               mov=0;
  966.               system("cls");
  967.               gotoxy(36,12);
  968.               printf("Nivel %d\n",nivel);
  969.               pintar(nombre,nivel,&animacion);//Si pongo la impresion aca , cuando el personaje pasa se borra un poco el arbol pqeo el movimiento es mejor
  970.               i=4;
  971.               j=18;
  972.               //crearMapasAleatorios(&mapa[E],nivel,nombre);//iniciamos el juego
  973.           }  
  974.        
  975.         } /*else
  976.         if (C==75) {//IZQUIERDA
  977.         i=i-2;//para moverse mas
  978.         if (i>3){
  979.         gotoxy(i,j);
  980.         moverHeroe(i,j);
  981.         }else {
  982.             gotoxy(4,j);
  983.             moverHeroe(4,j);
  984.             i=4;
  985.         }
  986.         } else
  987.         if (C==72) {//ARRIBA
  988.         j=j-2;//para moverse mas
  989.         if (j>3){
  990.         gotoxy(i,j);
  991.         moverHeroe(i,j);
  992.         }else {
  993.             gotoxy(i,4);
  994.             moverHeroe(i,4);
  995.             j=4;
  996.         }
  997.         }else
  998.         if (C==80) {//ABAJO
  999.         j=j+2;//para moverse mas
  1000.         if (j<19){
  1001.         gotoxy(i,j);
  1002.         moverHeroe(i,j);
  1003.         }else {
  1004.             gotoxy(i,18);
  1005.             moverHeroe(i,18);
  1006.             j=18;
  1007.         }
  1008.     }*/ else if (C==27){
  1009.              
  1010.             eliminarMapa(mapa);
  1011.             system("cls");
  1012.             break;
  1013.         }
  1014.         else {
  1015.             gotoxy(i,j);
  1016.             moverHeroe(i,j);
  1017.       }
  1018.    
  1019.     }
  1020.    
  1021.     return 0;
  1022. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!