Daniel's Fantasy

// MAIN.C //
#include "utility.h"

int main()
{
    initscr();
    keypad(stdscr,TRUE);
    cbreak();
    noecho();
    int c;
    start_color();
    init_pair(1,COLOR_WHITE, COLOR_BLUE);
    init_pair(2,COLOR_GREEN, COLOR_GREEN);
    init_pair(3,COLOR_BLACK, COLOR_GREEN);
    init_pair(4,COLOR_BLACK, COLOR_YELLOW);
    init_pair(5,COLOR_CYAN, COLOR_BLUE);
    init_pair(6,COLOR_RED, COLOR_GREEN);
    init_pair(7,COLOR_CYAN, COLOR_CYAN);
    init_pair(8,COLOR_YELLOW, COLOR_YELLOW);
    init_pair(9,COLOR_BLACK, COLOR_BLACK);
    init_pair(10,COLOR_RED, COLOR_YELLOW);
    while(1){
        printw("\t****************************\n");
        printw("\t*                          *\n");
        printw("\t*                          *\n");
        printw("\t*     DANIEL'S FANTASY     *\n");
        printw("\t*                          *\n");
        printw("\t*                          *\n");
        printw("\t*      <PREMI INVIO>       *\n");
        printw("\t****************************\n");
        refresh();
        while((c = getch()) != 10);
        clear();
        game();
    }
//    int i = 0;
//    char *stringhe[] = {"1. Ciao", "2. Addio","3. Arivederci","4. Salutiamo!","5. Alla prossima!","6. Wow!","7. Accidenti...","8. Perfetto...!"};
//    do{
//        print2(stringhe,8,i);
//        c = getch();
//        switch(c){
//        case KEY_UP:
//            if((i - 1) > -1 && (i - 1) < 8)
//                i--;
//            break;
//        case KEY_DOWN:
//            if((i + 1) > -1 && (i + 1) < 8)
//                i++;
//            break;
//        }
//    }while(1);
    endwin();
    return 0;
}


// UTILITY.C //

#include "utility.h"

/*
    0 - oggetto generico
    1 - arma
    2 - protezione
    3 - accessorio
    4 - oggetto usabile (cura ecc...)
*/

arma armi[M_ARMI] = {
    {"spada di legno lunga",3},
    {"bacchetta magica corta",2},
    {"pugnale corto",1},
    {"becco rapace",1},
    {"spada di ferro corta",5},
    {"spada di ferro media",7},
    {"spada di ferro lunga",10},
    {"bastone incantato leggero",4},
    {"bastone incantato lungo carismatico",6},
    {"bastone incantato lungo maestoso",10},
    {"nunchaku",3},
    {"daga",5},
    {"arco lungo",7}
};

protezione protezioni[M_PROT] = {
    {"armatura di ferro",1},
    {"mantello corto",1},
    {"scudo grande di ferro",3},
    {"pelliccia pesante",1},
    {"armatura di acciaio",5},
    {"armatura d'oro",7},
    {"armatura di platino",10},
    {"cappa corta incantata",4},
    {"mantello lungo incantato",6},
    {"mantello lungo incantato maestoso", 10},
    {"scudo grande d'argento",3},
    {"scudo grande d'oro",5},
    {"granscudo di platino",7}
};

accessorio accessori[M_ACC] = {
    {"scarpe leggere",0,1},
    {"scarpe pesanti",0,4},
    {"scarpe veloci",0,7},
    {"orecchini incantati",0,5},
    {"orecchini stregati",0,10},
    {"anello stregato",7,0},
    {"cintura bianca",1,1},
    {"cintura blu",3,3},
    {"cintura nera",6,6},
    {"cintura rossa",10,10},
    {"guanti di ferro",7,5},
    {"guanti di pezza",3,3},
    {"guanti d'oro",10,10},
};

Cura cure[M_CURE] = {
    {"pozione",20},
    {"granpozione",50},
    {"extrapozione",300},
    {"midelisir",625},
    {"elisir",1250}
};

Mostro mostri[M_MOSTRI] = {
    {"Cane",50,5,2,25,250,{"pozione",4}},
    {"Lupo",70,6,3,25,200,{"zanna scheggiata",0}},
    {"Aquila reale",75,6,5,30,0,{"becco rapace",1}},
    {"Gnomo dispettoso",60,4,7,40,10,{"anello stregato",3}},
    {"Orso",125,8,1,30,100,{"pelliccia pesante",2}},
    {"Pianta carnivora gigante",150,8,7,30,240,{"granpozione",4}},
    {"Spirito errante",150,7,10,35,100,{"bastone incantato lungo carismatico",1}},
    {"Nano delle foreste",225,12,8,50,400,{"spada di ferro media",1}},
    {"Troll",250,15,11,70,100,{"midelisir",4}},
    {"Orco delle caverne",250,16,9,65,450,{"armatura di platino",2}},
    {"Drago",500,100,85,1000,20000,{"bastone incantato lungo maestoso",1}},
    {"Basilisco",425,75,70,750,10000,{"elisir",4}}
};

Mostro boss[4] = {
    {"Ciclope",400,60,50,0,1000,{"spada di ferro corta",1}},
    {"Demone draconico infernale",700,75,60,0,2000,{"arco lungo",1}},
    {"Angelo decaduto",2000,110,85,0,0,{"bastone incantato lungo maestoso",1}},
    {"Rape monster",10000,200,140,0,0,{"elisir",4}}
};

int inputInt(){
    int x;
    char c;
    puts("Scrivi un numero:");
    while(scanf("%d", &x) != 1){
        puts("input errato...riprova:");
        do{
            c = getchar();
        }while(c != '\n');
    }
    do{
        c = getchar();
    }while(c != '\n');
    return x;
}

int **allocaMat(int righe, int colonne){
    int i;
    int **new = (int **)malloc(righe*sizeof(int *));
    for(i = 0; i < righe; i++){
        new[i] = (int *)malloc(colonne*sizeof(int));
    }
    return new;
}

char **allocaMatchar(int righe, int colonne){
    int i;
    char **new = (char **)malloc(righe*sizeof(char *));
    for(i = 0; i < righe; i++){
        new[i] = (char *)malloc(colonne*sizeof(char));
    }
    return new;
}

Matrice newMatrice(){
    Matrice new = (Matrice)malloc(sizeof(matrice));
    new->righe = inputInt();
    new->colonne = inputInt();
    new->matrice = allocaMat(new->righe,new->colonne);
    return new;
}

Matchar newMatchar(){
    Matchar new = (Matchar)malloc(sizeof(matchar));
    new->righe = inputInt();
    new->colonne = inputInt();
    new->matrice = allocaMatchar(new->righe,new->colonne);
    return new;
}

void setMatrice(Matrice this){
    int i, j;
    for(i = 0; i < this->righe; i++)
        for(j = 0; j < this->colonne; j++)
            this->matrice[i][j] = inputInt();
}

void setRandomMatrice(Matrice this){
    int i, j;
    for(i = 0; i < this->righe; i++)
        for(j = 0; j < this->colonne; j++)
            this->matrice[i][j] = (rand() % 2);
}

void setRandomMatchar(Matchar this){
    int i, j, c, d;
    for(i = 0; i < this->righe; i++){
        for(j = 0; j < this->colonne; j++){
            do{
                c = rand() % 100;
            }while(c != 32 && c != 94);
            this->matrice[i][j] = c;
        }
    }
    for(i = 0; i < (this->righe * this->colonne); i++){
        c = rand() % this->righe;
        d = rand() % this->colonne;
        if(this->matrice[c][d] == 94)
            this->matrice[c][d] = ' ';
    }
}

void initMatchar(Matchar this){
    int i, j;
    for(i = 0; i < this->righe; i++)
        for(j = 0; j < this->colonne; j++)
            this->matrice[i][j] = ' ';
}

void initMatrice(Matrice this){
    int i, j;
    for(i = 0; i < this->righe; i++)
        for(j = 0; j < this->colonne; j++)
            this->matrice[i][j] = 0;
}

void getMatrice(Matrice this){
    int i, j;
    for(i = 0; i < this->colonne + 2; i++)
        printf("#");
    puts("");
    for(i = 0; i < this->righe; i++){
        printf("#");
        for(j = 0; j < this->colonne; j++)
            printf("%d\t", this->matrice[i][j]);
        puts("#");
    }
    for(i = 0; i < this->colonne + 2; i++)
        printf("#");
    puts("");
}

