cyberk0s

CYBERK.0SM

ici, la consigne était de faire un jeu simple dans le terminal linux, en C. le professeur avait fourni des fonctions pour gérer la mémoire (du genre "stdprof_free()"). je ne vais inclure que les parties du code sur lesquelles j'ai travaillé, donc certains fichiers (main.c notamment) vont sembler incohérents. comme précisé dans l'index, il y a aussi une vidéo pour visualiser le rendu final.

entity.c

            
#include "entity.h"
#include "stdprof.h"
#include "player.h"



Pentity Init_monstre(void){
    /*Initalise une entité par défaut*/
    Pentity Monstre = stdprof_malloc(sizeof(entity));
    Monstre->name = stdprof_malloc(64*sizeof(char));
    Monstre->strength = 0;
    Monstre->hp = 0;
    Monstre->hp_max = 0;
    Monstre->coX = 0;
    Monstre->coY = 0;
    return Monstre;
}

/*INUTILE pour l'instant*/
void Update_health(Pentity E, int n_vie) { /* Pour modifier la vie du joueur avec la nouvelle valeur*/
    if (n_vie>=0 && n_vie<=E->hp){
        E->hp = n_vie;
    }
    else {
        fprintf(stderr, "La nouvelle valeur de vie n'est pas inclue entre 0 et %d",E->hp);
        exit(1);
    }
}

void DelEntity(Pentity E){
    stdprof_free(E->name);
    E->name = NULL;
    if (E!=NULL){
        stdprof_free(E);
        E = NULL;
    }

}

entity.h

            
#ifndef ENTITY_H
#define ENTITY_H
#include <stdlib.h>
#include <stdio.h>
#include "player.h"

typedef struct entity_struct {
    char * name;
    int strength;
    int hp_max;
    int hp;
    int coX;
    int coY;

}entity;

typedef entity * Pentity;



char *GetEntityName(entity *E);
/*int attack(entity * attaquant, entity * cible, int IDA);*/
Pentity Init_monstre(void);
void Update_health(entity *E, int n_vie);
void init_monstre(Pentity * ListeMonstre); /*la fonction renvoie un tableau de pointeurs, on prend donc le pointeur vers le premier élément du tableau*/
void DelEntity(Pentity E);


#endif

object.c

                
#include <stdlib.h>
#include "object.h"
#include "stdprof.h"

Pobject Init_Object(void) {
    /*Initialise un objet avec des valeurs par défaut*/
    Pobject Obj = stdprof_malloc(sizeof(Pobject));
    Obj->nom_item = stdprof_malloc(64*sizeof(char));
    Obj->description_item = stdprof_malloc(64*sizeof(char));
    Obj->stat_item = 0;
    Obj->ID = -1;
    Obj->coX = 0;
    Obj->coY = 0;
    return Obj;
}

void DelObjet(Pobject O) {
    stdprof_free(O->nom_item);
    O->nom_item = NULL;
    stdprof_free(O->description_item);
    O->description_item = NULL;
}

object.h

                
#ifndef OBJECT_H
#define OBJECT_H
#include <stdlib.h>
#include "object.h"
#include "stdprof.h"

enum id {chaussures, protections, armes};

typedef struct object_struct{
    char * nom_item;
    char * description_item;
    int stat_item;
    int ID;
    int coX;
    int coY;
}object;

typedef object * Pobject;
Pobject Init_Object(void);
void DelObjet(Pobject O);

#endif

combat.c

                
#include "player.h"
#include "entity.h"
#include "combat.h"
#include "stdprof.h"
#include "commandes.h"

