Load All

/*
 * File:   main.c
 * Author: Alvaro
 *
 * Created on 20 de junio de 2015, 10:55 AM
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 30
#define MAXCAD 20

/*
 *
 */
typedef struct arma{
    int atack;
    int defense;
    int speed;
}TWpn;

typedef struct consumible{//son las pociones
    int consumible;
}TUse;


typedef struct item{//es la clase a la que pertenecen las armas y los consumibles
    int id;
    char name[30];
    int peso;
    TWpn *arma;
    TUse *consumible;
}TItem;



typedef struct nodo{//nodo para la mochila (pila) y tambien nodo para la correa(lista doblemente enlazada)
    struct nodo *sig;
    struct nodo *ant;
    TItem *elemento;
    int capacidad;
}TNodo;

typedef struct Monstruo{//es el tipo mounstruo
    char name[30];
    int health;
    int atack;
    int defense;
    int speed;
}TMonst;

typedef struct cinturon{//es la correa que se usa como lista doblemente enlazada y usa punteros a nodos para el head y tail
    int max;
    int cant;
    TNodo *head;
    TNodo *tail;
}TBelt;

typedef struct mochila{// es la mochila que se usa como pila y usa puntero a nodo para su cima
    TNodo *cima;
}TBag;

typedef struct hero{ //es el heroe y además de sus caracteristicas puede poseer una mochila y un cinturon
    char name[30];
    int health;
    int healthMax;
    int atack;
    int defense;
    int speed;
    TBag *mochila;
    TBelt *cinturon;
}THero;

typedef struct objeto{ //Tipo objeto es la clase que alberga a los heroes mounstruos e items
    int id;
    THero *hero;
    TMonst *monstruo;
    TItem *item;

}TObject;

void crearArma(TObject *A,char nombre[],int peso, int atack, int defense, int speed){
    A->id = 3;
    A->hero = NULL;
    A->monstruo = NULL;
    TItem *Item = malloc(sizeof(TItem));
        Item->id = 1;
        strcpy(Item->name,nombre);
        Item->peso = peso;
        Item->consumible = NULL;
        TWpn *arma = malloc(sizeof(TWpn));
        arma->atack = atack;
        arma->defense = defense;
        arma->speed = speed;
        Item->arma = arma;
    A->item =Item;
}


void crearConsumible(TObject *C,char nombre[],int peso,int cura){
    C->id=3;//se le coloca el tipo de objeto que será en este caso es un item]
    C->hero = NULL;//no es heroe
    C->monstruo = NULL;//no es monstruo
    TItem *Item = malloc(sizeof(TItem));//creo un nuevo item en la memorio
        Item->id = 2;//al cual le asignare el tipo poción
        strcpy(Item->name,nombre);//le pongo el nombre
        Item->peso = peso;//y el peso que son campos para los items en general
        Item->arma = NULL;//al campo que podria apuntar a un arma naturalmente lo coloco en 0
        TUse *usable = malloc(sizeof(TUse));//creo un espacio en la memoria para una pocion que tiene nombre de usable
            usable->consumible = cura;//esa subcatergoria de item tiene un campo llamado consumible y le doy
                                      // el valor del parametro cura
        Item->consumible = usable;//finalmente hago que el campoco consumible(pocion) apunte al nuevo consumible creado
    C->item = Item;// y que el campo puntero a item del objeto apunte al item creado al inicio
}

void eliminarItem(TObject *I){//Este eliminarItem funciona tanto para el arma como para el consumible
    if(I->id==3){
        TItem *Item; TUse *User;
        TWpn *weapon;
        Item = I->item;
        User = Item->consumible;
        weapon = Item->arma;
        free(weapon);
        free(User);
        free(Item);
        I->item = NULL;
        I->id = 0;
    }
}



void crearMonstruo(TObject *M, char nombre[],int vida,int atacke, int defensa, int velocidad){
    M->id = 2;
    M->hero = NULL;
    M->item = NULL;

    TMonst *monstruo = malloc(sizeof(TMonst));
        strcpy(monstruo->name,nombre);
        monstruo->health =vida;  // puede ser de 30 a 150
        monstruo->atack = atacke; // de 50 a 70
        monstruo->defense = defensa; // 20 a 80
        monstruo->speed = velocidad; // 10 a 30

    M->monstruo = monstruo;

}

