[C/C++] Gestion des IAs - bug

Le côté programmation du développement d'un jeu vidéo.

Gestion des IAs - bug

Messagepar Nieluj » 20 Aoû 2011, 00:33

Bonjour à tous,

J'ai à nouveau un soucis sur lequel je bloque complètement. Je viens de mettre en place le calcul des IAs au sein de mon moteur de jeu.

--------------------------------------------------------------------------

Ca fonctionne comme suit:

Dans une instance d'une classe Environment, j'instancie tout les éléments pouvant intéragir entre eux ( pour le moment la map, le player et les ennemis ).

Dans une classe System, j'ai ma boucle principale dans laquelle je demande de calculer l'IA de chaque élément intelligent par l'intermédiaire d'une méthode AIHandler() appartenant à une classe IntelligentObject ( classe mère ), ces élément sont stockés dans un vecteur.

-------------------------------------------------------------------------

Donc mon premier test est de créer une classe Monstre héritant de IntelligenObject qui dispose d'une IA très simple: le monstre commence à marcher vers la droite, s'il rencontre un obstacle il change de direction ( à la mario bross quoi ).

Je créé donc une première instance 'monstre1' de ce monstre dans ma classe Environment: pas de souscis, mon monstre fonctionne bien.

En revanche, je créé 3 nouvelles instances 'monstre2', 'monstre3' et 'monstre4' : 'monstre1' fonctionne bien mais les autres semblent être liée à monstre1 ( ??? ). En effet, lors de la collision vers la droite, il y a un comportement bizarre et lorsque monstre1 collisione vers la gauche et change de direction,les 3 autres le miment et changent de direction également. :00000017:

Voilà un peu de code:

Le constructeur de la classe Environment:
----------------------------------------

Code: Tout sélectionner
#include "Environment.h"
#include "Player.h"
#include "Monster.h"

//***********************************************************************
//Méthode : ENVIRONMENT
//-----------------------------------------------------------------------
//Definition : Constructeur de la classe
//***********************************************************************
Environment::Environment( SDL_Surface* _destination )
{

    this->dest = _destination;
   
    //Creation de la map
    this->map = new Map( this->dest );
       
    //Creation d'un player
    player = new Player( this );
    player->posx = 800;
    player->posy = 2800;
    player->hitbox.width = 32;
    player->hitbox.height = 32;
    player->hitbox.x = 16;
    player->hitbox.y = 32;
   
    //POUR TESTS
    Monster* monster1 = new Monster( this );
    monster1->posx = 128;
    monster1->posy = 2800;
    monster1->hitbox.width = 32;
    monster1->hitbox.height = 32;
    monster1->hitbox.x = 16;
    monster1->hitbox.y = 32;
   
    Monster* monster2 = new Monster( this );
    monster2->posx = 300;
    monster2->posy = 2800;
    monster2->hitbox.width = 32;
    monster2->hitbox.height = 32;
    monster2->hitbox.x = 16;
    monster2->hitbox.y = 32;
   
    Monster* monster3 = new Monster( this );
    monster3->posx = 400;
    monster3->posy = 2800;
    monster3->hitbox.width = 32;
    monster3->hitbox.height = 32;
    monster3->hitbox.x = 16;
    monster3->hitbox.y = 32;
   
    Monster* monster4 = new Monster( this );
    monster4->posx = 600;
    monster4->posy = 2800;
    monster4->hitbox.width = 32;
    monster4->hitbox.height = 32;
    monster4->hitbox.x = 16;
    monster4->hitbox.y = 32;

    //Insertion des objets physx dans le vecteur
    physxObjects.push_back( player );
    physxObjects.push_back( monster1 );
    physxObjects.push_back( monster2 );
    physxObjects.push_back( monster3 );
    physxObjects.push_back( monster4 );

    //Insertion des objets intel dans le vecteur
    intelObjects.push_back( monster1 );
    intelObjects.push_back( monster2 );
    intelObjects.push_back( monster3 );
    intelObjects.push_back( monster4 );
                         
}