void getMatchar(Matchar this){
    int i, j;
    attron(COLOR_PAIR(5));
    for(i = 0; i < this->colonne + 2; i++)
        printw("#");
    attroff(COLOR_PAIR(5));
//    printw("\n");
    for(i = 0; i < this->righe; i++){
        attron(COLOR_PAIR(5));
        printw("\n#");
        attroff(COLOR_PAIR(5));
        for(j = 0; j < this->colonne; j++){
            if(this->matrice[i][j] == '@'){
                attron(COLOR_PAIR(1));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(1));
                continue;
            }
            else if(this->matrice[i][j] == ' '){
                attron(COLOR_PAIR(2));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(2));
                continue;
            }
            else if(this->matrice[i][j] == ',' || this->matrice[i][j] == '.'){
                attron(COLOR_PAIR(3));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(3));
                continue;
            }
            else if(this->matrice[i][j] == 'm' || this->matrice[i][j] == 'M' || this->matrice[i][j] == 'g'){
                attron(COLOR_PAIR(6));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(6));
                continue;
            }
            else if(this->matrice[i][j] == '#'){
                attron(COLOR_PAIR(7));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(7));
                continue;
            }
            else if(this->matrice[i][j] == '*'){
                attron(COLOR_PAIR(8));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(8));
                continue;
            }
            else if(this->matrice[i][j] == '+'){
                attron(COLOR_PAIR(9));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(9));
                continue;
            }
            else if(this->matrice[i][j] == 'N'){
                attron(COLOR_PAIR(10));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(10));
                continue;
            }
            else{
                attron(COLOR_PAIR(4));
                printw("%c", this->matrice[i][j]);
                attroff(COLOR_PAIR(4));
                continue;
            }
        }
        attron(COLOR_PAIR(5));
        printw("#");
        attroff(COLOR_PAIR(5));
    }
    attron(COLOR_PAIR(5));
    for(i = 0; i < this->colonne + 2; i++)
        printw("#\n");
    attroff(COLOR_PAIR(5));
    printw("\n");
    refresh();
}

void saveMatchar(Matchar this, FILE *f){
    int i, j;
    fprintf(f,"%d %d\n",this->righe, this->colonne);
    for(i = 0; i < this->righe; i++){
        for(j = 0; j < this->colonne; j++)
            fprintf(f,"%c", this->matrice[i][j]);
        fputs("\n",f);
    }
}

Matchar loadMatchar(char *nomefile){
    char app[ML];
    sprintf(app,"./maps/%s",nomefile);
    FILE *f = fopen(app,"r");
    Matchar new = (Matchar)malloc(sizeof(matchar));
    int righe, colonne;
    new->righe = 25;
    new->colonne = 75;
    new->matrice = allocaMatchar(new->righe,new->colonne);
    for(righe = 0; righe < new->righe; righe++){
        fgetc(f);
        for(colonne = 0; colonne < new->colonne; colonne++)
            fscanf(f,"%c",&(new->matrice[righe][colonne]));
    }
    return new;
}

int choose(int min, int max){
    int x;
    do{
        x = inputInt();
        if(x < min || x > max)
            puts("input fuori intervallo...riprova:");
    }while(x < min || x > max);
    return x;
}

void menu1(Matchar this){
    int c;
    system("cls");
    printf("1) mappa piccola (10 x 30)\n2) mappa media (25 x 75)\n3) mappa grande (50 x 150)\n> ");
    c = choose(1,3);
    switch(c){
        case 1:
            this->righe = 10;
            this->colonne = 30;
            this->matrice = allocaMatchar(10,30);
            break;
        case 2:
            this->righe = 25;
            this->colonne = 75;
            this->matrice = allocaMatchar(25,75);
            break;
        case 3:
            this->righe = 50;
            this->colonne = 150;
            this->matrice = allocaMatchar(50,150);
            break;
    }
    system("cls");
    printf("1) mappa vuota\n2) mappa random\n> ");
    c = choose(1,2);
    switch(c){
        case 1:
            initMatchar(this);
            edita(this);
            break;
        case 2:
            srand(time(NULL));
            setRandomMatchar(this);
            edita(this);
            break;
    }
}

void edita(Matchar this){
    Pos c;
    int d,e;
    while(1){
        system("cls");
        getMatchar(this);
        printf("\n1) continua editing\n2) esci\n> ");
        d = choose(1,2);
        switch(d){
            case 1:
                puts("Scrivi le coordinate:");
                c.x = choose(0,this->colonne - 1);
                c.y = choose(0,this->righe - 1);
                printf("\n1) vuoto\n2) muro\n> ");
                e = choose(1,2);
                switch(e){
                    case 1:
                        this->matrice[c.y][c.x] = ' ';
                        break;
                    case 2:
                        this->matrice[c.y][c.x] = '#';
                        break;
                }
                break;
            case 2:
                return;
        }
    }
}

