#ifndef DEF_JEUX
#define DEF_JEUX
int Affichage(int niveauTraduit[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR], pos postion_s[100], int last_touche, pos pos_cerise, int cerise_ok, int point);
void deplacementSnake(pos position[], int point, int* touche, int* last_touche);
void jeux(char niveau[], pos position[]);
int verifPosDeplacement(pos position[100]);
void apparitionCerise(pos position[],int niveau[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR],int point, pos *cerise);
int mangerCerise(pos position[], pos position_cerise);
int toucheCorp(pos position[], int point);
int terainTueur(pos position[],int niveau_traduit[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR]);
char* fgets(char* chaine, int nombreDeCaracteresALire, FILE* pointeurSurFichier);
#endif
Salut, c'est encore moi, je voulais juste dire que l'option de compilation demandée par paraze pour Code::blocks "-Wstrict-prototypes" n'est pas valide en C++ (du moins c'est ce que dit mon compilateur).
Oui, effectivement, moi aussi, ça me met un warning : j'ai enlevé l'option.
@ schadocalex, informaticienzero et Pouet_forever : Merci.
Salut, c'est encore moi, je voulais juste dire que l'option de compilation demandée par paraze pour Code::blocks "-Wstrict-prototypes" n'est pas valide en C++ (du moins c'est ce que dit mon compilateur).
Après une profonde réflexion petite discution avec Pouet, j'ai supprimé certaines (beaucoup) d'options de compilations.
Il ne reste que : -Wall -pedantic -Wextra.
salut,
pour suivre l'avancement de mon tetris, vous pouvez le dl ici.
ce n'est pas une version finale, je vais travailler un peu le design et quelques options supplémentaires comme un mode plein écran et la possibilité de couper la musique.
salut,
effectivement afficher les controles en cours reste à faire,
sinon dans les options il est possible de les redéfinir, y compris pour un pad.
les lignes "quitter" et "sauvgarder et quitter" ne sont pas actives (ça vient...)dans la page option, quitter la page option ,score ou jeu par la touche echap.
dans les petits problèmes à résoudre, si un pad est selectionné, ça bloque un autre pad éventuel.
effectivement, bien vu pour le skin au retour du menu, en fait ça marchait mais je l'avais enlevé pour tester un truc et je l'ai paz remis quand j'ai compilé le release, merci, si tu ne l'avais pas vu ce serait ptet resté
J'aimerais arriver à supprimer l'effet de vague sur les pieces quand elles bougent, mais je ne sais pas si on sait faire de la synchro verticale avec la SDL, même forcée sur les Carte Graphiques l'effet persiste...
J'ai aussi remarqué que si on essaie de changer l'apparence (skin) puis qu'on reviens dans les options, le skin affiché est celui par défaut (alors que dans le jeu, tout va bien).
Bonjour, j'ai poster il y a quelque jour pour présenter mon projet : Lord of War, mais visiblement il n'a pas été remarqué, je re-post donc plein d'espoir
Don voici mon projet : Lord of War
Il s'agit d'un jeu de stratégie sur plateau (genre un échiquier) où deux équipes s'affrontent, le thème est l'époque romaine, le joueur peut donc contrôler 5 unités différentes allant du légionnaire au char. Les unités sont entraînés dans des camps, disposés sur la carte.
Pour ce qui connaîssent, c'est un peu le principe de advances wars sur nintendo ds, mais en simplifié .
L'objectif principal de mon projet est de fournir une carte jouable.
Les objectifs secondaires sont :
Possibilité de sauvegarde de la partie,
Possibilité de chargement
Editeur de carte,
Choix de la carte a jouer lors du debut d'une nouvelle partie.
Actuellement ce qui manque :
Les fonctions de chargements au debut de la partie,
L'intelligence artificielle,
La fonction de sauvegarde a la fin.
Je post mon code : (je l'ai entièrement réécris 2 fois depuis mon premier post)
Les fonctions qui ne sont pas encore implémentées sont remplacées par :
/* ... */
main.cpp
#include "main.h"
#include "partieClassique.h"
int main (int argc, char *argv[])
{
/// Initialisation SDL
mainSurface Surface;
Surface.image=SDL_LoadBMP("ressourceGraphique.bmp");
SDL_SetColorKey(Surface.image, SDL_SRCCOLORKEY, SDL_MapRGB(Surface.image->format, 0, 255, 0));
SDL_Init(SDL_INIT_VIDEO);
Surface.ecran=SDL_SetVideoMode(DIMX_ECRAN, DIMY_ECRAN, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Lord of War", NULL);
/// MENU DE SELECTION
/* ... */
/// PARTIE CLASSIQUE (Nouvelle ou Chargement)
partieClassique(Surface, NOUVELLE_PARTIE, "Carte Test");
/// EDITEUR DE CARTE
/* ... */
/// Fin SDL
SDL_FreeSurface(Surface.image);
SDL_Quit();
exit(EXIT_SUCCESS);
}
#include "main.h"
#include "partieClassique.h"
#include "event.h"
#include "affichage.h"
#include "gestionActions.h"
bool playerLoop;
int partieClassique(mainSurface Surface, int mode, const char *map) // Renvoi 0 en cas de sortie direct, 1 en cas de retour au menu
{
/// Variables de jeu
parametresPartie partie;
cooUnit cooFixe;
cooFixe.x=0;
cooFixe.y=0;
cooUnit cooCible;
cooCible.x=0;
cooCible.y=0;
Case plateau[TAILLEY_CARTE][TAILLEX_CARTE];
Init_Carte(plateau);
/// Variables programme
bool mainLoop=true;
bool sortieDirect=false;
SDL_Event quitEvent;
evenement event;
/// Initialisation en fonction du mode choisis
// Nouvelle partie
if (mode==NOUVELLE_PARTIE)
{
partie.deniers=500;
partie.jour=0;
/* .g.. */
}
// Charger derniere partie jouee
if (mode==CHARGER_PARTIE)
{
/* ... */
}
/// BOUCLE PRINCIPALE
while (mainLoop)
{
/// Initialisation du tour
playerLoop=true;
initialisationTour(plateau);
/// BOUCLE DU JOUEUR
while (playerLoop)
{
/// Sortie direct du programme
SDL_PollEvent(&quitEvent);
switch (quitEvent.type)
{
case SDL_QUIT:
playerLoop=false;
mainLoop=false;
sortieDirect=true;
break;
}
/// Gestion des evenements lies a la souris
updateEvent(event);
/// Affichage
affichageGeneral(Surface, cooFixe, cooCible, plateau);
/// Gestion de l'interface et des action possibles
actionsPossibles(Surface, event, cooFixe, cooCible, plateau, partie);
/// Actualisation de l'ecran
SDL_Flip(Surface.ecran);
} // On sort a la fin du tour du joueur
/// Si on est pas en sortie direct
if (!sortieDirect)
{
/// Panneau fin du tour
panneauTexte(Surface, "Fin", "de votre", "tour");
SDL_Flip(Surface.ecran);
SDL_Delay(TEMPO_PANNEAU);
/// IA
/* ... */
/// Panneau fin de la journee
panneauTexte(Surface, "Fin", "de la", "journee");
SDL_Flip(Surface.ecran);
SDL_Delay(TEMPO_PANNEAU);
/// FIN DE LA JOURNEE
partie.jour++;
}
}
/// SAUVEGARDE DE LA PARTIE ///
/* ... */
if (sortieDirect) return 0;
return 1;
}
void demandeFindeTour(void)
{
playerLoop=false;
}
/// FONCTION(S) DE TEST ///
void Init_Carte(Case plateau[][TAILLEX_CARTE])
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
plateau[i][j].creerTerrain(j, i, YPLAINE, XPLAINE1);
}
}
/// Creation des unites tests
plateau[0][1].creerUnite(LEGIONNAIRE, J1);
plateau[0][2].creerUnite(CENTURION, J1);
plateau[0][3].creerUnite(IMPERIAL, J1);
plateau[0][4].creerUnite(DECURION, J1);
plateau[0][5].creerUnite(CHAR, J1);
plateau[4][6].creerUnite(LEGIONNAIRE, J2);
plateau[5][6].creerUnite(CENTURION, J2);
plateau[6][6].creerUnite(IMPERIAL, J2);
plateau[7][6].creerUnite(DECURION, J2);
plateau[8][6].creerUnite(CHAR, J2);
plateau[12][14].creerUnite(CAMP, J1);
plateau[12][15].creerUnite(CAMP, J2);
}
partieClassique.h
#ifndef PARTIE_CLASSIQUE_H
#define PARTIE_CLASSIQUE_H
#include "jeu.h"
int partieClassique(mainSurface Surface, int mode, const char *map="");
/// PARTIECLASSIQUE :
/// Renvoi 0 en cas de demande de fermeture du programme
/// Renvoi 1 en cas de demande de retour au menu
/// Le mode peut etre NOUVELLE_PARTIE ou CHARGER_PARTIE
/// En cas de CHARGER_PARTIE, le champ "map" n'est pas obligatoire
void demandeFindeTour(void);
/// DEMANDEFINDETOUR
/// Met fin au tour du joueur
/// FONCTIONS DE TEST ///
void Init_Carte(Case plateau[][TAILLEX_CARTE]);
#endif
event.cpp
#include "main.h"
#include "event.h"
void updateEvent(evenement &event)
{
// Actualisation des evenements
SDL_PumpEvents();
// Recuperation de la position de la souris
int x, y;
SDL_GetMouseState(&x, &y);
event.posSouris.x=x;
event.posSouris.y=y;
// Recuperation de l'etat du clic gauche
if (SDL_GetRelativeMouseState(NULL, NULL)==SDL_BUTTON(1)) event.clic=true;
else event.clic=false;
// Position sur la carte
if (x>=DIMX_INTERFACE+DIM_BORDURE && x<=DIMX_ECRAN-DIM_BORDURE && y>=DIM_BORDURE && y<=DIMY_ECRAN-DIM_BORDURE)
{
// Si la souris est sur la carte, on donne sa position en cases
event.posSurCarte.x=(x-DIMX_INTERFACE-DIM_BORDURE)/DIM_CASE;
event.posSurCarte.y=(y-DIM_BORDURE)/DIM_CASE;
// On valide que la souris est sur la carte
event.sourisSurCarte=true;
}
else
{
// Sinon sa position est {0, 0}
event.posSurCarte.x=0;
event.posSurCarte.y=0;
// On dit que la souris n'est pas sur la carte
event.sourisSurCarte=false;
}
}
int survol(SDL_Rect souris, SDL_Rect zone)
{
if (souris.x>=zone.x && souris.x<=zone.x+zone.w && souris.y>=zone.y && souris.y<=zone.y+zone.h)
{
return 1;
}
return 0;
}
event.h
#ifndef EVENT_H
#define EVENT_H
void updateEvent(evenement &event);
/// UPDATEEVENT :
/// Met a jour les parametres de event :
/// posSouris indiquant la position actuel de la souris
/// clic indiquant l'etat du clic gauche de la souris (true pour enfonce, false pour relache)
int survol(SDL_Rect souris, SDL_Rect zone);
/// SURVOL
/// Renvoi 1 si la souris est dans la zone
/// Renvoi 0 sinon
#endif
affichage.cpp
#include "main.h"
#include "affichage.h"
void affichageGeneral(mainSurface Surface, cooUnit cooFixe, cooUnit cooCible, Case plateau[][TAILLEX_CARTE])
{
affichageBordure(Surface);
affichageCarte(Surface, plateau);
affichageMenu(Surface);
affichageFixe(Surface, plateau[cooFixe.y][cooFixe.x]);
afficherCible(Surface, plateau[cooFixe.y][cooFixe.x], plateau[cooCible.y][cooCible.x]);
}
void affichageBordure(mainSurface Surface)
{
SDL_Rect position;
SDL_Rect source;
source.w=DIM_BORDURE;
source.h=DIM_BORDURE;
source.y=YBORDURE;
/// Affichage des coins
// Coin haut gauche
source.x=XBORD_HG;
position.x=DIMX_INTERFACE;
position.y=0;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Coin bas gauche
source.x=XBORD_BG;
position.y=DIMY_ECRAN-DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Coin bas droit
source.x=XBORD_BD;
position.x=DIMX_ECRAN-DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Coin haut droit
source.x=XBORD_HD;
position.y=0;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
/// Affichage des bordures
for (int i=DIMX_INTERFACE+DIM_BORDURE; i<DIMX_ECRAN-DIM_BORDURE; i+=DIM_BORDURE)
{
position.x=i;
// Bordure haut
source.x=XBORD_H;
position.y=0;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Bordure bas
source.x=XBORD_B;
position.y=DIMY_ECRAN-DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
for (int i=DIM_BORDURE; i<DIMY_ECRAN-DIM_BORDURE; i+=DIM_BORDURE)
{
position.y=i;
// Bordure gauche
source.x=XBORD_G;
position.x=DIMX_INTERFACE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Bordure bas
source.x=XBORD_D;
position.x=DIMX_ECRAN-DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
}
void affichageMenu(mainSurface Surface)
{
SDL_Rect source;
source.x=XINT_MENU;
source.y=YINT_MENU;
source.w=DIMX_INTERFACE;
source.h=DIMY_MENU;
SDL_Rect position;
position.x=position.y=0;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
void affichageFixe(mainSurface Surface, Case uniteFixe)
{
SDL_Rect position;
position.x=0;
position.y=DIMY_MENU;
SDL_Rect source;
source.y=0;
source.w=DIMX_INTERFACE;
source.h=DIMY_INTERFACE;
/// Si l'unite est a l'equipe 1, elle est affichee
if (uniteFixe.retournerUnite().joueur==J1)
{
source.x=uniteFixe.retournerUnite().type.unite;
}
/// Sinon l'ecran vide est afficher
else source.x=XINT_LOW;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
void afficherCible(mainSurface Surface, Case uniteFixe, Case uniteCible)
{
SDL_Rect position;
position.x=0;
position.y=DIMY_MENU+DIMY_INTERFACE;
SDL_Rect source;
source.y=0;
source.w=DIMX_INTERFACE;
source.h=DIMY_INTERFACE;
/// Si l'unite fixe est pas un camp de l'equipe 1
if (uniteFixe.retournerUnite().type.unite==CAMP && uniteFixe.retournerUnite().joueur==J1)
{
source.x=XINT_CAMP_INT; // On affiche l'interface du camp
}
/// Sinon
else source.x=uniteCible.retournerUnite().type.unite; // On affiche l'unite ciblee
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
void affichageCarte(mainSurface Surface, Case plateau[][TAILLEX_CARTE])
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
plateau[i][j].affichage(Surface);
}
}
}
void panneauTexte(mainSurface Surface, const char *texteL1, const char *texteL2, const char *texteL3)
{
/// Creation du texte
TTF_Init();
TTF_Font *Adonais=TTF_OpenFont("Adonais.ttf", 30);
SDL_Color couleurNoire={0, 0, 0};
SDL_Surface *ligne1=TTF_RenderText_Blended(Adonais, texteL1, couleurNoire);
SDL_Surface *ligne2=TTF_RenderText_Blended(Adonais, texteL2, couleurNoire);
SDL_Surface *ligne3=TTF_RenderText_Blended(Adonais, texteL3, couleurNoire);
TTF_CloseFont(Adonais);
TTF_Quit();
/// Creation du panneau
int x=0;
int y=0;
while (x<=ligne1->w || x<=ligne2->w || x<=ligne3->w)
{
x+=DIM_BORDURE;
}
while (y<=(ligne1->h+ligne2->h+ligne3->h))
{
y+=DIM_BORDURE;
}
SDL_Rect source;
source.w=DIM_BORDURE;
source.h=DIM_BORDURE;
source.y=YBORDURE;
SDL_Rect position;
/// Blit des coin
// Haut gauche
source.x=XBORD_HG;
position.x=(DIMX_ECRAN-(x+2*DIM_BORDURE))/2;
position.y=(DIMY_ECRAN-(y+2*DIM_BORDURE))/2;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Haut droit
source.x=XBORD_HD;
position.x+=x+DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Bas droit
source.x=XBORD_BD;
position.y+=y+DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Bas gauche
source.x=XBORD_BG;
position.x-=x+DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
/// Blit des bords
for (int i=0; i<x; i+=DIM_BORDURE)
{
// Haut
source.x=XBORD_H;
position.x=(DIMX_ECRAN-x)/2+i;
position.y=(DIMY_ECRAN-y)/2-DIM_BORDURE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Bas
source.x=XBORD_B;
position.x=(DIMX_ECRAN-x)/2+i;
position.y=(DIMY_ECRAN-y)/2+y;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
for (int i=0; i<y; i+=DIM_BORDURE)
{
// Gauche
source.x=XBORD_G;
position.x=(DIMX_ECRAN-x)/2-DIM_BORDURE;
position.y=(DIMY_ECRAN-y)/2+i;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
// Droit
source.x=XBORD_D;
position.x=(DIMX_ECRAN-x)/2+x;
position.y=(DIMY_ECRAN-y)/2+i;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
/// Blit du fond
for (int i=0; i<x; i+=DIM_BORDURE)
{
for (int j=0; j<y; j+=DIM_BORDURE)
{
position.x=(DIMX_ECRAN-x)/2+i;
position.y=(DIMY_ECRAN-y)/2+j;
source.x=XBORD_INT;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
}
/// Blit du texte
// Ligne1
position.x=(x-ligne1->w)/2+(DIMX_ECRAN-(x+2*DIM_BORDURE))/2+DIM_BORDURE;
position.y=(DIMY_ECRAN-y)/2;
SDL_BlitSurface(ligne1, NULL, Surface.ecran, &position);
// Ligne2
position.x=(x-ligne2->w)/2+(DIMX_ECRAN-(x+2*DIM_BORDURE))/2+DIM_BORDURE;
position.y=(DIMY_ECRAN-y)/2+ligne1->h;
SDL_BlitSurface(ligne2, NULL, Surface.ecran, &position);
// Ligne3
position.x=(x-ligne3->w)/2+(DIMX_ECRAN-(x+2*DIM_BORDURE))/2+DIM_BORDURE;
position.y=(DIMY_ECRAN-y)/2+ligne1->h+ligne2->h;
SDL_BlitSurface(ligne3, NULL, Surface.ecran, &position);
SDL_FreeSurface(ligne1);
SDL_FreeSurface(ligne2);
SDL_FreeSurface(ligne3);
}
affichage.h
#ifndef AFFICHAGE_H
#define AFFICHAGE_H
#include "jeu.h"
void affichageGeneral(mainSurface Surface, cooUnit cooFixe, cooUnit cooCible, Case plateau[][TAILLEX_CARTE]);
/// AFFICHAGEINTERFACE
/// Regroupe toutes les fonctions d'affichage de l'interface
void affichageBordure(mainSurface Surface);
/// AFFICHAGEBORDURE
/// Affiche la bordure rectengulaire autour de la carte
void affichageMenu(mainSurface Surface);
/// AFFICHAGEMENU
/// Affiche le fond du menu
void affichageFixe(mainSurface Surface, Case uniteFixe);
/// AFFICHAGEFIXE
/// Affiche l'unite fixe si elle est de l'equipe 1, sinon affiche l'interface LOW
void afficherCible(mainSurface Surface, Case uniteFixe, Case uniteCible);
/// AFFICHERCIBLE
/// Affiche l'unite cible si l'unite fixe n'est pas un camp de l'equipe 1
void affichageCarte(mainSurface Surface, Case plateau[][TAILLEX_CARTE]);
/// AFFICHAGECARTE
/// Affiche la carte passee en argument
void panneauTexte(mainSurface Surface, const char *texteL1, const char *texteL2, const char *texteL3);
/// PANNEAUTEXTE
/// Creer un panneau avec les 3 lignes de texte au centre de l'ecran
#endif
icones.cpp
#include "main.h"
#include "icone.h"
#include "gestionIcones.h"
#include "event.h"
#include "gestionActions.h"
#include "affichage.h"
Icone::Icone()
{
_position.x=NUL;
_position.y=NUL;
_infoTexte=NULL;
_type=NUL;
}
Icone::~Icone() {}
/// AFFICHAGE
void Icone::afficher(mainSurface Surface, int parametre)
{
/// Si l'icone est creee
if (_infoTexte!=NULL)
{
SDL_Rect source;
source.w=DIM_ICONE;
source.h=DIM_ICONE;
source.y=YICONE;
source.x=_type;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &_position);
if (parametre<INFINI)
{
afficherParametre(Surface, _position, parametre);
}
}
}
/// GESTION
void Icone::creer(int x, int y, int type, const char *texte)
{
_position.x=x;
_position.y=y;
_type=type;
_infoTexte=texte;
}
void Icone::infoBulle(mainSurface Surface, evenement event)
{
if (survol(event.posSouris, _position))
{
creerInfoBulle(Surface, event.posSouris, _infoTexte);
}
}
void Icone::action(evenement event, void (*fonctionAction)())
{
if (survol(event.posSouris, _position) && event.clic)
{
fonctionAction();
}
}
void Icone::achat(mainSurface Surface, evenement event, parametresPartie &partie, cooUnit cooCamp, Case plateau[][TAILLEX_CARTE], int unite)
{
if (survol(event.posSouris, _position) && event.clic)
{
SDL_Delay(100);
/// Si il y a assez d'argent
if (partie.deniers>=plateau[cooCamp.y][cooCamp.x].retournerUnite().cout[((unite+1)/152)])
{
bool placeDispo=false;
bool achatEffectue=false;
/// Verification d'une place disponible
if (plateau[cooCamp.y][cooCamp.x+1].retournerUnite().type.unite==NUL && !achatEffectue) // A l'est
{
placeDispo=true;
plateau[cooCamp.y][cooCamp.x+1].creerUnite(unite, plateau[cooCamp.y][cooCamp.x].retournerUnite().joueur);
partie.deniers-=plateau[cooCamp.y][cooCamp.x].retournerUnite().cout[((unite+1)/152)]; // Prix de l'unite enleve au deniers actuel
achatEffectue=true;
}
if (plateau[cooCamp.y+1][cooCamp.x].retournerUnite().type.unite==NUL && !achatEffectue) // Au sud
{
placeDispo=true;
plateau[cooCamp.y+1][cooCamp.x].creerUnite(unite, plateau[cooCamp.y][cooCamp.x].retournerUnite().joueur);
partie.deniers-=plateau[cooCamp.y][cooCamp.x].retournerUnite().cout[((unite+1)/152)]; // Prix de l'unite enleve au deniers actuel
achatEffectue=true;
}
if (plateau[cooCamp.y][cooCamp.x-1].retournerUnite().type.unite==NUL && !achatEffectue) // A l'ouest
{
placeDispo=true;
plateau[cooCamp.y][cooCamp.x-1].creerUnite(unite, plateau[cooCamp.y][cooCamp.x].retournerUnite().joueur);
partie.deniers-=plateau[cooCamp.y][cooCamp.x].retournerUnite().cout[((unite+1)/152)]; // Prix de l'unite enleve au deniers actuel
achatEffectue=true;
}
if (plateau[cooCamp.y-1][cooCamp.x].retournerUnite().type.unite==NUL && !achatEffectue) // Au nord
{
placeDispo=true;
plateau[cooCamp.y-1][cooCamp.x].creerUnite(unite, plateau[cooCamp.y][cooCamp.x].retournerUnite().joueur);
partie.deniers-=plateau[cooCamp.y][cooCamp.x].retournerUnite().cout[((unite+1)/152)]; // Prix de l'unite enleve au deniers actuel
achatEffectue=true;
}
/// Si il n'y a pas de place
if (!placeDispo) panneauTexte(Surface, "Pas de", "place a", "cote du camp");
}
else panneauTexte(Surface, "Vous n'avez", "pas assez", "d'argent");
}
}
icones.h
#ifndef ICONE_H
#define ICONE_H
#include "jeu.h"
/// CLASSE ICONE
/// Permet de dialoguer avec l'utilisateur
/// Affiche une info-bulle sur l'action effectuer ou les donnees affichees lors du survol de la souris
class Icone
{
public:
Icone();
~Icone();
/// Affichage
void afficher(mainSurface Surface, int parametre); // Affiche l'icone ainsi que son parametre
/// Gestion
void creer(int x, int y, int type, const char *texte);
void infoBulle(mainSurface Surface, evenement event);
void action(evenement event, void (*fonctionAction)()); // Pour les deplacements et attaques
void achat(mainSurface Surface, evenement event, parametresPartie &partie, cooUnit cooCamp, Case plateau[][TAILLEX_CARTE], int unite); // Pour les achats d'unite
private:
SDL_Rect _position; // Position sur l'ecran
int _type; // Type d'image de l'icone
const char *_infoTexte; // Texte de l'info-bulle
};
#endif
gestionIcones.cpp
#include "main.h"
#include "gestionIcones.h"
#include "icone.h"
#include "gestionActions.h"
#include "partieClassique.h"
void gestionGeneraleIcones(mainSurface Surface, evenement event, cooUnit cooFixe, cooUnit cooCible, Case plateau[][TAILLEX_CARTE], parametresPartie &partie)
{
gestionIconesMenu(Surface, event, partie);
/// Si l'unite fixe est un camp de l'equipe 1
if (plateau[cooFixe.y][cooFixe.x].retournerUnite().type.unite==CAMP && plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur==J1)
{
gestionIconesFixe(Surface, event, plateau[cooFixe.y][cooFixe.x]);
gestionIconesCamp(Surface, event, cooFixe, plateau, partie);
}
else
{
/// Si il y a une unite fixe de l'equipe 1
if (plateau[cooFixe.y][cooFixe.x].retournerUnite().type.unite!=NUL && plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur==J1)
{
gestionIconesFixe(Surface, event, plateau[cooFixe.y][cooFixe.x]);
}
/// Si il y a une unite cible
if (plateau[cooCible.y][cooCible.x].retournerUnite().type.unite!=NUL)
{
gestionIconesCible(Surface, event, plateau[cooCible.y][cooCible.x]);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////
void gestionIconesMenu(mainSurface Surface, evenement event, parametresPartie partie)
{
Icone Menu;
Menu.creer(XBUT_MENU, YBUT_MENU, XIC_MENU, "Menu");
Icone FinTour;
FinTour.creer(XBUT_FIN_TOUR, YBUT_FIN_TOUR, XIC_FIN_TOUR, "Fin du tour");
Icone Deniers;
Deniers.creer(XBUT_DENIERS, YBUT_DENIERS, XIC_DENIERS, "Deniers");
Icone Jour;
Jour.creer(XBUT_JOUR, YBUT_JOUR, XIC_JOUR, "Jour actuel");
// Affichage
Menu.afficher(Surface, INFINI);
FinTour.afficher(Surface, INFINI);
Deniers.afficher(Surface, partie.deniers);
Jour.afficher(Surface, partie.jour);
// Info-bulles
Menu.infoBulle(Surface, event);
FinTour.infoBulle(Surface, event);
Deniers.infoBulle(Surface, event);
Jour.infoBulle(Surface, event);
// Action
FinTour.action(event, demandeFindeTour);
}
void gestionIconesFixe(mainSurface Surface, evenement event, Case uniteFixe)
{
/// Si c'est un camp de l'equipe 1
if (uniteFixe.retournerUnite().type.unite==CAMP && uniteFixe.retournerUnite().joueur==J1)
{
Icone Joueur;
Joueur.creer(XBUT_JOUEURf, YBUT_JOUEURf, XIC_EQUIPE1, "Equipe 1");
// Affichage
Joueur.afficher(Surface, INFINI);
// Info-bulles
Joueur.infoBulle(Surface, event);
}
/// Sinon on affiche les icones de l'unite
else
{
Icone Attaque;
Attaque.creer(XBUT_ATTAQUEf, YBUT_ATTAQUEf, XIC_ATTAQUER, "Attaquer");
Icone Defense;
Defense.creer(XBUT_DEFf, YBUT_DEFf, XIC_DEFENSE, "Defense");
Icone Mouvement;
Mouvement.creer(XBUT_MOUVf, YBUT_MOUVf, XIC_DEPLACER, "Deplacer");
Icone Troupes;
Troupes.creer(XBUT_TROUPESf, YBUT_TROUPESf, XIC_TROUPES, "Troupes");
Icone Joueur;
Joueur.creer(XBUT_JOUEURf, YBUT_JOUEURf, XIC_EQUIPE1, "Equipe 1");
// Affichage
Attaque.afficher(Surface, uniteFixe.retournerUnite().attaque);
Defense.afficher(Surface, uniteFixe.retournerUnite().defense);
Mouvement.afficher(Surface, uniteFixe.retournerUnite().mouvement);
Troupes.afficher(Surface, uniteFixe.retournerUnite().troupes);
Joueur.afficher(Surface, INFINI);
// Info-bulles
Attaque.infoBulle(Surface, event);
Defense.infoBulle(Surface, event);
Mouvement.infoBulle(Surface, event);
Troupes.infoBulle(Surface, event);
Joueur.infoBulle(Surface, event);
// Actions
Mouvement.action(event, demandeMouvement);
Attaque.action(event, demandeAttaque);
}
}
void gestionIconesCible(mainSurface Surface, evenement event, Case uniteCible)
{
/// Si c'est un camp
if (uniteCible.retournerUnite().type.unite==CAMP)
{
Icone Joueur;
if (uniteCible.retournerUnite().joueur==J1)
{
Joueur.creer(XBUT_JOUEURc, YBUT_JOUEURc, XIC_EQUIPE1, "Equipe 1");
}
if (uniteCible.retournerUnite().joueur==J2)
{
Joueur.creer(XBUT_JOUEURc, YBUT_JOUEURc, XIC_EQUIPE2, "Equipe 2");
}
// Affichage
Joueur.afficher(Surface, INFINI);
// Info-bulles
Joueur.infoBulle(Surface, event);
}
/// Sinon on affiche les icones de l'unite
else
{
Icone Attaque;
Attaque.creer(XBUT_ATTAQUEc, YBUT_ATTAQUEc, XIC_ATTAQUE, "Attaque");
Icone Defense;
Defense.creer(XBUT_DEFc, YBUT_DEFc, XIC_DEFENSE, "Defense");
Icone Troupes;
Troupes.creer(XBUT_TROUPESc, YBUT_TROUPESc, XIC_TROUPES, "Troupes");
Icone Joueur;
if (uniteCible.retournerUnite().joueur==J1)
{
Joueur.creer(XBUT_JOUEURc, YBUT_JOUEURc, XIC_EQUIPE1, "Equipe 1");
}
if (uniteCible.retournerUnite().joueur==J2)
{
Joueur.creer(XBUT_JOUEURc, YBUT_JOUEURc, XIC_EQUIPE2, "Equipe 2");
}
// Affichage
Attaque.afficher(Surface, uniteCible.retournerUnite().attaque);
Defense.afficher(Surface, uniteCible.retournerUnite().defense);
Troupes.afficher(Surface, uniteCible.retournerUnite().troupes);
Joueur.afficher(Surface, INFINI);
// Info-bulles
Attaque.infoBulle(Surface, event);
Defense.infoBulle(Surface, event);
Troupes.infoBulle(Surface, event);
Joueur.infoBulle(Surface, event);
}
}
void gestionIconesCamp(mainSurface Surface, evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE], parametresPartie &partie)
{
Icone AchLegionnaire;
AchLegionnaire.creer(XBUT_ACHAT_LEGIONNAIRE, YBUT_ACHAT_LEGIONNAIRE, XIC_ACHETER, "Acheter Legionnaire");
Icone AchCenturion;
AchCenturion.creer(XBUT_ACHAT_CENTURION, YBUT_ACHAT_CENTURION, XIC_ACHETER, "Acheter Centurion");
Icone AchImperial;
AchImperial.creer(XBUT_ACHAT_IMPERIAL, YBUT_ACHAT_IMPERIAL, XIC_ACHETER, "Acheter Imperial");
Icone AchDecurion;
AchDecurion.creer(XBUT_ACHAT_DECURION, YBUT_ACHAT_DECURION, XIC_ACHETER, "Acheter Decurion");
Icone AchChar;
AchChar.creer(XBUT_ACHAT_CHAR, YBUT_ACHAT_CHAR, XIC_ACHETER, "Acheter Char");
// Affichage
AchLegionnaire.afficher(Surface, plateau[cooFixe.y][cooFixe.x].retournerUnite().cout[0]);
AchCenturion.afficher(Surface, plateau[cooFixe.y][cooFixe.x].retournerUnite().cout[1]);
AchImperial.afficher(Surface, plateau[cooFixe.y][cooFixe.x].retournerUnite().cout[2]);
AchDecurion.afficher(Surface, plateau[cooFixe.y][cooFixe.x].retournerUnite().cout[3]);
AchChar.afficher(Surface, plateau[cooFixe.y][cooFixe.x].retournerUnite().cout[4]);
// Info-bulles
AchLegionnaire.infoBulle(Surface, event);
AchCenturion.infoBulle(Surface, event);
AchImperial.infoBulle(Surface, event);
AchDecurion.infoBulle(Surface, event);
AchChar.infoBulle(Surface, event);
// Achat
AchLegionnaire.achat(Surface, event, partie, cooFixe, plateau, LEGIONNAIRE);
AchCenturion.achat(Surface, event, partie, cooFixe, plateau, CENTURION);
AchImperial.achat(Surface, event, partie, cooFixe, plateau, IMPERIAL);
AchDecurion.achat(Surface, event, partie, cooFixe, plateau, DECURION);
AchChar.achat(Surface, event, partie, cooFixe, plateau, CHAR);
}
//////////////////////////////////////////////////////////////////////////////////
void creerInfoBulle(mainSurface Surface, SDL_Rect position, const char *texte)
{
/// Creation du texte
TTF_Init(); // Initialisation de TTF
TTF_Font *Adonais=TTF_OpenFont("Adonais.ttf", 22); // Ouverture de la police
SDL_Color couleurNoire= {0, 0, 0};
SDL_Surface *surfaceTexte=TTF_RenderText_Blended(Adonais, texte, couleurNoire); // Ecriture
TTF_CloseFont(Adonais); // Fermeture de la police
TTF_Quit(); // Fermeture de TTF
/// Creation du cadre
SDL_Rect source;
source.y=YICONE;
source.w=DIMX_CADRE_TEXTE;
source.h=DIM_ICONE;
position.x+=DIM_ICONE+6;
// Bord gauche
source.x=XCADRE_GAUCHE;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
position.x+=DIMX_CADRE_TEXTE;
source.x=XCADRE_MILIEU;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
position.x+=DIMX_CADRE_TEXTE;
int xOrigine=position.x;
// Milieu
int i=0;
while (i<=surfaceTexte->w)
{
source.x=XCADRE_MILIEU;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
position.x+=DIMX_CADRE_TEXTE;
i+=DIMX_CADRE_TEXTE;
}
// Bord droit
source.x=XCADRE_MILIEU;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
position.x+=DIMX_CADRE_TEXTE;
source.x=XCADRE_DROIT;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
position.x+=DIMX_CADRE_TEXTE;
/// Affichage du texte
position.x=xOrigine+(i-surfaceTexte->w)/2;
position.y+=2+(DIM_ICONE-surfaceTexte->h)/2;
SDL_BlitSurface(surfaceTexte, NULL, Surface.ecran, &position);
}
void afficherParametre(mainSurface Surface, SDL_Rect position, int parametre)
{
TTF_Init(); // Initialisation de TTF
TTF_Font *Adonais=TTF_OpenFont("Adonais.ttf", 10); // Ouverture de la police
SDL_Color couleurNoire= {0, 0, 0};
/// Passage de int en const char *
char texte[4]="";
// Si le parametre est correct
if (parametre<10000) sprintf(texte, "%d", parametre);
SDL_Surface *surfaceTexte=TTF_RenderText_Blended(Adonais, texte, couleurNoire); // Ecriture
TTF_CloseFont(Adonais); // Fermeture de la police
TTF_Quit(); // Fermeture de TTF
SDL_Rect positionTexte;
positionTexte.x=position.x+DIM_ICONE+6;
positionTexte.y=position.y+(DIM_ICONE-surfaceTexte->h)/2;
SDL_BlitSurface(surfaceTexte, NULL, Surface.ecran, &positionTexte);
}
gestionIcones.h
#ifndef GESTION_ICONE_H
#define GESTION_ICONE_H
#include "jeu.h"
void gestionGeneraleIcones(mainSurface Surface, evenement event, cooUnit cooFixe, cooUnit cooCible, Case plateau[][TAILLEX_CARTE], parametresPartie &partie);
/// GESTIONGENERALEICONES
/// Gere toutes les fonctions de gestion d'icone
void gestionIconesMenu(mainSurface Surface, evenement event, parametresPartie partie);
/// GESTIONICONESMENU
/// Gere toutes les icones du menu :
/// Affichages, info-bulles, actions
void gestionIconesFixe(mainSurface Surface, evenement event, Case uniteFixe);
/// GESTIONICONESFIXE
/// Meme principe que pour le menu, avec l'unite fixe
void gestionIconesCible(mainSurface Surface, evenement event, Case uniteCible);
/// GESTIONICONESCIBLE
/// ...
void gestionIconesCamp(mainSurface Surface, evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE], parametresPartie &partie);
/// GESTIONICONESCAMP
/// Gere les icones d'achat d'unite
void creerInfoBulle(mainSurface Surface, SDL_Rect position, const char *texte);
/// CREERINFOBULLE
/// Affiche le texte donne en argument a cote de la position
void afficherParametre(mainSurface Surface, SDL_Rect position, int parametre);
/// AFFICHERPARAMETRE
/// Affiche le parametre donnee en argument a cote de la position
#endif
jeu.cpp
#include "main.h"
#include "jeu.h"
#include "gestionFichiersTexte.h"
Case::Case()
{
_unite.attaque=NUL;
_unite.defense=NUL;
_unite.mouvement=NUL;
_unite.troupes=NUL;
_unite.joueur=NUL;
_unite.type.unite=NUL;
_unite.type.banniere=NUL;
_unite.autoAttaque=false;
_unite.autoMouv=false;
_typeTerrain=NUL;
_typeImage=NUL;
_typeCurseur=NUL;
_x=NUL;
_y=NUL;
_peutAttaque=false;
_peutMouv=false;
}
Case::~Case() {}
void Case::affichage(mainSurface Surface)
{
SDL_Rect position;
position.x=DIMX_INTERFACE+DIM_BORDURE+_x*DIM_CASE;
position.y=DIM_BORDURE+_y*DIM_CASE;
SDL_Rect source;
source.w=DIM_CASE;
source.h=DIM_CASE;
/// Terrain
source.y=_typeTerrain;
source.x=_typeImage;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
/// Unite
if (_unite.type.unite!=NUL && _unite.joueur!=NUL)
{
source.y=_unite.joueur;
source.x=_unite.type.banniere;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
/// Curseur
if (_typeCurseur!=NUL)
{
source.y=YCURSEUR;
source.x=_typeCurseur;
SDL_BlitSurface(Surface.image, &source, Surface.ecran, &position);
}
}
/// TERRAIN
void Case::creerTerrain(int x, int y, int terrain, int image)
{
_x=x;
_y=y;
_typeTerrain=terrain;
_typeImage=image;
_peutAttaque=false;
_peutMouv=false;
}
/// UNITE
void Case::initAuto(void)
{
_unite.autoAttaque=true;
_unite.autoMouv=true;
}
void Case::creerUnite(int type, int joueur)
{
_unite=chargerDonneesUnite(type);
_unite.joueur=joueur;
_unite.type.unite=type;
_unite.type.banniere=(type/(DIMX_INTERFACE+1))*DIM_CASE; // Recuperation de la banniere en fonction du type de l'unite
_unite.troupes=100;
}
void Case::copierUnite(Case &cible)
{
_unite.attaque=cible._unite.attaque;
_unite.defense=cible._unite.defense;
_unite.mouvement=cible._unite.mouvement;
_unite.joueur=cible._unite.joueur;
_unite.troupes=cible._unite.troupes;
_unite.type.unite=cible._unite.type.unite;
_unite.type.banniere=cible._unite.type.banniere;
_unite.autoAttaque=cible._unite.autoAttaque;
_unite.autoMouv=false;
}
void Case::supprUnite(void)
{
_unite.attaque=NUL;
_unite.defense=NUL;
_unite.mouvement=NUL;
_unite.joueur=NUL;
_unite.troupes=NUL;
_unite.type.unite=NUL;
_unite.type.banniere=NUL;
_unite.autoAttaque=false;
_unite.autoMouv=false;
}
void Case::recevoirAttaque(int attaque)
{
_unite.troupes-=(attaque/(_unite.defense*2/3))*20;
if (_unite.troupes<=0) supprUnite(); // Si l'unite n'a plus de troupes, on la supprime
}
void Case::attaquer(Case &uniteCible, parametresPartie &partie)
{
int coutUniteCible=uniteCible.retournerUnite().cout[((uniteCible._unite.type.unite+1)/152)-1]; // Prix de l'unite cible
uniteCible.recevoirAttaque(_unite.attaque);
if (uniteCible._unite.troupes==NUL) // Si l'unite est supprime
{
partie.deniers+=(coutUniteCible/3)*2; // Argent gagne lors de la destruction de l'unite (2/3 du prix de l'unite)
}
_unite.autoAttaque=false;
}
parametresUnite Case::retournerUnite(void)
{
return _unite;
}
/// CURSEUR
void Case::setCurseur(int type)
{
// Verification que le type de curseur est correct
if (type>=NUL && type<=XCURSEUR_MOUVEMENT)
{
_typeCurseur=type;
}
}
int Case::retournerCurseur(void)
{
return _typeCurseur;
}
/// AUTORISATION
void Case::setAuto(int autorisation)
{
switch (autorisation)
{
case 0:
_peutAttaque=false;
_peutMouv=false;
break;
case 1:
_peutMouv=true;
break;
case 2:
_peutAttaque=true;
break;
}
}
int Case::retournerAuto(void)
{
if (_peutMouv) return 1;
if (_peutAttaque) return 2;
return 0;
}
jeu.h
#ifndef JEU_H
#define JEU_H
/// CLASSE CASE :
/// La classe case defini chaqu'une des 280 cases du plateau
/// Elle defini son terrain, l'unite presente ainsi que le curseur present
/// Elle gere donc les methodes liees au terrain, a l'unite et au curseur.
class Case
{
public:
Case();
~Case();
void affichage(mainSurface Surface);
/// -Terrain
void creerTerrain(int x, int y, int terrain, int image);
/// -Unite
void initAuto(void); // Met a true autoMouv et autoAttaque
void creerUnite(int type, int joueur);
void copierUnite(Case &cible);
void supprUnite(void);
void recevoirAttaque(int attaque);
void attaquer(Case &uniteCible, parametresPartie &partie);
parametresUnite retournerUnite(void);
/// -Curseur
void setCurseur(int type); // Place un curseur sur la case (CIBLE, FIXE, MOUVEMENT, ATTAQUE ou NUL)
int retournerCurseur(void);
/// Autorisation
void setAuto(int autorisation); // 1 Autorise le mouvement, 2 l'attaque, 0 n'autorise rien
int retournerAuto(void); // Retourne 1 si _peutMouv, 2 si _peutAttaque, 0 sinon
private:
parametresUnite _unite; // Parametres de l'unite presente sur la case (tous a NUL si aucune unite presente)
int _typeTerrain; // Coordonnee en y sur le fichier source
int _typeImage; // Coordonnee en x
int _typeCurseur;
int _x; // Coordonnee en x dans la matrice du plateau
int _y; // Coordonnee en y
bool _peutMouv; // Indique si une unite peut s'y deplacer
bool _peutAttaque; // ou l'attaquer
};
#endif
gestionActions.cpp
#include "main.h"
#include "gestionActions.h"
#include "jeu.h"
#include "gestionIcones.h"
#include "event.h"
#include "affichage.h"
static int actionEnCours=AUCUNE; // Renvoi la valeur de l'action en cours (AUCUNE, ATTAQUE ou MOUVEMENT)
void actionsPossibles(mainSurface Surface, evenement event, cooUnit &cooFixe, cooUnit &cooCible, Case plateau[][TAILLEX_CARTE], parametresPartie &partie)
{
/// Si il n'y a pas d'action en cours
if (actionEnCours==AUCUNE)
{
/// Si la souris est sur la carte
if (event.sourisSurCarte)
{
// On donne l'unite cible
cooCible.x=event.posSurCarte.x;
cooCible.y=event.posSurCarte.y;
// On place le curseur
placerCurseurCible(cooCible, plateau);
}
/// Si il y a clic sur la carte
if (event.clic && event.sourisSurCarte)
{
// On donne l'unite fixe
cooFixe.x=event.posSurCarte.x;
cooFixe.y=event.posSurCarte.y;
// On place le curseur
placerCurseurFixe(cooFixe, plateau);
}
}
else
{
switch (actionEnCours)
{
case MOUVEMENT:
supprCurseur(plateau, XCURSEUR_ATTAQUE); // Suppression des curseurs d'attaque
/// Si le mouvement de l'unite fixe est autorise
if (plateau[cooFixe.y][cooFixe.x].retournerUnite().autoMouv)
{
/// Gestion du clic
mouvement(event, cooFixe, plateau);
/// Affichage des cases accessibles
afficherMouvement(cooFixe, plateau);
/// Positionnement du curseur cible
if (event.sourisSurCarte)
{
// On donne l'unite cible
cooCible.x=event.posSurCarte.x;
cooCible.y=event.posSurCarte.y;
// On place le curseur
placerCurseurCible(cooCible, plateau);
}
}
else
{
actionEnCours=AUCUNE;
panneauTexte(Surface, "Plus de deplacement", "autorise pendant", "ce tour");
}
break;
case ATTAQUE:
supprCurseur(plateau, XCURSEUR_MOUVEMENT); // Suppression des curseurs de mouvement
/// Si l'attaque de l'unite fixe est autorise
if (plateau[cooFixe.y][cooFixe.x].retournerUnite().autoAttaque)
{
/// Affichage des possibilitees
afficherAttaque(Surface, cooFixe, plateau);
/// Positionnement du curseur cible
if (event.sourisSurCarte)
{
// On donne l'unite cible
cooCible.x=event.posSurCarte.x;
cooCible.y=event.posSurCarte.y;
// On place le curseur
placerCurseurCible(cooCible, plateau);
}
/// Gestion du clic
attaque(Surface, event, cooFixe, plateau, partie);
}
else
{
actionEnCours=AUCUNE;
panneauTexte(Surface, "Plus d'attaque", "autorisee pendant", "ce tour");
}
break;
case AUCUNE: // Si il n'y a pas d'action
supprCurseur(plateau, XCURSEUR_MOUVEMENT); // Suppression des curseurs de mouvement
supprCurseur(plateau, XCURSEUR_ATTAQUE); // Suppression des curseurs d'attaque
break;
}
}
/// Gestion des icones
gestionGeneraleIcones(Surface, event, cooFixe, cooCible, plateau, partie);
}
/// GESTION DU MOUVEMENT
void demandeMouvement(void)
{
actionEnCours=MOUVEMENT;
}
void afficherMouvement(cooUnit cooFixe, Case plateau[][TAILLEX_CARTE])
{
int mouvMax=plateau[cooFixe.y][cooFixe.x].retournerUnite().mouvement;
for (int i=1; i<=mouvMax; i++)
{
if (cooFixe.x+i<TAILLEX_CARTE && plateau[cooFixe.y][cooFixe.x+i].retournerUnite().type.unite==NUL)
{
plateau[cooFixe.y][cooFixe.x+i].setCurseur(XCURSEUR_MOUVEMENT); // Direction est
plateau[cooFixe.y][cooFixe.x+i].setAuto(1); // Autorise le mouvement sur cette case
}
if (cooFixe.x-i>=0 && plateau[cooFixe.y][cooFixe.x-i].retournerUnite().type.unite==NUL)
{
plateau[cooFixe.y][cooFixe.x-i].setCurseur(XCURSEUR_MOUVEMENT); // Direction ouest
plateau[cooFixe.y][cooFixe.x-i].setAuto(1); // Autorise le mouvement sur cette case
}
if (cooFixe.y+i<TAILLEY_CARTE && plateau[cooFixe.y+i][cooFixe.x].retournerUnite().type.unite==NUL)
{
plateau[cooFixe.y+i][cooFixe.x].setCurseur(XCURSEUR_MOUVEMENT); // Direction sud
plateau[cooFixe.y+i][cooFixe.x].setAuto(1); // Autorise le mouvement sur cette case
}
if (cooFixe.y-i>=0 && plateau[cooFixe.y-i][cooFixe.x].retournerUnite().type.unite==NUL)
{
plateau[cooFixe.y-i][cooFixe.x].setCurseur(XCURSEUR_MOUVEMENT); // Direction nord
plateau[cooFixe.y-i][cooFixe.x].setAuto(1); // Autorise le mouvement sur cette case
}
}
}
void mouvement(evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE])
{
/// Si l'on clic sur l'unite, on annule le mouvement
if (event.posSurCarte.x==cooFixe.x && event.posSurCarte.y==cooFixe.y && event.clic)
{
supprCurseur(plateau, XCURSEUR_MOUVEMENT); // Suppression de tout les curseurs de deplacement
actionEnCours=AUCUNE; // Fin direct de l'action
}
/// Si l'on clique sur une case correcte, on deplace l'unite
if (plateau[event.posSurCarte.y][event.posSurCarte.x].retournerAuto()==1 && event.clic && event.sourisSurCarte) // event.sourisSurCarte permet de ne pas prendre en compte le clic sur l'icone deplacer
{
plateau[event.posSurCarte.y][event.posSurCarte.x].copierUnite(plateau[cooFixe.y][cooFixe.x]); // Copie de l'unite sur la nouvelle case
plateau[cooFixe.y][cooFixe.x].supprUnite(); // Suppression de l'unite source
plateau[event.posSurCarte.y][event.posSurCarte.x].setAuto(NUL); // Suppression de l'autorisation de deplacement sur la case
supprCurseur(plateau, XCURSEUR_MOUVEMENT); // Suppression de tout les curseurs de deplacement
actionEnCours=AUCUNE; // Fin de l'action
}
}
/// GESTION DE L'ATTAQUE
void demandeAttaque(void)
{
actionEnCours=ATTAQUE;
}
void afficherAttaque(mainSurface Surface, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE])
{
bool possibiliteAttaque=false;
if (plateau[cooFixe.y][cooFixe.x+1].retournerUnite().joueur!=plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur && plateau[cooFixe.y][cooFixe.x+1].retournerUnite().type.unite!=NUL && plateau[cooFixe.y][cooFixe.x+1].retournerUnite().type.unite!=CAMP)
{
plateau[cooFixe.y][cooFixe.x+1].setCurseur(XCURSEUR_ATTAQUE); // Direction est
plateau[cooFixe.y][cooFixe.x+1].setAuto(2); // Autorise l'attaque sur cette case
possibiliteAttaque=true; // Il y a au moin une possibilite d'attaque
}
if (plateau[cooFixe.y][cooFixe.x-1].retournerUnite().joueur!=plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur && plateau[cooFixe.y][cooFixe.x-1].retournerUnite().type.unite!=NUL && plateau[cooFixe.y][cooFixe.x-1].retournerUnite().type.unite!=CAMP)
{
plateau[cooFixe.y][cooFixe.x-1].setCurseur(XCURSEUR_ATTAQUE); // Direction ouest
plateau[cooFixe.y][cooFixe.x-1].setAuto(2); // Autorise l'attaque sur cette case
possibiliteAttaque=true; // Il y a au moin une possibilite d'attaque
}
if (plateau[cooFixe.y+1][cooFixe.x].retournerUnite().joueur!=plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur && plateau[cooFixe.y+1][cooFixe.x].retournerUnite().type.unite!=NUL && plateau[cooFixe.y+1][cooFixe.x].retournerUnite().type.unite!=CAMP)
{
plateau[cooFixe.y+1][cooFixe.x].setCurseur(XCURSEUR_ATTAQUE); // Direction sud
plateau[cooFixe.y+1][cooFixe.x].setAuto(2); // Autorise l'attaque sur cette case
possibiliteAttaque=true; // Il y a au moin une possibilite d'attaque
}
if (plateau[cooFixe.y-1][cooFixe.x].retournerUnite().joueur!=plateau[cooFixe.y][cooFixe.x].retournerUnite().joueur && plateau[cooFixe.y-1][cooFixe.x].retournerUnite().type.unite!=NUL && plateau[cooFixe.y-1][cooFixe.x].retournerUnite().type.unite!=CAMP)
{
plateau[cooFixe.y-1][cooFixe.x].setCurseur(XCURSEUR_ATTAQUE); // Direction nord
plateau[cooFixe.y-1][cooFixe.x].setAuto(2); // Autorise l'attaque sur cette case
possibiliteAttaque=true; // Il y a au moin une possibilite d'attaque
}
if (!possibiliteAttaque)
{
actionEnCours=AUCUNE; // Si il n'y a pas de possibilite d'attaque, on arrete l'action en cours
panneauTexte(Surface, "Aucune", "unite a", "portee");
}
}
void attaque(mainSurface Surface, evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE], parametresPartie &partie)
{
/// Si l'on clic sur l'unite, on annule l'attaque
if (event.posSurCarte.x==cooFixe.x && event.posSurCarte.y==cooFixe.y && event.clic)
{
supprCurseur(plateau, XCURSEUR_ATTAQUE); // Suppression de tout les curseurs d'attaque
actionEnCours=AUCUNE; // Fin direct de l'action
}
/// Si l'on clique sur une case correcte, on attaque
if (plateau[event.posSurCarte.y][event.posSurCarte.x].retournerAuto()==2 && event.clic && event.sourisSurCarte) // event.sourisSurCarte permet de ne pas prendre en compte le clic sur l'icone deplacer
{
plateau[cooFixe.y][cooFixe.x].attaquer(plateau[event.posSurCarte.y][event.posSurCarte.x], partie);
plateau[event.posSurCarte.y][event.posSurCarte.x].setAuto(NUL); // Suppression de l'autorisation d'attaque sur la case
supprCurseur(plateau, XCURSEUR_ATTAQUE); // Suppression de tout les curseurs de deplacement
actionEnCours=AUCUNE; // Fin de l'action
SDL_Delay(1);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void initialisationTour(Case plateau[][TAILLEX_CARTE])
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
// Si une unite differente d'un camp est presente sur la case
if (plateau[i][j].retournerUnite().type.unite>=LEGIONNAIRE && plateau[i][j].retournerUnite().type.unite<=CHAR && (plateau[i][j].retournerUnite().joueur==J1 || plateau[i][j].retournerUnite().joueur==J2))
{
plateau[i][j].initAuto(); // On autorise son deplacement et son attaque
}
}
}
}
void placerCurseurCible(cooUnit cooCible, Case plateau[][TAILLEX_CARTE])
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
/// Si la case actuel est celle ciblee
if (cooCible.x==j && cooCible.y==i)
{
/// Si la case actuel n'a pas de curseur fixe
if (plateau[i][j].retournerCurseur()!=XCURSEUR_FIXE)
{
plateau[i][j].setCurseur(XCURSEUR_CIBLE); // On place un curseur cible
}
}
else
{
/// Si la case n'est pas celle ciblee mais qu'elle a un curseur cible
if (plateau[i][j].retournerCurseur()==XCURSEUR_CIBLE)
{
plateau[i][j].setCurseur(NUL); // On supprime le curseur
}
}
}
}
}
void placerCurseurFixe(cooUnit cooFixe, Case plateau[][TAILLEX_CARTE])
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
/// Si la case actuel est la fixe
if (cooFixe.x==j && cooFixe.y==i)
{
plateau[i][j].setCurseur(XCURSEUR_FIXE); // On place le curseur fixe
}
else
{
/// Si elle a un curseur fixe mais qu'elle n'est pas la case fixe
if (plateau[i][j].retournerCurseur()==XCURSEUR_FIXE)
{
plateau[i][j].setCurseur(NUL); // On supprime le curseur
}
}
}
}
}
void supprCurseur(Case plateau[][TAILLEX_CARTE], int type)
{
for (int i=0; i<TAILLEY_CARTE; i++)
{
for (int j=0; j<TAILLEX_CARTE; j++)
{
if (plateau[i][j].retournerCurseur()==type)
{
plateau[i][j].setCurseur(NUL);
plateau[i][j].setAuto(NUL);
}
}
}
}
gestionAction.h
#ifndef GESTION_ACTION_H
#define GESTION_ACTION_H
#include "jeu.h"
void actionsPossibles(mainSurface Surface, evenement event, cooUnit &cooFixe, cooUnit &cooCible, Case plateau[][TAILLEX_CARTE], parametresPartie &partie);
/// ACTIONSPOSSIBLES
/// Regroupe toutes les actions possible par le joueur pendant son tour
/// Si il n'ya pas d'action en cours, on gere les curseurs
/// Sinon on gere l'action
/// On gere tout le temps les icones
/// /// /// /// ///
void demandeMouvement(void);
/// DEMANDEMOUVEMENT
/// Passe l'action en cours a mouvement
void afficherMouvement(cooUnit cooFixe, Case plateau[][TAILLEX_CARTE]);
/// AFFICHERMOUVEMENT
/// Place un curseur mouvement sur chaque case accessible par l'unite
void mouvement(evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE]);
/// MOUVEMENT
/// Copie l'unite a deplacer a sa nouvelle case si c'est une case possible et la supprime a son ancienne case
/// /// /// /// ///
void demandeAttaque(void);
/// DEMANDEATTAQUE
/// Passe l'action en cours a attaque
void afficherAttaque(mainSurface Surface, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE]);
/// AFFICHERATTAQUE
/// Place un curseur sur chaque unite a portee de l'unite qui attaque
void attaque(mainSurface Surface, evenement event, cooUnit cooFixe, Case plateau[][TAILLEX_CARTE], parametresPartie &partie);
/// ATTAQUE
/// Attaque l'unite cible si elle est correcte et gagne de l'argent si l'unite cible est tuee
/// /// /// /// ///
void initialisationTour(Case plateau[][TAILLEX_CARTE]);
/// INITIALISATIONTOUR
/// Permet d'initialiser la carte a chaque debut de tour (ou jour)
/// Remet autoMouv & autoAttaque a true
void placerCurseurCible(cooUnit cooCible, Case plateau[][TAILLEX_CARTE]);
/// PLACERCURSEURCIBLE
/// Place un curseur sur la case "cible"
/// Et supprime le curseur si c'est un curseur cible, sur une case qui n'est pas "cible"
void placerCurseurFixe(cooUnit cooFixe, Case plateau[][TAILLEX_CARTE]);
/// PLACERCURSEURFIXE
/// Meme principe que PLACERCURSEURCIBLE
void supprCurseur(Case plateau[][TAILLEX_CARTE], int type);
/// SUPPRCURSEUR
/// Supprime tout les curseur du type donne en entree sur le plateau
#endif
gestionFichiersTextes.cpp
#include "main.h"
#include "gestionFichiersTexte.h"
parametresUnite chargerDonneesUnite(int type)
{
parametresUnite retour; // Parametres a renvoyer
FILE *base=fopen("donneesUnit.txt", "r"); // Base de donnee
int posZone=((type/151)-1)*((NB_PARAMETRES_PROPRE+1)*NB_CARACT); // Position de la zone (chaque parametre prend 4 caracteres)
char zoneUnit[(NB_PARAMETRES_PROPRE+1)*NB_CARACT]="";
char zoneCout[NB_UNIT*NB_CARACT+NB_CARACT]="";
/// Recuperation des parametres des unites
if (type!=CAMP) // Si l'unite demandee n'est pas un camp
{
fseek(base, posZone, SEEK_SET);
fgets(zoneUnit, (NB_PARAMETRES_PROPRE+1)*NB_CARACT, base);
sscanf(zoneUnit, "%d %d %d %d", &retour.type.unite, &retour.attaque, &retour.defense, &retour.mouvement);
}
else
{
retour.attaque=0;
retour.defense=0;
retour.mouvement=0;
}
/// Recuperation du prix des unites
posZone=((NB_PARAMETRES_PROPRE+1)*NB_CARACT)*NB_UNIT;
fseek(base, posZone, SEEK_SET);
fgets(zoneCout, NB_UNIT*NB_CARACT+NB_CARACT, base);
sscanf(zoneCout, "%d %d %d %d %d %d", &type, &retour.cout[0], &retour.cout[1], &retour.cout[2], &retour.cout[3], &retour.cout[4]);
fclose(base);
return retour; // On retourne les parametres
}
gestionFichiersTextes.h
#ifndef GESTION_FICHIERS_TEXTE_H
#define GESTION_FICHIERS_TEXTE_H
parametresUnite chargerDonneesUnite(int type);
/// CHARGERDONNEESUNITE
/// Renvoi les 3 parametres propre au type d'unite donnee en argument :
/// Attaque, defense et mouvement
#endif
Voici quelques screenshot de mon projet, avec une map de test :
Oua bravo LordOfWar en voyant ton projet ça m'a fait penser à Age Of Empire .
C'est du bon boulot .
Les graphismes sont de toi?
Il y aura de la musique dans le jeu .
Sinon
Félicitation !
Merci
Oui j'ai tout fait sous paint
J'ai pas encore pensé au son je me concentre plutôt sur l'IA actuellement, qui, je pense va me donner un peu de boulot
Bonjour, il se trouve que je suis justement en train d'adapter mon projet de la console à la SDL (mais bon en fait je dois tout réécrire rien n'est récupérable). Je ne sais pas si j'aurais le temps de le finir en un mois mais je vais essayer donc je m'inscrit. Si vous voulez une description du projet c'est par ici
Voici ce qu'il n'y aura pas par rapport à la description :
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.