Eat game - affrontez vos amis
Description
Un petit jeu qui consiste à manger le plus vite que possible des chiffres avant son adversaire.
Il y a 2 joueurs et chacun peut utiliser une attaque qui bloc pendant 5s les mouvements de l'ennemi.
Une partie dure 2 m.
Il y a 2 joueurs et chacun peut utiliser une attaque qui bloc pendant 5s les mouvements de l'ennemi.
Une partie dure 2 m.
Source / Exemple :
_____________________________________
Main.ccp
_____________________________________
#include <iostream>
#include <time.h>
#include <windows.h>
#include "include/Map.h"
#include "include/Perso.h"
#include "include/Perso_2.h"
using namespace std;
int main()
{
//Présentation
cout << "Hello world!" << endl;
cout<<"Bienvenue Dans Eat GAME !!!! "<<endl<<"Manger les 1 et ton score augmentera"<<endl<< "Manger les 8 et tu pourras blocker ton adversaire pendant 5 seconde !"<<endl;
cout<<"Le joueur Y utilise les touches directionnelles pour se deplacer"<<endl<<" et la barre d'espace pour attaquer !!"<<endl;
cout<<"Le joueur X utilise Z, S, Q, D pour se deplacer et A pour attaquer !!!"<<endl;
system("PAUSE");
//variable pour l'ajouter objet chaque 5s
long seconde1970(0);
//le temps de jeu
long secjeu(0);
Map RPG;
Perso Y('Y',10,10);
Perso_2 X('X',11,11);
//ajouter perso dans le tableau dans l'objet rpg de type map
X.AjouterPerso(RPG);
Y.AjouterPerso(RPG);
//afficher la map
RPG.Afficher();
//le temps a comparer pour ajouter des objet
seconde1970=time(NULL);
//le temps a comparer pour sortir du while donc fin du jeu
secjeu=time(NULL);
while (true)
{
//après 5 secondes on ajoute un 1 ou un 8 dans le tableau
if ((seconde1970+5)==time(NULL))
{
RPG.AjouterObjet();
seconde1970=time(NULL);
}
//deplacer dans la map les 2 perso ,le paramètre de droite est le perso a attaquer
X.Deplacer(RPG,Y);
Y.Deplacer(RPG,X);
//après 2m de jeu on fini le jeu et on sort de la boucle
if ((secjeu+120)==time(NULL))
{
system("cls");
break;
}
}
//
if (X.GetScore()<Y.GetScore())
cout<<"Bravo Y tu as gagne !!!!! !!!! !!!!"<<endl;
else if (X.GetScore()>Y.GetScore())
cout<<"Bravo X tu as gagne !!!!! !!!! !!!!"<<endl;
else
cout<<"Egalite !!!!! !!!! !!!!"<<endl;
Sleep(4000);
cout<<"FFFFFFFF"<<endl;
cout<<"FFFFFFFF"<<endl;
cout<<"FFFF"<<endl;
cout<<"FFFFFFFF"<<endl;
cout<<"FFFFFFFF"<<endl;
cout<<"FFFF"<<endl;
cout<<"FFFF"<<endl;
cout<<"FFFF"<<endl;
Sleep(500);
system("cls");
cout<<"FFFFFFFF IIIIII"<<endl;
cout<<"FFFFFFFF IIIIII"<<endl;
cout<<"FFFF IIII"<<endl;
cout<<"FFFFFFFF IIII"<<endl;
cout<<"FFFFFFFF IIII"<<endl;
cout<<"FFFF IIII"<<endl;
cout<<"FFFF IIIIII"<<endl;
cout<<"FFFF IIIIII"<<endl;
Sleep(500);
system("cls");
cout<<"FFFFFFFF IIIIII NNNNN NNNN"<<endl;
cout<<"FFFFFFFF IIIIII NNNNNN NNNN"<<endl;
cout<<"FFFF IIII NNNNNNN NNNN"<<endl;
cout<<"FFFFFFFF IIII NNNN NNN NNNN"<<endl;
cout<<"FFFFFFFF IIII NNNN NNN NNNN"<<endl;
cout<<"FFFF IIII NNNN NNN NNNN"<<endl;
cout<<"FFFF IIIIII NNNN NNNNNNNN"<<endl;
cout<<"FFFF IIIIII NNNN NNNNNNN"<<endl;
Sleep(5000);
system("PAUSE");
return 0;
}
_____________________________________
Perso.h
_____________________________________
#ifndef PERSO_H
#define PERSO_H
#define lol 20
#include <windows.h>
#include <winuser.h>
#include "Map.h"
class Perso
{
public:
Perso();
Perso(char nom,int X=0,int Y=0);
//retourner abscisse
int GetX();
//retourner ordonnée
int GetY();
//retourner la lettre qui correspond a son nom
char GetNom();
//Afficher l'etat du perso ,m_actif = il peut ce déplacer ou pas
bool Getactif();
//afficher score
int GetScore();
//retourner la valeur de m_attaque
bool Getattaque();
//Mofifier l'etat , blocker ou en mouvement
void Setactif(bool valeur);
//Ajouter un perso dans la map
void AjouterPerso(Map &A);
//deplacer un perso dans le tableau
int Deplacer(Map &A,Perso &X);
//super attaque elle block le perso adverse
void Attaquer(Perso &A);
virtual ~Perso();
protected:
int m_X;
int m_Y;
char m_nom;
bool m_actif;
bool m_attaque;
int m_score;
long m_tempB;
private:
};
//pour afficher en bas de la map le nom le score et l'attaque
void EtatPerso(Perso &A,Perso &B);
#endif // PERSO_H
_____________________________________
Perso.ccp
_____________________________________
#include "../include/Perso.h"
using namespace std;
Perso::Perso():m_nom('X'),m_X(0),m_Y(0),m_actif(true),m_attaque(false),m_score(0),m_tempB(0)
{
}
Perso::Perso(char nom,int X,int Y):m_nom(nom),m_X(X),m_Y(Y),m_actif(true),m_attaque(false),m_score(0),m_tempB(0)
{
}
int Perso::GetX()
{
return m_X;
}
int Perso::GetY()
{
return m_Y;
}
char Perso::GetNom()
{
return m_nom;
}
bool Perso::Getactif()
{
return m_actif;
}
int Perso::GetScore()
{
return m_score;
}
bool Perso::Getattaque()
{
return m_attaque;
}
void Perso::Setactif(bool valeur)
{
m_actif=valeur;
}
void Perso::AjouterPerso(Map &A)
{
A.SetTerrain(m_nom,m_X,m_Y);
}
int Perso::Deplacer(Map &A,Perso &X)
{
//si m_actif n'est pas = a true alors il peut pas bouger
if (m_actif==true)
{
if (GetAsyncKeyState(VK_UP))
{
//si la case en haut du perso = a un . alors on echange les 2 objet (. et perso) on affiche la map et l'etat du perso (nom,score,et attaque)
if (A.GetTerrain(m_X-1,m_Y)=='.')
{
A.Echange(m_X,m_Y,m_X--,m_Y);
A.Afficher();
EtatPerso(*this,X);
}
//si la case en haut du perso = a un 1 alors on modifie la case 1 en un . on ajoute 1 au score et afficher l'etat
else if (A.GetTerrain(m_X-1,m_Y)=='1')
{
A.SetTerrain('.',m_X-1,m_Y);
m_score++;
A.Afficher();
EtatPerso(*this,X);
}
//si la case en haut du perso = a un 8 alors on modifie la case 8 en un . on ajoute 1 au score ,on modifie la variable attaque et on afficher l'etat
else if (A.GetTerrain(m_X-1,m_Y)=='8')
{
A.SetTerrain('.',m_X-1,m_Y);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(*this,X);
}
}
else if (GetAsyncKeyState(VK_DOWN))
{
if (A.GetTerrain(m_X+1,m_Y)=='.')
{
A.Echange(m_X,m_Y,m_X++,m_Y);
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X+1,m_Y)=='1')
{
A.SetTerrain('.',m_X+1,m_Y);
m_score++;
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X+1,m_Y)=='8')
{
A.SetTerrain('.',m_X+1,m_Y);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(*this,X);
}
}
else if (GetAsyncKeyState(VK_LEFT))
{
if (A.GetTerrain(m_X,m_Y-1)=='.')
{
A.Echange(m_X,m_Y,m_X,m_Y--);
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X,m_Y-1)=='1')
{
A.SetTerrain('.',m_X,m_Y-1);
m_score++;
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X,m_Y-1)=='8')
{
A.SetTerrain('.',m_X,m_Y-1);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(*this,X);
}
}
else if (GetAsyncKeyState(VK_RIGHT))
{
if (A.GetTerrain(m_X,m_Y+1)=='.')
{
A.Echange(m_X,m_Y,m_X,m_Y++);
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X,m_Y+1)=='1')
{
A.SetTerrain('.',m_X,m_Y+1);
m_score++;
A.Afficher();
EtatPerso(*this,X);
}
else if (A.GetTerrain(m_X,m_Y+1)=='8')
{
A.SetTerrain('.',m_X,m_Y+1);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(*this,X);
}
}
//le perso attaque son adversaire pour le blocker pendant 5 s
else if (GetAsyncKeyState(VK_SPACE))
{
if (m_attaque==true)
{
m_attaque=false;
this->Attaquer(X);
m_tempB=time(NULL);
}
}
}
//après 5s on rappel la methode attaque pour activer les mouvement de l'autre perso
if ((m_tempB+5)==time(NULL))
{
this->Attaquer(X);
}
}
void Perso::Attaquer(Perso &A)
{
if (A.Getactif()==true)
A.Setactif(false);
else
A.Setactif(true);
}
Perso::~Perso()
{
//dtor
}
//afficher l'etat des perso nom score et attaque
void EtatPerso(Perso &A,Perso &B)
{
cout<<"nom :"<<A.GetNom()<<" score :"<<A.GetScore()<<" attaque "<<A.Getattaque()<<endl;
cout<<"nom :"<<B.GetNom()<<" score :"<<B.GetScore()<<" attaque "<<B.Getattaque()<<endl;
}
_____________________________________
Perso_2.h
_____________________________________
#ifndef PERSO_2_H
#define PERSO_2_H
#include "Perso.h"
class Perso_2:public Perso
{
public:
Perso_2();
Perso_2(char nom,int X,int Y);
int Deplacer(Map &A,Perso &X);
virtual ~Perso_2();
protected:
private:
};
#endif // PERSO_2_H
_____________________________________
Perso_2.ccp
_____________________________________
#include "../include/Perso_2.h"
Perso_2::Perso_2():Perso()
{
//ctor
}
Perso_2::Perso_2(char nom,int X,int Y):Perso(nom,X,Y)
{
}
int Perso_2::Deplacer(Map &A,Perso &X)
{
if (m_actif==true)
{
if (GetAsyncKeyState('Z'))
{
if (A.GetTerrain(m_X-1,m_Y)=='.')
{
A.Echange(m_X,m_Y,m_X--,m_Y);
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X-1,m_Y)=='1')
{
A.SetTerrain('.',m_X-1,m_Y);
m_score++;
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X-1,m_Y)=='8')
{
A.SetTerrain('.',m_X-1,m_Y);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(X,*this);
}
}
else if (GetAsyncKeyState('S'))
{
if (A.GetTerrain(m_X+1,m_Y)=='.')
{
A.Echange(m_X,m_Y,m_X++,m_Y);
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X+1,m_Y)=='1')
{
A.SetTerrain('.',m_X+1,m_Y);
m_score++;
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X+1,m_Y)=='8')
{
A.SetTerrain('.',m_X+1,m_Y);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(X,*this);
}
}
else if (GetAsyncKeyState('Q'))
{
if (A.GetTerrain(m_X,m_Y-1)=='.')
{
A.Echange(m_X,m_Y,m_X,m_Y--);
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X,m_Y-1)=='1')
{
A.SetTerrain('.',m_X,m_Y-1);
m_score++;
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X,m_Y-1)=='8')
{
A.SetTerrain('.',m_X,m_Y-1);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(X,*this);
}
}
else if (GetAsyncKeyState('D'))
{
if (A.GetTerrain(m_X,m_Y+1)=='.')
{
A.Echange(m_X,m_Y,m_X,m_Y++);
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X,m_Y+1)=='1')
{
A.SetTerrain('.',m_X,m_Y+1);
m_score++;
A.Afficher();
EtatPerso(X,*this);
}
else if (A.GetTerrain(m_X,m_Y+1)=='8')
{
A.SetTerrain('.',m_X,m_Y+1);
m_score++;
m_attaque=true;
A.Afficher();
EtatPerso(X,*this);
}
}
else if (GetAsyncKeyState('A'))
{
if (m_attaque==true)
{
m_attaque=false;
this->Attaquer(X);
m_tempB=time(NULL);
}
}
}
if ((m_tempB+5)==time(NULL))
{
this->Attaquer(X);
}
}
Perso_2::~Perso_2()
{
//dtor
}
_____________________________________
Map.h
_____________________________________
#ifndef MAP_H
#define MAP_H
#include <iostream>
#include <windows.h>
#include <time.h>
#define lol 20
class Map
{
public:
Map();
//modifier terrain a une case
void SetTerrain(char no,int X,int Y);
//Afficher une case
char GetTerrain(int X,int Y);
//echanger 2 element dans le tableau
bool Echange(int Xa,int Ya,int Xn,int Yn);
//afficher la map
void Afficher();
//ajouter un objet dans la map a chaque execution il ajoute 1 element en plus
void AjouterObjet();
virtual ~Map();
protected:
char m_terrain[lol][lol];
int m_nbObjet;
private:
};
#endif // MAP_H
_____________________________________
Map.ccp
_____________________________________
#include "../include/Map.h"
using namespace std;
Map::Map()
{
int i(0),j(0);
for (i=0;i<lol;i++)
{
for (j=0;j<lol;j++)
{
m_terrain[i][j]='.';
}
}
m_nbObjet=0;
srand(time(NULL));
}
////modifier terrain a une case
void Map::SetTerrain(char no,int X,int Y)
{
m_terrain[X][Y]=no;
}
char Map::GetTerrain(int X,int Y)
{
return m_terrain[X][Y];
}
bool Map::Echange(int Xa,int Ya,int Xb,int Yb)
{
char stock;
stock=m_terrain[Xa][Ya];
m_terrain[Xa][Ya]=m_terrain[Xb][Yb];
m_terrain[Xb][Yb]=stock;
return true;
}
void Map::Afficher()
{
int i(0),j(0);
system("cls");
for (i=0;i<lol;i++)
{
cout<<endl;
for (j=0;j<lol;j++)
{
cout<<m_terrain[i][j]<<" ";
}
}
cout<<endl<<endl;
}
void Map::AjouterObjet()
{
//cette condition permet de ne pas executer indéfiniment les objet dans la map
if (m_nbObjet<=12)
{
int X;
int Y;
//ajouter un 1 ou un 8
int alea(0);
for (int i(0);i<=m_nbObjet;i++)
{
do {
X=(rand()%lol)-1;
Y=(rand()%lol)-1;
} while (m_terrain[X][Y] != '.');
alea=rand()%10;
if (alea<=7)
{
m_terrain[X][Y]='1';
}
else
{
m_terrain[X][Y]='8';
}
}
m_nbObjet++;
}
}
Map::~Map()
{
//dtor
}
Codes Sources
A voir également
- Eat game - affrontez vos amis
- Coding game java ✓ - Forum Java
- Comment declarer plusieurs classes dans un fichier java - Forum Java
- Game javascript - Forum Javascript / DHTML
- War game java - Forum Java
- Coding game php ✓ - Forum PHP
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.