La méthode AIHandler du monstre:
---------------------------------

Code: Tout sélectionner
//***********************************************************************
//Méthode : AIHandler
//-----------------------------------------------------------------------
//Definition : IA du monstre
//***********************************************************************
void Monster::AIHandler()
{   

    if( this->CheckForCollision( 2 ) == 1 )
    {
        this->sens = !this->sens;
       
        this->posx -= ( this->posx % TILE_SIZE ) - ( this->offset.w - ( this->hitbox.x + this->hitbox.width ) );
    }
    else if( this->CheckForCollision( 4 ) == 1 )
    {
         this->sens = !this->sens;
         
         this->posx += TILE_SIZE - ( this->posx % TILE_SIZE ) - this->hitbox.x;
    }

    if( this->sens )
    {
        this->posx += this->walkspeed;
        this->Move( 2, 4 );
    }
    else
    {
        this->posx -= this->walkspeed;
        this->Move( 3, 4 );
    }
   
}


La partie calcul des IAs de la boucle principale:
---------------------------------------------

Code: Tout sélectionner
    //TEST POUR L'IA DES MONSTRES
    int intel_size = env->intelObjects.size();
   
    for( int i=0; i<intel_size; i++ )
    {
        intelem = env->intelObjects.at( i );

        if( ( env->map->camerax < intelem->posx < ( env->map->camerax + SCREEN_WIDTH ) ) && ( env->map->cameray < intelem->posy < ( env->map->cameray + SCREEN_HEIGHT ) ) )
        {
            intelem->AIHandler();
        }

    }



Merci d'avance pour votre aide.

Julien.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Gavos » 20 Aoû 2011, 01:21

Là il faudrait que tu rajoutes des traces (ou que tu fasses du debug pas à pas). Affiche notamment les valeurs de retour de CheckForCollision(), les autres ennemis changent peut-être de sens parce que cette fonction retourne une fausse valeur. Tu peux aussi poster le code de CheckForCollision() mais je suis sûr que tu peux arriver à isoler un bug comme celui-ci. Est-ce que certaines de tes données membres sont static ? À noter que tes objets réagissent peut-être correctement et que le problème vient de l'affichage, mais là on ne peut pas dire. Élimine d'abord la possibilité d'un bug dans le code que tu as posté, puis va voir du côté de l'affichage.

Au passage je trouve que ta fonction AIHandler() est mal nommée. Une méthode comme ça fait quelque chose, son nom doit refléter son action. Pour moi AIHandler() c'est le nom d'un objet ou d'une classe, HandleAI() serait déjà mieux.
Gavos
 
Messages: 1089
Inscription: 19 Mar 2005, 13:00

Messagepar Nieluj » 20 Aoû 2011, 09:23

En effet, je devrais regarder du côté de la fonction CheckForCollision(). Je n'avais pas pensé à l'affichage mais dans la mesure où au moins 1 élément fonctionne, j'en déduis, peut-être à tord, que ça vient d'autre part. Je n'ai pas de données membres statics. Pour le nom de la méthode, c'est noté, merci du conseil.

Au cas où, voici la méthode CheckForCollision() appartenant à la classe PhysicObject:

