C++ Joueur类代码示例

void LabyClavierSpecial(int key,int x,int y)
{
	switch(key)
	{
	case GLUT_KEY_UP:{
		MonJoueur.BougerEnHaut();
					 break;}
	case GLUT_KEY_DOWN:{
		MonJoueur.BougerEnBas();
					  break;}
	case GLUT_KEY_LEFT:{
		MonJoueur.BougerAGauche();
					   break;}
	case GLUT_KEY_RIGHT:{
		MonJoueur.BougerADroite();
						break;}
	}

	EnnemiBase* pointeur=premierEnnemi;
	while(pointeur!= NULL)
	{
		pointeur->TestCollision();
		pointeur=pointeur->GetSuivant();
	}
	TestVictoire();
	glutPostRedisplay();
}

void Interface::m_show_window_detruire()
{
    Joueur *joueur = m_plateau->getPlateau()->getJoueurTour();
    if (m_window_detruire)
    {
        m_window_detruire->ResetContener();
        int x=0;
        int y=0;
        for (CasePropriete* m_case : joueur->proprietes())
        {
            if (m_case->peutDetruire())
            {
                GuiButtonItem *button = new GuiButtonItem;
                button->SetCharacterSize(18);
                button->SetText(m_case->nom());
                button->SetData("case", m_case);
                button->SetData("this", this);
                button->SetCallBack("clicked", Interface::detruire);
                button->SetNormalColor(sf::Color(0,0,0), sf::Color(0,0,0,0));
                button->SetMouseOverColor(sf::Color(255,0,0), sf::Color(0,0,0,0));
                m_window_detruire->GetContener()->AjouterItem(button, 0, x);
                ++x;
            }
        }
        m_window_detruire->CalculerTaille();
        x = (m_engine->GetRenderWindow()->getSize().x/2)-(m_window_detruire->GetContener()->GetSize().x/2);
        y = (m_engine->GetRenderWindow()->getSize().y/2)-(m_window_detruire->GetContener()->GetSize().y/2);
        m_window_detruire->SetRelativePosition(x, y);
        m_window_detruire->SetVisible(true);
    }
}

void OuvrirNiveau(string nom_fichier)
{
	ifstream f;
	f.open(nom_fichier.c_str());

	if(!f)
	{
		cout<< "Error when open the level file !"<<endl;
		#ifdef _WIN32
            system("pause");
        #else
            cout<<"Press enter to continue > "<<endl;
            getchar();
        #endif
		exit(0);
	}

	f>> NbColonnes;
	f>> NbLignes;

	matrice= new char* [NbLignes];
	for(int i=0;i<NbLignes;i++)
		matrice[i]= new char[NbColonnes];


	for(int i=0;i<NbLignes;i++)
		for(int j=0;j<NbColonnes;j++)
			matrice[i][j]= '0';

	for(int i=0;i<NbLignes;i++)
		for(int j=0;j<NbColonnes;j++)
		{
			f>> matrice[i][j];

			switch(matrice[i][j])
			{
			case 'j':
			case 'J':{
				MonJoueur.SetPosC(j);
				MonJoueur.SetPosL(i);
				break;}
			case 's':
			case 'S':{
				SortieC = j;
				SortieL = i;
				break;}
			case 'v':
			case 'V':{
				AddEnnemi(vert,j,i);
				break;}
			case 'r':
			case 'R':{
				AddEnnemi(rouge,j,i);
				break;}
			}
		}
	f.close();
}

bool ShakeManager::rechercherMouvement(Score *scoreJoueur, Mat threshold, Mat HSV, Mat &cameraFeed, Rect const &fleche){

    vector <Joueur> mouvements;

    Mat temp;
    threshold.copyTo(temp);
    vector< vector<Point> > contours;
    vector<Vec4i> hierarchy;
    findContours(temp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);

    bool mouvementTrouver = false;
    if (hierarchy.size() > 0) {

        int numObjects = hierarchy.size();

        if (numObjects<MAX_MOUVEMENT){
            for (int index = 0; index >= 0; index = hierarchy[index][0]) {

                Moments moment = moments((cv::Mat)contours[index]);
                double area = moment.m00;

                if (area>MIN_OBJECT_AREA){

                    Joueur mouvement;

                    mouvement.setXPos(moment.m10 / area);
                    mouvement.setYPos(moment.m01 / area);

                    mouvements.push_back(mouvement);

                    if (mouvement.getXPos() >= fleche.x && mouvement.getXPos() < (fleche.x + 105) && mouvement.getYPos() >= fleche.y && mouvement.getYPos() < (fleche.y + 105)){
                        if(son->mediaStatus() == QMediaPlayer::PlayingState)
                            son->stop();
                        son->setMedia(QUrl("qrc:/sounds/power-up.wav"));
                        son->setVolume(5);
                        son->play();
                        scoreJoueur->addToScore(10);
                        return true;
                    }

                    mouvementTrouver = true;

                }
                else mouvementTrouver = false;

            }

            afficherMouvement(mouvements, cameraFeed);

        }
    }
    // le rectangle n'a pas été trouvé
    return false;
}