void display_combat(Pentity E,radahn R) {
    /*Affiche le menu de combat avec les interaction*/
    float i, j, p,l;
    i = ((float)R->Pentity->hp/(float)R->Pentity->hp_max)*50;
    j = ((float)E->hp/(float)E->hp_max) * 50;
    printf("\n\n\n\n");
    printf("\t\t\t\t\t+----------------------------------------------------------------------------+\n");
    printf("\t\t\t\t\t|    #####      #####     ####     ####   #####         ####     ########### |\n");
    printf("\t\t\t\t\t|  ########    ##   ##    #####   #####   ### ##      ###  ###   ########### |\n");
    printf("\t\t\t\t\t| ###         ##     ##   ### ## ## ###   #####      ###    ###      ###     |\n");
    printf("\t\t\t\t\t| ###         ##     ##   ###  ###  ###   ######    ############     ###     |\n");
    printf("\t\t\t\t\t|  ########    ##   ##    ###       ###   ###  ##  ###        ###    ###     |\n");
    printf("\t\t\t\t\t|    #####      #####     ###       ###   ######   ###        ###    ###     |\n");
    printf("\t\t\t\t\t+----------------------------------------------------------------------------+\n");
    printf("\n\n\n\n\n");
    printf("+--------------------------------------------------+\n|");
    for (p=0; p < i; p++) {
        printf("#");
    }
    for (l=p; l < 50; l++) {
        printf(" ");
    }
    printf("| Radahn: %d/%d\n+--------------------------------------------------+\n\n\n\n",R->Pentity->hp,R->Pentity->hp_max);

    printf("+--------------------------------------------------+\n|");
    for (p=0; p < j; p++) {
        printf("#");
    }
    for (l=p; l < 50; l++) {
        printf(" ");
    }
    printf("| %s: %d/%d\n+--------------------------------------------------+\n", E->name, E->hp,E->hp_max);
    
}

void damage(Pentity E, int dmg){
    /*Inflige les dégats à l'entité*/
    E->hp -= dmg;
}

void attack_fjoueur(radahn R, Pentity cible){
    /*Attaque le joueur*/
    damage(cible,R->Pentity->strength);
    printf("Vous avez infligé %d points de dégâts à %s \n",R->Pentity->strength,cible->name);
}

void attack_fentity(Pentity E, radahn R){
    /*Attaque l'entité*/
    damage(R->Pentity,E->strength);
    printf("Vous avez reçu %d points de dégâts de %s. PV : %d/%d \n",E->strength, E->name,R->Pentity->hp,R->Pentity->hp_max);
}

combat.h

                
#ifndef COMBAT_H
#define COMBAT_H
#include <stdio.h>
#include <stdlib.h>
#include "player.h"
#include "entity.h"

void display_combat(Pentity E,radahn R);
void attack_fentity(Pentity E,radahn R);
void attack_fjoueur(radahn R, Pentity cible);
void damage(Pentity E, int dmg);

#endif

player.c

                
#include "player.h"
#include "stdprof.h"
#include "entity.h"
#include "object.h"

radahn Init_player(void) { /*initialisation du joueur*/
    radahn Player = stdprof_malloc(sizeof(player));
    Player->Pentity = stdprof_malloc(sizeof(entity));
    Player->Parmure = stdprof_malloc(sizeof(object)); 
    Player->Parme = stdprof_malloc(sizeof(object));
    Player->Pbottes = stdprof_malloc(sizeof(object));
    Player->Pentity->coX = 0;
    Player->Pentity->coY = 0;
    Player->Pentity->strength=10;
    Player->coX_old = 0;
    Player->coY_old = 0;
    Player->tile1 = ' ';
    Player->tile2 = ' ';
    Player->Pentity->hp = 45;
    Player->Pentity->hp_max = 50;
    Player->vitesse = 1;
    Player->vitesse_max = 1;
    Player->crouchCondition = 0;
    return Player;
}

void heal(radahn R, Pobject O){
    /*Soigne le joueur*/
    if (R->Pentity->hp+O->stat_item>=R->Pentity->hp_max){
        R->Pentity->hp = R->Pentity->hp_max;
    }
    else{
        R->Pentity->hp += O->stat_item;}
}


void crouch(radahn R) {
    /*Permet au joueur de réduire sa vitesse ou de la remettre par défaut selon crouch_condition*/
    if (R->crouchCondition == 0) {
        R->crouchCondition = 1;
        R->vitesse = 1;
    }
    else {
        R->vitesse = R->vitesse_max;
        R->crouchCondition = 0;
    }
}