Code: Tout sélectionner
//**********************************|
//Méthode :      CHECKFORCOLLISION   |
//-----------------------------------------------------------------------
//Definition :   Detection des collisions objet/map sur 4 directions par
//            localisation des sommets du rectangle contenant l'objet.
//-----------------------------------------------------------------------
//Renvoie:      true en cas de collision sinon false.
//-----------------------------------------------------------------------
//            Directions:
//               -haut:      1
//               -droite:   2
//               -bas:      3
//               -gauche:   4
//-----------------------------------------------------------------------
//Glossaire :
//            _direction      détermine la direction vers laquelle la
//                        vérification de collision est effectuée.
//            tilecoord_x:   sert à déterminer la coordonnée x du tile
//                        dans lequel se trouve le coin vérifié.
//            tilecoord_y:   sert à déterminer la coordonnée y du tile
//                        dans lequel se trouve le coin vérifié.
//***********************************************************************
bool PhysicObject::CheckForCollision( int _direction )
{

    int tilecoord_x;
    int tilecoord_y;

      int coinHG_x;
   int coinHG_y;
   
   int coinBG_x;
   int coinBG_y;
   
   int coinHD_x;
   int coinHD_y;
   
   int coinBD_x;
   int coinBD_y;
   
   int milieuD_x;
   int milieuD_y;
   
   int milieuG_x;
   int milieuG_y;
      
    switch( _direction )
    {
      
      //----------------
        //Direction droite
      //----------------
      case 2:
      
      //Determination des coordonnées du coin HD
      coinHD_x = ( this->posx + this->hitbox.x ) + this->hitbox.width;
      coinHD_y = this->posy + this->hitbox.y;
         
      //Determination des coordonnées du tile dans lequel se trouve le coin HD
      tilecoord_x = static_cast<int>( ( coinHD_x ) / TILE_SIZE );
      tilecoord_y = static_cast<int>( ( coinHD_y ) / TILE_SIZE );

        //Si le tile franchi est solide on replace le player
        if( map[tilecoord_x][tilecoord_y] > 6 )
        {
            return( true );
        }   
        else
        {
            //Determination des coordonnées du coin BD
         coinBD_x = ( this->posx + this->hitbox.x ) + this->hitbox.width;
         coinBD_y = ( this->posy + this->hitbox.y ) + this->hitbox.height;
         
         //Determination des coordonnées du tile dans lequel se trouve le coin BD
         tilecoord_x = static_cast<int>( ( coinBD_x ) / TILE_SIZE );
         tilecoord_y = static_cast<int>( ( coinBD_y ) / TILE_SIZE );

            //Si le tile franchi est solide on replace le player
            if( ( map[tilecoord_x][tilecoord_y] > 6 ) && ( coinBD_y % TILE_SIZE != 0 ) )
            {
                return( true );
            }
//            else
//            {
//                //Determination des coordonnées du milieu D
//             milieuD_x = _element->posx + _element->offset.w;
//             milieuD_y = _element->posy + _element->offset.h/2;
//             
//             //Determination des coordonnées du tile dans lequel se trouve le milieu D
//             tilecoord_x = static_cast<int>( ( milieuD_x ) / TILE_SIZE );
//             tilecoord_y = static_cast<int>( ( milieuD_y ) / TILE_SIZE );
//   
//                //Si le tile franchi est solide on replace le player
//                if( ( map[tilecoord_x][tilecoord_y] > 6 ) )
//                {
//                    return( true );
//                }
//            }

        }
 
        break;
              
      //----------------
      //Direction gauche
      //----------------
      case 4:

        //Determination des coordonnées du coin HG
        coinHG_x = this->posx + this->hitbox.x;
        coinHG_y = this->posy + this->hitbox.y;
         
        //Determination des coordonnées du tile dans lequel se trouve le coin HG
        tilecoord_x = static_cast<int>( ( coinHG_x ) / TILE_SIZE );
        tilecoord_y = static_cast<int>( ( coinHG_y ) / TILE_SIZE );

        //Si le tile franchi est solide on replace le player
        if( map[tilecoord_x][tilecoord_y] > 6 )
        {
            return( true );
        }
        else
        {
            //Determination des coordonnées du coin BG
            coinBG_x = this->posx + this->hitbox.x;
            coinBG_y = ( this->posy + this->hitbox.x ) + this->hitbox.height;
         
         //Determination des coordonnées du tile dans lequel se trouve le coin BG
         tilecoord_x = static_cast<int>( ( coinBG_x ) / TILE_SIZE );
         tilecoord_y = static_cast<int>( ( coinBG_y ) / TILE_SIZE );

            //Si le tile franchi est solide on replace le player
            if( ( map[tilecoord_x][tilecoord_y] > 6 ) && ( coinBG_y % TILE_SIZE != 0 ) )
            {
                return( true );
            }
//            else
//            {
//                //Determination des coordonnées du milieu G
//             milieuG_x = _element->posx;
//             milieuG_y = _element->posy + _element->offset.h/2;
//             
//             //Determination des coordonnées du tile dans lequel se trouve le milieu G
//             tilecoord_x = static_cast<int>( ( milieuG_x ) / TILE_SIZE );
//             tilecoord_y = static_cast<int>( ( milieuG_y ) / TILE_SIZE );
//   
//                //Si le tile franchi est solide on replace le player
//                if( ( map[tilecoord_x][tilecoord_y] > 6 ) )
//                {
//                    return( true );
//                }
//            }

        }
   
        break;
   
        //----------------
        //Direction haut
        //----------------
        case 1:

        //Determination des coordonnées du coin HG
        coinHG_x = this->posx + this->hitbox.x;
        coinHG_y = this->posy + this->hitbox.y;
         
        //Determination des coordonnées du tile dans lequel se trouve le coin HG
        tilecoord_x = static_cast<int>( ( coinHG_x ) / TILE_SIZE );
        tilecoord_y = static_cast<int>( ( coinHG_y ) / TILE_SIZE );

        //Si le tile franchi est solide on replace le player
        if( map[tilecoord_x][tilecoord_y] > 6 )
        {
            return( true );
        }
        else
        {
            //Determination des coordonnées du coin HD
            coinHD_x = ( this->posx + this->hitbox.x ) + this->hitbox.width;
            coinHD_y = this->posy + this->hitbox.y;
         
         //Determination des coordonnées du tile dans lequel se trouve le coin HD
         tilecoord_x = static_cast<int>( ( coinHD_x ) / TILE_SIZE );
         tilecoord_y = static_cast<int>( ( coinHD_y ) / TILE_SIZE );

            //Si le tile franchi est solide on replace le player
            if( ( map[tilecoord_x][tilecoord_y] > 6 ) && ( coinHD_x % TILE_SIZE != 0 ) )
            {
                return( true );
            }
            else
            {
                return( false );
            }

        }

   
        break;
         
        //----------------
        //Direction bas
        //----------------
        case 3:

        //Determination des coordonnées du coin BG
        coinBG_x = this->posx + this->hitbox.x;
        coinBG_y = ( this->posy + this->hitbox.y ) + this->hitbox.height;
         
        //Determination des coordonnées du tile dans lequel se trouve le coin BG
        tilecoord_x = static_cast<int>( ( coinBG_x ) / TILE_SIZE );
        tilecoord_y = static_cast<int>( ( coinBG_y ) / TILE_SIZE );

        //Si le tile franchi est solide on replace le player
        if( map[tilecoord_x][tilecoord_y] > 6 )
        {
            return( true );
        }
        else
        {
            //Determination des coordonnées du coin BD
            coinBD_x = ( this->posx + this->hitbox.x ) + this->hitbox.width;
            coinBD_y = ( this->posy + this->hitbox.x ) + this->hitbox.height;
         
            //Determination des coordonnées du tile dans lequel se trouve le coin BD
            tilecoord_x = static_cast<int>( ( coinBD_x ) / TILE_SIZE );
            tilecoord_y = static_cast<int>( ( coinBD_y ) / TILE_SIZE );

            //Si le tile franchi est solide on replace le player
            if( ( map[tilecoord_x][tilecoord_y] > 6 ) && ( coinBD_x % TILE_SIZE != 0 ) )
            {
              return( true );
            }
         else
            {
                return( false );
            }
        }

        break;
         
        //Retourne false par defaut
        default: return( false );
        break;
       
    }


Je ne vais pas pouvoir me pencher sur le problème aujourd'hui, je vais profiter de la mer ce week-end :). Je viendrai parler de mon avancé ( peut être demain soir si j'ai le temps ).