void Objet::draw(SDL_Surface* gpScreen) {
    int phg[2];
    phg[0] = gpJeu->getPhg(0);
    phg[1] = gpJeu->getPhg(1);
    
    Joueur* gpJoueur = gpJeu->getJoueur();
    Monde* gpMonde = gpJeu->getMonde();
    int val = gpMonde->motifValue(x+8,y+8);
    
    if (type && vie && (val<30 || val>39)) {
            
        SDL_Rect src; src.h = h; src.w = w;
        SDL_Rect dst; dst.x = x-phg[0]; dst.y = y-phg[1];    
       
        
        switch(type) {                
            case I_RUBIS_VERT : src.x = anim*16; src.y = 17; break;
            case I_RUBIS_BLEU : src.x = 48 + anim*16; src.y = 17; break;
            case I_RUBIS_ROUGE : src.x = anim*16; src.y = 34; break;
            case I_PETIT_COEUR : src.x = 48; src.y = 34; break;
            case I_FLECHE : if (gpJoueur->hasObjet(O_ARC) < 5) {src.x = 64; src.y = 34;}
                if (gpJoueur->hasObjet(O_ARC) == 5) {src.x = 208; src.y = 17;} break;
            case I_BOMBE : src.x = 0; src.y = 0; break;
            case I_MAGIE_PEU : src.x = 80; src.y = 34; break;
            case I_MAGIE_BCP : src.x = 96; src.y = 34; break;
            case I_QUART_COEUR : src.x = 80; src.y = 0; break;
            case I_COEUR : src.x = 64; src.y = 0; break;
            case I_EPEE : src.x = 96; src.y = 17; break;
            case I_CRISTAL : src.x = anim*16; src.y = 51; break;
            case I_EXCALIBUR : src.x = 160;src.y = 0; src.h = 22; src.w = 16; break;
            case I_PETITE_CLE : src.x = 32; src.y = 0; break;
            case I_TRIFORCE : src.x = 166; src.y = 26; src.h = 25;src.w = 26; break;
            case I_ARC : src.x = 144; src.y = 34; break;
        }
        
        w=src.w; h=src.h;
    
        SDL_BlitSurface(image, &src, gpScreen, &dst);
    
        if(max){    
            if(SDL_GetTicks() > lastAnimTime + vanim) {
            lastAnimTime = SDL_GetTicks();
                anim++;
                if (anim > max) anim = 0;
            }
        }
    }
    
    if (suivant != NULL) 
        if (((Objet*)suivant)->vie == 0) enleve(suivant);
    if (suivant != NULL) ((Objet*)suivant)->draw(gpScreen);
}

string ReceptionClient::traitementInfoJoueur()
{
    char* argument[6] = {NULL};
    int manaActuel = -1, manaMax = -1, gainMana = -1, abilite = -1, niveauAbilite = -1;
    Joueur* joueur;
    for(int i = 0; i < 7; i++)
    {
        argument[i] = strtok (NULL, SEPARATEUR_ELEMENT);
        if(argument[i] == NULL)
        {
            //Info fausse
            return "";
        }
    }

    manaActuel = atoi(argument[2]);
    manaMax = atoi(argument[3]);
    gainMana = atoi(argument[4]);
    abilite = atoi(argument[5]);
    niveauAbilite = atoi(argument[6]);

    joueur = this->partie->getJoueur(argument[0]);
    if(joueur == NULL)
    {
        joueur = new Joueur(gainMana, manaMax, niveauAbilite, argument[0], (TypeSort) abilite);
        joueur->setManaActuel(manaActuel);
        if(strcmp(argument[1], CHAMPS_VIDE) != 0)
        {
            joueur->setEquipe(this->partie->getEquipe(argument[1]));
        }
        this->partie->ajouterJoueur(joueur);
    }
    else
    {
        if(manaMax != -1)
        {
            joueur->setManaMaximum(manaMax);
        }
        if(manaActuel != -1)
        {
            joueur->setManaActuel(manaActuel);
        }
        if(gainMana != -1)
        {
            joueur->setGainMana(gainMana);
        }
        if(abilite != -1)
        {
            joueur->setAbilite((TypeSort) abilite);
        }
        if(niveauAbilite != -1)
        {
            joueur->setNiveauAbilite(niveauAbilite);
        }
    }
    return joueur->getNom();
}

