JCS-Prod/AST
1
0
Fork 0
Code Issues Releases Activity

Merge branch 'arena'

Browse Source
This commit is contained in:
JackCarterSmith 2018-06-23 11:45:32 +02:00
commit 8faa5edc7b
19 changed files with 2204 additions and 1882 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -41,6 +41,9 @@
*.su
*.idb
*.pdb
docs\
latex\
html\
# Kernel Module Compile Results
*.mod*

0
data/Adventurer2/playerInterface.h → data/Adventurer2/playerInterface.h~HEAD
View File

1005
src/IAEngine.c
View File

File diff suppressed because it is too large Load Diff

53
src/IAEngine.h
View File

@ -1,30 +1,23 @@
/*
* IAEngine.h
*
* Created on: 17 juin 2018
* Author: isen
*/
#ifndef IAENGINE_H_
#define IAENGINE_H_
typedef struct noeud
{
int compteur, min, cout_f; //
int ParentX;
int ParentY;
// 'adresse' du parent (qui sera toujours dans la map fermée)
}NOEUD;
int FindShortestPath(int Player1PositionX, int Player1PositionY, int Player2PositionX, int Player2PositionY);
//int IAEngine(PLAYER * player1, PLAYER * player2);
int IAEngine(ARENA_H_TILE* arena,PLAYER * player1, PLAYER * player2);
int distance(int x1, int y1, int x2, int y2);
//int CalculatePath(ARENA_H_TILE* arena,int PositionX, int PositionY,PLAYER * player1, int compteur, int distance,int min);
//int CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1, int compteur, int dist,int min);
NOEUD * CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1,PLAYER * player2, int compteur, int dist,int min);
//NOEUD * CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1, int compteur, int dist,int min);
#endif /* IAENGINE_H_ */
#ifndef IAENGINE_H_
#define IAENGINE_H_
typedef struct noeud
{
int compteur, min, cout_f; //
int ParentX;
int ParentY;
// 'adresse' du parent (qui sera toujours dans la map fermée)
}NOEUD;
int FindShortestPath(int Player1PositionX, int Player1PositionY, int Player2PositionX, int Player2PositionY);
//int IAEngine(PLAYER * player1, PLAYER * player2);
int IAEngine(ARENA_H_TILE* arena,PLAYER * player1, PLAYER * player2);
int distance(int x1, int y1, int x2, int y2);
//int CalculatePath(ARENA_H_TILE* arena,int PositionX, int PositionY,PLAYER * player1, int compteur, int distance,int min);
//int CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1, int compteur, int dist,int min);
NOEUD * CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1,PLAYER * player2, int compteur, int dist,int min);
//NOEUD * CalculatePath(ARENA_H_TILE* arena,int posX, int posY,NOEUD * n1,PLAYER * player1, int compteur, int dist,int min);
#endif /* IAENGINE_H_ */

491
src/arenaEngine.c
View File