Merci.

EDIT : Vous me pardonnerez le fait que mon code soit un peu crado par moment. Il y a parfois des commentaires ou des variables obsolètes par exemple. Il y a surement des énormités également, je pense au static_cast par exemple ( je n'ai pas trouvé d'autres solutions pour le moment ). Donc je suis ouvert aux critiques et conseils bien évidemment ;).
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Nieluj » 23 Aoû 2011, 00:00

Bonsoir,

Bon ça a l'air de venir de la fonction de collision. J'ai remplacé la détection de collision par un compteur qui change la direction du monstre lorsqu'il atteint une valeur déterminée et il n'y a aucun problème.

Par contre j'ai beau chercher une anomalie dans cette fonction mais je n'en vois pas. C'est une méthode qui appartient à PhysicObject. IntelligentObject hérite de PhysicObject et Monster hérite de IntelligentObject. Donc je dois pouvoir utilisé CheckForCollision à partir de Monster sans qu'il y ai de problèmes... :00000017:

Sur ce, bonne nuit !
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Gavos » 23 Aoû 2011, 01:30

Que veut dire cette condition ?
Code: Tout sélectionner
if( map[tilecoord_x][tilecoord_y] > 6 )


Et pour les coordonnées des tuiles, pourquoi fais-tu un static_cast<int> sur le résultat d'une division entière ? À moins que TILE_SIZE ne soit pas un int ?