void start(Matchar this, Giocatore eroe){
    srand(time(NULL));
    flushinp();
    timeout(350);
    char s = ' ';
    Pos coord;
    Pos npg1, npg2;
    Oggetto o;
    cercaPng1(this,&npg1);
    cercaPosizione(this,&coord);
    int c1, c2, d1, d2;
    c1 = this->colonne / 3;
    c2 = c1 * 2;
    d1 = M_MOSTRI / 3;
    d2 = (d1 * 2);
    Punti a = NULL, b = NULL;
    this->matrice[coord.y][coord.x] = '@';
    this->matrice[npg1.y][npg1.x] = 'g';
    eroe->passi = 10;
    int c, d, v = 0, casual;
    while(1){
        this->matrice[npg1.y][npg1.x] = ' ';
        a = removeTesta(a,&npg1);
        if(a == NULL)
            a = moveMonster(this,npg1);
        this->matrice[npg1.y][npg1.x] = 'g';
        if(strcmp(this->scenario,"caverna.txt") == 0){
            this->matrice[npg2.y][npg2.x] = ' ';
            b = removeTesta(b,&npg2);
            if(b == NULL)
                b = moveMonster(this,npg2);
            this->matrice[npg2.y][npg2.x] = 'g';
        }
        if(eroe->passi == 0){
            timeout(-1);
            if(((coord.x)) <= c1)
                v = battle(eroe,mostri[rand()% d1]);
            else if(((coord.x)) > c1 && ((coord.x)) <= c2)
                v = battle(eroe,mostri[(rand()% d1)+d1]);
            else
                v = battle(eroe,mostri[(rand()% d1)+d2]);
            flushinp();
            timeout(350);
        }
        clear();
        printw("frecce - 4 direzioni\tINVIO - azione/interagisci/parla\n1 - pausa\n2 - salva posizione\t3 - esci\n");
        getMatchar(this);
        c = getch();
        switch(c){
            case KEY_LEFT:
                eroe->passi--;
                if((d = (coord.x) - 1) >= 0)
                if(this->matrice[coord.y][(coord.x) - 1] != '#' && this->matrice[coord.y][(coord.x) - 1] != 94 && this->matrice[coord.y][(coord.x) - 1] != '.' && this->matrice[coord.y][(coord.x) - 1] != ',' && this->matrice[coord.y][(coord.x) - 1] != 'M' && this->matrice[coord.y][(coord.x) - 1] != 'N' && this->matrice[coord.y][(coord.x) - 1] != 'g'){
                    this->matrice[coord.y][coord.x] = s;
                    (coord.x)--;
                    s = this->matrice[coord.y][(coord.x)];
                    this->matrice[coord.y][coord.x] = '@';
                }
                break;
            case KEY_DOWN:
                eroe->passi--;
                if((d = (coord.y) + 1) < this->righe)
                if(this->matrice[(coord.y) + 1][coord.x] != '#' && this->matrice[coord.y + 1][(coord.x)] != 94 && this->matrice[coord.y + 1][(coord.x)] != '.' && this->matrice[coord.y + 1][(coord.x)] != ',' && this->matrice[coord.y + 1][(coord.x)] != 'M' && this->matrice[coord.y + 1][(coord.x)] != 'N' && this->matrice[coord.y + 1][(coord.x)] != 'g'){
                    this->matrice[coord.y][coord.x] = s;
                    (coord.y)++;
                    s = this->matrice[coord.y][coord.x];
                    this->matrice[coord.y][coord.x] = '@';
                }
                break;
            case KEY_RIGHT:
                eroe->passi--;
                if((d = (coord.x) + 1) < this->colonne)
                if(this->matrice[coord.y][(coord.x) + 1] != '#' && this->matrice[coord.y][(coord.x) + 1] != 94 && this->matrice[coord.y][(coord.x) + 1] != '.' && this->matrice[coord.y][(coord.x) + 1] != ',' && this->matrice[coord.y][(coord.x) + 1] != 'M' && this->matrice[coord.y][(coord.x) + 1] != 'N' && this->matrice[coord.y][(coord.x) + 1] != 'g'){
                    this->matrice[coord.y][coord.x] = s;
                    (coord.x)++;
                    s = this->matrice[coord.y][coord.x];
                    this->matrice[coord.y][coord.x] = '@';
                }
                break;
            case KEY_UP:
                eroe->passi--;
                if((d = (coord.y) - 1) >= 0)
                if(this->matrice[(coord.y) - 1][coord.x] != '#' && this->matrice[coord.y - 1][(coord.x)] != 94 && this->matrice[coord.y - 1][(coord.x)] != '.' && this->matrice[coord.y - 1][(coord.x)] != ',' && this->matrice[coord.y - 1][(coord.x)] != 'M' && this->matrice[coord.y - 1][(coord.x)] != 'N' && this->matrice[coord.y - 1][(coord.x)] != 'g'){
                    this->matrice[coord.y][coord.x] = s;
                    (coord.y)--;
                    s = this->matrice[coord.y][coord.x];
                    this->matrice[coord.y][coord.x] = '@';
                }
                break;
            case 50:
                timeout(-1);
                salva(eroe,this);
                flushinp();
                timeout(350);
                break;
            case 51:
                timeout(-1);
                printw("\n1) salva ed esci\n2) esci senza salvare\n\n");
                refresh();
                do{
                    d = getch();
                    if(d < 49 || d > 50){
                        printw("riprova:\n");
                        refresh();
                    }
                }while(d < 49 || d > 50);
                switch(d){
                    case 49:
                        salva(eroe,this);
                        printw("Fatto!\nPremi un tasto...");
                        refresh();
                        getch();
                        clear();
                        return;
                    case 50:
                        printw("Premi un tasto...");
                        refresh();
                        getch();
                        clear();
                        return;
                }
            case 10:
                timeout(-1);
                if(s == '+'){
                    if(strcmp(this->scenario,"inizio.txt") == 0){
                        loadLivello(this,"caverna.txt");
                        cercaPng1(this,&npg1);
                        cercaPng1(this,&npg2);
                        a = freePunti(a);
                        b = freePunti(b);
                        a = singolo(npg1);
                        b = singolo(npg2);
                        eroe->passi = (rand() % 10) + 10;
                        strcpy(eroe->scenario,"caverna.txt");
                    }
                    else{
                        loadLivello(this,"inizio.txt");
                        cercaPng1(this,&npg1);
                        a = freePunti(a);
                        a = singolo(npg1);
                        eroe->passi = (rand() % 10) + 10;
                        strcpy(eroe->scenario,"inizio.txt");
                    }
                }
                else if(this->matrice[coord.y - 1][coord.x] == 'N' || this->matrice[coord.y + 1][coord.x] == 'N' || this->matrice[coord.y][coord.x - 1] == 'N' || this->matrice[coord.y][coord.x + 1] == 'N'){
                    clear();
                    negozio(eroe,this);
                }
                else if(this->matrice[coord.y - 1][coord.x] == '.' || this->matrice[coord.y + 1][coord.x] == '.' || this->matrice[coord.y][coord.x - 1] == '.' || this->matrice[coord.y][coord.x + 1] == '.'){
                    strcpy(o.nome,cure[rand() % 5].nome);
                    o.tipo = 4;
                    printw("Ottieni un %s !\n", o.nome);
                    eroe->inv = addInventario(eroe->inv,o);
                    getch();
                    if(this->matrice[coord.y - 1][coord.x] == '.'){
                        this->matrice[coord.y - 1][coord.x] = ' ';
                    }
                    else if(this->matrice[coord.y + 1][coord.x] == '.'){
                        this->matrice[coord.y + 1][coord.x] = ' ';
                    }
                    else if(this->matrice[coord.y][coord.x - 1] == '.'){
                        this->matrice[coord.y][coord.x - 1] = ' ';
                    }
                    else if(this->matrice[coord.y][coord.x + 1] == '.'){
                        this->matrice[coord.y][coord.x + 1] = ' ';
                    }
                }
                else if(this->matrice[coord.y - 1][coord.x] == ',' || this->matrice[coord.y + 1][coord.x] == ',' || this->matrice[coord.y][coord.x - 1] == ',' || this->matrice[coord.y][coord.x + 1] == ','){
                    casual = rand() % 3;
                    switch(casual){
                        case 0:
                            strcpy(o.nome,armi[rand() % M_ARMI].nome);
                            o.tipo = 1;
                            printw("Ottieni un %s !\n", o.nome);
                            eroe->inv = addInventario(eroe->inv,o);
                            getch();
                            break;
                        case 1:
                            strcpy(o.nome,protezioni[rand() % M_PROT].nome);
                            o.tipo = 2;
                            printw("Ottieni un %s !\n", o.nome);
                            eroe->inv = addInventario(eroe->inv,o);
                            getch();
                            break;
                        case 2:
                            strcpy(o.nome,accessori[rand() % M_ACC].nome);
                            o.tipo = 3;
                            printw("Ottieni un %s !\n", o.nome);
                            eroe->inv = addInventario(eroe->inv,o);
                            getch();
                            break;
                    }
                    if(this->matrice[coord.y - 1][coord.x] == ','){
                        this->matrice[coord.y - 1][coord.x] = ' ';
                    }
                    else if(this->matrice[coord.y + 1][coord.x] == ','){
                        this->matrice[coord.y + 1][coord.x] = ' ';
                    }
                    else if(this->matrice[coord.y][coord.x - 1] == ','){
                        this->matrice[coord.y][coord.x - 1] = ' ';
                    }
                    else if(this->matrice[coord.y][coord.x + 1] == ','){
                        this->matrice[coord.y][coord.x + 1] = ' ';
                    }
                }
                else if(this->matrice[coord.y - 1][coord.x] == 'M' || this->matrice[coord.y + 1][coord.x] == 'M' || this->matrice[coord.y][coord.x - 1] == 'M' || this->matrice[coord.y][coord.x + 1] == 'M'){
                    switch(eroe->boss_sconfitti){
                        case 0:
                            v = battle(eroe,boss[0]);
                            break;
                        case 1:
                            v = battle(eroe,boss[1]);
                            break;
                        case 2:
                            v = battle(eroe,boss[2]);
                            break;
                        case 3:
                            v = battle(eroe,boss[3]);
                            break;
                        default:
                            printw("Boss gia' sconfitto...\n");
                            refresh();
                            getch();
                            break;
                        }
                        if(v == 0){
                            eroe->boss_sconfitti++;
                            if(this->matrice[coord.y - 1][coord.x] == 'M'){
                                this->matrice[coord.y - 1][coord.x] = ' ';
                            }
                            else if(this->matrice[coord.y + 1][coord.x] == 'M'){
                                this->matrice[coord.y + 1][coord.x] = ' ';
                            }
                            else if(this->matrice[coord.y][coord.x - 1] == 'M'){
                                this->matrice[coord.y][coord.x - 1] = ' ';
                            }
                            else if(this->matrice[coord.y][coord.x + 1] == 'M'){
                                this->matrice[coord.y][coord.x + 1] = ' ';
                            }
                        }
                }
                else if(this->matrice[coord.y - 1][coord.x] == 'g' || this->matrice[coord.y + 1][coord.x] == 'g' || this->matrice[coord.y][coord.x - 1] == 'g' || this->matrice[coord.y][coord.x + 1] == 'g'){
                    parla(this,eroe);
                    refresh();
                    getch();
                }
                flushinp();
                timeout(350);
                break;
            case 49:
                timeout(-1);
                pausa(eroe,this);
                flushinp();
                timeout(350);
                break;
        }
    }
}

Matchar load(Giocatore eroe){
    Matchar this = (Matchar)malloc(sizeof(matchar));
    char *str, app[1024], dir[ML];
    int i = 0, c, j = 0;
    char **stringhe = (char **)malloc(ML * sizeof(char*));
    for(c = 0; c < ML; c++)
        stringhe[c] = (char *)malloc(ML * sizeof(char));
    DIR *d;
    strcpy(dir,"dati");
    struct stat s;
    struct dirent *file;
    str = (char *)malloc(1024 * sizeof(char));
    strcpy(str,"");
    d = opendir("dati");
    if(!d){
        printw("\n\nNon ci sono salvataggi!");
        refresh();
        sleep(3);
        return NULL;
    }
    while( (file = readdir(d)) != NULL ){
        sprintf(app,"%s", file->d_name);
        stat(file->d_name,&s);
        if(strcmp(file->d_name,".") == 0 || strcmp(file->d_name,"..") == 0)
            continue;
        strcat(app,"\n");
        strcpy(stringhe[i++],app);
//        stringhe[i-1][strlen(stringhe[i-1]) - 5] = '\0';
    }
    while((c = getch()) != KEY_F(1)){
        switch(c){
            case KEY_DOWN:
                if((j + 1) > -1 && (j + 1) < i)
                    j++;
                print(stringhe,i,j);
                break;
            case KEY_UP:
                if((j - 1) > -1 && (j - 1) < i)
                    j--;
                print(stringhe,i,j);
                break;
            case 10:
                this = carica(eroe,stringhe[j]);
                return this;
            }
    }
    return this;
}

