//calcul du best
int Joueur::getMeilleur(Carte **tas, Couleur atout, int premierJoueur){
int best = premierJoueur;
Carte *prems = tas[premierJoueur];
bool isAtout = false;
for(int i = 0; i < 4; i++){
if(tas[i] != nullptr){
//Si la carte actuelle est un atout
if(tas[i]->isCouleur(atout)){
//Si la meilleure carte est aussi un atout on doit comparer
if(isAtout){
if(tas[best]->getValeur(atout) < tas[i]->getValeur(atout))
best = i;
}else{ // Sinon ça devient automatiquement la meilleure carte
best = i;
}
}//sinon, si la carte actuelle est de la couleur demandée (et qu'on a pas déjà eu un atout
else if(tas[i]->isCouleur(prems->getCouleur())){
//On compare la puissance de l'âme des cartes, Yugi
if(tas[best]->getValeur(atout) < tas[i]->getValeur(atout))
best = i;
}
}
}
return best;
}
void Solitaire::deplacerColonneAColonne(int p_colonneSource, int p_colonneDestination, int p_nbCartes)
{
PRECONDITION(p_colonneSource >=0 && p_colonneSource <=6);
PRECONDITION(p_colonneDestination >=0 && p_colonneDestination <=6);
//variables temporaires permettant de faire les validations.
int positionCarteSource = (m_colonnes[p_colonneSource].reqTailleColonne() + 1) - p_nbCartes;
Carte derniereCarteDestination = m_colonnes[p_colonneDestination].derniereCarteColonne();
Carte carteSource = m_colonnes[p_colonneSource].carteALaPosition(positionCarteSource);
int valeurCarteSource = carteSource.reqValeur();
int tailleColonneDestination = m_colonnes[p_colonneDestination].colonneEstVide();
//Si la taille de la colonneDestination est vide et que la première carte à bouger est un Roi, le déplacement est possible.
if((tailleColonneDestination == 0) && (valeurCarteSource == Carte::ROI))
{
m_colonnes[p_colonneSource].deplacePaquet(m_colonnes[p_colonneDestination], p_nbCartes);
}
//Si la colone n'est pas vide, verification de la dernière carte de la colonne. Deplacement si elle est suivante à la carteSource.
else if(derniereCarteDestination.estSuivante(carteSource) &&
!derniereCarteDestination.estMemeCouleur(carteSource))
{
m_colonnes[p_colonneSource].deplacePaquet(m_colonnes[p_colonneDestination], p_nbCartes);
}
else
{
cout << endl << "Ce deplacement est invalide!" << endl << endl;
}
}
void CaseCarte::joueurArrive(Joueur* j)
{
Case::joueurArrive(j);
Carte *carte = m_paquet->tirer();
j->setLastCarte(carte);
if (!dynamic_cast<Payer_ou_tirer*>(carte))
carte->tirer(j);
}
Carte* Joueur::pullCarte(unsigned int i){
Carte *ret = getCarte(i);
if(!ret->isDefault()){
jeu[i]->setPlayed(true);
jeu[i] = jeu[0];
jeu.erase(jeu.begin());
}
return ret;
}
Carte* PaquetCarte::tirer()
{
Carte* carte;
do
{
carte = m_cartes.front();
m_cartes.pop_front();
m_cartes.push_back(carte);
}while(carte->estEnPossession());
return carte;
}
void Carte::afficherS () {
Carte* ec = teteS;
while (ec->_suc != queueS ) {
ec->afficher();
ec=ec->_suc;
}
}
void Carte::afficherN () {
Carte* ec = teteN;
while (ec->_suc != queueN ) {
ec->afficher();
ec=ec->_suc;
}
}
/**
*\fn afficherS()
*\brief display a card of the S player
*/
void Carte::afficherS()
{
if(firstS == nullptr)
{
printf("No card");
}else{
Carte * cardToDisplay = firstS;
while(cardToDisplay != nullptr)
{
cardToDisplay->afficher();
cardToDisplay = cardToDisplay->nextCard;
}
}
}
Deck::Deck(string fichier)
{
int pdv,pa,cm,fct,i,j,sz;
i = 0;
j = 0;
string ligne,nom,des;
bool charge,provoc,sort;
vector<Carte> myvector;
ifstream ifs(fichier.c_str());
srand(time(0));
if(ifs)
{
while(getline(ifs,ligne))
{
istringstream iss(ligne);
iss >> pa;
iss >> pdv;
iss >> nom;
iss >> cm;
iss >> charge;
iss >> provoc;
iss >> sort;
iss >> fct;
iss >> des;
//cout << pdv << " " << pa << " " << nom << " " << cm << endl;
replace(nom.begin(),nom.end(),'_',' ');
replace(des.begin(),des.end(),'_',' ');
Carte * c = new Carte(pdv,pa,nom,cm,charge,provoc,sort,fct,des);
myvector.push_back(*c);
//d.push(*c);
std::random_shuffle ( myvector.begin(), myvector.end() );
// using myrandom:
std::random_shuffle ( myvector.begin(), myvector.end(), myrandom);
i++;
cout << c->toString() << endl;
}
}
else
{
/*!
@fn void AskDataBase::CreateFile(void)
@brief Cree ou recupere une BDD puis lance la feetre principale.
\note Dans les faits la recuperation ou la creation de la base de donnée se fait à l'appel de datacreate on récupére aussi les catagories qui ont été sauvergardé dans les QSettings.
*/
void AskDataBase::CreateFile(void)
{
filename= ui->comboBox->currentText().remove(".db");
database::dataCreate(filename)->initTable();
int i = 0 ;
QStringList Categories;
QSettings settings("CartoTeam", "Cartographe");
Categories.append(settings.value("Categories").toStringList());
for(i=0;i<Categories.count();i++)
{
addCategorie(Categories.value(i));
}
Carte * WCarte = new Carte();
WCarte->show();
this->close();
}
vector<Carte*> Joueur::priorite(Carte** tas, Couleur atout){
int premier = 0, moi = -1, part = -1;
Carte *prems = tas[premier];
// On trouve le premier joueur
while(premier < 4 && (prems == nullptr || tas[(premier+3)%4] != nullptr)){
prems = tas[++premier];
}
//On trouve ma position, et par conséquent celle de mon partenaire
for(int i = 0; i < 4; i++){
int ii = (i+premier)%4;
if(tas[ii] == nullptr){
moi = ii;
part = (moi+2)%4;
}
}
vector<Carte*> ret;
if(premier == 4){//On est le premier
ret = jeu;
}else{ // Sinon
if(prems->getCouleur() != atout){ // SI la couleur demandée n'est pas l'atout
if(aCouleur(prems->getCouleur())){ //Si on a la couleur demandée, alors couleur
for(Carte *c:jeu){
if(c->getCouleur() == prems->getCouleur()){
ret.push_back(c);
}
}
}else{
int best = getMeilleur(tas, atout, premier); // Sinon on regarde qui est le meilleur
if(part == best){ // Si le partenaire est le meilleur, ça implique qu'il ait déjà joué, on peut jouer n'imp
ret = jeu;
}
}
}else{ // SI la couleur demandée est de l'atout
int best = getMeilleur(tas, atout, premier);
if(tas[best]->getCouleur() == atout){
int bestVal = tas[best]->getValeur(atout);
for(Carte *c:jeu){ // On regarde si on peut mettre un meilleur atout
if(c->getCouleur() == atout && c->getValeur(atout) > bestVal){
ret.push_back(c);
}
}
}
}
if(ret.empty()){// Si ret est toujours vide, on regarde si on a une carte de la couleur demandée
if(aCouleur(prems->getCouleur())){ //Si on a la couleur demandée, alors couleur
for(Carte *c:jeu){
if(c->getCouleur() == prems->getCouleur()){
ret.push_back(c);
}
}
}else{ // sinon n'importe quelle carte
ret = jeu;
}
}
}
return ret;
}
bool operator<(const Carte& lhs, const Carte& rhs)
{
if(lhs.getColor() < rhs.getColor())
return true;
else if (lhs.getColor() == rhs.getColor() && lhs.getValue() < rhs.getValue())
return true;
else
return false;
}
int main(){
Carte* carteD = new Carte(0,{{'#','_','#'},{'#','_','#'},{'#','_','_'}});
Carte* carteA = new Carte(1,{{'_','_','#'},{'#','_','#'},{'#','_','#'}});
Coordonnees coordD(0,0);
Coordonnees coordA(1,0);
PersonnageJouable* pers = new PersonnageJouable("Jerôme",coordD,carteD);
((CelluleAccessible*)carteD->getCel(coordD))->setPersonnage(pers);
ActionChangementCarte act(carteD,carteA,coordD,coordA);
cout << "Personnage présent dans la carte de départ?" << ((CelluleAccessible*)carteD->getCel(coordD))->getPersonnage() << endl;
cout << "Personnage présent dans la carte d'arrivée?" << ((CelluleAccessible*)carteA->getCel(coordA))->getPersonnage() << endl << endl;
act.lancerAction();
cout << "Lancement de l'action déplacer" << endl << endl;
cout << "Personnage présent dans la carte de départ?" << ((CelluleAccessible*)carteD->getCel(coordD))->getPersonnage() << endl;
cout << "Personnage présent dans la carte d'arrivée?" << ((CelluleAccessible*)carteA->getCel(coordA))->getPersonnage() << endl << endl;
cout << "Affichage texte interaction" << endl;
cout << act.getTexteInteraction() << endl << endl;
cout << "L'action est-elle toujours active?" << endl;
cout << "est actif?" << act.isActive() <<endl << endl;
cout << "On fait un toggle active" << endl << endl;
act.toggleActive();
cout << "L'action est-elle toujours active?" << endl;
cout << "est actif?" << act.isActive() <<endl;
}
bool operator<(Carte const &a, Carte const& b)
{
return (int)a.getValeur()<(int)b.getValeur();
}
bool Carte::supAbs(Carte c) { return _valeur>c.valeur();}
void Jeu::lireJoueurs(){//DONE
ifstream file("donnees/Joueurs.d", ios::in);
int idCartePerso, xPerso, yPerso;
string nomPerso;
file >> nomPerso
>> idCartePerso
>> xPerso
>> yPerso;
Carte* cartePerso = monde.getCarte(idCartePerso);
personnageJouable = new JoueurHumain(nomPerso, Coordonnees(xPerso, yPerso), cartePerso);
personnageJouable->setCarte(cartePerso);
personnageJouable->setCoordonnees(Coordonnees(xPerso, yPerso));
((CelluleAccessible*)cartePerso->getCellules()[xPerso][yPerso])->setPersonnage(personnageJouable);
int nbAdversaire;
file >> nbAdversaire;
for(int i=0; i<nbAdversaire; i++){
int typePerso, xTailleGrille, yTailleGrille;
char bossFinal;
string aCasesCombat, armePerso;
file >> typePerso
>> nomPerso
>> idCartePerso
>> xPerso
>> yPerso
>> armePerso
>> bossFinal
>> xTailleGrille
>> yTailleGrille;
int nbBateauFlotte;
vector<int> bateaux;
file >> nbBateauFlotte;
for(int i=0; i<nbBateauFlotte; i++){
int tailleBateau;
file >> tailleBateau;
bateaux.push_back(tailleBateau);
}
Arme* arme;
if(armePerso == "ArmeFatale")
arme = new ArmeFatale();
else if (armePerso == "ArmeChercheuse")
arme = new ArmeChercheuse();
else if (armePerso == "ArmeCroix")
arme = new ArmeCroix();
else
arme = new ArmeClassique();
PersonnageNonJouable* perso;
switch(typePerso) {
case 1: //JoueurIA
perso = new JoueurIA(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
break;
case 2: //JoueurIAAvance
perso = new JoueurIAAvance(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
break;
case 3: //JoueurIACheate
perso = new JoueurIACheate(nomPerso, xTailleGrille, yTailleGrille, bateaux, arme);
break;
}
if(bossFinal=='Y')
perso->getInventaire()->ajoutObjet(new BadgeFinal());
cartePerso = monde.getCarte(idCartePerso);
perso->setCarte(cartePerso);
perso->setCoordonnees(Coordonnees(xPerso, yPerso));
((CelluleAccessible*)cartePerso->getCellules()[xPerso][yPerso])->setPersonnage(perso);
personnagesNonJouables.push_back(perso);
file >> aCasesCombat;
if(aCasesCombat == "Y"){
int nbCasesCombat;
file >> nbCasesCombat;
Action* action = new ActionCombat(perso, "");
for(int j=0; j<nbCasesCombat; j++){
int xCase, yCase, idCarteCase;
file >> idCarteCase >> xCase >> yCase;
monde.getCarte(idCarteCase)->getCellules()[xCase][yCase]->setType("x");
monde.getCarte(idCarteCase)->getCellules()[xCase][yCase]->setAction(action);
}
}
}
bool operator==(const Carte& lhs, const Carte& rhs)
{
return lhs.getValue() == rhs.getValue() && lhs.getColor() == rhs.getColor();
}
/**
* Methode qui lance le jeu
*/
void Jeu::jouer()
{
if (system("CLS")) system("clear");
bool finJeu = false;
if (this->joueurCourant->getPdm() == 0)
{
this->joueurCourant->ajouterMain(this->joueurCourant->getDeck()->tirerCarte());
this->joueurCourant->ajouterMain(this->joueurCourant->getDeck()->tirerCarte());
}
if (this->joueurCourant->getPdm() < 10)
{
this->joueurCourant->setPDM(this->joueurCourant->getPdm()+1);
}
this->joueurCourant->setPDMTour(this->joueurCourant->getPdm());
Carte c = this->joueurCourant->getDeck()->tirerCarte();
if (c.getPdv() == -1 )
{
this->joueurCourant->setPDV(this->joueurCourant->getPdv()-1);
finJeu = notifierObs();
}
else
{
this->joueurCourant->ajouterMain(c);
}
enleverMalinvoc();
vue->afficherDebutTour(joueurCourant);
vue->afficher2Board(joueurCourant,joueurAutre);
int choix = -1;
if (this->testNoMana() == true && this->testNoAttaque() == true )
{
this->setEtat(this->getEtatDoubleNo());
} else {
if (this->testNoMana() == true )
{
this->setEtat(this->getEtatNoMana());
}
if (this->testNoAttaque() == true )
{
this->setEtat(this->getEtatNoAttaque());
}
}
while (choix != 0 && finJeu == false)
{
vue->afficherPersonnage(joueurCourant);
vue->afficherPersonnageAutre(joueurAutre);
choix = etatCourant->afficherChoixEtat();
finJeu = notifierObs();
}
if (finJeu != true)
{
vue->afficherFinTour();
usleep(1000000);
this->finTour();
}
}
void FenetrePrincipale::AfficherCarte() const
{
int xZero, yZero;
int l = carteGraphicsScene->getLargeurUnite(), h = carteGraphicsScene->getHauteurUnite();
QPen styloNoir;
styloNoir.setWidth(2);
styloNoir.setColor(QColor("black"));
QPen styloBleu;
styloBleu.setWidth(10);
styloBleu.setColor(QColor("blue"));
Carte* carte = JoueurSingleton::getInstance()->getCarte();
for(int i=0; i<16; i++)
{
for(int j=0; j<16; j++)
{
xZero = j*l;
yZero = i*h;
if(carte->getCase(j, i) == CHEMIN_NORD)
{
QPixmap butPixmap(QString(":/images/chemin_N.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
//tmp->setScale(ScalePourUnite(butPixmap, l, h));
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_NORD");
}
else if(carte->getCase(j, i) == CHEMIN_SUD)
{
QPixmap butPixmap(QString(":/images/chemin_S.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_SUD");
}
else if(carte->getCase(j, i) == CHEMIN_OUEST)
{
QPixmap butPixmap(QString(":/images/chemin_W.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_OUEST");
}
else if(carte->getCase(j, i) == CHEMIN_EST)
{
QPixmap butPixmap(QString(":/images/chemin_E.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_EST");
}
else if(carte->getCase(j, i) == CHEMIN_NO)
{
if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
{
QPixmap butPixmap(QString(":/images/chemin_SE.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_NO");
}
else
{
QPixmap butPixmap(QString(":/images/chemin_NW.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_NO");
}
}
else if(carte->getCase(j, i) == CHEMIN_SE)
{
if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
{
QPixmap butPixmap(QString(":/images/chemin_SE.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_SE");
}
else
{
QPixmap butPixmap(QString(":/images/chemin_NW.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_SE");
}
}
else if(carte->getCase(j, i) == CHEMIN_NE)
{
if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
{
QPixmap butPixmap(QString(":/images/chemin_SW.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_NE");
}
else
{
QPixmap butPixmap(QString(":/images/chemin_NE.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_NE");
}
}
else if(carte->getCase(j, i) == CHEMIN_SO)
{
if(carte->getCase(j, i-1) == CHEMIN_NORD || carte->getCase(j, i-1) == CHEMIN_SUD)
{
QPixmap butPixmap(QString(":/images/chemin_SW.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_SO");
}
else
{
QPixmap butPixmap(QString(":/images/chemin_NE.jpg"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "CHEMIN_SO");
}
}
else if(carte->getCase(j, i) == BUT_ENNEMIS)
{
QPixmap butPixmap(QString(":/images/but.png"));
butPixmap = butPixmap.scaled(l, h);
QGraphicsPixmapItem* tmp = carteGraphicsScene->addPixmap(butPixmap);
tmp->setPos(xZero, yZero);
tmp->setData(0, "BUT_ENNEMIS");
}
else if(carte->getCase(j, i) == DEPART_NORD || carte->getCase(j, i) == DEPART_SUD || carte->getCase(j, i) == DEPART_OUEST || carte->getCase(j, i) == DEPART_EST)
{
QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, styloBleu, Qt::blue);
item->setData(0, "DEPART");
}
else if(carte->getCase(j, i) == BOUE)
{
QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, QPen(Qt::darkGreen), Qt::darkGreen);
item->setData(0, "BOUE");
}
else
{
QGraphicsItem* item = carteGraphicsScene->addRect(xZero, yZero, l, h, QPen(Qt::transparent));
item->setData(0, "LIBRE");
}
}
}
}
/* Met à jour le joueur.*/
void Joueur::update(Carte const &carte)
{
// Si les coins du personnages touchent une tile solide.
bool coins[4];
EnumDirections direction_deplacement = HAUT;
// Les dimensions d'une tile de la carte.
int hauteur_tile = carte.getHauteurTile();
int largeur_tile = carte.getLargeurTile();
// La position du joueur à l'image précédente.
Coordonnees pos_precedente = m_position;
//---------------------------------
// Mise à jour des attributs du joueur.
//---------------------------------
// Déplacement du joueur.
// Attribution de la direction en fonction du déplacement demandé.
if(m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
{
direction_deplacement = HAUT;
m_direction_deplacement = 0;
}
else if(m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
{
direction_deplacement = HAUT_DROITE;
m_direction_deplacement = M_PI_4;
}
else if(!m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
{
direction_deplacement = DROITE;
m_direction_deplacement = M_PI_2;
}
else if(!m_actions[DIR_HAUT] && m_actions[DIR_DROITE] && m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
{
direction_deplacement = BAS_DROITE;
m_direction_deplacement = 3. * M_PI_4;
}
else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && m_actions[DIR_BAS] && !m_actions[DIR_GAUCHE])
{
direction_deplacement = BAS;
m_direction_deplacement = M_PI;
}
else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
{
direction_deplacement = BAS_GAUCHE;
m_direction_deplacement = 5. * M_PI_4;
}
else if(!m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
{
direction_deplacement = GAUCHE;
m_direction_deplacement = 3. * M_PI_2;
}
else if(m_actions[DIR_HAUT] && !m_actions[DIR_DROITE] && !m_actions[DIR_BAS] && m_actions[DIR_GAUCHE])
{
direction_deplacement = HAUT_GAUCHE;
m_direction_deplacement = 7. * M_PI_4;
}
// Si le joueur se déplace
if(m_actions[DIR_BAS] || m_actions[DIR_DROITE] || m_actions[DIR_GAUCHE] || m_actions[DIR_HAUT])
{
// Calcul de la vitesse.
m_vitesse.x = sin(m_direction_deplacement) * m_vitesse_max;
m_vitesse.y = (-1.) * cos(m_direction_deplacement) * m_vitesse_max;
// Changement de la position.
m_position.x += m_vitesse.x;
m_position.y += m_vitesse.y;
}
// Test de collisions avec les tiles solides de la carte et modification du déplacement si il y a collision.
coins[0] = carte.isTileSolide(m_position.x/largeur_tile, m_position.y/hauteur_tile);
coins[1] = carte.isTileSolide((m_position.x+largeur_tile-1)/largeur_tile, m_position.y/hauteur_tile);
coins[2] = carte.isTileSolide((m_position.x+largeur_tile-1)/largeur_tile, (m_position.y+hauteur_tile-1)/hauteur_tile);
coins[3] = carte.isTileSolide(m_position.x/largeur_tile, (m_position.y+hauteur_tile-1)/hauteur_tile);
if(coins[0] && coins[1]) {
m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
}
if(coins[1] && coins[2]) {
m_position.x = (m_position.x/largeur_tile) * largeur_tile;
}
if(coins[2] && coins[3]) {
m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
}
if(coins[3] && coins[0]) {
m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
}
if (coins[0] && !(coins[1] || coins[2] || coins[3])) {
switch(direction_deplacement) {
case GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
break;
case HAUT: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
break;
case HAUT_DROITE: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
break;
case BAS_GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
break;
case HAUT_GAUCHE:
if (pos_precedente.x - (m_position.x / largeur_tile + 1)*largeur_tile > pos_precedente.y - (m_position.y / hauteur_tile + 1)*hauteur_tile) {
m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
} else {
m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
}
break;
default:
break;
}
}
if (coins[1] && !(coins[0] || coins[2] || coins[3])) {
switch(direction_deplacement) {
case DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
break;
case HAUT: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
break;
case HAUT_GAUCHE: m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
break;
case BAS_DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
break;
case HAUT_DROITE:
if((m_position.x/largeur_tile)*largeur_tile - pos_precedente.x > pos_precedente.y - (m_position.y/hauteur_tile + 1) * hauteur_tile) {
m_position.x = (m_position.x/largeur_tile) * largeur_tile;
} else {
m_position.y = (m_position.y/hauteur_tile + 1) * hauteur_tile;
}
break;
default:
break;
}
}
if (coins[2] && !(coins[0] || coins[1] || coins[3])) {
switch(direction_deplacement) {
case DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
break;
case BAS: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
break;
case BAS_GAUCHE: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
break;
case HAUT_DROITE: m_position.x = (m_position.x/largeur_tile) * largeur_tile;
break;
case BAS_DROITE:
if((m_position.x/largeur_tile)*largeur_tile - pos_precedente.x > (m_position.y/hauteur_tile)*hauteur_tile - pos_precedente.y) {
m_position.x = (m_position.x/largeur_tile) * largeur_tile;
} else {
m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
}
break;
default:
break;
}
}
if (coins[3] && !(coins[0] || coins[1] || coins[2])) {
switch(direction_deplacement) {
case GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
break;
case BAS: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
break;
case BAS_DROITE: m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
break;
case HAUT_GAUCHE: m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
break;
case BAS_GAUCHE:
if(pos_precedente.x - (m_position.x/largeur_tile + 1)*largeur_tile > (m_position.y/hauteur_tile)*hauteur_tile - pos_precedente.y) {
m_position.x = (m_position.x/largeur_tile + 1) * largeur_tile;
} else {
m_position.y = (m_position.y/hauteur_tile) * hauteur_tile;
}
break;
default:
break;
}
}
// Changement de l'image du joueur en fonction de la direction.
if(m_actions[CHANGE_DIRECTION])
{
if(m_direction_visee >= 15. * M_PI_8 || m_direction_visee < M_PI_8)
{
m_image = m_textures[HAUT];
}
else if(m_direction_visee >= M_PI_8 && m_direction_visee < 3. * M_PI_8)
{
m_image = m_textures[HAUT_DROITE];
}
else if(m_direction_visee >= 3. * M_PI_8 && m_direction_visee < 5. * M_PI_8)
{
m_image = m_textures[DROITE];
}
else if(m_direction_visee >= 5. * M_PI_8 && m_direction_visee < 7. * M_PI_8)
{
m_image = m_textures[BAS_DROITE];
}
else if(m_direction_visee >= 7. * M_PI_8 && m_direction_visee < 9. * M_PI_8)
{
m_image = m_textures[BAS];
}
else if(m_direction_visee >= 9. * M_PI_8 && m_direction_visee < 11. * M_PI_8)
{
m_image = m_textures[BAS_GAUCHE];
}
else if(m_direction_visee >= 11. * M_PI_8 && m_direction_visee < 13. * M_PI_8)
{
m_image = m_textures[GAUCHE];
}
else if(m_direction_visee >= 13. * M_PI_8 && m_direction_visee < 15. * M_PI_8)
{
m_image = m_textures[HAUT_GAUCHE];
}
m_actions[CHANGE_DIRECTION] = false;
}
//---------------------------------
// Utilisation de l'arme.
// Écoulement du compteur de recharge.
if(m_compteur_recharge > 0)
{
m_compteur_recharge--;
std::cout << "compteur recharge : " << m_compteur_recharge << std::endl;
}
if(m_actions[UTILISE_ARME] && m_compteur_recharge == 0)
{
m_compteur_recharge = m_arme_selectionnee->getTpsRecharge();
m_arme_selectionnee->utiliser(*this);
m_actions[UTILISE_ARME] = false;
}
}
//////////////////////////////////////////////////////////////////////
/////////////////////////////Opérator/////////////////////////////////
/////////////////////////////////////////////////////////////////////
bool operator==(Carte const& a, Carte const& b)
{
return (int)a.getValeur()==(int)b.getValeur() && (int)a.getCouleur()==(int)b.getCouleur();
}
bool Carte::egale(Carte c) { return _valeur==c.valeur();}
void Interface::update()
{
int x, y;
x=y=0;
m_button_achat->SetVisible(false);
m_button_hypothequer->SetVisible(false);
m_button_deshypothequer->SetVisible(false);
m_button_construire->SetVisible(false);
m_button_detruire->SetVisible(false);
m_button_liberer->SetVisible(false);
m_button_caution->SetVisible(false);
Joueur *joueur = m_plateau->getPlateau()->getJoueurTour();
m_infoCase->SetText(joueur->nom()+" est sur : " + joueur->estSur()->nom()+"\n"+joueur->estSur()->description());
if (dynamic_cast<CasePropriete*>(joueur->estSur()) && !((CasePropriete*)(joueur->estSur()))->estAchete()
&& joueur->argent() > ((CasePropriete*)(joueur->estSur()))->prixAchat())
m_button_achat->SetVisible(true);
if (joueur->estEnPrison() && joueur->cartesLiberte().size() != 0)
m_button_liberer->SetVisible(true);
if (joueur->estEnPrison() && joueur->getToursPrison() != 0)
m_button_caution->SetVisible(true);
for (CasePropriete *m_case : joueur->proprietes())
{
if (!m_case->estEnHypotheque())
m_button_hypothequer->SetVisible(true);
if (m_case->estEnHypotheque())
m_button_deshypothequer->SetVisible(true);
if (m_case->peutConstruire() && joueur->argent() > ((CasePropriete*)(joueur->estSur()))->prixAchat())
m_button_construire->SetVisible(true);
if (m_case->peutDetruire())
m_button_detruire->SetVisible(true);
}
Carte* carte = joueur->lastCarte();
joueur->setLastCarte(nullptr);
if(carte && !dynamic_cast<Payer_ou_tirer*>(carte))
m_lastInfos = joueur->nom()+":\nCarte " + carte->paquet()->nom() + "\n" + carte->description();
if (dynamic_cast<Payer_ou_tirer*>(carte))
{
new MessageBox("Carte "+carte->paquet()->nom(), carte->description(), m_plateau->getPlateau(), dynamic_cast<Payer_ou_tirer*>(carte), m_button_des);
m_button_des->SetVisible(false);
}
if (m_window_hypothequer && m_window_deshypothequer && m_window_construire && m_window_detruire)
{
if (m_window_hypothequer->IsVisible() || m_window_deshypothequer->IsVisible() || m_window_construire->IsVisible() || m_window_detruire->IsVisible())
m_button_des->SetVisible(false);
}
else
m_button_des->SetVisible(true);
if (!m_window_hypothequer)
{
m_window_hypothequer = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
m_window_hypothequer->SetCharacterSizeTitle(22);
m_window_hypothequer->SetWindowTitle("Hypotéquer");
m_window_hypothequer->SetColorShape(sf::Color(255, 255, 255));
m_window_hypothequer->SetColorOutlineShape(sf::Color(255, 0, 0));
m_window_hypothequer->SetColorContener(sf::Color(255, 255, 255));
m_window_hypothequer->SetColorOutlineContener(sf::Color(255, 0, 0));
m_window_hypothequer->SetClosable(true);
m_window_hypothequer->CloseItem()->SetData("this", this);
m_window_hypothequer->CloseItem()->SetCallBack("onClosed", Interface::closeHypotheque);
m_window_hypothequer->SetVisible(false);
}
if(!m_window_deshypothequer)
{
m_window_deshypothequer = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
m_window_deshypothequer->SetCharacterSizeTitle(22);
m_window_deshypothequer->SetWindowTitle("Deshypothéquer");
m_window_deshypothequer->SetColorShape(sf::Color(255, 255, 255));
m_window_deshypothequer->SetColorOutlineShape(sf::Color(255, 0, 0));
m_window_deshypothequer->SetColorContener(sf::Color(255, 255, 255));
m_window_deshypothequer->SetColorOutlineContener(sf::Color(255, 0, 0));
m_window_deshypothequer->SetClosable(true);
m_window_deshypothequer->CloseItem()->SetData("this", this);
m_window_deshypothequer->CloseItem()->SetCallBack("onClosed", Interface::closeDeshypotheque);
m_window_deshypothequer->SetVisible(false);
}
if(!m_window_construire)
{
m_window_construire = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
m_window_construire->SetCharacterSizeTitle(22);
m_window_construire->SetWindowTitle("Construire");
m_window_construire->SetColorShape(sf::Color(255, 255, 255));
m_window_construire->SetColorOutlineShape(sf::Color(255, 0, 0));
m_window_construire->SetColorContener(sf::Color(255, 255, 255));
m_window_construire->SetColorOutlineContener(sf::Color(255, 0, 0));
m_window_construire->SetClosable(true);
m_window_construire->CloseItem()->SetData("this", this);
m_window_construire->CloseItem()->SetCallBack("onClosed", Interface::closeConstruire);
m_window_construire->SetVisible(false);
}
if(!m_window_detruire)
{
m_window_detruire = m_engine->GetGuiManager()->GetRootNode()->AddWindow();
m_window_detruire->SetCharacterSizeTitle(22);
m_window_detruire->SetWindowTitle("Détruire");
m_window_detruire->SetColorShape(sf::Color(255, 255, 255));
m_window_detruire->SetColorOutlineShape(sf::Color(255, 0, 0));
m_window_detruire->SetColorContener(sf::Color(255, 255, 255));
m_window_detruire->SetColorOutlineContener(sf::Color(255, 0, 0));
m_window_detruire->SetClosable(true);
m_window_detruire->CloseItem()->SetData("this", this);
m_window_detruire->CloseItem()->SetCallBack("onClosed", Interface::closeDetruire);
m_window_detruire->SetVisible(false);
}
m_info->SetText(m_lastInfos);
}
int main(int argc, char** argv) {
if (argc && argv); //pour éviter un warning.....
std::srand(std::time(NULL));
SDL_Rect src;
SDL_Rect dst;
src.w=640; src.h=480; src.y=0;src.x=0;dst.x=0; dst.y=0;
SDL_Surface* gpScreen = NULL;
int mode = 2; //mode=0;
gpScreen = init();
SDL_Surface* gpScreen2 = SDL_CreateRGBSurface(SDL_HWSURFACE, 320, 240, 32, 0, 0, 0, 0);
SDL_Surface* gpScreen3 = NULL;
Audio* gpAudio = new Audio();
Jeu* gpJeu = new Jeu(gpAudio);
Carte* gpCarte = new Carte(gpJeu);
Encyclopedie* gpEncyclopedie = new Encyclopedie(gpJeu);
Keyboard* gpKeyboard = new Keyboard(gpJeu, gpCarte, gpEncyclopedie, gpScreen, mode);
gpJeu->setKeyboard(gpKeyboard);
Generique* gpGenerique = new Generique(gpJeu);
gpJeu->setGenerique(gpGenerique);
gpGenerique->initLogo();
//gpJeu->init(0);
bool gLoop = true;
Uint32 lastAnimTime = SDL_GetTicks();
while (gLoop) {
if (gpKeyboard->gererClavier() == -1) {gLoop = false;}
switch (gpKeyboard->getMode()) {
case 0 : //jeu normal
gpJeu->draw(gpScreen2); break;
case 1 : //disclamer
case 2 : //logo
case 3 : //titre
case 14 : //générique score
case 17 : //menu d'aide 1
case 18 : //menu d'aide 2
gpGenerique->draw(gpScreen2); break;
case 4 : //selection
gpGenerique->drawSelection(gpScreen2, gpKeyboard->getLigne(),
gpKeyboard->getColonne()); break;
case 6 : //options
gpGenerique->drawOption(gpScreen2, gpKeyboard->getLigneOption(),
gpKeyboard->getVolume()/8, gpKeyboard->getVolson()/8); break;
case 7 : //charger partie
gpGenerique->drawCharger(gpScreen2, gpKeyboard->getLigne(),
gpKeyboard->getLigneVal()); break;
case 8 : //générique intro
gpGenerique->drawIntro(gpScreen2, gpKeyboard->getIntro()); break;
case 9 : //effacer partie
gpGenerique->drawEffacerSave(gpScreen2, gpKeyboard->getLigne(),
gpKeyboard->getLigneVal()); break;
case 10 : //générique début chez link
gpGenerique->drawDebut(gpScreen2); break;
case 11 : //générique fin
gpGenerique->drawFin(gpScreen2); break;
case 12 : //carte
case 22 : //carte téléportation
gpCarte->draw(gpScreen2); break;
case 13 : //encyclopédie des monstres
gpEncyclopedie->draw(gpScreen2); break;
case 15 : //records
case 19 : //rang 100%
case 20 : //rang ultime
case 21 : //rang de rapidité
gpGenerique->drawRecord(gpScreen2, gpKeyboard->getLigneRecord(),
gpKeyboard->getColonneRecord()); break;
case 16 : //effacer record
gpGenerique->drawEffacer(gpScreen2, gpKeyboard->getLigneVal()); break;
default : break;
}
SDL_FreeSurface(gpScreen3);
gpScreen3 = zoomSurface (gpScreen2, 2, 2, 0);
SDL_BlitSurface(gpScreen3, &src, gpScreen, &dst);
SDL_Flip(gpScreen);
if (SDL_GetTicks() < lastAnimTime + 20) SDL_Delay(lastAnimTime+20-SDL_GetTicks());
lastAnimTime = SDL_GetTicks();
}
SDL_FreeSurface(gpScreen2);
SDL_FreeSurface(gpScreen3);
delete gpEncyclopedie;
delete gpGenerique;
delete gpKeyboard;
delete gpCarte;
delete gpJeu;
delete gpAudio;
SDL_ShowCursor(SDL_ENABLE);
SDL_Quit();
exit(0);
return 0;
}