void eliminarMonstruo(TObject *M){
    if(M->id==2){
        TMonst *monstruo;
        monstruo = M->monstruo;
        free(monstruo);
        M->monstruo = NULL;
        M->id = 0;
    }
}

///////////////////////// Funciones de Mochilas ////////////////////
void crearMochila(TBag *M){
    M->cima=NULL;
}

int esMochilaVacia(TBag *M){
    return (M->cima == NULL);
}

void apilarItem(TBag *M, TItem *Item){//Esta funcion es solo para mochila
    TNodo *neoNodo = malloc(sizeof(TNodo));
    neoNodo->elemento = Item;
    neoNodo->capacidad = 100; //en la mochila no hay capacidad de peso
    neoNodo->ant = NULL; // no se usa
    neoNodo->sig = M->cima;
    M->cima = neoNodo;
}


TItem* desapilarItem(TBag *M){ //Retira los objetos de la mochila y devuelve un puntero al item que acabas de sacar la mochila
    TItem *Item;
    TNodo *ptrNodo;
    if(!esMochilaVacia(M)){
        ptrNodo = M->cima;
        Item = ptrNodo->elemento;
        M->cima = ptrNodo->sig;
        free(ptrNodo);
        return Item;
    }
    return NULL;
}

void finalizarMochila(TBag *M){
  while (!esMochilaVacia(M)){
      desapilarItem(M);
  }
}
////////////////////////Funciones de cinturon///////////////////
void crearNodos(TBelt *B){//crea nodos necesarios para el cinturon
    int i;
    for(i=1;i <= B->max;i++){
        TNodo *neoNodo = malloc(sizeof(TNodo));
        neoNodo->elemento = NULL;
        neoNodo->capacidad = rand() % 11 + 10;///// el peso tendra valor aleatorio entre 10 y 20
        neoNodo->ant = NULL;
        neoNodo->sig = NULL;
        if (i==1){
            B->head = neoNodo;
            B->tail = neoNodo;
        }
        else {
            B->tail->sig = neoNodo;
            neoNodo->ant = B->tail;
            B->tail = neoNodo;
        }

    }
} //creo todos los nodos que deberá tener el cinturon con su capacidad aleatoria


void eliminarNodo(TBelt *B){ //eliminando nodos de la correa
    int i;
    for(i=B->max;i>0;(i--)){
        TNodo *ptrNodo;
        ptrNodo = B->tail;
        B->tail = B->tail->ant;
        free(ptrNodo);
    }
}

void crearCinturon(TBelt *B){

    B->cant= 0;
    B->max = rand() % 8 + 3 ;
    B->head= NULL;
    B->tail= NULL;
    crearNodos(B); // verificar punteros
};

void finalizarCinturon(TBelt *B){
    eliminarNodo(B);  //verificar puntero too
    B->cant= 0;
    B->max = 0;
    B->head= NULL;
    B->tail= NULL;
}

int agregarCinturon(TBelt *B,TItem *Item,int pos){ //devuelve 1 si es un exito o cero si no es posible agregar

    if(pos > B->max) return 0;
    TNodo *ptrNodo;
    ptrNodo = B->head; // ir hasta la posicion deseada
    int i;
    for(i = pos;i > 1;(i--)){
        ptrNodo = ptrNodo->sig;
    }
    if((ptrNodo->capacidad < Item->peso) ||(ptrNodo->elemento != NULL) )
        return 0; //si la capacidad del nodo es menor al peso o si el nodo esta lleno no se puede agregar
    else{
        ptrNodo->elemento = Item;
        return 1;
    }
}

TItem *quitarCinturon(TBelt *B,int pos){
    if(pos > B->max) return NULL;
    TNodo *ptrNodo;
    ptrNodo = B->head; // ir hasta la posicion deseada
    int i;
    for(i = pos;i > 1;(i--)){
        ptrNodo = ptrNodo->sig;
    }
    if(ptrNodo->elemento == NULL) return NULL;
    else{
        TItem *ptrItem;
        ptrItem = ptrNodo->elemento;
        ptrNodo->elemento = NULL;
        return(ptrItem);
    }

} //saca un item del cinturon, dejando vacio un espacio y devuelve el item sacado
 //si no se puede sacer ya esa por posicion mal dada o nodo vacio devuenve NULL