void game(){
    int c, i = 0;
    char *scelte[] = {"1. new game","2. load game","3. exit"};
    Matchar mappa = NULL;
    Giocatore eroe = newGiocatore();
    clear();
    print(scelte,3,i);
    while((c = getch()) != KEY_F(1))
    switch(c){
        case KEY_DOWN:
            if((i + 1) > -1 && (i + 1) < 3)
                i++;
            print(scelte,3,i);
            break;
        case KEY_UP:
            if((i - 1) > -1 && (i - 1) < 3)
                i--;
            print(scelte,3,i);
            break;
        case 10:
            switch(i){
                case 0:
                    mappa = new_game(eroe);
                    story(mappa,eroe);
                    break;
                case 1:
                    mappa = load(eroe);
                    if(!mappa)
                        break;
                    story(mappa,eroe);
                    break;
                case 2:
                    exit(1);
            }
            break;
    }
}

Matchar new_game(Giocatore eroe){
    int i = 0;
    Matchar mappa = (Matchar)malloc(sizeof(matchar));
    mappa->colonne = 75;
    mappa->righe = 25;
    mappa->matrice = (char **)malloc(25 * sizeof(char *));
    for(i = 0; i < 75; i++)
        mappa->matrice[i] = (char *)malloc(75 * sizeof(char));
    loadLivello(mappa, "inizio.txt");
    creaGiocatore(eroe);
    return mappa;
}

void story(Matchar mappa, Giocatore eroe){
    start(mappa,eroe);
}

int battle(Giocatore eroe, Mostro m){
    char *scelte[] = {
        "1. attacca",
        "2. oggetti",
        "3. fuggi"
    };
    char l;
    int c, d, e, i = 0, contr;
    clear();
    printw("Battaglia!\n");
    while(eroe->vita > 0 && m.vita > 0){
        print(scelte,3,i);
        printw("\n\n%s %d/%d\t-\t%s %d\n\n", eroe->nome, eroe->vita, eroe->salute, m.nome, m.vita);
        refresh();
        c = getch();
        switch(c){
            case KEY_DOWN:
                if((i + 1) > -1 && (i + 1) < 3)
                    i++;
                break;
            case KEY_UP:
                if((i - 1) > -1 && (i - 1) < 3)
                    i--;
                break;
            case 10:
                switch(i){
                    case 0:
                        e = rand() % 12;
                        printw("%s attacca...\n", eroe->nome);
                        if(e == 0){
                            if(eroe->attacco >= eroe->difesa){
                                m.vita -= 1;
                                printw("...fetecchia (attacco scarsissimo)\n");
                            }
                            else
                                printw("...ma non gli hai fatto un graffio...! (difesa nemica troppo alta)\n");
                        }
                        else if(e == 11){
                            contr = eroe->attacco * 2;
                            if(contr > m.difesa){
                                m.vita -= (eroe->attacco * 2);
                                printw("...azz! (danno doppio)\n");
                            }
                            else
                                printw("...ma non gli hai fatto un graffio...! (difesa nemica troppo alta)\n");
                        }
                        else{
                            contr = ((eroe->attacco * 2) - m.difesa);
                            if(contr > 0)
                                m.vita -= contr;
                            else
                                printw("...ma non gli hai fatto un graffio...! (difesa nemica troppo alta)\n");
                        }
                        if(m.vita <= 0)
                            break;
                        e = rand() % 12;
                        printw("%s attacca...\n", m.nome);
                        refresh();
                        if(e == 0){
                            if(m.attacco > eroe->difesa){
                                eroe->vita -= 1;
                                printw("...ma si e' distratto facendoti pochissimi danni!\n");
                            }
                            else
                                printw("...ma sei troppo forte per lui! (difesa piu' alta)\n");
                        }
                        else if(e == 11){
                            contr = m.attacco * 2;
                            if(contr > eroe->difesa){
                                eroe->vita -= contr;
                                printw("...e ti ha fatto anche malissimo! (danno doppio)\n");
                            }
                            else
                                printw("...ma sei troppo forte per lui! (difesa piu' alta)\n");
                        }
                        else{
                            contr = ((m.attacco * 2) - eroe->difesa);
                            if(contr > 0)
                                eroe->vita -= contr;
                            else
                                printw("...ma sei troppo forte per lui! (difesa piu' alta)\n");
                        }
                        if(eroe->vita <= 0)
                            break;
                        sleep(2);
                        system("cls");
                        break;
                    case 1:
                        do{
                            clear();
                            printw("Vuoi usare qualcosa? [ 1 si - 2 no ]\n");
                            do{
                                d = getch();
                                if(d < 49 || d > 50){
                                    printw("riprova:\n");
                                    refresh();
                                }
                            }while(d < 49 || d > 50);
                            switch(d){
                                case 49:
                                    settaEquip(eroe,1);
                                    break;
                                case 50:
                                    break;
                            }
                        }while(d != 50);
                        clear();
                        break;
                    case 2:
                        printw("GAMBE!\n");
                        printw("Premi un tasto...");
                        refresh();
                        getch();
                        eroe->passi = (rand() % 10) + 10;
                        clear();
                        return 1;
                }
                break;
        }
    }
    if(eroe->vita >= 0){
    printw("...e vince!\n");
        printw("Dannies + [ %d ]\nExp + [ %d ]\nOttieni un %s.\n", m.dannies,m.esperienza,m.object.nome);
        eroe->dannies += m.dannies;
        eroe->esperienza += m.esperienza;
        level_up(eroe);
        eroe->inv = addInventario(eroe->inv,m.object);
        refresh();
        getch();
        eroe->passi = (rand() % 10) + 10;
        return 0;
    }
    else{
        printw("...e perdi!!");
        eroe->vita = eroe->salute;
        getch();
        eroe->passi = (rand() % 10) + 10;
        return 1;
    }
    do{
        scanw("%c", &l);
    }while(l == '\n');
}

void level_up(Giocatore eroe){
        int c = (eroe->esperienza / 100) + 1;
        if(eroe->livello < 100)
            if(eroe->livello < c){
                eroe->livello = c;
                if(eroe->vita < 9999){
                    eroe->vita = eroe->salute += (50 * c);
                    if(eroe->vita > 9999)
                        eroe->vita = 9999;
                }
                if(eroe->livello % 2){
                    if(eroe->attacco < 255){
                        eroe->attacco += 3*c;
                        if(eroe->attacco > 255)
                            eroe->attacco = 255;
                    }
                    if(eroe->difesa < 255){
                        eroe->difesa += c;
                        if(eroe->difesa > 255)
                            eroe->difesa = 255;
                    }
                }
                else{
                    if(eroe->attacco < 255){
                        eroe->attacco += c;
                        if(eroe->attacco > 255)
                            eroe->attacco = 255;
                    }
                    if(eroe->difesa < 255){
                        eroe->difesa += 3*c;
                        if(eroe->difesa > 255)
                            eroe->difesa = 255;
                    }
                }
                printw("Level up! Sali al livello %d!\n", eroe->livello);
            }
}