void DelItem(Pobject Item){
    /*Supprime la mémoire allouée à l'armure*/
    DelObjet(Item);
    if (Item !=NULL){
        stdprof_free(Item);
    }
    Item=NULL;
}

void DeleteRadahn(radahn R) {
    /*Supprime le joueur*/
    DelItem(R->Parmure);
    DelItem(R->Parme);
    DelItem(R->Pbottes);
    if (R->Pentity!=NULL){
        DelEntity(R->Pentity);
        stdprof_free(R->Pentity);
    }
    R->Pentity=NULL;
    stdprof_free(R);
    R=NULL;
}

player.h


                
#ifndef PLAYER_H
#define PLAYER_H
#include <stdlib.h>
#include <stdio.h>
#include "entity.h"
#include "object.h"

typedef struct player_struct {
    struct entity_struct * Pentity;
    struct object_struct * Parmure;
    struct object_struct * Parme;
    struct object_struct * Pbottes;
    int coX_old;
    int coY_old;
    char tile1;
    char tile2;
    int vitesse;
    int crouchCondition;
    int vitesse_max;
} player;

typedef player * radahn; /*Pour faciliter la modification du joueur */

radahn Init_player(void);

void heal(radahn R, Pobject O);
void crouch(radahn R);

void DelItem(Pobject Item);

void DeleteRadahn(radahn R);

#endif

main.c

                
#include <stdio.h>
#include <stdlib.h>
#include "stdprof.h"
#include "map_editor.h"
#include "player.h"
#include "entity.h"
#include "combat.h"
#include "commandes.h"
#define False 0
#define True 1

void interaction(radahn R,char current_tile, char ** Matrice, int x, int y,map_info*Map);
Pentity EmplacementMonstre(int X, int Y,map_info *Map);
Pobject EmplacementNourriture(int X, int Y, map_info *Map);
Pobject EmplacementObjet(int X, int Y,map_info *Map);

void SetCurrentWeapon(radahn R, Pobject PW) { 
    /*Si l'arme découverte est meilleure, Radahn la prend*/
    if ((R->Pentity->strength - 10 ) < PW->stat_item){
        R->Pentity->strength = 10 + PW->stat_item;
        R->Parme->nom_item = PW->nom_item;
        R->Parme = PW;
    }
}


void SetCurrentChaussures(radahn R, Pobject C){
    /*Remplace les bottes si leur vitesse est supérieure à celle du joueur*/
    if (R->vitesse_max <= C->stat_item){
        
        R->vitesse_max = 1+C->stat_item;
        R->vitesse = 1+C->stat_item;
        R->Pbottes = C;
    }

}

void SetCurrentArmor(radahn R, Pobject A) {
    /*Rajoute de l'armure au joueur si celle ci lui rapporte plus de points de vie*/
    if (R->Pentity->hp_max - 50 < A->stat_item){
        R->Parmure = A;
        R->Pentity->hp_max = 50+A->stat_item;
        if (R->Pentity->hp + A->stat_item >= R->Pentity->hp_max){
            R->Pentity->hp = R->Pentity->hp_max; }
        else{ R->Pentity->hp = R->Pentity->hp + A->stat_item; }
    }

}

Pentity EmplacementMonstre(int X, int Y,map_info *Map){ 
    /*cette fonction n'est appelée que dans interaction (donc quand un @ est rencontré)*/
    int i = 0,l = Map->nombreMonstre;
    for (i=0;i<l;i++){
        if (X==Map->ListeMonstre[i]->coX && Y==Map->ListeMonstre[i]->coY){
            return Map->ListeMonstre[i];
        }
    }
    return NULL;

}

Pobject EmplacementNourriture(int X, int Y, map_info *Map){ 
    /*cette fonction n'est appelée que dans interaction (donc quand un @ est rencontré)*/
    int i = 0, l = Map->nombreNourriture;
    for (i=0;i<l;i++){
        if (X==Map->ListeNourriture[i]->coX && Y==Map->ListeNourriture[i]->coY){
            return Map->ListeNourriture[i];
        }
    }
    return NULL;
}