@ -1,105 +1,168 @@
#include "arenaEngine.h"
#include <stdlib.h>
#include <stdio.h>
#include "fileHandler.h"
//#include "logHelper.h"
#include "logHelper.h"
#include "arenaEngine.h"
/*
* Arena generate functions
*/
TILE *createTileList(void) {
TILE *tile_0 = NULL, *tile_1 = NULL, *tile_2 = NULL, *tile_3 = NULL, *tile_4 = NULL, *tile_5 = NULL;
#define BLOC_SIZE 32 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 20
#define NB_BLOCS_HAUTEUR 20
#define LARGEUR_FENETRE BLOC_SIZE * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE BLOC_SIZE * NB_BLOCS_HAUTEUR
tile_0 = calloc(1,sizeof(TILE));
tile_1 = calloc(1,sizeof(TILE));
tile_2 = calloc(1,sizeof(TILE));
tile_3 = calloc(1,sizeof(TILE));
tile_4 = calloc(1,sizeof(TILE));
tile_5 = calloc(1,sizeof(TILE));
tile_0->type_id = 0;
tile_0->texture = IMG_Load("data/tile_grass.png");
tile_0->canBeMined = 0;
tile_0->isGround = 1;
tile_0->nextTile = tile_1;
tile_1->type_id = 1;
tile_1->texture = IMG_Load("data/tile_rock.png");
tile_1->canBeMined = 0;
tile_1->isGround = 1;
tile_1->nextTile = tile_2;
ARENA_H_TILE* genNewArena(int size_h, int size_w)
{
ARENA_H_TILE* arenaOrigin = NULL;
ARENA_H_TILE* TmpCursor_h = NULL;
ARENA_W_TILE* TmpCursor_w = NULL;
int i,j;
tile_2->type_id = 2;
tile_2->texture = IMG_Load("data/tile_tree.png");
tile_2->canBeMined = 0;
tile_2->isGround = 0;
tile_2->nextTile = tile_3;
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
//int i = 0, j = 0;
tile_3->type_id = 3;
tile_3->texture = IMG_Load("data/tile_water.png");
tile_3->canBeMined = 0;
tile_3->isGround = 0;
tile_3->nextTile = tile_4;
printf("Chargement du fichier\n");
fichier = fopen("level2-20x20.lvl", "r");
tile_4->type_id = 4;
tile_4->texture = IMG_Load("data/tile_gold.png");
tile_4->canBeMined = 1;
tile_4->isGround = 1;
tile_4->nextTile = tile_5;
if (fichier == NULL)
return 0;
tile_5->type_id = 5;
tile_5->texture = IMG_Load("data/tile_spawn.png");
tile_5->canBeMined = 0;
tile_5->isGround = 1;
tile_5->nextTile = NULL;
fgets(ligneFichier, size_w * size_h + 1, fichier);
for(i=0;i<size_h;i++)
{
if (i==0)
{
arenaOrigin = createHTile(NULL);
TmpCursor_h = arenaOrigin;
}
else
{
TmpCursor_h = createHTile(TmpCursor_h);
}
for(j=0;j<size_w;j++)
{
if (j==0)
{
TmpCursor_w = createWTile(TmpCursor_h, NULL);
}
else
{
createWTile(NULL, TmpCursor_w);
}
switch (ligneFichier[(i * size_w) + j])
{
case '0': TmpCursor_w->type_id = 0;
//printf("herbe\n");
break;
case '1':
TmpCursor_w->type_id = 1;
// printf("caillou\n");
break;
case '2':
TmpCursor_w->type_id = 2;
//printf("arbre\n");
break;
}
if (j!=0) TmpCursor_w = TmpCursor_w->nextColumn;
}
}
return arenaOrigin;
return tile_0;
}
PLAYER *createPlayerList(void) {
PLAYER *p0 = NULL, *p1 = NULL, *p2 = NULL, *p3 = NULL;
p0 = calloc(1,sizeof(PLAYER));
p1 = calloc(1,sizeof(PLAYER));
p2 = calloc(1,sizeof(PLAYER));
p3 = calloc(1,sizeof(PLAYER));
p0->Id = 0;
p0->PositionX = 0;
p0->PositionY = 0;
p0->texture[DOWN] = IMG_Load("data/sprite_player_0.png");
p0->texture[UP] = IMG_Load("data/sprite_player_1.png");
p0->texture[LEFT] = IMG_Load("data/sprite_player_2.png");
p0->texture[RIGHT] = IMG_Load("data/sprite_player_3.png");
p0->suiv = p1;
ARENA_H_TILE* createHTile(ARENA_H_TILE* prevHTile)
{
p1->Id = 1;
p1->PositionX = A_WIDTH;
p1->PositionY = A_HEIGHT;
p1->texture[DOWN] = IMG_Load("data/sprite_ia_0.png");
p1->texture[UP] = IMG_Load("data/sprite_ia_1.png");
p1->texture[LEFT] = IMG_Load("data/sprite_ia_2.png");
p1->texture[RIGHT] = IMG_Load("data/sprite_ia_3.png");
p1->suiv = p2;
p2->Id = 0;
p2->PositionX = 0;
p2->PositionY = A_HEIGHT;
//p2->texture[DOWN] = IMG_Load("data/sprite_player_0.png");
//p2->texture[UP] = IMG_Load("data/sprite_player_1.png");
//p2->texture[LEFT] = IMG_Load("data/sprite_player_2.png");
//p2->texture[RIGHT] = IMG_Load("data/sprite_player_3.png");
p2->suiv = p3;
p3->Id = 0;
p3->PositionX = A_WIDTH;
p3->PositionY = 0;
//p3->texture[DOWN] = IMG_Load("data/sprite_player_0.png");
//p3->texture[UP] = IMG_Load("data/sprite_player_1.png");
//p3->texture[LEFT] = IMG_Load("data/sprite_player_2.png");
//p3->texture[RIGHT] = IMG_Load("data/sprite_player_3.png");
p3->suiv = NULL;
return p1;
}
void clearRessourcesCache(TILE *t, PLAYER *p) {
PLAYER *p0 = NULL, *p1 = NULL, *p2 = NULL, *p3 = NULL;
TILE *tile_0 = NULL, *tile_1 = NULL, *tile_2 = NULL, *tile_3 = NULL, *tile_4 = NULL, *tile_5 = NULL;
int i;
p0 = p;
p1 = p0->suiv;
p2 = p1->suiv;
p3 = p2->suiv;
tile_0 = t;
tile_1 = tile_0->nextTile;
tile_2 = tile_1->nextTile;
tile_3 = tile_2->nextTile;
tile_4 = tile_3->nextTile;
tile_5 = tile_4->nextTile;
for (i=0;i<=3;i++) {
SDL_FreeSurface(p0->texture[i]);
}
for (i=0;i<=3;i++) {
SDL_FreeSurface(p1->texture[i]);
}
/*
for (i=0;i<=3;i++) {
SDL_FreeSurface(p2->texture[i]);
}
for (i=0;i<=3;i++) {
SDL_FreeSurface(p3->texture[i]);
}
*/
free(p3);free(p2);free(p1);free(p0);
SDL_FreeSurface(tile_0->texture);
SDL_FreeSurface(tile_1->texture);
SDL_FreeSurface(tile_2->texture);
SDL_FreeSurface(tile_3->texture);
SDL_FreeSurface(tile_4->texture);
SDL_FreeSurface(tile_5->texture);
free(tile_0);free(tile_1);free(tile_2);free(tile_3);free(tile_4);free(tile_5);
}
ARENA_H_TILE* createHTile(ARENA_H_TILE* prevHTile) {
ARENA_H_TILE* tile_h = NULL;
if (prevHTile == NULL)
{
if (prevHTile == NULL) {
tile_h = calloc(1,sizeof(ARENA_H_TILE)); //Using calloc because of resetting all memory allocated to 0
tile_h->type_id = 0;
//tile_h->type_id = random_lim(5);
//tile_h->playerOnTile = NULL;
tile_h->nextRow = NULL;
tile_h->nextColumn = NULL;
}
else if (prevHTile != NULL)
{
} else if (prevHTile != NULL) {
tile_h = calloc(1,sizeof(ARENA_H_TILE));
prevHTile->nextRow = tile_h;
tile_h->type_id = 0;
//tile_h->type_id = random_lim(5);
//tile_h->playerOnTile = NULL;
tile_h->nextRow = NULL;
tile_h->nextColumn = NULL;
@ -108,59 +171,96 @@ ARENA_H_TILE* createHTile(ARENA_H_TILE* prevHTile)
return tile_h;
}
ARENA_W_TILE* createWTile(ARENA_H_TILE* prevHTile, ARENA_W_TILE* prevWTile)
{
ARENA_W_TILE* createWTile(ARENA_H_TILE* prevHTile, ARENA_W_TILE* prevWTile) {
ARENA_W_TILE* tile_w = NULL;
if (prevHTile != NULL && prevWTile == NULL)
{
if (prevHTile != NULL && prevWTile == NULL) {
tile_w = calloc(1,sizeof(ARENA_W_TILE));
prevHTile->nextColumn = tile_w;
tile_w->type_id = 0;
//tile_w->type_id = random_lim(5);
//tile_w->playerOnTile = NULL;
tile_w->nextColumn = NULL;
return tile_w;
}
else if (prevHTile == NULL && prevWTile != NULL)
{
} else if (prevHTile == NULL && prevWTile != NULL) {
tile_w = calloc(1,sizeof(ARENA_W_TILE));
prevWTile->nextColumn = tile_w;
tile_w->type_id = 0;
//tile_w->type_id = random_lim(5);
//tile_w->playerOnTile = NULL;
tile_w->nextColumn = NULL;
}
return NULL;
}
/*
ARENA_H_TILE* genNewArena(int size_h, int size_w)
{
int setTileTypeID(ARENA_H_TILE* arena, int x, int y, int new_id) {
int i;
//x=coord_x-1;
//y=coord_y-1;
if (x > A_WIDTH || y > A_HEIGHT || x < 0 || y < 0) return -1;
if (y == 0) {
ARENA_H_TILE* tile_h = NULL;
tile_h = arena;
if (x != 0) {
for (i=0;i<x;i++) {
tile_h = tile_h->nextRow;
}
}
tile_h->type_id = new_id;
if (tile_h->type_id == new_id) return 0;
} else {
ARENA_W_TILE* tile_w = NULL;
ARENA_H_TILE* tile_h = NULL;
tile_h = arena;
if (x != 0) {
for (i=0;i<x;i++) {
tile_h = tile_h->nextRow;
}
}
tile_w = tile_h->nextColumn;
if (y != 0) {
for (i=0;i<y;i++) {
tile_w = tile_w->nextColumn;
}
}
tile_w->type_id = new_id;
if (tile_w->type_id == new_id) return 0;
}
return -1;
}
ARENA_H_TILE* genNewArena(int size_h, int size_w) {
ARENA_H_TILE* arenaOrigin = NULL;
ARENA_H_TILE* TmpCursor_h = NULL;
ARENA_W_TILE* TmpCursor_w = NULL;
int i,j;
int z,i,j,rand_x,rand_y;
for(i=0;i<size_h;i++)
{
if (i==0)
{
/*
* Generate new flatgrass arena
*/
for(i=0;i<=size_h;i++){
if (i==0) {
arenaOrigin = createHTile(NULL);
TmpCursor_h = arenaOrigin;
}
else
{
} else {
TmpCursor_h = createHTile(TmpCursor_h);
}
for(j=0;j<size_w;j++)
{
if (j==0)
{
for(j=0;j<=size_w;j++){
if (j==0) {
TmpCursor_w = createWTile(TmpCursor_h, NULL);
}
else
{
} else {
createWTile(NULL, TmpCursor_w);
}
@ -168,16 +268,103 @@ ARENA_H_TILE* genNewArena(int size_h, int size_w)
}
}
/*
* Generate some rock area
*/
for (z=1; z <= A_WIDTH * A_HEIGHT * ROCK_GEN_RATE/100; z++) {
rand_x = random_lim(A_WIDTH)-1;
rand_y = random_lim(A_HEIGHT)-1;
for (i=-2;i<=1;i++) {
for (j=-1;j<=3;j++) {
if (random_lim(101) < 65) {
if (((rand_x + i) >= 0 && (rand_x + i) < A_WIDTH) && ((rand_y + j) >= 0 && (rand_y + j) < A_HEIGHT)) {
if(setTileTypeID(arenaOrigin, rand_x+i, rand_y+j, ROCK)!=0) addLogWarn("Failed to add rock on arena."); else z++;
}
}
}
}
}
/*
* Generate some tree area on grass
*/
for (z=1; z <= A_WIDTH * A_HEIGHT * TREE_GEN_RATE/100; z++) {
rand_x = random_lim(A_WIDTH)-1;
rand_y = random_lim(A_HEIGHT)-1;
for (i=-2;i<=2;i++) {
for (j=-2;j<=2;j++) {
if (random_lim(101) < 65) {
if (((rand_x + i >= 0 && rand_x + i < A_WIDTH) && (rand_y + j >= 0 && rand_y + j < A_HEIGHT)) && getTileTypeID(arenaOrigin, rand_x+i, rand_y+j) == GRASS) {
if(setTileTypeID(arenaOrigin, rand_x+i, rand_y+j, TREE)!=0) addLogWarn("Failed to tree add on arena."); else z++;
}
}
}
}
}
/*
* Generate some gold area on rock
*/
for (z=1; z <= A_WIDTH * A_HEIGHT * GOLD_GEN_RATE/100; z++) {
rand_x = random_lim(A_WIDTH)-1;
rand_y = random_lim(A_HEIGHT)-1;
if (((rand_x + i >= 0 && rand_x + i <= A_WIDTH) && (rand_y + j >= 0 && rand_y + j <= A_HEIGHT)) && getTileTypeID(arenaOrigin, rand_x+i, rand_y+j) == ROCK) {
if(setTileTypeID(arenaOrigin, rand_x+i, rand_y+j, GOLD)!=0) addLogWarn("Failed to add gold on arena."); else z++;
}
}
/*
* Generate some water area on grass
*/
for (z=1; z <= A_WIDTH * A_HEIGHT * WATER_GEN_RATE/100; z++) {
rand_x = random_lim(A_WIDTH)-1;
rand_y = random_lim(A_HEIGHT)-1;
for (i=-2;i<=2;i++) {
for (j=-3;j<=3;j++) {
if (i >= -1 && j >= -1 && i <= 1 && j <= 1) {
if (((rand_x + i) >= 0 && (rand_x + i) < A_WIDTH) && ((rand_y + j) >= 0 && (rand_y + j) < A_HEIGHT)) {
if(setTileTypeID(arenaOrigin, rand_x+i, rand_y+j, WATER)!=0) {
addLogWarn("Failed to add water on arena.");
}else z++;
}
} /*else {
if (random_lim(101) < 60) {
if ((rand_x + i >= 0 && rand_x + i <= A_WIDTH) && (rand_y + i >= 0 && rand_y + i <= A_HEIGHT)) {
if(setTileTypeID(arenaOrigin, rand_x+i, rand_y+j, WATER)!=0) addLogWarn("Tree failed to add on arena."); else z++;
}
}
}*/
}
}
}
/*
* Generate spawn
*/
for (z=0; z <= 1; z++) {
if(setTileTypeID(arenaOrigin, 0+z, 0, SPAWN)!=0) addLogWarn("Failed to add spawn area up left corner");
if(setTileTypeID(arenaOrigin, 0, 0+z, SPAWN)!=0) addLogWarn("Failed to add spawn area up left corner");
if(setTileTypeID(arenaOrigin, 0+z, 0+z, SPAWN)!=0) addLogWarn("Failed to add spawn area up left corner");
}
for (z=0; z <= 1; z++) {
if(setTileTypeID(arenaOrigin, A_WIDTH-1-z, A_HEIGHT-1, SPAWN)!=0) addLogWarn("Failed to add spawn area botton right corner");
if(setTileTypeID(arenaOrigin, A_WIDTH-1, A_HEIGHT-1-z, SPAWN)!=0) addLogWarn("Failed to add spawn area botton right corner");
if(setTileTypeID(arenaOrigin, A_WIDTH-1-z, A_HEIGHT-1-z, SPAWN)!=0) addLogWarn("Failed to add spawn area botton right corner");
}
return arenaOrigin;
}
*/
/*
* Arena delete functions
*/
void deleteWTile(ARENA_W_TILE* WTile)
{
void deleteWTile(ARENA_W_TILE* WTile) {
if (WTile->nextColumn != NULL) {
deleteWTile(WTile->nextColumn);
}
@ -185,10 +372,8 @@ void deleteWTile(ARENA_W_TILE* WTile)
free(WTile);
}
void deleteHTile(ARENA_H_TILE* HTile)
{
if (HTile->nextRow != NULL)
{
void deleteHTile(ARENA_H_TILE* HTile) {
if (HTile->nextRow != NULL) {
deleteHTile(HTile->nextRow);
}
@ -196,8 +381,7 @@ void deleteHTile(ARENA_H_TILE* HTile)
free(HTile);
}
void deleteArena(ARENA_H_TILE* arena)
{
void deleteArena(ARENA_H_TILE* arena) {
deleteHTile(arena);
}
@ -206,45 +390,39 @@ void deleteArena(ARENA_H_TILE* arena)
/*
* Arena status functions
*/
int getTileTypeID(ARENA_H_TILE* arena, int coord_x, int coord_y)
{
int getTileTypeID(ARENA_H_TILE* arena, int coord_x, int coord_y) {
int type_id = -1;
int i;
//coord_x=x-1;
//coord_y=y-1;
if (coord_y == 0)
{
if (coord_x > A_WIDTH || coord_y > A_HEIGHT || coord_x < 0 || coord_y < 0) return -1;
if (coord_y == 0) {
ARENA_H_TILE* tile_h = NULL;
tile_h = arena;
if (coord_x != 0)
{
for (i=0;i<coord_x;i++)
{
tile_h = arena->nextRow;
if (coord_x != 0) {
for (i=0;i<coord_x;i++) {
tile_h = tile_h->nextRow;
}
}
type_id = tile_h->type_id;
}
else
{
} else {
ARENA_W_TILE* tile_w = NULL;
ARENA_H_TILE* tile_h = NULL;
tile_h = arena;
if (coord_x != 0)
{
for (i=0;i<coord_x;i++)
{
if (coord_x != 0) {
for (i=0;i<coord_x;i++) {
tile_h = tile_h->nextRow;
}
}
tile_w = tile_h->nextColumn;
if (coord_y != 0)
{
for (i=0;i<coord_y;i++)
{
if (coord_y != 0) {
for (i=0;i<coord_y;i++) {
tile_w = tile_w->nextColumn;
}
}
@ -254,3 +432,66 @@ int getTileTypeID(ARENA_H_TILE* arena, int coord_x, int coord_y)
return type_id;
}
int isGroundTile(TILE *t_list, int id) {
TILE *tmp_tile = NULL;
int i=0;
tmp_tile = t_list;
while (i<id) {
tmp_tile = tmp_tile->nextTile;
i++;
}
return tmp_tile->isGround;
}
SDL_Surface *getTileSurfaceFromID(TILE *t_list, int id) {
TILE *tmp_tile = NULL;
int i=0;
tmp_tile = t_list;
while (i<id) {
tmp_tile = tmp_tile->nextTile;
i++;
}
return tmp_tile->texture;
}
int isPlayerAdjacent(PLAYER* p1, PLAYER* p2) {
int adjPlayer = -1;
if ((p1->PositionX-1 || p1->PositionX+1) == p2->PositionX && (p1->PositionY-1 || p1->PositionY+1) == p2->PositionY) adjPlayer = 1;
return adjPlayer;
}
int isMoveCorrect(ARENA_H_TILE* arena, TILE *t_list, int coord_x, int coord_y, int direction) {
if (!((coord_x <= 0 && direction == LEFT) || (coord_y <= 0 && direction == UP) || (coord_x >= A_HEIGHT && direction == RIGHT) || (coord_y >= A_WIDTH && direction == DOWN))) {
if (isGroundTile(t_list,getTileTypeID(arena,coord_x,coord_y))) {
return 1;
}
}
return 0;
}
int getRelativeDirection(SDL_Rect pos1, SDL_Rect pos2) {
int _x,_y;
_x = pos2.x - pos1.x;
_y = pos2.y - pos1.y;
if (_x>1) {
return DOWN;
} else if (_x<1) {
return UP;
} else if (_y>1) {
return RIGHT;
} else if (_y<1) {
return LEFT;
} else {
return -1;
}
}

122
src/arenaEngine.h
View File

@ -1,52 +1,70 @@
//#include "playerInterface.h"
#ifndef ARENAENGINE_H_
#define ARENAENGINE_H_
/*
typedef struct items{
int type_id;
//texture?
int isFlat;
int minedId;
struct items *nextItem;
}ITEMS;
*/
typedef struct tileType
{
int type_id;
//texture?
int isGround;
int canBeMined;
}TILE;
typedef struct arena_h_tile
{ //Rows chained list
int type_id;
//PLAYER* playerOnTile;
struct arena_h_tile *nextRow;
struct arena_w_tile *nextColumn;
}ARENA_H_TILE;
typedef struct arena_w_tile
{ //Columns chained list
int type_id;
//PLAYER* playerOnTile;
struct arena_w_tile *nextColumn;
}ARENA_W_TILE;
//Generation functions
ARENA_H_TILE* genNewArena(int size_h, int size_w);
void deleteArena(ARENA_H_TILE* arena);
ARENA_H_TILE* createHTile(ARENA_H_TILE* prevHTile);
ARENA_W_TILE* createWTile(ARENA_H_TILE* prevHTile, ARENA_W_TILE* prevWTile);
//Status functions
int getTileTypeID(ARENA_H_TILE* arena, int coord_x, int coord_y);
#endif
#include "main.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#ifndef ARENAENGINE_H_
#define ARENAENGINE_H_
typedef struct tileType{
int type_id;
SDL_Surface *texture;
int isGround;
int canBeMined;
struct tileType *nextTile;
}TILE;
typedef struct Player
{
int Id;
char Name[35];
//char Race[20];
SDL_Surface *texture[4];
int HealthPoints;
int AttacksPoints;
int DefensePoints;
int PositionX;
int PositionY;
//char Weapons[Max_Weapons];
//int Coins;
struct Player * suiv;
}PLAYER;
typedef struct arena_h_tile{ //Rows chained list
int type_id;
//PLAYER* playerOnTile;
struct arena_h_tile *nextRow;
struct arena_w_tile *nextColumn;
}ARENA_H_TILE;
typedef struct arena_w_tile{ //Columns chained list
int type_id;
//PLAYER* playerOnTile;
struct arena_w_tile *nextColumn;
}ARENA_W_TILE;
//Generation functions
TILE* createTileList(void);
PLAYER *createPlayerList(void);
void clearRessourcesCache(TILE *t, PLAYER *p);
int setTileTypeID(ARENA_H_TILE* arena, int x, int y, int new_id);
ARENA_H_TILE* genNewArena(int size_h, int size_w);
void deleteArena(ARENA_H_TILE* arena);
//Status functions
int getTileTypeID(ARENA_H_TILE* arena, int coord_x, int coord_y);
int isGroundTile(TILE *t_list, int id);
SDL_Surface *getTileSurfaceFromID(TILE *t_list, int id);
int isPlayerAdjacent(PLAYER* p1, PLAYER* p2);
int isMoveCorrect(ARENA_H_TILE* arena, TILE *t_list, int coord_x, int coord_y, int direction);
int getRelativeDirection(SDL_Rect pos1, SDL_Rect pos2);
#endif

37
src/arenaGUI.c
View File

@ -1,3 +1,34 @@
#include <stdio.h>
#include <stdlib.h>
#include "SDL2/SDL.h"
#include <stdio.h>
#include <stdlib.h>
#include "logHelper.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include "arenaGUI.h"
void displayArena(ARENA_H_TILE* arena, SDL_Window* window, TILE *tiles, int size_h, int size_w, int tile_size) {
SDL_Rect tmp_tile_coord;
int i,j;
for (i=0; i<size_h; i++) {
for (j=0; j<size_w; j++) {
tmp_tile_coord.x = i * tile_size;
tmp_tile_coord.y = j * tile_size;
SDL_BlitSurface(getTileSurfaceFromID(tiles,getTileTypeID(arena,i,j)), NULL, SDL_GetWindowSurface(window), &tmp_tile_coord);
SDL_UpdateWindowSurface(window);
}
}
}
void updatePlayerPos(ARENA_H_TILE* arena, SDL_Window* window, PLAYER *player, TILE *tiles, SDL_Rect new_coord) {
SDL_Rect old_coord;
old_coord.x = player->PositionX;
old_coord.y = player->PositionY;
SDL_BlitSurface(getTileSurfaceFromID(tiles,getTileTypeID(arena,player->PositionX,player->PositionY)), NULL, SDL_GetWindowSurface(window), &old_coord);
SDL_BlitSurface(player->texture[getRelativeDirection(old_coord, new_coord)], NULL, SDL_GetWindowSurface(window), &new_coord);
SDL_UpdateWindowSurface(window);
}

16
src/arenaGUI.h
View File

@ -1,6 +1,10 @@
#ifndef ARENAGUI_H_
#define ARENAGUI_H_
#endif
#include "main.h"
#include "arenaEngine.h"
#ifndef ARENAGUI_H_
#define ARENAGUI_H_
void displayArena(ARENA_H_TILE* arena, SDL_Window* windows, TILE *tiles, int size_h, int size_w, int tile_size);
void updatePlayerPos(ARENA_H_TILE* arena, SDL_Window* window, PLAYER *player, TILE *tiles, SDL_Rect new_coord);
#endif

220
src/fileHandler.c
View File

@ -1,118 +1,102 @@
/*
* fileHandler.c
*
* Created on: 20 juin 2018
* Author: isen
*
* Contient la gestion des fichier et notament la récupération d'un niveau
*/
#include <stdlib.h>
#include <stdio.h>
#include "SDL2/SDL.h"
#include "SDL2/SDL_image.h"
#include "fileHandler.h"
//#include "main.c"
#define BLOC_SIZE 32 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 20
#define NB_BLOCS_HAUTEUR 20
#define LARGEUR_FENETRE BLOC_SIZE * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE BLOC_SIZE * NB_BLOCS_HAUTEUR
/*
PLAYER * LoadLevel(ARENA_H_TILE *Head)
{
printf("Fonction Chargement d'un niveau\n");
if(Head == NULL)
{
printf("La liste est vide\n");
}
else
{
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
int i = 0, j = 0;
//Ouverture du fichier
fichier = fopen("level1.lvl", "r");
if (fichier == NULL)
return 0;
//Lecture du fichier
fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
{
case '0':
//Herbe
ARENA_H_TILE->Type = 0;
break;
case '1':
//Pierre
ARENA_H_TILE->Type = 1;
break;
case '2':
//Arbre
ARENA_H_TILE->Type = 2;
break;
case '3':
//Rivière
ARENA_H_TILE->Type = 3;
break;
}
Head = Head->suiv;
}
}
}
}
*/
//Fonction a réadapter avec la liste chainée Arene
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
int i = 0, j = 0;
printf("Chargement du fichier\n");
fichier = fopen("level1.lvl", "r");
if (fichier == NULL)
return 0;
fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
//printf("j= %i \n",j);
switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
{
case '0':
niveau[j][i] = 0;
//printf("herbe\n");
break;
case '1':
niveau[j][i] = 1;
// printf("caillou\n");
break;
case '2':
niveau[j][i] = 2;
//printf("arbre\n");
break;
}
}
//printf("Ligne\n");
}
fclose(fichier);
return 1;
}
#include <stdlib.h>
#include <stdio.h>
#include "SDL2/SDL.h"
#include "SDL2/SDL_image.h"
#include "fileHandler.h"
/*
PLAYER * LoadLevel(ARENA_H_TILE *Head)
{
printf("Fonction Chargement d'un niveau\n");
if(Head == NULL)
{
printf("La liste est vide\n");
}
else
{
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
int i = 0, j = 0;
//Ouverture du fichier
fichier = fopen("level1.lvl", "r");
if (fichier == NULL)
return 0;
//Lecture du fichier
fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
{
case '0':
//Herbe
ARENA_H_TILE->Type = 0;
break;
case '1':
//Pierre
ARENA_H_TILE->Type = 1;
break;
case '2':
//Arbre
ARENA_H_TILE->Type = 2;
break;
case '3':
//Rivière
ARENA_H_TILE->Type = 3;
break;
}
Head = Head->suiv;
}
}
}
}
*/
//Fonction a réadapter avec la liste chainée Arene
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
int i = 0, j = 0;
printf("Chargement du fichier\n");
fichier = fopen("level1.lvl", "r");
if (fichier == NULL)
return 0;
fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
//printf("j= %i \n",j);
switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
{
case '0':
niveau[j][i] = 0;
//printf("herbe\n");
break;
case '1':
niveau[j][i] = 1;
// printf("caillou\n");
break;
case '2':
niveau[j][i] = 2;
//printf("arbre\n");
break;
}
}
//printf("Ligne\n");
}
fclose(fichier);
return 1;
}

25
src/fileHandler.h
View File

@ -1,19 +1,6 @@
/*
* fileHandler.h
*
* Created on: 20 juin 2018
* Author: isen
*/
#ifndef FILEHANDLER_H_
#define FILEHANDLER_H_
#define BLOC_SIZE 32 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 20
#define NB_BLOCS_HAUTEUR 20
#define LARGEUR_FENETRE BLOC_SIZE * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE BLOC_SIZE * NB_BLOCS_HAUTEUR
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR]);
#endif /* FILEHANDLER_H_ */
#ifndef FILEHANDLER_H_
#define FILEHANDLER_H_
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR]);
#endif /* FILEHANDLER_H_ */

152
src/logHelper.c
View File

@ -1,76 +1,76 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "logHelper.h"
FILE *log_file=NULL;
int initialise_logger(){
time_t raw_time;
struct tm *pdh;
time(&raw_time);
pdh = localtime(&raw_time);
char name[32];
sprintf(name, "%04d-%02d-%02d.log", pdh->tm_year+1900, pdh->tm_mon+1, pdh->tm_mday);
log_file=fopen(name, "a");
if(log_file==NULL) //fichier innexistant
{
log_file=fopen(name,"w+");
if(log_file==NULL) { //Le prog n'a pas les droits en écriture
printf("\n****************************************************************\nATTENTION ! Le fichier de log ne peut être écris, aucune info ne sera enregistré !\n****************************************************************\n");
return -1;
}
}
return 0;
}
void stop_logger() {fclose(log_file);}
void addLogInfo(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[INFO][%s] %s\n", buffer, mess);
stop_logger();
}
void addLogWarn(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[WARN][%s] %s\n", buffer, mess);
stop_logger();
}
void addLogCritical(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[CRITICAL][%s] %s\n", buffer, mess);
stop_logger();
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "logHelper.h"
FILE *log_file=NULL;
int initialise_logger(){
time_t raw_time;
struct tm *pdh;
time(&raw_time);
pdh = localtime(&raw_time);
char name[32];
sprintf(name, "logs/%04d-%02d-%02d.log", pdh->tm_year+1900, pdh->tm_mon+1, pdh->tm_mday);
log_file=fopen(name, "a");
if(log_file==NULL) //fichier innexistant
{
log_file=fopen(name,"w+");
if(log_file==NULL) { //Le prog n'a pas les droits en écriture
printf("\n****************************************************************\nATTENTION ! Le fichier de log ne peut être écris, aucune info ne sera enregistré !\n****************************************************************\n");
return -1;
}
}
return 0;
}
void stop_logger() {fclose(log_file);}
void addLogInfo(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[INFO][%s] %s\n", buffer, mess);
stop_logger();
}
void addLogWarn(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[WARN][%s] %s\n", buffer, mess);
stop_logger();
}
void addLogCritical(char *mess){
time_t now;
struct tm* tm_info;
char buffer[12];
initialise_logger();
time(&now);
tm_info = localtime(&now);
strftime(buffer, 12, "%H:%M:%S", tm_info);
fprintf(log_file,"[CRITICAL][%s] %s\n", buffer, mess);
stop_logger();
}

22
src/logHelper.h
View File

@ -1,11 +1,11 @@
#ifndef LOGGER_H_
#define LOGGER_H_
int initialise_logger(); //Prépare le logger à écrire dans les fichiers de logs
void stop_logger();
void addLogInfo(char *mess); //Ajoute une entrée dans le fichier de log de type INFO
void addLogWarn(char *mess);
void addLogCritical(char *mess); //Ajoute une entrée dans le fichier de log de type CRITICAL
#endif
#ifndef LOGGER_H_
#define LOGGER_H_
int initialise_logger(); //Prépare le logger à écrire dans les fichiers de logs
void stop_logger();
void addLogInfo(char *mess); //Ajoute une entrée dans le fichier de log de type INFO
void addLogWarn(char *mess);
void addLogCritical(char *mess); //Ajoute une entrée dans le fichier de log de type CRITICAL
#endif

513
src/main.c
View File

@ -1,220 +1,293 @@
/*
* main.c
*
* Created on: 17 juin 2018
* Author: isen
*/
//#include "IAEngine.h"
#include "playerInterface.h"
#include "fileHandler.h"
#include "arenaEngine.h"
#include "SDL2/SDL.h"
#include "SDL2/SDL_image.h"
#include <stdio.h>
#include <stdlib.h>
#define BLOC_SIZE 32 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 20
#define NB_BLOCS_HAUTEUR 20
#define LARGEUR_FENETRE BLOC_SIZE * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE BLOC_SIZE * NB_BLOCS_HAUTEUR
enum {HAUT, BAS, GAUCHE, DROITE};
enum {GRASS, ROCK, TREE,FIRSTPLAYER, IA1}; //Définit quel type de case il s'agit
int main(void)
{
SDL_Init(SDL_INIT_VIDEO);
if (SDL_Init(SDL_INIT_VIDEO) != 0 )
{
fprintf(stdout,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
return -1;
}
else
{
int continuer = 1;
int action;
ARENA_H_TILE* arena = NULL; //Déclaration de l'arène
SDL_Surface *player[4] = {NULL}; // 4 surfaces pour 4 directions de mario
SDL_Surface *IA1[4] = {NULL}; // 4 surfaces pour 4 directions de mario
SDL_Surface *grass = NULL;
SDL_Surface *rock = NULL, *tree = NULL, *river = NULL,*actualPlayer = NULL, *actualIA1 = NULL;
SDL_Rect position, positionJoueur;
int i = 0, j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
//SDL_WM_SetIcon(IMG_Load("adventurer_resize.png"),NULL); //Définit l'icone de la fenêtre
// Création de la fenêtre
SDL_Window* pWindow = NULL;
pWindow = SDL_CreateWindow("Arena Survival Tournament",SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,LARGEUR_FENETRE,HAUTEUR_FENETRE,SDL_WINDOW_SHOWN);
//Génération de la nouvelle arène à partir du fichier
arena = genNewArena(NB_BLOCS_HAUTEUR, NB_BLOCS_LARGEUR);
if (arena == NULL)
{
printf("Erreur de la génération de l'arène\n");
}
// Chargement des sprites (décors, personnage...)
grass = IMG_Load("Landscape/grass_green_32x32.png");
rock = IMG_Load("Landscape/stone_green_32x32.png");
tree = IMG_Load("Landscape/tree_green_32x32.png");
river = IMG_Load("Landscape/river_green_32x32.png");
player[BAS] = IMG_Load("Adventurer/adventurer1_32x32.png");
player[HAUT] = IMG_Load("Adventurer/adventurer_back_32x32.png");
player[DROITE] = IMG_Load("Adventurer/adventurer1_right_32x32.png");
player[GAUCHE] = IMG_Load("Adventurer/adventurer1_left_32x32.png");
IA1[BAS] = IMG_Load("IA1/adventurer2_32x32.png");
IA1[HAUT] = IMG_Load("IA1/adventurer2_back_32x32.png");
IA1[DROITE] = IMG_Load("IA1/adventurer2_right_32x32.png");
IA1[GAUCHE] = IMG_Load("IA1/adventurer2_left_32x32.png");
actualPlayer = player[BAS];
actualIA1 = IA1[BAS];
SDL_Surface* Sprites[5]= {grass,rock,tree,actualPlayer,actualIA1};
// Chargement du niveau pour le tableau (Phase de test)
/*if (!chargerNiveau(carte))
{
printf("Niveau non chargé\n");// On arrête le jeu si on n'a pas pu charger le niveau
}*/
/*
//Cette fonction peut être utile pour rechercher un joueur ( Pour la detection)
// Recherche de la position de Mario au départ
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
if (carte[i][j] == MARIO) // Si Mario se trouve à cette position
{
positionJoueur.x = i;
positionJoueur.y = j;
carte[i][j] = VIDE;
}
}
}
*/
// Placement des objets à l'écran à la création de l'arène
drawArena(pWindow,arena,Sprites);
SDL_Event event; // Cette variable servira plus tard à gérer les événements
if( pWindow )
{
SDL_UpdateWindowSurface(pWindow); //Rafaichis la fenetre
//SDL_Delay(3000); /* Attendre trois secondes, que l'utilisateur voie la fenêtre */
while (continuer)
{
action = PlayerInterface(pWindow,arena,Sprites);
if (action == -1)
{
continuer = 0;
}
else
{
}
}
//SDL_DestroyWindow(pWindow);
}
else
{
fprintf(stderr,"Erreur de création de la fenêtre: %s\n",SDL_GetError());
}
}
//IAEngine();
SDL_Quit();
//PlayerInterface();
return 0;
}
int drawArena(SDL_Window* pWindow,ARENA_H_TILE* arena,SDL_Surface **Sprites)
{
SDL_Rect position;
int ID;
for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * BLOC_SIZE;
position.y = j * BLOC_SIZE;
ID = getTileTypeID( arena, i, j);
switch(ID)
{
case GRASS:
SDL_BlitSurface(Sprites[GRASS], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case ROCK:
SDL_BlitSurface(Sprites[ROCK], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case TREE:
SDL_BlitSurface(Sprites[TREE], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
}
}
}
}
/*//Fonction draw avec un tableau. A servi de test pour le graphique
int drawArena(SDL_Window* pWindow,int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR],SDL_Surface **Sprites)
{
SDL_Rect position;
for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * BLOC_SIZE;
position.y = j * BLOC_SIZE;
switch(carte[i][j])
{
case GRASS:
SDL_BlitSurface(Sprites[GRASS], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case ROCK:
SDL_BlitSurface(Sprites[ROCK], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case TREE:
SDL_BlitSurface(Sprites[TREE], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
}
}
}
}
*/
#include "main.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "logHelper.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
//#include <SDL2/SDL_ttf.h>
//#include <SDL2/SDL_thread.h>
//#include <SDL2/SDL_mutex.h>
#include "arenaEngine.h"
#include "arenaGUI.h"
#include "IAEngine.h"
#include "playerInterface.h"
void initDisplayLib() {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
addLogCritical("Init SDL libs failed !");
exit(EXIT_FAILURE);
}
}
int random_lim(int max) {
int r, d = RAND_MAX / max;
max *= d;
do { r = rand(); } while (r >= max);
return r / d;
}
int main(int argc, char *argv[]) {
addLogInfo("Starting game...");
srand(time(NULL));
addLogInfo("Try init SDL libs...");
initDisplayLib();
addLogInfo("Load ressources in memory...");
TILE *tile_ressources = createTileList();
PLAYER *player_ressources = createPlayerList();
addLogInfo("Create SDL windows instance...");
SDL_Window* gameWindows = SDL_CreateWindow("Arena Survival Tournament - alpha 0.3", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOWS_WIDTH, WINDOWS_HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
addLogInfo("Creating new arena...");
ARENA_H_TILE* arena = NULL;
arena = genNewArena(A_HEIGHT, A_WIDTH);
if (arena == NULL) {
addLogCritical("Error with arena generator !");
exit(EXIT_FAILURE);
}
addLogInfo("Successfully created arena.");
addLogInfo("Display arena GUI...");
displayArena(arena, gameWindows, tile_ressources, A_HEIGHT, A_WIDTH, TILE_SIZE);
SDL_Delay(3000);
deleteArena(arena);
addLogInfo("Cleared arena.");
clearRessourcesCache(tile_ressources, player_ressources);
addLogInfo("Free ressources.");
addLogInfo("Unload SDL libs...");
SDL_Quit();
return EXIT_SUCCESS;
}
/*
* main.c
*
* Created on: 17 juin 2018
* Author: isen
*/
//#include "IAEngine.h"
#include "playerInterface.h"
#include "fileHandler.h"
#include "arenaEngine.h"
#include "SDL2/SDL.h"
#include "SDL2/SDL_image.h"
#include <stdio.h>
#include <stdlib.h>
#define BLOC_SIZE 32 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 20
#define NB_BLOCS_HAUTEUR 20
#define LARGEUR_FENETRE BLOC_SIZE * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE BLOC_SIZE * NB_BLOCS_HAUTEUR
enum {HAUT, BAS, GAUCHE, DROITE};
enum {GRASS, ROCK, TREE,FIRSTPLAYER, IA1}; //Définit quel type de case il s'agit
int main(void)
{
SDL_Init(SDL_INIT_VIDEO);
if (SDL_Init(SDL_INIT_VIDEO) != 0 )
{
fprintf(stdout,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
return -1;
}
else
{
int continuer = 1;
int action;
ARENA_H_TILE* arena = NULL; //Déclaration de l'arène
SDL_Surface *player[4] = {NULL}; // 4 surfaces pour 4 directions de mario
SDL_Surface *IA1[4] = {NULL}; // 4 surfaces pour 4 directions de mario
SDL_Surface *grass = NULL;
SDL_Surface *rock = NULL, *tree = NULL, *river = NULL,*actualPlayer = NULL, *actualIA1 = NULL;
SDL_Rect position, positionJoueur;
int i = 0, j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
//SDL_WM_SetIcon(IMG_Load("adventurer_resize.png"),NULL); //Définit l'icone de la fenêtre
// Création de la fenêtre
SDL_Window* pWindow = NULL;
pWindow = SDL_CreateWindow("Arena Survival Tournament",SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,LARGEUR_FENETRE,HAUTEUR_FENETRE,SDL_WINDOW_SHOWN);
//Génération de la nouvelle arène à partir du fichier
arena = genNewArena(NB_BLOCS_HAUTEUR, NB_BLOCS_LARGEUR);
if (arena == NULL)
{
printf("Erreur de la génération de l'arène\n");
}
// Chargement des sprites (décors, personnage...)
grass = IMG_Load("Landscape/grass_green_32x32.png");
rock = IMG_Load("Landscape/stone_green_32x32.png");
tree = IMG_Load("Landscape/tree_green_32x32.png");
river = IMG_Load("Landscape/river_green_32x32.png");
player[BAS] = IMG_Load("Adventurer/adventurer1_32x32.png");
player[HAUT] = IMG_Load("Adventurer/adventurer_back_32x32.png");
player[DROITE] = IMG_Load("Adventurer/adventurer1_right_32x32.png");
player[GAUCHE] = IMG_Load("Adventurer/adventurer1_left_32x32.png");
IA1[BAS] = IMG_Load("IA1/adventurer2_32x32.png");
IA1[HAUT] = IMG_Load("IA1/adventurer2_back_32x32.png");
IA1[DROITE] = IMG_Load("IA1/adventurer2_right_32x32.png");
IA1[GAUCHE] = IMG_Load("IA1/adventurer2_left_32x32.png");
actualPlayer = player[BAS];
actualIA1 = IA1[BAS];
SDL_Surface* Sprites[5]= {grass,rock,tree,actualPlayer,actualIA1};
// Chargement du niveau pour le tableau (Phase de test)
/*if (!chargerNiveau(carte))
{
printf("Niveau non chargé\n");// On arrête le jeu si on n'a pas pu charger le niveau
}*/
/*
//Cette fonction peut être utile pour rechercher un joueur ( Pour la detection)
// Recherche de la position de Mario au départ
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
if (carte[i][j] == MARIO) // Si Mario se trouve à cette position
{
positionJoueur.x = i;
positionJoueur.y = j;
carte[i][j] = VIDE;
}
}
}
*/
// Placement des objets à l'écran à la création de l'arène
drawArena(pWindow,arena,Sprites);
SDL_Event event; // Cette variable servira plus tard à gérer les événements
if( pWindow )
{
SDL_UpdateWindowSurface(pWindow); //Rafaichis la fenetre
//SDL_Delay(3000); /* Attendre trois secondes, que l'utilisateur voie la fenêtre */
while (continuer)
{
action = PlayerInterface(pWindow,arena,Sprites);
if (action == -1)
{
continuer = 0;
}
else
{
}
}
//SDL_DestroyWindow(pWindow);
}
else
{
fprintf(stderr,"Erreur de création de la fenêtre: %s\n",SDL_GetError());
}
}
//IAEngine();
SDL_Quit();
//PlayerInterface();
return 0;
}
int drawArena(SDL_Window* pWindow,ARENA_H_TILE* arena,SDL_Surface **Sprites)
{
SDL_Rect position;
int ID;
for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * BLOC_SIZE;
position.y = j * BLOC_SIZE;
ID = getTileTypeID( arena, i, j);
switch(ID)
{
case GRASS:
SDL_BlitSurface(Sprites[GRASS], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case ROCK:
SDL_BlitSurface(Sprites[ROCK], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case TREE:
SDL_BlitSurface(Sprites[TREE], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
}
}
}
}
/*//Fonction draw avec un tableau. A servi de test pour le graphique
int drawArena(SDL_Window* pWindow,int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR],SDL_Surface **Sprites)
{
SDL_Rect position;
for (int i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (int j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * BLOC_SIZE;
position.y = j * BLOC_SIZE;
switch(carte[i][j])
{
case GRASS:
SDL_BlitSurface(Sprites[GRASS], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case ROCK:
SDL_BlitSurface(Sprites[ROCK], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
case TREE:
SDL_BlitSurface(Sprites[TREE], NULL, SDL_GetWindowSurface(pWindow), &position);
break;
}
}
}
}
*/

38
src/menuGUI.c
View File

@ -1,19 +1,19 @@
#include <stdio.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
int createGameMenuWindows() {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("Erreur chargement librairie SDL ! %s\n",SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_Window *main_test;
main_test = SDL_CreateWindow("My test windows", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 320, 140, SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS);
SDL_Delay(5000);
SDL_DestroyWindow(main_test);
SDL_Quit();
return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
int createGameMenuWindows() {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
printf("Erreur chargement librairie SDL ! %s\n",SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_Window *main_test;
main_test = SDL_CreateWindow("My test windows", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 320, 140, SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS);
SDL_Delay(5000);
SDL_DestroyWindow(main_test);
SDL_Quit();
return EXIT_SUCCESS;
}

12
src/menuGUI.h
View File

@ -1,6 +1,6 @@
#ifndef MENUGUI_H_
#define MENUGUI_H_
#endif
#ifndef MENUGUI_H_
#define MENUGUI_H_
#endif

6
src/menuGUI.h~HEAD Normal file
View File

@ -0,0 +1,6 @@
#ifndef MENUGUI_H_
#define MENUGUI_H_
#endif

6
src/menuGUI.h~arena Normal file
View File

@ -0,0 +1,6 @@
#ifndef MENUGUI_H_
#define MENUGUI_H_
#endif

1259
src/playerInterface.c
View File

File diff suppressed because it is too large Load Diff

106
src/playerInterface.h
View File

@ -1,57 +1,49 @@
/*
* playerInterface.h
*
* Created on: 17 juin 2018
* Author: isen
*/
#include "arenaEngine.h"
#ifndef PLAYERINTERFACE_H_
#define PLAYERINTERFACE_H_
/** Structure d'un joueur (IA ou utilisateur)
*
* */
typedef struct Player
{
int Id;
char Name[35];
//char Race[20];
int Race;
int HealthPoints;
int AttacksPoints;
int DefensePoints;
int PositionX;
int PositionY;
//char Weapons[Max_Weapons];
//int Coins;
struct Player * suiv;
}PLAYER;
//Prototypes
PLAYER* createPlayer(int Id);
PLAYER* insertRightPlaceRecursive(PLAYER* Head, PLAYER* Element);
void displayList(PLAYER * Head);
PLAYER * freeElement(PLAYER *Head, int Id);
PLAYER * freeList(PLAYER *Head);
PLAYER * SearchPlayer(PLAYER *Head, int idPlayer);
void AttackPlayer( PLAYER *player1, PLAYER *player2);
//void ActionPlayer(PLAYER * player, int action);
void ActionPlayer(ARENA_H_TILE* arena,PLAYER * player, int action);
int NumberPlayerAlive(PLAYER *Head);
int getEvent(void);
#define ARENAMAX 20
#endif /* PLAYERINTERFACE_H_ */
#include <SDL2/SDL.h>
#include "arenaEngine.h"
#include "IAEngine.h"
#ifndef PLAYERINTERFACE_H_
#define PLAYERINTERFACE_H_
/** Structure d'un joueur (IA ou utilisateur)
*
* */
typedef struct Player
{
int Id;
char Name[35];
//char Race[20];
int Race;
int HealthPoints;
int AttacksPoints;
int DefensePoints;
int PositionX;
int PositionY;
//char Weapons[Max_Weapons];
//int Coins;
struct Player * suiv;
}PLAYER;
//Prototypes
PLAYER* createPlayer(int Id);
PLAYER* insertRightPlaceRecursive(PLAYER* Head, PLAYER* Element);
void displayList(PLAYER * Head);
PLAYER * freeElement(PLAYER *Head, int Id);
PLAYER * freeList(PLAYER *Head);
PLAYER * SearchPlayer(PLAYER *Head, int idPlayer);
void AttackPlayer( PLAYER *player1, PLAYER *player2);
//void ActionPlayer(PLAYER * player, int action);
void ActionPlayer(ARENA_H_TILE* arena,PLAYER * player, int action);
int NumberPlayerAlive(PLAYER *Head);
int getEvent(void);
#endif /* PLAYERINTERFACE_H_ */