daily pastebin goal
16%
SHARE
TWEET

Untitled

a guest Nov 21st, 2017 56 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdbool.h>
  3. #include "fauces.h"
  4.  
  5.  
  6.  
  7. #define ARCHIVO_ATAQUES "ataques_por_vulnerabilidad.txt"
  8. #define ARCHIVO_RESUMEN "resumen_ataques.txt"
  9.  
  10. #define READ_BIN "rb"
  11. #define WRITE_BIN "wb"
  12. #define READ "r"
  13. #define WRITE "w"
  14.  
  15. #define LINEA_ATAQUE "%c;%c;%i\n" //H;X;5
  16.  
  17. #define LINEA_RESUMEN "%c;%i;%i\n"
  18.  
  19. #define MAX_ESCUADRONES 26
  20. #define MAX_VUL 7
  21.  
  22.  
  23.  
  24. #define MAX 50
  25.  
  26. typedef struct linea_ataque{
  27.   char elemento;
  28.   char codigo;
  29.   int naves_baja;
  30. } linea_ataque_t;
  31.  
  32.  
  33. void procesar_escuadron_alta(squads_t *squad, char codigo_escuadron, int cantidad_naves,
  34.    char elemento_ataque, int potencia_ataque){
  35.      (*squad).codigo_escuadron = codigo_escuadron;
  36.      (*squad).cantidad_naves = cantidad_naves;
  37.      (*squad).elemento_ataque = elemento_ataque;
  38.      (*squad).potencia_ataque = potencia_ataque;
  39. }
  40. void ordenar_escuadrones(squads_t squads[MAX_ESCUADRONES], int tope){
  41.   int i,j=0;
  42.   squads_t aux;
  43.   bool ordenado;
  44.   ordenado = true;
  45.   while ((j<tope) &&ordenado){
  46.     ordenado = false;
  47.     for (i=0;i<tope-1;i++){
  48.       if (squads[i].elemento_ataque > squads[i+1].elemento_ataque){
  49.         aux = squads[i];
  50.         squads[i] = squads[i+1];
  51.         squads[i+1] = aux;
  52.         ordenado = true;
  53.       }
  54.     }
  55.     j++;
  56.   }
  57. }
  58. bool abrir_archivos_ataques(FILE** escuadrones, FILE** vulnerabilidades, FILE** ataques_por_vulnerabilidad, FILE** resumen){
  59.  
  60.   *ataques_por_vulnerabilidad = fopen(ARCHIVO_ATAQUES,READ);
  61.   *escuadrones = fopen(RUTA_MAESTRO_ESCUADRONES,READ_BIN);
  62.   *vulnerabilidades = fopen(RUTA_MAESTRO_VULNERABILIDADES,READ_BIN);
  63.   *resumen = fopen(ARCHIVO_RESUMEN,WRITE);
  64.   if (!resumen){
  65.     fclose(*ataques_por_vulnerabilidad);
  66.     fclose(*escuadrones);
  67.     fclose(*vulnerabilidades);
  68.     return false;
  69.     }
  70.   return true;
  71.   }
  72. void cerrar_archivos_ataques(FILE** escuadrones, FILE** vulnerabilidades, FILE** ataques_por_vulnerabilidad, FILE** resumen_ataques){
  73.   fclose(*escuadrones);
  74.   fclose(*vulnerabilidades);
  75.   fclose(*ataques_por_vulnerabilidad);
  76.   fclose(*resumen_ataques);
  77. }
  78.  
  79. void cargar_escuadrones(squads_t escuadrones[MAX_ESCUADRONES], FILE* maestro_escuadrones, int *tope_escuadrones){
  80.     squads_t escuadron_actual;
  81.     fseek(maestro_escuadrones,0,SEEK_SET);
  82.     for (int i=0;fread(&escuadron_actual,sizeof(squads_t),1,maestro_escuadrones);i++){
  83.         escuadrones[i] = escuadron_actual;
  84.         (*tope_escuadrones)++;
  85.     }
  86. }
  87. void generar_resumen_ataques(FILE* maestro_escuadrones, FILE* maestro_vulnerabilidades, FILE* ataques_por_vulnerabilidad, FILE* resumen_ataques,bool *fauces_destruida){
  88.   int ataque, bajas;
  89.   int turnos_resistencia, turnos_durabilidad;
  90.   int tope_escuadrones = 0;
  91.   int i = 0;
  92.   linea_ataque_t linea_ataque;
  93.   vulnerabilidad_t vulnerabilidad_actual;
  94.   squads_t escuadrones[tope_escuadrones];
  95.  
  96.   cargar_escuadrones(escuadrones, maestro_escuadrones,&tope_escuadrones);
  97.   ordenar_escuadrones(escuadrones, tope_escuadrones);
  98.   printf("\tEscuadrones ordenados por elemento \n");
  99.   for(int b=0;b<tope_escuadrones;b++){
  100.     printf("%c %i %c %i\n",escuadrones[b].codigo_escuadron,escuadrones[b].cantidad_naves,escuadrones[b].elemento_ataque,escuadrones[b].potencia_ataque);
  101.   }
  102.  
  103.   //Leo el primer elemento_actual de archivo_ataques y vulnerabilidades
  104.   fscanf(ataques_por_vulnerabilidad,LINEA_ATAQUE,&linea_ataque.elemento,&linea_ataque.codigo,&linea_ataque.naves_baja);
  105.   fread(&vulnerabilidad_actual,sizeof(vulnerabilidad_t),1,maestro_vulnerabilidades);
  106.  
  107.   while (!feof(ataques_por_vulnerabilidad)){
  108.     printf("\t\t 1er While\n");
  109.     turnos_resistencia = 0;
  110.     printf("turnos_resistencia: %i\n",turnos_resistencia);
  111.     turnos_durabilidad = 0;
  112.     printf("turnos_durabilidad: %i\n",turnos_durabilidad);
  113.  
  114.     while(!feof(ataques_por_vulnerabilidad) && vulnerabilidad_actual.elemento == linea_ataque.elemento){
  115.       printf("\t\t 2do While\n");
  116.  
  117.       printf("vulnerabilidad_actual.elemento: %c\n",vulnerabilidad_actual.elemento);
  118.       printf("linea_ataque: %c;%i;%i\n",linea_ataque.elemento,linea_ataque.codigo,linea_ataque.naves_baja);
  119.  
  120.       bajas = 0;
  121.       printf("Bajas:%i \n",bajas);
  122.  
  123.       while(!feof(ataques_por_vulnerabilidad) && (vulnerabilidad_actual.elemento == linea_ataque.elemento) && escuadrones[i].codigo_escuadron==linea_ataque.codigo){
  124.         printf("\t\t 3er While\n");
  125.         printf("Elemento: %c, Codigo: %c",linea_ataque.elemento,linea_ataque.codigo);
  126.  
  127.         ataque = (escuadrones[i].cantidad_naves - bajas) * (escuadrones[i].potencia_ataque);
  128.         printf("ataque: %i\n",ataque);
  129.  
  130.         if (vulnerabilidad_actual.resistencia > 0){
  131.           vulnerabilidad_actual.resistencia -= ataque;
  132.           printf("Resistencia: %i\n",vulnerabilidad_actual.resistencia);
  133.           }
  134.         if (vulnerabilidad_actual.resistencia<0 && vulnerabilidad_actual.durabilidad>0){
  135.           vulnerabilidad_actual.durabilidad -= ataque;
  136.  
  137.           printf("Durabilidad: %i\n",vulnerabilidad_actual.durabilidad);
  138.           }
  139.         bajas += linea_ataque.naves_baja;
  140.         fscanf(ataques_por_vulnerabilidad,LINEA_ATAQUE,&linea_ataque.elemento,&linea_ataque.codigo,&linea_ataque.naves_baja);
  141.         }
  142.  
  143.       i++;
  144.     }
  145.     if (vulnerabilidad_actual.resistencia>0){
  146.       turnos_resistencia = -1;
  147.       }
  148.     if (vulnerabilidad_actual.durabilidad>0){
  149.       turnos_durabilidad = -1;
  150.       }
  151.     if(vulnerabilidad_actual.durabilidad>0 || vulnerabilidad_actual.resistencia>0){
  152.       *fauces_destruida = false;
  153.     }
  154.     printf("Linea a escribir:\n%c;%i;%i\n",vulnerabilidad_actual.elemento,turnos_resistencia,turnos_durabilidad);
  155.     fprintf(resumen_ataques,LINEA_RESUMEN,vulnerabilidad_actual.elemento,turnos_resistencia,turnos_durabilidad);
  156.     fread(&vulnerabilidad_actual,sizeof(vulnerabilidad_t),1,maestro_vulnerabilidades);
  157.   }
  158. }
  159.  
  160. bool realizar_ataques(char* archivo_ataques,char* archivo_resumen, bool* fauces_destruida){
  161.   //Leo el archivo
  162.   FILE* maestro_squads;
  163.   FILE* maestro_vulnerabilidades;
  164.   FILE* ataques_por_vulnerabilidad;
  165.   FILE* resumen_ataques;
  166.  
  167.   if (!abrir_archivos_ataques(&maestro_squads,&maestro_vulnerabilidades,&ataques_por_vulnerabilidad,&resumen_ataques)){
  168.     return false;
  169.   }
  170.   generar_resumen_ataques(maestro_squads,maestro_vulnerabilidades,ataques_por_vulnerabilidad,resumen_ataques,fauces_destruida);
  171.   cerrar_archivos_ataques(&maestro_squads,&maestro_vulnerabilidades,&ataques_por_vulnerabilidad,&resumen_ataques);
  172.   return true;
  173. }
  174.  
  175. int main(){
  176.   char archivo_ataques,archivo_resumen;
  177.   bool fauces_destruida = true;
  178.   realizar_ataques(ARCHIVO_ATAQUES,ARCHIVO_RESUMEN,&fauces_destruida);
  179.   return 0;
  180. }
RAW Paste Data
Top