int main()
{

  Personnage* guerrier = new Guerrier();
  cout << guerrier->toString();
  Joueur* Pierre = new Joueur("Pierre", *guerrier,"test.txt");
  cout << Pierre->getDeck()->tirerCarte().toString() << endl;
  Pierre->getPersonnage().setCP(new ComportementPouvoirGuerrier());
  cout << Pierre->getPersonnage().utiliserPouvoir() << endl;
 

  return 0;
}

void Table::addJoueur(Spectateur* s, char* aConvertir){
  int place=-1;
  int jeton=-1;
  if(isServeur && convertirCharDeJoueur(aConvertir,s,place,jeton)){
    Joueur* j = new Joueur(*s, jeton);
    cout<<"Le nouveau joueur est: "<<j->getNom()<<endl;
    joueurs[place] = j;
    if(partieEnCours)
      actif[place]=true;
    else
      actif[place]=false;
    nbJoueur++;
    stringstream ss;
    ss<<place;
    string newJoueur = "NewJo";
    newJoueur+=separateur;
    newJoueur+=ss.str();
    newJoueur+=separateur;
    newJoueur+=j->getNom();
    newJoueur+=separateur;
    stringstream ssa;
    ssa<<j->getJeton();
    newJoueur+=ssa.str();
    newJoueur+=separateur;
    newJoueur+="0";
    newJoueur+=separateur;
    newJoueur+="t";
    newJoueur+=separateur;
    cout<<newJoueur<<endl;
    char nJ[100] = "";
    strcpy(nJ,newJoueur.c_str());
    for(int i=0; i<spectacteurs.size();i++){
      send(spectacteurs[i]->getDesc(),nJ, strlen(nJ),0);
    }
    char jEnPlus[]="NewJo&";
    write(descEnvoie,jEnPlus,10);
    if(!partieEnCours && nbJoueur>1){
      partieEnCours=true;
      lancerPartie();
    }
    else{
      if(!partieEnCours){
	//prochainAMiser=place;
	dealer=place;
      }
    }
  }
}

void Interface::deshypothequer_propriete(GuiItem* g)
{
    ((CasePropriete*)g->GetData("case"))->deshypothequer();
    ((Interface*)g->GetData("this"))->m_show_window_deshypothequer();
    Joueur *joueur = ((Interface*)g->GetData("this"))->m_plateau->getPlateau()->getJoueurTour();
    int cpt=0;
    for (CasePropriete* c : joueur->proprietes())
        if (!c->estEnHypotheque())
            ++cpt;

    if (cpt == joueur->proprietes().size())
    {
        ((Interface*)g->GetData("this"))->m_window_deshypothequer->Remove();
        ((Interface*)g->GetData("this"))->m_window_deshypothequer = nullptr;
        ((Interface*)g->GetData("this"))->m_deshypothequer = false;
    }
}

void TestVictoire()
{
	if(MonJoueur.GetPosC()==SortieC && MonJoueur.GetPosL()==SortieL)
	{
		LabyAffichage();			//refraîchir la scène manuellement
		glutExit();
		LibererMemoire();
		cout<<"Congratulations! You win!"<<endl;
		#ifdef _WIN32
            system("pause");
        #else
            cout<<"Press enter to continue > "<<endl;
            getchar();
        #endif
		exit(0);
	}
}

void Interface::detruire(GuiItem* g)
{
    Joueur *joueur = ((Interface*)g->GetData("this"))->m_plateau->getPlateau()->getJoueurTour();
    ((CaseTerrain*)g->GetData("case"))->vendre(joueur);
    ((Interface*)g->GetData("this"))->m_show_window_detruire();
    int cpt=0;
    for (CasePropriete* c : joueur->proprietes())
        if (!c->peutDetruire())
            ++cpt;

    if (cpt == joueur->proprietes().size())
    {
        ((Interface*)g->GetData("this"))->m_window_detruire->Remove();
        ((Interface*)g->GetData("this"))->m_window_detruire = nullptr;
        ((Interface*)g->GetData("this"))->m_detruire = false;
    }
}