Pobject EmplacementObjet(int X, int Y,map_info *Map){ 
    /*cette fonction n'est appelée que dans interaction (donc quand un @ est rencontré)*/
    int i = 0, l = Map->nombreObjet;
    for (i=0;i<l;i++){
        if (X==Map->ListeObjet[i]->coX && Y==Map->ListeObjet[i]->coY){
            return Map->ListeObjet[i];
        }
    }
    return NULL;
}

int combat(Pentity Mob, radahn R){ 
    /*si return 0, le mob est mort, si return 1 radahn est mort, si return -1, le joueur fuit*/
    char touche;
    int tour = 0;
    
    do{
        display_combat(Mob, R);
        printf("%s vous attaque. 'a' pour attaquer, 'f' pour fuir.\n Que faire> ",Mob->name);
        while (getchar() != '\n') {}
        touche = getchar();
        /*while (getchar() != '\n') {}*/
        switch (touche) {
            case 'a' : 
                {
                    if (tour%2==0){
                        attack_fjoueur(R,Mob);
                    }
                    else{
                        attack_fentity(Mob,R);
                    }
                    tour++;
                    break;
                }
            case 'f' : 
                printf("Vous fuyez, lâchement...\n");
                return -1;
            }
    }   while (Mob->hp > 0 && R->Pentity->hp > 0);
        display_combat(Mob, R);
        if (R->Pentity->hp <= 0){
            printf("Vous êtes mort...\n");
            return 1;
        }
        printf("Vous avez vaincu %s!\n",Mob->name);
        return 0;
}


void Liberer_OBJECTS(Pobject * L){
    /*Libere une liste d'objets*/
    int i = 0;
    for (i=0;i<100;i++){
        DelItem(L[i]);
        stdprof_free(L[i]);
        L[i] = NULL;
    }
    stdprof_free(L);
    *L = NULL;
}

void Liberer_ENTITY(Pentity * L){
    /*Libère une liste d'entités*/
    int i = 0;
    for (i=0;i<100;i++){
        DelEntity(L[i]);
        stdprof_free(L[i]);
        L[i] = NULL;
    }
    stdprof_free(L);
    *L = NULL;
}



void interaction(radahn R,char current_tile, char ** Matrice, int x, int y, map_info * Map) {
    /*Vérifie quel type d'interaction le joueur va déclencher et appelle les fonctions en conséquences*/
    Pobject objet; 
    int issue_combat;
    switch (current_tile)
    {

    case ' ':
        Arret_joueur = 0;
        break;
    case 'Y':
        printf("Olivier, l'Arbre Démiurge. \n");
        break;
    case '*':
        printf("Vous avez trouvé de la nourriture : ");
        printf("%s",EmplacementNourriture(x,y, Map)->description_item);
        heal(R,EmplacementNourriture(x,y, Map));
        Matrice[y][x] = ' ';
        Arret_joueur = 0;
        break;
    case '@':
        printf("Vous affrontez un %s", EmplacementMonstre(x,y, Map)->name);
        issue_combat = combat(EmplacementMonstre(x,y, Map),R);
        if (issue_combat == 0){
            Matrice[y][x] = ' ';
        }
        else if (issue_combat == 1) {
            mort_joueur = 1;
        }
        Arret_joueur = 1;
        break;
    case '!':
        objet = EmplacementObjet(x,y, Map);
        printf("%d", objet->ID);
        if (objet->ID==0){
            SetCurrentChaussures(R,objet);
        }
        if (objet->ID == 1){
            SetCurrentArmor(R,objet);
        }
        if (objet->ID == 2){
            SetCurrentWeapon(R,objet);
        }
        Matrice[y][x] = ' ';
        /*stdprof_free(objet);
        objet=NULL;*/
        Arret_joueur = 1;
        break;
    default:
        printf("Interaction");
        Arret_joueur = 1;
        break;
        
    }
    
}   

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

    stdprof_free(nom_fichier);
    DeleteRadahn(Radahn);
    Liberer_OBJECTS(Map->ListeNourriture);
    Liberer_OBJECTS(Map->ListeObjet);
    Liberer_ENTITY(Map->ListeMonstre);
    Liberer_matrice(Matrice, Map);
    return 0;

}