void salva(const Giocatore eroe, const Matchar mappa){
    char app[ML], app1[ML], dir[ML];
    sprintf(dir,"dati\\");
    sprintf(app1,"_%d_x_%d.txt",mappa->righe,mappa->colonne);
    strcpy(app,eroe->nome);
    strcat(app,app1);
    strcat(dir,app);
    FILE *f;
    do{
        f = fopen(dir,"w");
        if(!f)
            mkdir("dati", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
    }while(!f);
    fprintf(f,"%s: %d %d %d %d %s: %f %f %d %d\n",
    eroe->nome,eroe->vita,eroe->salute,eroe->esperienza,eroe->dannies,eroe->classe,eroe->attacco,eroe->difesa,\
    eroe->progresso,eroe->livello);
    fprintf(f,"%s:%s:%s\n",eroe->equip->arma->nome,eroe->equip->protezione->nome,eroe->equip->accessorio->nome);
    salvaInv(eroe->inv,f);
    saveMatchar(mappa,f);
    fclose(f);
}

Matchar carica(Giocatore eroe, char *nomefile){
    Matchar mappa = (Matchar)malloc(sizeof(matchar));
    FILE *f;
    int x;
    char app[20];
    strcpy(app,"./dati/");
    strcat(app,nomefile);
    app[strlen(app)-1] = '\0';
    f = fopen(app,"r");
    if(f){
        x = 0;
        if(eroe ==  NULL){
            printw("non c'e' alcun eroe!!");
            refresh();
        }
        while(!feof(f)){
            eroe->nome[x++] = fgetc(f);
            if(eroe->nome[x-1] == ':'){
                break;
            }
        }
        eroe->nome[x-1]='\0';
        printw("c%sc\n", eroe->nome);
        fscanf(f,"%d%d%d%d",&(eroe->vita), &(eroe->salute), &(eroe->esperienza),&(eroe->dannies));
        x = 0;
        fgetc(f);
        while(!feof(f)){
            eroe->classe[x++] = fgetc(f);
            if(eroe->classe[x-1] == ':'){
                break;
            }
        }
        eroe->classe[x-1]='\0';
        fscanf(f,"%f%f%d%d",&(eroe->attacco),&(eroe->difesa),&(eroe->progresso),&(eroe->livello));
        fgetc(f);
        x=0;
        while(!feof(f)){
            eroe->equip->arma->nome[x++] = fgetc(f);
            if(eroe->equip->arma->nome[x-1] == ':'){
                break;
            }
        }
        eroe->equip->arma->nome[x-1]='\0';
        x = 0;
        while(!feof(f)){
            eroe->equip->protezione->nome[x++] = fgetc(f);
            if(eroe->equip->protezione->nome[x-1] == ':'){
                break;
            }
        }
        eroe->equip->protezione->nome[x-1]='\0';
        x = 0;
        while(!feof(f)){
            eroe->equip->accessorio->nome[x++] = fgetc(f);
            if(eroe->equip->accessorio->nome[x-1] == '\n'){
                break;
            }
        }
        eroe->equip->accessorio->nome[x-1]='\0';
        eroe->inv = caricaInv(f);
        fscanf(f,"%s",eroe->scenario);
        mappa = loadMatchar(eroe->scenario);
        printw("\ncont7\n");
        return mappa;
    }
    else{
        printw("File non trovato!");
        refresh();
        return NULL;
    }
}

void creaGiocatore(const Giocatore eroe){
    char *stringhe[] = {
        "1. Guerriero","2. Mago","3. Difensore"
    };
    int d, i = 0;
    Oggetto o = {"messaggio di benvenuto",0};
    Oggetto o1 = {"pozione",4};
    Oggetto a1 = {"spada di legno lunga",1};
    Oggetto a2 = {"bacchetta magica corta",1};
    Oggetto a3 = {"pugnale corto",1};
    Oggetto p1 = {"armatura di ferro",2};
    Oggetto p2 = {"mantello corto",2};
    Oggetto p3 = {"scudo grande di ferro",2};
    Oggetto s1 = {"scarpe leggere",3};
    clear();
    echo();
    printw("Che nome vuoi?\n> ");
    refresh();
    scanw("%[^\n]s", eroe->nome);
    noecho();
    eroe->inv = addInventario(eroe->inv,o);
    i = 0;
    while(i < 3){
        eroe->inv = addInventario(eroe->inv,o1);
        i++;
    }
    eroe->progresso = 0;
    eroe->livello = 1;
    eroe->vita = 1000;
    eroe->salute = 1000;
    eroe->esperienza = 0;
    eroe->dannies = 0;
    eroe->boss_sconfitti = 0;
    strcpy(eroe->equip->arma->nome,"-");
    strcpy(eroe->equip->protezione->nome,"-");
    strcpy(eroe->equip->accessorio->nome,"-");
    i = 0;
    noecho();
    print(stringhe,3,i);
    do{
        print(stringhe,3,i);
        d = getch();
        switch(d){
            case KEY_DOWN:
                if((i + 1) > -1 && (i + 1) < 3)
                    i++;
                break;
            case KEY_UP:
                if((i - 1) > -1 && (i - 1) < 3)
                    i--;
                break;
            case 10:
                switch(i){
                    case 0:
                        eroe->inv = addInventario(eroe->inv,a1);
                        eroe->inv = addInventario(eroe->inv,p1);
                        eroe->inv = addInventario(eroe->inv,s1);
                        eroe->attacco = 3;
                        eroe->difesa = 1;
                        strcpy(eroe->classe,"Guerriero");
                        printw("Fatto!\nPremi un tasto per continuare...\n");
                        refresh();
                        getch();
                        break;
                    case 1:
                        eroe->inv = addInventario(eroe->inv,a2);
                        eroe->inv = addInventario(eroe->inv,p2);
                        eroe->inv = addInventario(eroe->inv,s1);
                        eroe->attacco = 2;
                        eroe->difesa = 1;
                        strcpy(eroe->classe,"Mago");
                        printw("Fatto!\nPremi un tasto per continuare...\n");
                        refresh();
                        getch();
                        break;
                    case 2:
                        eroe->inv = addInventario(eroe->inv,a3);
                        eroe->inv = addInventario(eroe->inv,p3);
                        eroe->inv = addInventario(eroe->inv,s1);
                        eroe->attacco = 1;
                        eroe->difesa = 3;
                        strcpy(eroe->classe,"Difensore");
                        printw("Fatto!\nPremi un tasto per continuare...\n");
                        refresh();
                        getch();
                        break;
                }
                break;
        }
    }while(d != 10);
}

void pausa(const Giocatore eroe, const Matchar mappa){
    int c;
    clear();
    do{
        printw("Nome: [ %s ]\nLivello: [ %d ]\nHP: [ %d / %d]\nClasse: [ %s ]\nAttacco: [ %.0f ]\nDifesa: [ %.0f ]\nExp: [ %d ]\nDannies: [ %d ]\n\n",\
        eroe->nome, eroe->livello, eroe->vita, eroe->salute, eroe->classe, eroe->attacco, eroe->difesa, eroe->esperienza, eroe->dannies);
        printw("1) Cambia nome\n2) Usa oggetti\n3) Salva progressi\n4) Ritorna al gioco\n\n");
        refresh();
        do{
            c = getch();
            if(c < 49 || c > 52){
                printw("riprova:\n");
                refresh();
            }
        }while(c < 49 || c > 52);
        switch(c){
            case 49:
                settaNome(eroe);
                clear();
                break;
            case 50:
                settaEquip(eroe,0);
                clear();
                break;
            case 51:
                salva(eroe, mappa);
                clear();
                break;
            case 52:
                return;
        }
    }while(1);
}

void cercaPosizione(Matchar this, Pos *pos){
    int i, j;
    for(i = 0; i < this->righe;i++){
        for(j = 0; j < this->colonne; j++){
            if(this->matrice[i][j] == '@'){
                (pos->x) = j;
                (pos->y) = i;
                this->matrice[i][j] = ' ';
                return;
            }
        }
    }
    pos->x = pos->y = 0;
}

Inventario caricaInv(FILE *f){
    Inventario inv = NULL;
    Oggetto obj;
    int x = 0, c;
    while(!feof(f)){
        obj.nome[x++] = fgetc(f);
        if(obj.nome[x-1] == ':')
            break;
        if(obj.nome[x-1] == '\n')
            return inv;
    }
    obj.nome[x-1] = '\0';
    fscanf(f,"%d",&(obj.tipo));
    inv = addInventario(inv,obj);
    while(!feof(f)){
        x = 0;
        while(!feof(f)){
            obj.nome[x++] = fgetc(f);
            if(obj.nome[x-1] == ':')
                break;
            if(obj.nome[x-1] == '\n')
                return inv;
            if(obj.nome[x-1] == ' ' && (c = x-1) == 0)
                x--;
        }
        obj.nome[x-1] = '\0';
        fscanf(f,"%d",&(obj.tipo));
        inv = addInventario(inv,obj);
    }
    return inv;
}

void salvaInv(Inventario inv, FILE *f){
    Inventario app = inv;
    if(!inv)
        return;
    while(app){
        fprintf(f,"%s: %d ",(app->object).nome,(app->object).tipo);
        app = app->next;
    }
    fprintf(f,"\n");
}

int cercaInventario(Inventario inv, char *nome){
    Inventario app = inv;
    while(app){
        if(strcmp((app->object).nome,nome) == 0)
            return (app->object).tipo;
        app = app->next;
    }
    return -1;
}

void settaEquip(const Giocatore eroe, int toggle){
    int d, heal, oldw, att, def, f, g, i;
    char **nome = inventString(eroe->inv);
    int quanti = conta(eroe->inv);
    Oggetto o;
    if(!(eroe->equip))
        printw("Non hai niente addosso...\n");
    else{
        printw("Protezione: [ %s ]\nArma: [ %s ]\nAccessorio: [ %s ]\n\n", eroe->equip->protezione->nome, \
        eroe->equip->arma->nome, eroe->equip->accessorio->nome);
    }
    refresh();
    if((eroe->inv) == NULL)
        printw("Non hai niente nell'inventario...\n");
    else{
        i = 0;
        do{
            print2(nome,quanti,i);
            move(7,0);
            printw("\nSU | GIU' o F1 per uscire\n");
            refresh();
            g = getch();
            switch(g){
                case KEY_DOWN:
                    if((i + 1) > -1 && (i + 1) < quanti)
                        i++;
                    break;
                case KEY_UP:
                    if((i - 1) > -1 && (i - 1) < quanti)
                        i--;
                    break;
                case 10:
                d = cercaInventario(eroe->inv,nome[i]);
                switch(d){
                    case 0:
                        printw("[ %s ]\nPremi un tasto...", nome[i]);
                        refresh();
                        getch();
                        clear();
                        break;
                    case 1:
                        printw("E' un'arma: vuoi equipaggiarla? [ 1 si - 2 no ]\n");
                        do{
                            f = getch();
                            if(f < 49 || f > 50){
                                printw("riprova:");
                                refresh();
                            }
                        }while(f < 49 || f > 50);
                        switch(f){
                            case 49:
                                if(eroe->equip != NULL){
                                    if(strcmp(eroe->equip->arma->nome,"-") != 0){
                                        oldw = cercaArma(armi,eroe->equip->arma->nome);
                                        eroe->attacco -= oldw;
                                    }
                                    strcpy(o.nome,eroe->equip->arma->nome);
                                    o.tipo = d;
                                    eroe->inv = addInventario(eroe->inv,o);
                                    heal = cercaArma(armi,nome[i]);
                                    eroe->attacco += heal;
                                    strcpy(eroe->equip->arma->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                else{
                                    eroe->equip = (Equipaggiamento)malloc(sizeof(equipaggiamento));
                                    eroe->equip->arma = (Arma)malloc(sizeof(arma));
                                    heal = cercaArma(armi,nome[i]);
                                    eroe->attacco += heal;
                                    strcpy(eroe->equip->arma->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                clear();
                                break;
                            case 50:
                                break;
                        }
                        break;
                    case 2:
                        printw("E' una protezione: vuoi equipaggiarla? [ 1  si - 2 no ]\n");
                        do{
                            f = getch();
                            if(f < 49 || f > 50){
                                printw("riprova:");
                                refresh();
                            }
                        }while(f < 49 || f > 50);
                        switch(f){
                            case 49:
                                if(eroe->equip != NULL){
                                    if(strcmp(eroe->equip->protezione->nome,"-") != 0){
                                        oldw = cercaProtezione(protezioni,eroe->equip->protezione->nome);
                                        eroe->difesa -= oldw;
                                    }
                                    strcpy(o.nome,eroe->equip->protezione->nome);
                                    o.tipo = d;
                                    eroe->inv = addInventario(eroe->inv,o);
                                    heal = cercaProtezione(protezioni,nome[i]);
                                    eroe->difesa += heal;
                                    strcpy(eroe->equip->protezione->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                else{
                                    eroe->equip = (Equipaggiamento)malloc(sizeof(equipaggiamento));
                                    eroe->equip->protezione = (Protezione)malloc(sizeof(protezione));
                                    heal = cercaProtezione(protezioni,nome[i]);
                                    eroe->difesa += heal;
                                    strcpy(eroe->equip->protezione->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                clear();
                                break;
                            case 50:
                                break;
                        }
                        break;
                    case 3:
                        printw("E' un accessorio: vuoi equipaggiarlo? [ 1 si - 2 no ]\n");
                        do{
                            f = getch();
                            if(f < 49 || f > 50){
                                printw("riprova:");
                                refresh();
                            }
                        }while(f < 49 || f > 50);
                        switch(f){
                            case 49:
                                if(eroe->equip != NULL){
                                    if(strcmp(eroe->equip->accessorio->nome,"-") != 0){
                                        cercaAccessorio(accessori,eroe->equip->accessorio->nome,&att,&def);
                                        eroe->attacco -= att;
                                        eroe->difesa -= def;
                                    }
                                    strcpy(o.nome,eroe->equip->accessorio->nome);
                                    o.tipo = d;
                                    eroe->inv = addInventario(eroe->inv,o);
                                    cercaAccessorio(accessori,nome[i],&att,&def);
                                    eroe->attacco += att;
                                    eroe->difesa += def;
                                    strcpy(eroe->equip->accessorio->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                else{
                                    eroe->equip = (Equipaggiamento)malloc(sizeof(equipaggiamento));
                                    eroe->equip->accessorio = (Accessorio)malloc(sizeof(accessorio));
                                    cercaAccessorio(accessori,nome[i],&att,&def);
                                    eroe->attacco += att;
                                    eroe->difesa += def;
                                    strcpy(eroe->equip->accessorio->nome,nome[i]);
                                    rimuoviOggetto(eroe->inv,nome[i]);
                                }
                                clear();
                                break;
                            case 50:
                                break;
                        }
                        break;
                    case 4:
                        if(eroe->vita == eroe->salute)
                            printw("Salute al massimo!\n");
                        else{
                            eroe->inv = rimuoviOggetto(eroe->inv,nome[i]);
                            heal = cercaCura(cure,nome[i]);
                            if((eroe->salute - eroe->vita) > heal)
                                eroe->vita +=heal;
                            else
                                eroe->vita += (eroe->salute - eroe->vita);
                        }
                        printw("Premi un tasto...");
                        refresh();
                        getch();
                        clear();
                        break;
                    default:
                        printw("Oggetto appena usato!\n");
                        refresh();
                        getch();
                        break;
                }
                break;
            }
        }while(g != KEY_F(1));
    }
}

Inventario rimuoviOggetto(Inventario top, char *nome) {
    Inventario tmp;
    if (top != NULL){
        if (strcmp((top->object).nome,nome) == 0) {
            tmp = top->next;
            free(top);
            top = NULL;
            top=tmp;
        }
        else
            top->next = rimuoviOggetto(top->next,nome);
    }
    return top;
}

int cercaCura(Cura *cura, char *nome){
    int i;
    for(i = 0; i < M_CURE; i++){
        if(strcmp(cura[i].nome,nome) == 0)
            return cura[i].vita;
    }
    return -1;
}

int cercaArma(arma *weapon, char *nome){
    int i;
    for(i = 0; i < M_ARMI; i++){
        if(strcmp(weapon[i].nome,nome) == 0)
            return weapon[i].attacco;
    }
    return -1;
}

int cercaProtezione(protezione *prot, char *nome){
    int i;
    for(i = 0; i < M_PROT; i++){
        if(strcmp(prot[i].nome,nome) == 0)
            return prot[i].difesa;
    }
    return -1;
}

void cercaAccessorio(accessorio *acc, char *nome, int *atk, int *def){
    int i;
    for(i = 0; i < M_ACC; i++){
        if(strcmp(acc[i].nome,nome) == 0){
            *atk = acc[i].attacco;
            *def = acc[i].difesa;
            break;
        }
    }
}

void mappaMostri(Matchar this){
    int i, c, d;
    for(i = 0; i < (this->righe * this->colonne) / 5; i++){
        c = rand() % this->righe;
        d = rand() % this->colonne;
        if(this->matrice[c][d] == ' ')
            this->matrice[c][d] = 'm';
    }
    this->matrice[this->righe - 1][this->colonne - 1] = 'M';
}

void mappaOggetti(Matchar this){
    int i, c, d, e;
    for(i = 0; i < (this->righe * this->colonne) / 5; i++){
        c = rand() % this->righe;
        d = rand() % this->colonne;
        if(this->matrice[c][d] == 94){
            e = rand() % 2;
            if(e == 0)
                this->matrice[c][d] = '.';
            else if(e == 1)
                this->matrice[c][d] = ',';
        }
    }
}

int leggiInventario(Inventario inv, int toggle){
    Inventario app = inv;
    int i = 1, c = 0, atk, def;
    if(toggle == 0){
        while(app){
            if(strcmp((app->object).nome,"-") == 0){
                app = app->next;
                continue;
            }
            else{
                printw("%d) %s - ", i, (app->object).nome);
                if((app->object).tipo == 0)
                    printw("Oggetto\n");
                else if((app->object).tipo == 1){
                    printw("Arma [ attacco + %d ]\n", cercaArma(armi,(app->object).nome));
                    c++;
                }
                else if((app->object).tipo == 2){
                    printw("Protezione [ difesa + %d ]\n", cercaProtezione(protezioni,(app->object).nome));
                    c++;
                }
                else if((app->object).tipo == 3){
                    cercaAccessorio(accessori,(app->object).nome,&atk,&def);
                    printw("Accessorio [ attacco + %d | difesa + %d ]\n", atk, def);
                    c++;
                }
                else if((app->object).tipo == 4){
                    printw("Cura [ salute + %d ]\n", cercaCura(cure,(app->object).nome));
                }
                app = app->next;
                i++;
                refresh();
            }
        }
    }
    else if(toggle == 1){
        while(app){
            if((app->object).tipo == 4){
                printw("%d) %s - ", i, (app->object).nome);
                printw("Cura [ salute + %d ]\n", cercaCura(cure,(app->object).nome));
                i++;
            }
            app = app->next;
            refresh();
        }
    }
    return c;
}

Inventario addInventario(Inventario inv, Oggetto object){
    Inventario new = (Inventario)malloc(sizeof(inventario));
    strcpy((new->object).nome,object.nome);
    (new->object).tipo = object.tipo;
    new->next = inv;
    return new;
}


void print(char **stringhe, int quanti, int quale){
    int i;
    clear();
    printw("Scegli:\n\n");
    for(i = 0; i < quanti; i++){
        if(i == quale){
            attron(COLOR_PAIR(1));
            printw(" > %s\n",stringhe[i]);
            attroff(COLOR_PAIR(1));
            continue;
        }
        printw(" > %s\n", stringhe[i]);
    }
    refresh();
}

Giocatore newGiocatore(){
    Giocatore new = (Giocatore)malloc(sizeof(giocatore));
    new->equip = (Equipaggiamento)malloc(sizeof(equipaggiamento));
    new->equip->arma = (Arma)malloc(sizeof(arma));
    new->equip->accessorio = (Accessorio)malloc(sizeof(accessorio));
    new->equip->protezione = (Protezione)malloc(sizeof(protezione));
    new->inv = NULL;
    return new;
}


void settaNome(const Giocatore eroe){
    printw("Il tuo nome attuale e' [ %s ]\n\n", eroe->nome);
    printw("Che nome vuoi?\n> ");
    echo();
    scanw("%[^\n]s", eroe->nome);
    noecho();
}

void printFile(const char *filename){
    FILE *f = fopen(filename,"r");
    char c;
    while(!feof(f)){
        c = fgetc(f);
        if(c == EOF)
            break;
        printf("%c",c);
    }
    fclose(f);
}

void loadLivello(Matchar this, char *nomeScena){
    int i, j;
    char c;
    strcpy(this->scenario,nomeScena);
    FILE *f = fopen(nomeScena,"r");
    if(f){
        for(i = 0; i < this->righe; i++){
            for(j = 0; j < this->colonne; j++)
                fscanf(f,"%c", &(this->matrice[i][j]));
            fscanf(f,"%c", &c);
        }
        fclose(f);
    }
    else{
        printw("OPS!");
        refresh();
        getch();
    }
}

void negozio(Giocatore eroe, Matchar this){
    char *neg1[] = {"1. Pozione - cura [ 50 d ]","2. Granpozione - cura [ 100 d ]","3. Spada di ferro corta [ 150 d ]","4. Spada di ferro media [ 50 d ]","5. Nunchaku [ 50 d ]","6. Daga [ 50 d ]","7. Scudo grande di ferro [ 50 d ]","8. Armatura di acciaio [ 50 d ]","9. Cappa corta incantata [ 50 d ]","10. Scudo grande d'oro [ 50 d ]"};
    char *neg2[] = {"1. Extrapozione - cura [ 250 d ]","2. Midelisir - cura [ 400 d ]","3. Elisir - cura [ 1000 d ]"};
    int c, i = 0;
    Oggetto o;
    if(strcmp(this->scenario,"inizio.txt") == 0){
        refresh();
        print(neg1,2,i);
        printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
        while((c = getch()) != KEY_F(1)){
            switch(c){
                case KEY_DOWN:
                    if((i + 1) > -1 && (i + 1) < 2)
                        i++;
                    refresh();
                    print(neg1,2,i);
                    printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
                    break;
                case KEY_UP:
                    if((i - 1) > -1 && (i - 1) < 2)
                        i--;
                    refresh();
                    print(neg1,2,i);
                    printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
                    break;
                case 10:
                    switch(i){
                        case 0:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            else{
                                eroe->dannies -= 50;
                                strcpy(o.nome,"pozione");
                                o.tipo = 4;
                                eroe->inv = addInventario(eroe->inv,o);
                                printw("Preso!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 1:
                            if(eroe->dannies < 100){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            else{
                                eroe->dannies -= 100;
                                strcpy(o.nome,"granpozione");
                                o.tipo = 4;
                                eroe->inv = addInventario(eroe->inv,o);
                                printw("Preso!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 2:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 3:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 4:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 5:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 6:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 7:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 8:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 9:
                            if(eroe->dannies < 50){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            break;
                    }
            }
        }
    }
    else{
        refresh();
        print(neg2,3,i);
        printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
        while((c = getch()) != KEY_F(1)){
            switch(c){
                case KEY_DOWN:
                    if((i + 1) > -1 && (i + 1) < 3)
                        i++;
                    refresh();
                    print(neg2,3,i);
                    printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
                    break;
                case KEY_UP:
                    if((i - 1) > -1 && (i - 1) < 3)
                        i--;
                    refresh();
                    print(neg2,3,i);
                    printw("\n\n:- NEGOZIO -:\n\nDANNIES : %d\n\nSU | GIU' o F1 per uscire\n\n", eroe->dannies);
                    break;
                case 10:
                    switch(i){
                        case 0:
                            if(eroe->dannies < 250){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            else{
                                eroe->dannies -= 250;
                                strcpy(o.nome,"extrapozione");
                                o.tipo = 4;
                                eroe->inv = addInventario(eroe->inv,o);
                                printw("Preso!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 1:
                            if(eroe->dannies < 400){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            else{
                                eroe->dannies -= 400;
                                strcpy(o.nome,"midelisir");
                                o.tipo = 4;
                                eroe->inv = addInventario(eroe->inv,o);
                                printw("Preso!\n");
                                refresh();
                                getch();
                            }
                            break;
                        case 2:
                            if(eroe->dannies < 1000){
                                printw("Soldi non sufficienti!\n");
                                refresh();
                                getch();
                            }
                            else{
                                eroe->dannies -= 1000;
                                strcpy(o.nome,"elisir");
                                o.tipo = 4;
                                eroe->inv = addInventario(eroe->inv,o);
                                printw("Preso!\n");
                                refresh();
                                getch();
                            }
                            break;
                    }
                    break;
            }
        }
    }
}

char **inventString(Inventario inv){
    Inventario app = inv;
    char **strings;
    int i, cont = 0;
    while(app){
        cont++;
        app = app->next;
    }
    app = inv;
    strings = (char **)malloc(cont * sizeof(char *));
    for(i = 0; i < cont; i++){
        strings[i] = (char *)malloc(ML * sizeof(char));
    }
    i = 0;
    while(app){
        if(strcmp((app->object).nome,"-") != 0)
            strcpy(strings[i++],(app->object).nome);
        app = app->next;
    }
    return strings;
}

int conta(Inventario inv){
    int i = 0;
    Inventario app = inv;
    while(app){
        if(strcmp((app->object).nome,"-") != 0)
            i++;
        app = app->next;
    }
    return i;
}

void cercaPng1(Matchar this, Pos *coord){
    int i, j;
    for(i = 0; i < this->righe; i++)
        for(j = 0; j < this->colonne; j++)
            if(this->matrice[i][j] == 'g'){
                coord->x = j;
                coord->y = i;
                this->matrice[i][j] = ' ';
                return;
            }
}

Punti singolo(Pos pos){
    Punti a = (Punti)malloc(sizeof(punti));
    a->pos = pos;
    a->next = NULL;
    return a;
}

Punti addCoda(Punti old, Pos pos){
    if(!old)
        return singolo(pos);
    else
        old->next = addCoda(old->next,pos);
    return old;
}

Punti moveMonster(Matchar ok, Pos then){
    Punti a = singolo(then);
    then.x += 1;
//    if(then.x > ok->colonne)
//        then.x = then.x - ok->colonne;
    a = addCoda(a,then);
    then.x += 1;
//    if(then.x > ok->colonne)
//        then.x = then.x - ok->colonne;
    a = addCoda(a,then);
    then.x -= 1;
//    if(then.x < 0)
//        then.x = ok->colonne + then.x;
    a = addCoda(a,then);
    then.x -= 1;
//    if(then.x < 0)
//        then.x = ok->colonne + then.x;
    a = addCoda(a,then);
    then.y += 1;
//    if(then.y > ok->righe)
//        then.y = then.y - ok->righe;
    a = addCoda(a,then);
    then.y += 1;
//    if(then.y > ok->righe)
//        then.y = then.y - ok->righe;
    a = addCoda(a,then);
    then.y -= 1;
//    if(then.y < 0)
//        then.y = ok->righe + then.y;
    a = addCoda(a,then);
    then.y -= 1;
//    if(then.y < 0)
//        then.y = ok->righe + then.y;
    a = addCoda(a,then);
    then.x -= 1;
//    if(then.x < 0)
//        then.x = ok->colonne + then.x;
    a = addCoda(a,then);
    then.x -= 1;
//    if(then.x < 0)
//        then.x = ok->colonne + then.x;
    a = addCoda(a,then);
    then.x += 1;
//    if(then.x > ok->colonne)
//        then.x = then.x - ok->colonne;
    a = addCoda(a,then);
    then.x += 1;
//    if(then.x > ok->colonne)
//        then.x = then.x - ok->colonne;
    a = addCoda(a,then);
    then.y -= 1;
//    if(then.y < 0)
//        then.y = ok->righe + then.y;
    a = addCoda(a,then);
    then.y -= 1;
//    if(then.y < 0)
//        then.y = ok->righe + then.y;
    a = addCoda(a,then);
    then.y += 1;
//    if(then.y > ok->righe)
//        then.y = then.y - ok->righe;
    a = addCoda(a,then);
    then.y += 1;
//    if(then.y > ok->righe)
//        then.y = then.y - ok->righe;
    a = addCoda(a,then);
    return a;
}

Punti removeTesta(Punti a, Pos *then){
    if(a){
        then->x = (a->pos).x;
        then->y = (a->pos).y;
        a = a->next;
    }
    return a;
}

Punti freePunti(Punti old){
    if(old){
        old->next = freePunti(old->next);
        free(old);
        old = NULL;
    }
    return old;
}

void print2(char **stringhe, int quante, int quale){
    int i;
    clear();
    printw("Scegli un oggetto:\n\n");
    for(i = quale; i < quale + 5; i++){
        if(i == quale){
            attron(COLOR_PAIR(1));
            printw("%d. %s\n", i + 1, stringhe[i]);
            attroff(COLOR_PAIR(1));
            continue;
        }
        else if(i == quante)
            break;
        printw("%d. %s\n", i + 1, stringhe[i]);
    }
    refresh();
}

void parla(Matchar this, Giocatore eroe){
    char *scelte[] = {"Si","No"};
    int c, i = 0, v;
    if(strcmp(this->scenario,"inizio.txt") == 0){
        printw("Ciao! Vuoi sentire una storia?");
        refresh();
        getch();
        while(1){
            print(scelte,2,i);
            c = getch();
            switch(c){
                case KEY_UP:
                    i--;
                    if(i < 0)
                        i = 1;
                    break;
                case KEY_DOWN:
                    i++;
                    if(i == 2)
                        i = 0;
                    break;
                case 10:
                    switch(i){
                        case 1:
                            printw("Vabbe', ciao allora :-\\");
                            refresh();
                            getch();
                            break;
                        case 0:
                            printw("LOL no!! :^D");
                            refresh();
                            getch();
                            break;
                    }
                    return;
            }
        }
    }
    else{
        printw("Cerchi rogne?!");
        refresh();
        getch();
        while(1){
            print(scelte,2,i);
            c = getch();
            switch(c){
                case KEY_UP:
                    i--;
                    if(i < 0)
                        i = 1;
                    break;
                case KEY_DOWN:
                    i++;
                    if(i == 2)
                        i = 0;
                    break;
                case 10:
                    switch(i){
                        case 0:
                            printw("LE AVRAI!!");
                            refresh();
                            getch();
                            v = battle(eroe,boss[3]);
                            clear();
                            if(v == 1){
                                printw("Pfff...pivello!!");
                                refresh();
                                getch();
                            }
                            else{
                                printw("\n\nMmh...sei forte...VABBEH...");
                                refresh();
                                getch();
                            }
                            break;
                        case 1:
                            printw("MEGLIO PER TE!!");
                            refresh();
                            getch();
                            break;
                    }
                    return;
            }
        }
    }
}

// UTILITY.H //

#ifndef HEADER_240D4408939FB0C2
#define HEADER_240D4408939FB0C2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <curses.h>
#include <math.h>

#define M_ARMI 13
#define M_PROT 13
#define M_ACC 13
#define M_CURE 5
#define M_MOSTRI 12
#define ML 1024

typedef struct matrice matrice;
typedef matrice *Matrice;
typedef struct matchar matchar;
typedef matchar *Matchar;
typedef struct posizione Pos;

typedef struct giocatore giocatore;
typedef giocatore *Giocatore;
typedef struct equipaggiamento equipaggiamento;
typedef equipaggiamento *Equipaggiamento;
typedef struct inventario inventario;
typedef inventario *Inventario;
typedef struct protezione protezione;
typedef protezione *Protezione;
typedef struct arma arma;
typedef arma *Arma;
typedef struct accessorio accessorio;
typedef accessorio *Accessorio;
typedef struct mostro Mostro;
typedef struct oggetto Oggetto;
typedef struct cura Cura;
typedef struct listaPunti punti;
typedef punti *Punti;

struct oggetto{
    char nome[ML];
    int tipo;
};

struct cura{
    char nome[ML];
    int vita;
};

struct protezione{
    char nome[ML];
    int difesa;
};

struct arma{
    char nome[ML];
    int attacco;
};

 struct accessorio{
    char nome[ML];
    int attacco;
    int difesa;
};

struct equipaggiamento{
    Protezione protezione;
    Arma arma;
    Accessorio accessorio;
};

struct giocatore{
    char nome[ML];
    char scenario[ML];
    int vita;
    int salute;
    int esperienza;
    int dannies;
    char classe[ML];
    float attacco;
    float difesa;
    int progresso;
    int livello;
    int passi;
    int boss_sconfitti;
    Equipaggiamento equip;
    Inventario inv;
};

struct inventario{
    Oggetto object;
    struct inventario *next;
};

struct mostro{
    char nome[ML];
    int vita;
    int attacco;
    int difesa;
    int esperienza;
    int dannies;
    Oggetto object;
};


Giocatore newGiocatore();

void settaNome(const Giocatore eroe);

void start();

/* funzione di input per gli interi con controllo degli errori
   pre: richiesta di acquisizione di un intero
   post: viene restituito effettivamente un intero
*/
int inputInt();

void printFile(const char *filename);

/* funzione di scelta di un opzione
   pre: richiesta di scelta di un intero nell'intervallo [min, max]
   post: viene restituito un intero all'interno dell'intervallo [min, max]
*/
int choose(int min, int max);

struct posizione{
    int x;
    int y;
};

struct matrice{
    int **matrice;
    int righe;
    int colonne;
};

struct matchar{
    char **matrice;
    int righe;
    int colonne;
    char scenario[ML];
};


struct listaPunti{
    Pos pos;
    struct listaPunti *next;
};

int inputInt();
int **allocaMat(int righe, int colonne);
char **allocaMatchar(int righe, int colonne);
Matrice newMatrice();
Matchar newMatchar();
void setMatrice(Matrice this);
void setRandomMatrice(Matrice this);
void setRandomMatchar(Matchar this);
void initMatchar(Matchar this);
void initMatrice(Matrice this);
void getMatrice(Matrice this);
void getMatchar(Matchar this);
void mappaMostri(Matchar this);
void mappaOggetti(Matchar this);

void saveMatchar(Matchar this,FILE *f);
void saveMatrice(Matrice this);
Matchar loadMatchar(char *nomefile);
void loadMatrice(Matchar this);

void start(Matchar this, Giocatore eroe);
Matchar menu();
void menu1(Matchar this);
/* v da fare v */
Matchar menu2();
void edita(Matchar this);
int choose(int min, int max);

void game();
Matchar new_game(Giocatore eroe);
Matchar load(Giocatore eroe);
void story(Matchar mappa, Giocatore eroe);
int battle(Giocatore eroe, Mostro m);
void level_up(Giocatore eroe);

void salva(const Giocatore eroe, const Matchar mappa);
Matchar carica(Giocatore eroe, char *nomefile);

void creaGiocatore(const Giocatore eroe);
void pausa(Giocatore eroe, Matchar mappa);
void cercaPosizione(Matchar this, Pos *pos);
Inventario caricaInv(FILE *f);
void salvaInv(Inventario inv, FILE *f);
int cercaInventario(Inventario inv, char *nome);
void settaEquip(const Giocatore eroe, int toggle);
int cercaCura(Cura *cura, char *nome);
int cercaArma(arma *weapon, char *nome);
int cercaProtezione(protezione *prot, char *nome);
void cercaAccessorio(accessorio *acc, char *nome, int *atk, int *def);
Inventario rimuoviOggetto(Inventario inv, char *nome);
int leggiInventario(Inventario inv, int toggle);
Inventario addInventario(Inventario inv, Oggetto object);

void print(char **stringhe, int quanti, int quale);
void loadLivello(Matchar this, char *nomeScena);
void negozio(Giocatore eroe, Matchar this);
char **inventString(Inventario inv);
int conta(Inventario inv);
void cercaPng1(Matchar this, Pos *coord);

Punti singolo(Pos pos);
Punti addCoda(Punti old, Pos pos);
Punti moveMonster(Matchar ok, Pos then);
Punti removeTesta(Punti a, Pos *then);

Punti freePunti(Punti old);

void print2(char **stringhe, int quante, int quale);
void parla(Matchar this, Giocatore eroe);

#endif // header guard