void Pnj::suit() {
    Joueur* gpJoueur = gpJeu->getJoueur();
    int pnjCX = x + gpZoneBase->getZone()->x + (gpZoneBase->getZone()->w/2);
    int pnjCY = y + gpZoneBase->getZone()->y + (gpZoneBase->getZone()->h);
    int linkCX = gpJoueur->getX() + 8;
    int linkCY = gpJoueur->getY() + 24;
    int difx = pnjCX - linkCX;
    int dify = pnjCY - linkCY;
    
    //test portée
    
    
    if ( max(abs(difx),abs(dify))>128) {
        if (gpJoueur->getAvancement()==6) gpJoueur->setAvancement(5);
        return;
    }
//    if (max(abs(difx),abs(dify))<16) return;
    if (gpJoueur->getAvancement()==5) gpJoueur->setAvancement(6);
    
    if (abs(difx) > abs(dify)) {
        if (difx>0) direction=O;
        else direction=E;
    }
    else {
        if (dify>0) direction=N;
        else direction=S;
    }
    
    if (gpJeu->getJoueur()->getX() < x) moveX(-1);
    if (gpJeu->getJoueur()->getX() > x) moveX(1);
    if (gpJeu->getJoueur()->getY() < y) moveY(-1);
    if (gpJeu->getJoueur()->getY() > y) moveY(1);
}

/*!
* \brief méthode pour détruire un quartier
* \param partie la partie
* \param joueur le joueur
*/
void ComportementCondottiereMachine::choixDestruction(Partie * partie , Joueur * joueur) {
    vector<Joueur*> tmp = partie->recupererListeJoueurs();
    vector<int> exclus;
    int i;
    Joueur * jj;
    bool trouve =false;

    while(exclus.size() < tmp.size() && !trouve) {
        i = Aleatoire::tirerEntierAvecExclusion(exclus,0,tmp.size()-1);
        jj = tmp.at(i);
        if(jj != joueur) {
            vector<Quartier*> qq= jj->recupererCite();

            for(vector<Quartier*>::iterator iter=qq.begin(); iter!=qq.end(); ++iter) {
                if(Condottiere::destruction(joueur,jj,(*iter))) {
                    trouve = true;
                }
            }
        }
    }
}

void Puissance4::newPartie (){
  Plateau *p = Partie::getPartie()->getPlateau();
  Joueur *j = Partie::getPartie()->getJoueurs();
  int choix_pos = 0;
    int i=0;
  j->next();
  do{
    j->next();
    cout << "Joueur "<< j->getCourrant()<< endl;
    affichage();
    do{
      i = 0;
      cout << "choisissez une position : " << endl;
      cin >> choix_pos;
      for(;i < nbLignes && not p->hasPion(i, choix_pos); i++){}
    }while(choix_pos < 0 || 
	   choix_pos > nbLignes || 
	   (i == 0 && p->hasPion(choix_pos, i)));
    i = (i==0)? 0 : i-1;
    if(j->getCourrant() == 0){
      p->mettrePionDansCase(pO, i, choix_pos);
    } else {
      p->mettrePionDansCase(pX, i, choix_pos);
    }
  }while(not hasP4(i, choix_pos));
  affichage();
  cout << "Le joueur " << j->getCourrant() << "a gagné "<<  endl; 
  
}

bool Pnj::parle() {
    Joueur* gpJoueur = gpJeu->getJoueur();
    int difx = (gpJoueur->getX()+8)-(x+(w/2));
    int dify = (gpJoueur->getY()+16)-(y+(h/2));
    
    if (abs(difx) < 24 && abs(dify) < 24) {
        if (abs(difx) < abs(dify)) {
            if (dify < 0) direction = N;
            else direction = S;
        }
        else {
            if (difx < 0) direction = O;
            else direction = E;
        }
        return true;
    }
    return false;
    
    if (gpJeu->isLink(x + gpZoneBase->getZone()->x-8, 
    y + gpZoneBase->getZone()->y+gpZoneBase->getZone()->h-8, 1, 1)) {
        direction = O;
        return true;
    }
    if (gpJeu->isLink(x + gpZoneBase->getZone()->x+gpZoneBase->getZone()->w+7, 
    y + gpZoneBase->getZone()->y+gpZoneBase->getZone()->h-8, 1, 1)) {
        direction = E;
        return true;
    }
    if (gpJeu->isLink(x + gpZoneBase->getZone()->x, y + gpZoneBase->getZone()->y-8, 1, 1)) {
        direction = N;
        return true;
    }
    if (gpJeu->isLink(x + gpZoneBase->getZone()->x, 
    y + gpZoneBase->getZone()->y+gpZoneBase->getZone()->h+7, 1, 1)) {
        direction = S;
        return true;
    }
    return false;
}