void crearHeroe(TObject *H,char nombre[]){ //recibe el nombre del heroe
    H->id = 1;
    H->item = NULL;
    H->monstruo = NULL;
    THero *heroe= malloc(sizeof(THero));
        strcpy(heroe-> name, nombre);
        heroe->healthMax= 100;
        heroe->health = 100;
        heroe->atack = rand() % 11 + 30;  //Rand() trae un numero entre 200000 random
        heroe->defense = rand() % 11 + 30;//para que saque del 0 al 10 se hace mod 11
        heroe->speed = rand()% 11 + 10;
        TBag *mochila;
        TBelt *cinturon;
        crearMochila(mochila); // estare pasando bien?
        crearCinturon(cinturon); //
        heroe->mochila = mochila;
        heroe->cinturon = cinturon;

        H->hero = heroe;
}
void eliminarHeroe(TObject *H){

    if(H->id == 1){
        THero *heroe;
        heroe = H->hero;
        finalizarMochila(heroe->mochila);
        finalizarCinturon(heroe->cinturon);
        free(heroe);
        H->hero = NULL;
        H->id = 0;
    }
}

/*
 *                  PROCEDIMIENTOS DE ALVARO
Estos procedimientos fueron creados por Alvaro, asi que no es perra de nadie
*/

void cargarMonstruosGen(){

    FILE* archivo;
    TObject obj_Mon[MAX];//creo un arreglo de tipos de objeto
    char name[30];//le asigno una capacidad maxima a name
    int health,atack,defense,speed,i;
    i=0;//inicializo contador

    archivo=fopen("monstruos.txt","r");//abro el archivo que usare
    if (archivo!=NULL)
        while (fscanf(archivo, "%s %d %d %d %d", name, &health,&atack,&defense,&speed) == 5){   //leo cada registro
            crearMonstruo(&obj_Mon[i], name,health,atack, defense, speed);                      // uso el procedimiento creado por Neil
            //notese que envio el elemtno objeto del arreglo con ampersan para que el procedimiento
            //reciba un puntero a tipo objeto
            i++;//incremento el contador para seguir recorriendo el arreglo

        }



}

void cargarPocionesGen(){
    FILE* archivo;
    TObject obj_Item[MAX];//creo un arreglo de tipos de objeto
    char name[30];//le asigno una capacidad maxima a name
    int peso,consumible,i;
    i=0;//inicializo contador

    archivo=fopen("pociones.txt","r");//abro el archivo que usare
    if (archivo!=NULL)
        while (fscanf(archivo, "%s %d %d", name, &peso,&consumible) == 3){//leo cada registro
            crearConsumible(&obj_Item[i],name,peso,consumible);// uso el procedimiento creado por Neil
            //notese que envio el elemtno objeto del arreglo con ampersan para que el procedimiento
            //reciba un puntero a tipo objeto
            i++;//incremento el contador para seguir recorriendo el arreglo

        }
}

void cargarArmasGen(){

    FILE* archivo;
    TObject obj_Item[MAX];  //creo un arreglo de tipos de objeto
    char name[30];          //le asigno una capacidad maxima a name
    int peso,atack,defense,speed,i;
    i=0;//inicializo contador

    archivo=fopen("armas.txt","r");//abro el archivo que usare
    if (archivo!=NULL)
        while (fscanf(archivo, "%s %d %d %d %d", name, &peso,&atack,&defense,&speed) == 5){//leo cada registro
            crearArma(&obj_Item[i],name,peso,atack,defense,speed);
/*
            uso el procedimiento creado por Neil
            notese que envio el elemetno objeto del arreglo con ampersan para que el procedimiento
            reciba un puntero a tipo objeto
*/
            i++;//incremento el contador para seguir recorriendo el arreglo

        }
}

int main(int argc, char** argv){




    cargarMonstruosGen();
    cargarPocionesGen();
    cargarArmasGen();

    return (EXIT_SUCCESS);
}