Maintenant ce qu'il faut que tu fasses c'est rajouter des traces pour savoir ce qui se passe sur les appels suivants (a priori le 1er fonctionne). Affiche toutes les valeurs que prennent successivement coinHD_x, coinHD_y, tilecoord_x, tilecoord_y, etc. Quelle est la condition fautive qui provoque le retour d'un true ?

Quelques petites notes au passage : ta méthode CheckForCollision devrait être const pour garantir qu'elle ne modifie pas l'objet (this sera alors const). Et n'hésite pas à utiliser des enum ou des const int globaux pour tes entiers constants, ça permet de comprendre le code sans avoir à se référer tout le temps aux commentaires :

Code: Tout sélectionner
[B]typedef enum eDirection
{
   Haut, Droite, Bas, Gauche
} Direction;[/B]

(...)

bool PhysicObject::CheckForCollision([B]Direction[/B] _direction) [B]const[/B]
{
   switch (_direction)
   {
      case [B]Droite[/B]:
      (...)
Gavos
 
Messages: 1089
Inscription: 19 Mar 2005, 13:00

Messagepar Kremtak » 23 Aoû 2011, 09:46

Tu n'aurais pas, par erreur, des membres déclarés statiques dans tes classes PhysicObject / IntelligentObject / Monster ... ?
But there's no sense crying over every mistake
You just keep trying until you run out of cake
Avatar de l’utilisateur
Kremtak
Hello World, I'm new !
 
Messages: 167
Inscription: 12 Déc 2007, 23:27
Localisation: Aubagne

Messagepar Nieluj » 23 Aoû 2011, 21:57

Gavos :

Code: Tout sélectionner
if( map[tilecoord_x][tilecoord_y] > 6 )


C'est juste que je n'ai pas encore mis en place une manière propre de gérer les éléments solides de la map. Donc là, ça test juste si l'élément est solide.

Le static_cast<int>, comme je le disais, c'est du bricolage:

Code: Tout sélectionner
tilecoord_x = static_cast<int>( ( coinHD_x ) / TILE_SIZE );


Si coinHD_x = 230 et que TILE_SIZE = 64, on se retrouve avec un nombre à virgule. Et je veux récupérer un entier pour tilecoord_x. L'utilisation de floor posait problème dans la mesure où il retourne un float. C'est la seule solution que j'ai trouvée :00000026: .

Sinon merci pour tes conseils Gavos. J'en prend note.

Kremtak :

Je n'ai pas de membres static mais je vais quand même vérifier.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Aranoth » 23 Aoû 2011, 22:18

Nieluj a écrit:Si coinHD_x = 230 et que TILE_SIZE = 64, on se retrouve avec un nombre à virgule.
Diviser un int par un int donne un int, pas un flottant. Si coinHD_x et TILE_SIZE sont déjà des entiers, pas besoin de cast.
Avatar de l’utilisateur
Aranoth
Hello World, I'm new !
 
Messages: 1327
Inscription: 10 Avr 2005, 00:10
Localisation: Montréal

Messagepar Nieluj » 23 Aoû 2011, 22:28

Aranoth a écrit:Diviser un int par un int donne un int, pas un flottant. Si coinHD_x et TILE_SIZE sont déjà des entiers, pas besoin de cast.


Tu es en train de me dire que ça floor automatiquement ? maintenant que tu le dis ça me dit quelque chose :00000023: . En réalité, j'avais enlevé ce static_cast hier et ça marchait correctement sans, donc ça doit être pour cette raison.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Nieluj » 23 Aoû 2011, 22:30

Sinon Kremtak, pas de membres static... J'aurais tellement voulu que ce soit une erreur de ce genre.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar Gavos » 23 Aoû 2011, 23:46

En fait ça fait une division entière, comme à l'école primaire où tu faisais des divisions sans connaître les nombres à virgule : « 17 / 5 = 3, reste 2 ». Et le reste tu l'obtiens avec l'opérateur % (modulo).

Tu as ajouté des traces dans ton code pour voir où ça posait problème ?
Gavos
 
Messages: 1089
Inscription: 19 Mar 2005, 13:00

Messagepar teto » 24 Aoû 2011, 10:15

si le projet est pas trop gros, pas trop de dépendances tu peux uploader source et binaire.

Compile avec -Wall histoire de voir si y a pas certains warnings qui pourraient t'aider. (genre le compilateur retourne une valeur par défaut dans la fonction X)
Avatar de l’utilisateur
teto
 
Messages: 1168
Inscription: 26 Juil 2005, 19:02
Localisation: /home/Paris

Messagepar Nieluj » 24 Aoû 2011, 21:47

Gavos a écrit:Tu as ajouté des traces dans ton code pour voir où ça posait problème ?


Bon là je vais passer pour un gland, mais je n'ai strictement rien me permettant de récupérer des informations. En tout cas je ne sais pas comment faire avec dev c++ ( j'aimerai bien avoir une console au mieux ). J'avais testé de mettre en place un moyen d'écrire avec SDL mais sans succès. Je n'ai pas insisté mais j'avoue que c'est moyen comme technique pour programmer...

Sinon pour le peu de tests que j'ai fais hier soir, j'ai trouvé un truc intéressant:

J'ai modifié mon IA pour que les monster se déplacent de bas en haut au lieu de gauche à droite et devinez quoi ? Ca fonctionne... Je n'ai pas approfondie mes recherches mais je vais surement m'y mettre ce soir.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar teto » 24 Aoû 2011, 22:05

Je pense que par "trace" gavos entendait des cout/printf (du log quoi) mais pas sûr.

T'as essayer de mettre des breakpoints et de compiler en mode debug puis de lancer un debugger pour voir le déroulement du programme ? ca te permettrait ptet de voir où ca coince.

Bonne chance (sans compter le courage)
Avatar de l’utilisateur
teto
 
Messages: 1168
Inscription: 26 Juil 2005, 19:02
Localisation: /home/Paris

Messagepar Nieluj » 24 Aoû 2011, 22:18

Bon j'ai trouvé d'où ça venait mais sans comprendre réellement le problème. J'ai naturellement comparé la différence entre la détection de collision droite/gauche et celle haut/bas et j'ai remarqué que suite à certaines modifications j'avais enlevé une partie du code:

Code: Tout sélectionner
if( ( this->map[tilecoord_x][tilecoord_y] > 6 ) && ( coinBD_y % TILE_SIZE != 0 ) )
{
      return( true );
}

//CETTE PARTIE ETAIT ENLEVEE :
else
{
      return( false );
}


En remettant le 2ème else ça marche. :00000020:

------------------------------------------------------------------

teto -> C'est ce que j'avais compris mais, comme je disais plus haut, je ne connais pas le moyen d'avoir une console en même temps que ma fenêtre d'application avec dev c++.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11

Messagepar teto » 24 Aoû 2011, 23:47

C'est à dire que sans ton else {}, la fct devait certainement retourner true


DevC++ est plus développé depuis des années non ? Je te recommande vivement http://www.codeblocks.org qui est très puissant je trouve, en tout cas bien mieux que devC++.

Généralement tu vas dans les propriétés du projet et t'as une case "activer la console". Sinon le programme écrit dans un fichier texte je crois.

Enfin c'est cool que t'ai trouvé.
Avatar de l’utilisateur
teto
 
Messages: 1168
Inscription: 26 Juil 2005, 19:02
Localisation: /home/Paris

Messagepar Gavos » 25 Aoû 2011, 00:47

Au pire, si tu n'arrives pas à avoir une console tu peux toujours écrire dans un fichier :

#include <iostream>

(...)

ofstream logFile("log.txt");
if (!logFile) exit(1);

(...)

logFile << "tilecoord_x = " << tilecoord_x << std::endl;

(...)


Sinon je suis d'accord, je pense qu'il vaut mieux prendre autre chose que DevC++ dont la dernière version date de plus de 6 ans. Tu peux aussi essayer Visual Studio 2010 Express qui est gratuit et déjà bien complet.
Gavos
 
Messages: 1089
Inscription: 19 Mar 2005, 13:00

Messagepar iliak » 25 Aoû 2011, 08:52

Gavos a écrit:Sinon je suis d'accord, je pense qu'il vaut mieux prendre autre chose que DevC++ dont la dernière version date de plus de 6 ans. Tu peux aussi essayer Visual Studio 2010 Express qui est gratuit et déjà bien complet.


Je plussois un maximum aussi !
- Iliak -
[http://www.mimicprod.net ArcEngine : a free 2D .Net gaming framework]
[http://www.dungeoneye.net Dungeon Eye : Remake open source de Eye of the beholder II]
iliak
Hello World, I'm new !
 
Messages: 141
Inscription: 25 Fév 2010, 14:53

Messagepar teto » 25 Aoû 2011, 13:52

et parce qu'on est tous parti en mode flood, tu pourrais remplacer to ncode actuel par:
Code: Tout sélectionner
return( ( this->map[tilecoord_x][tilecoord_y] > 6 ) && ( coinBD_y % TILE_SIZE != 0 ) )


c'était donc bien un code de retour par défaut ajoutée par le compilateur ? Si tu compiles avec -Wall (mingw/gcc) tu l'aurais vu :p
Avatar de l’utilisateur
teto
 
Messages: 1168
Inscription: 26 Juil 2005, 19:02
Localisation: /home/Paris

Messagepar Eva » 25 Aoû 2011, 20:16

Perso, je conseille virtualbox avec ubuntu...
Avatar de l’utilisateur
Eva
Hello World, I'm new !
 
Messages: 651
Inscription: 31 Mai 2005, 15:43

Messagepar Nieluj » 26 Aoû 2011, 21:53

Ok merci pour ces conseils.
J'ai déjà utilisé Codeblock, je pense repartir sur ce choix.
Avatar de l’utilisateur
Nieluj
Hello World, I'm new !
 
Messages: 110
Inscription: 27 Oct 2009, 14:11


Retourner vers Programmation

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 24 invités