IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Projets Discussion :

OpenAWars - Advance wars like


Sujet :

Projets

  1. #41
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    On ne fait rien sans SVN, et je le sais depuis que je l'utilise

    Je n'ai pas compris pour le debug, mais je sais qu'il faudra que je les désactive pour la release. Sinon je ne vois pas desquelles vous parler ( exemple de code ? )


    ------

    Bonjour à tous,

    Aujourd'hui on attaque directement avec un nouveau cursor, pour l'éditeur qui va avoir la possibilité de changer d'image si on ne peut pas poser la tuile sur son emplacement.
    Pour cela, j'hérite la classe Cursor, pour un EditingCursor.

    Dans cet héritage, je n'ajoute qu'un boulean est une fonction qui indique si le curseur est dans le mauvais mode, ou pas et pour changer son état.

    Voici la déclaration du EditingCursor:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     
    class EditingCursor : public Cursor
    {
    private:
     
    	AnimatedSprite* pWrongCursorSprite;
     
    	bool isWrong;
     
    public:
    	EditingCursor(SpriteManager& sm, const std::string& fileNameCursor, const std::string& fileNameWrongCursor, const Map* const pMap, const UVec2& initialPosition);
    	~EditingCursor(void);
     
    	bool getIsWrong(void)const { return isWrong; }
    	void setIsWrong(const bool isWrong) { this->isWrong = isWrong; }
     
    	virtual bool draw(const Renderer& r, const Camera& c, const unsigned int time)const;
    };
    Bien sur, j'ai du changer un peu le code de la classe Cursor, pour accepter l'héritage.
    Le seul code important qu'il y a dans le EditingCursor, c'est:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
    bool EditingCursor :: draw(const Renderer& r, const Camera& c, const unsigned int time)const
    {
    	UVec2 cameraPosition = c.getPosition();
    	IVec2 screenPosition = IVec2((this->position.x - cameraPosition.x ) * (static_cast<int>(Scaler::getXScaleFactor() * TILE_DEFAULT_WIDTH)),
    								 (this->position.y - cameraPosition.y ) * (static_cast<int>(Scaler::getYScaleFactor() * TILE_DEFAULT_HEIGHT)));
     
    	if ( isWrong )
    	{
    		return r.drawTile(*pWrongCursorSprite,screenPosition,time);
    	}
    	else
    	{
    		return r.drawTile(*pCursorSprite,screenPosition,time);
    	}
    }
    Oui, il n'y a qu'un test qui change

    Et je rajoute ça dans le main:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    ec.setIsWrong(!m.testTile(ec.getPosition(),buildingTB.getSelected()));
    Et ça fonctionne, encore heureux

    Comme on peut le voir dans la capture ( ou presque ), on ne peut pas mettre de plage sur de la plaine :p.

    Bon maintenant, j'attaque la deuxième chose que je n'aime pas \o/
    Une autre interface pour l'utilisateur, mais beaucoup plus simple que la TileBar. Effectivement, là on se rend compte que lorsque l'on selectionne une tuile, nous ne savons pas laquelle nous appliquons. Maintenant je vais donc rajouter une petite interface qui va indiquer la tuile sélectionné ( au cas ou que l'utilisateur à la mémoire courte )
    L'interface est composé de:
    Une image de fond, un titre, un nom, et l'image de la tuile ( sans animation, dans la jeu original ). C'est tout.

    Mais cela n'est pas vraiment très immédiat, car jusque là, je n'avais pas intégré SDL_TTF, et tout ce qui va avec ( un manager de police ).
    Il est un peu différent de celui des sprites. Notamment, parce que celui là, il prend en compte, le chemin ( comme ID ) mais aussi la taille.
    Cela complique légèrement la fonction qui récupère la police car elle doit faire ce qui suit:

    - Vérifié si le chemin de la police est connu
    - Non, alors on charge la police, et on stocke
    - Oui:
    - Verification des tailles des polices chargé pour ce chemin
    - On a trouvé, on retourne
    - On a pas trouvé, on charge

    Voilà.

    Maintenant, il faut une jolie classe Font, pour avoir tous les outils à porter de main sans toucher la SDL.
    La classe aura pour faculter de dessiner du texte ( en utilisant toujours le renderer ), de connaitre la taille du texte qui va être déssiné ( longueur, largeur ), et puis contiendra la couleur.
    Il n'y a rien de spécial sur cette classe, elle ressemble à la classe Sprite, mais pour les polices.

    Maintenant je peux enfin attaquer l'interface utilisateur
    La classe va s'appeler TileViewer, et ne va être présente que dans l'éditeur.

    Pour avoir le nom d'une tuile, j'ai rajouté dans le fichier Tile, un parser sur le type de la tuile, qui retourne le nom. C'est une des méthodes que je pouvaient faire, et en fait, plus tard, il faudrait mieux que je remplace tout ça par une bibliothèque, venant d'un fichier par exemple.

    Finalement, dans le main, je rajoute un code pour pouvoir affiché la boite d'information soit à gauche soit à droite, selon la position du cursueur ( le curseur ne doit pas être caché ).
    Cette condition appelle une fonction qui change la position en X de toute la boite. Le dessin des éléments de la boite se base tous sur cette position, donc en changeant une valeur, je change tout, sans rien cassé.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    if ( buildingTB.isClosed() )
    {
    	tileInformationViewer.draw(*r);
    }

    Et finalement la boite n'est affiché que lorsque le menu ( pour les tuile ( la TileBar donc ) ) n'est pas affiché.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    // Check if we have to move the TIleViewer
    if ( ec.getPosition().y >= 6 )
    {
    	if ( ec.getPosition().x <= 2  )
    	{
    		tileInformationViewer.putOnRight();
    	}
    	else if ( ec.getPosition().x >= 13 )
    	{
    		tileInformationViewer.putOnLeft();
    	}
    }
    Voilà, ça fonctionne

    En dernière modification de la journée, j'ai viré le compteur d'allocation / désallocations pour les Tile depuis que mes tuile sont toutes statiques ( aucun pointeur utilisé pour les tuiles )
    Images attachées Images attachées     
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  2. #42
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Aujourd'hui nous allons nous occuper d'un truc très importants ( mais si tout ce que j'ai fait été important, là, c'est TRES important, notez la différence ).

    Je m'attaque enfin aux unités.
    Alors, dans le principe logique ( gestion sur la carte / dans le fichier ) les unités, c'est tout comme des Tiles. Sauf que l'on ne peut pas les mettre ensemble, car c'est la deuxième couche de la carte.

    Tout comme les Tile, j'ai un enum, qui énumère toutes les unités que je peux avoir:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    enum UnitType
    {
    	UT_NO_UNIT = 0,
     
    	// Red
    	// Ground units
    	UT_R_INFANTRY,
    	UT_R_BAZOOKA,
    	UT_R_RECON,
    	...
    };
    J'ai voulu évité d'avoir les énumérants pour les 4 couleurs ( surtout que ce sont les mêmes à chaque fois ), mais finalement, je ne vais pas faire la simplification de l'énum, car cela risque de compliquer mon code.
    Dans la classe on va pouvoir trouver ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    static const unsigned int UC_NONE = 0;		// For non attacking unit
    static const unsigned int UC_LAND = 1;
    static const unsigned int UC_NAVY = 2;
    static const unsigned int UC_AIR = 4;
    C'est tout comme une énumération, mais je ne pouvais pas utiliser l'énumération car je dois pouvoir aussi faire des combinaisons des valeurs. Nous allons utiliser deux fois cette définition pour:
    - La catégorie de l'unité pour les déplacements
    - La catégorie de l'unité sur laquelle nous pouvons tirer

    ( Je me rend compte, qu'il va peut être y avoir des complications supplémentaires pour les débarquements ... quoique ... nous verrons un peu après :p )

    Note: Je sais aussi que plus tard, lorsque je ferai la partie jeu, plus que la partie editeur, il faudra que je rajoute des catégories ( ou sous catégories ) afin de géré efficacement les defenses / avantages sur les autres unités.

    Comme vous avez pu le remarqué avec les Tile, j'avais fait une fabrique, sauf que cela n'en ai pas une vrai comme le décrit le design pattern. Effectivement, je peux tout simplement faire un constructeur qui prend un TileType et le problème est réglé.
    ( La modification pour un avec constructeur, sera surement fait dans la prochaine version )

    Par contre, cette fois, j'ai vraiment besoin d'une fabrique, car la classe Unit est la classe mère et qu'elle sera hérité par les unités.



    Donc voici la classe
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
     
    class Unit
    {
    private:
     
    	UnitType type;
     
    	unsigned int category;
    	unsigned targetCategory;
     
    	unsigned int movement;
    	unsigned int fuel;
    	unsigned int fuelConsumption;
    	unsigned int ammo;
     
    	unsigned int life;
     
    public:
    	static const unsigned int UC_NONE = 0;		// For non attacking unit
    	static const unsigned int UC_LAND = 1;
    	static const unsigned int UC_NAVY = 2;
    	static const unsigned int UC_AIR = 4;
     
     
    	Unit(void):type(UT_NO_UNIT),category(UC_LAND),targetCategory(UC_LAND),movement(0),fuel(0),ammo(0),life(0) {}
    	Unit(const UnitType type, const unsigned int category, const unsigned int targetCategory, const unsigned int movement, const unsigned int fuelConsumption, const unsigned int ammo)
    		:type(type),category(category),targetCategory(targetCategory),movement(movement),fuel(99),fuelConsumption(fuelConsumption),ammo(ammo),life(10) {}
     
    	virtual ~Unit(void) {}
     
    	UnitType getType(void)const { return type; }
    };
    Vous remarquerez que pour le moment, je ne met pas les fonctions qui seront dans le jeu, car je n'ai pas encore décidé comment je vais géré le mouvement, ou l'attaque.

    Voici la factory:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
     
    Unit* UnitFactory(const UnitType type)
    {
    	switch (type)
    	{
    		case UT_R_INFANTRY:
    		case UT_B_INFANTRY:
    		case UT_G_INFANTRY:
    		case UT_Y_INFANTRY:
    			return new Unit(type,UC_LAND,UC_LAND,3,1,3);
    			break;
     
    		case UT_R_BAZOOKA:
    		case UT_B_BAZOOKA:
    		case UT_G_BAZOOKA:
    		case UT_Y_BAZOOKA:
    			return new Unit(type,UC_LAND,UC_LAND,2,1,3);
    			break;
    	...
    	}
     
    	assert(0);
    	return new Unit();
    }
    Et ce pour toute les unités. Dans les améliorations, je prévoit de faire en sorte que chaque paramètre soit chargé à partir d'un fichier.

    Maintenant je met à jour la classe Map, et les parseurs de la classe Map afin que l'on prennen en compte les unités.
    Tout d'abord, je rajoute ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    std::map<UnitType, AnimatedSprite*> unitsASprite;		/*!< The collection to associate type of the unit to a sprite */
    Pour avoir un dictionnaire des sprites associé aux unités.
    Je rajoute aussi dans la fonction loadGraphics, le chargement de tout les nouveaux sprites.

    Le deuxième ajout qu'il doit y avoir, c'est l'ajout de la carte des unités. Cette fois, je reviens avec un tableau à deux dimensions de pointeurs d'Unit car, je dois avoir un pointeur d'Unit pour que le polymorphisme fonctionne.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    Unit*** unitMap;			/*!< 2D Array representating the unit on the map */
    Cela implique de changer l'analiseur ( pour le jeu ) et le constructeur pour le MapEditor.
    Nouveau code de l'analiseur:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
     
    else if ( lineCounter >= 2+this->height && lineCounter < 2+this->height*2 )	// For the unit map
    {
    	unitMapLineCounter++;
     
    	// We are reading one line, by one
    	for ( unsigned int x = 0 ; x < this->width ; x++ )
    	{
    		int unitType = -1;
    		ss >> unitType;
    		if ( unitType != -1 )
    		{
    			if ( unitType < UT_END_LIST )
    			{
    				unitMap[lineCounter-(2+this->height)][x] = UnitFactory(static_cast<UnitType>(unitType));
    			}
    			else
    			{
    				LWarning << "Data in the map invalid (" << unitType << ")";
    				error = true;
    			}	
    		}
    		else
    		{
    			LError << "Fail to read the tile type @ " << x << ";" << lineCounter-(2+this->height);
    			error = true;
    		}
    	}
    }
    Nouveau code pour le MapEditor:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
     
    // Unit map allocation
    unitMap = new Unit**[this->height];
    if ( unitMap == NULL )
    {
    	LError << "Error to allocate memory for the unitMap! (at height)";
    	valid = false;
    }
    else
    {
    	for ( unsigned int y = 0 ; y < this->height ; y++ )
    	{
    		unitMap[y] = new Unit*[this->width];
    		if ( unitMap[y] == NULL )
    		{
    			LError << "Error to allocate memory for the unitMap! (at width (" << y << "))";
    			valid = false;
    		}
    	}
    }
     
    for ( unsigned int y = 0 ; y < this->height ; y++ )
    {
    	for ( unsigned int x = 0 ; x < this->width ; x++ )
    	{
    		map[y][x] = TileFactory(TT_Plain);
    		unitMap[y][x] = new Unit();		// Default is not unit
    	}
    }
    Il faut aussi mettre à jour la fonction de dessin, en ajoutant ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    if ( unitMap[y][x]->getType() != UT_NO_UNIT )	// If we have a unit
    {
    	r.drawTile(*unitsASprite[unitMap[y][x]->getType()],tilePos,time);
    }
    Et puis la fonction de sauvegarde du MapEditor:
    Et surtout, ne pas oublier le destructeur de Map sinon nous perdons de la mémoire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    // Delete the unit map
    for ( unsigned int y = 0 ; y < this->height ; y++ )
    {
    	for ( unsigned int x = 0 ; x < this->width ; x++ )
    	{
    		delete unitMap[y][x];
    	}
     
    	delete[] unitMap[y];
    }
     
    delete[] unitMap;
    Maintenant le test.
    Tout d'abord, comme je n'ai pas encore fait le code nécessaire pour placer les unités sur ma carte, je lance l'éditeur, afin de crée le nouveau fichier de carte, et surtout d'avoir le nouveau tableau.
    Une fois, la nouvelle carte de crée, je la modifie à la main, pour placer des unités, et je la charge dans le jeu, pour voir le résultat.
    Le résultat est comme le montre la capture d'ecran \o/

    Maintenant faut que j'aille en cours
    Images attachées Images attachées  
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #43
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Juillet 2010
    Messages
    61
    Détails du profil
    Informations personnelles :
    Âge : 31
    Localisation : France

    Informations forums :
    Inscription : Juillet 2010
    Messages : 61
    Points : 33
    Points
    33
    Par défaut
    Étant un grand fan d'AW je vous suis de tous cœur dans votre projet.

  4. #44
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    But d'aujourd'hui, rajouter une TileBar pour pouvoir poser des unités sur la carte \o/
    Vous savez tous, que j'ai déjà une TileBar de prêt, et qui me permet de poser les tuiles sur la carte. Comme il y a déjà 75% du travail de fait, je vais réutiliser cette TileBar pour mes unités.
    Petit problème, c'est que dans le design de la TileBar actuel, il n'est pas possible de prendre autre chose que des TileView ( structure d'un AnimatedSprite avec un TileType ). Mais cela va changer.

    La nouvelle implémentation a les contraintes suivantes:
    - Afficher ce que l'utilisateur veut ( des tuiles, des unités, des chouettes, ..., enfin, ce qu'il veut simplement )
    - N'avoir q'une seule fonction de dessin même si on dessine des tuiles, ou des unités ( de toute façon dans les deux cas ce sont des AnimatedSprite )

    Pour ce faire:
    - Création de deux nouvelles classes, TileBarUnits, et TileBarTiles, qui hérite de TileBar
    - Création d'une nouvelle classe View.
    - Création de deux nouvelles classes TileView et UnitView qui hérite de TBView.

    Dans le TileBar nous avons la liste de View à afficher. Comme l'AnimatedSprite est défini dans le View, il n'y a peut de changement ( juste la gestion des pointeur / mémoire )
    Dans les classes qui hérite de TileBar, nous n'avons pas grand chose, chose un getInstance() et un constructeur qui ne fait qu'appeler le constructeur de TileBar
    Exemple:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    class TileBarTiles : public TileBar
    {
    private:
     
    public:
     
    	TileBarTiles(SpriteManager& sm, const Window& win, std::vector<TileView*>& listTiles);
     
    	TileType getSelected(void)const;
    };
    J'avais prévenu, il n'y a presque rien.

    Une fois que cela à été en place, j'ai du changer la main de l'éditeur afin de pouvoir ouvrir / fermer / jouer avec la TileBarUnits
    La création de la TileBarUnits reprend exactement le même principe que pour la TileBarTiles ... avec un vecteur que l'on remplit.
    Pour la logique de l'éditeur, le gros changement c'est la prise en compte de la nouvelle barre, afin qu'elle ne s'ouvre pas sur l'ancienne, ou des petits détails comme ça.

    Le deuxième point, c'est le TileViewer, qui affiche la sélection actuelle.
    Déjà, j'ai mis un parserName() pour les unités afin d'avoir les noms des unités.
    Après j'ai du enlever le membre TileType du TileViewer, car finalement il été inutile, et comme ça je rendais mon Viewer compatible avec les unités \o/
    ça marche bien comme on peut le voir dans une des captures d'écran.

    Après, le dernier changement, c'est l'implémentation de setTile / testTile ( que je pourrais appeler setUnit / testUnit , mais comme l'énum permet on compilateur de faire la différence, je garde comme ça ( peut être que cela va changer ) )
    La logique pour les unités est beaucoup plus simple que pour les tuiles.
    Une unité marine ne peut aller sur terre ... et quelques détails comme cela qui sont implémenté dans testTile()

    Bien sur, j'utilise testTile() pour savoir si je dois afficher un curseur spécial ou pas ( en cas de non possibilité de mettre l'unité à tel endroit )

    Finalement, je dois dire qu'il y a un boolean dans le main, pour savoir si l'utilisateur à sélectionner une unité ou une tuile pour savoir de quel TileBar je dois récupéré l'information.

    Voilà tout pour aujourd'hui ... Go to the University Now !
    Images attachées Images attachées    
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #45
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Excellent boulot ! Puis-je demander à quand la demo ? ;-)

    Tu as déjà les animations ou pas ?

    Jc

  6. #46
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Et bah, j'y pense serieusement depuis quelques jours, et normalement, l'editeur de cartes ( car je suis loin d'avoir fini le jeu ) va sortir cette semaine, ou la semaine prochaine.

    La, je suis a l'universite, et les GP2X sont libre d'acces \o/
    Sachant que je vais avoir un Linux dans quelques jours ( j'attend la sortie du 10.10 ), je vais faire toute la correction de bugs / compilation aussi.

    Ce qu'il me reste a faire:

    Amelioration de code ( J'ai une ToDo liste )
    Boucle principale de l'editeur ( elle est ... comment dire ... en peux fouilli )
    Meilleure gestion des messages de debugguage.
    Un temps virtuel, est finalement, une vrai boucle de jeu ( comme ecrit, par exemple dans cet article: http://www.koonsolo.com/news/dewitters-gameloop/ )

    Et apres, cela devrait etre a peu pres bon ( ah si, l'ajout d'une unite ( fausse unite ) dans la barre , pour pouvoir effacer les unites mises en place ) ) et aussi une correction d'un autre bug.

    Mais normalement, nous sommes proche d'une finalisation de l'editeur ( la version Windows sortira en premier, car c'est sur ce systeme que je bosse )

    Par contre, reste la question des sprites, qui m'empeche de sortir une version ( normalement )

    Et je n'ai aucune animation, bien que je pourrai les faire ... mais cela va me prendre un peu de temps en plus ( le code est pret pour les animations, il me manque juste les fichiers )
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  7. #47
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Aujourd'hui, je n'ai pas beaucoup de temps, et je ne vais faire que des petites modifications sur le code.

    La première modification, c'est la réparation d'un bug. Effectivement, à chaque fois que l'on pose une tuile, il faut regarder si l'unité qui est dessus est encore valide pour la nouvelle tuile ( sinon on pourrai faire en sorte d'avoir des unités terrestre dans la mer, et autre incohérence de ce genre ).
    La modification est faite dans checkCoherencyAround() qui est appelé à chaque fois que nous avons besoin de changer de tuile.
    Cette vérification va juste intégré ce morceau de code:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    // Check if the unit that was here can stay or not
    if ( this->testTile(position,this->getUnit(position)->getType()) == false )
    {
    	// If not, removing it
    	this->setTile(position,UT_NO_UNIT);
    }
    Un code d'une facilité implacable qui fonctionne parfaitement .

    Comme je l'avais dit la dernière fois, la pseudo fabrique que j'ai fait pour les Tile à été enlevé pour ne juste implémenter un constructeur prenant directement un TileType.

    Autre changement au niveau du sprite manager. En fait, j'ai oublié en partie pourquoi je voulais faire ça, mais j'ai enlevé la sauvegarde du sprite de base, pour ne garder que le sprite redimenssionné. Plus précisément, je me suis rendu compte, que j'utilisais les sprites que dans la forme demandé à la création.
    Du coup, si le sprite n'a pas encore été chargé, le boolean 'needScaling' est important, sinon, bah on retourne le sprite en mémoire, et le boolean n'a pas d'effet.
    Cela me permet d'enlever un sprite de la mémoire ( donc le programme prend moins de mémoire ). Par contre, c'est que j'avais prévu de rajouter un troisième type de sprite, mais je ne me rappelle plus ce que c'est mais c'était en prévision pour le jeu. Et si jamais je n'ai pas besoin de ce changement ( au si j'ai rerouvé, c'est pour l'inversion horizontale des sprite, utile pour le jeu ) \o/. Bref, cela m'évite de faire de garder 4 sprites ( le normal, le normal inversé , le redimensionné inversé et le redimensionné simple ).

    J'ai ajouté la classe VTime pour le temps virtuel sur le SVN, mais pour l'instant, l'implémentation n'est pas prête ( faut que j'aille en cours des fois ( pour apprendre à faire un bon jeu ) ).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  8. #48
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Aujourd'hui, toujours peu d'amélioration coté visual ( quoique, je vais enfin rendre le projet fluide ), mais des améliorations dans le code.
    J'intègre enfin mon VTime. Qu'est ce que la VTime?
    Un VTime c'est un temps de repère ( pour mes animations et autres ) qui n'est pas facteur du temps. Si votre jeu, par exemple, il est en pause ou autre petit problème du genre ( lags ... ralentissements ), et bah le jeu en lui même ne le ressent pas trop.
    Du coup, je n'utiliserai pas le temps ( secondes ) comme repaire pour faire les animations, mais le temps virtuel

    Ma classe est la suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
     
    class VTime
    {
    private:
     
    	unsigned int time;
    	unsigned int lastUpdate;
     
    	const unsigned int msSecondsBetweenToFrame;
     
    	void update(void);
    public:
    	VTime(const unsigned int nbFPS);
     
    	void waitNextFrame(void);
     
    	unsigned int getTime()const { return time; }
    #ifdef _DEBUG
    	void getTime(const unsigned int newTime) { time = newTime; }
    #endif
    };
    Le principe final, c'est que on va crée un VTime avec un certain nombre d'image par secondes voulues, et on pourra faire en sorte d'attendre le nombre de milli secondes aproprié; tout ça dans le VTime. Donc l'utilisation est simple.
    Après, pour les animations, elle se baseront sur le temps retourné par VTime.
    waitNextFrame() va appeler lui même update pour mettre à jour les champs de la classe.

    Le deuxième gros changement est d'ordre logique et ne se ressend pas dans le jeu. Avant, j'avais toute ma boucle de jeu, dans le main. Cette fois j'ai crée une classe EditorEngine, qui a la forme suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
     
    class EditorEngine
    {
    private:
     
    	const Window* pWin;
    	Renderer* pRenderer;
     
    	SpriteManager* pSM;
    	FontManager* pFM;
     
    	TileBarTiles* pBuildingTB;
    	TileBarUnits* pUnitTB;
    	TileViewer* pTileViewer;
     
    	VTime* pVT;
     
    	Keyboard* pKB;
     
    	MapEditor* pMap;
    	EditingCursor* pEC;
    	Camera* pCam;
     
    public:
    	EditorEngine(void);
    	~EditorEngine(void);
     
    	bool init(const Window* win, const RenderingAPI rAPI);
    	bool load(const UVec2& mapSize);
     
    	bool run(void);
     
    	void saveMap(const std::string& fileName);
    };
    Le constructeur ne fait rien.
    La fonction d'initialisation initialise tout les pointeurs (construction des objets). La fonction de chargement, s'occupe de charger la carte (donc tout les sprites) ainsi que les TileBar* et la camera + curseur (qui sont dépendant de la carte).

    La fonction run, reproduit la boucle du jeu qui était auparavant dans le main. La boucle faite les choses suivantes:
    - Dessin des éléments
    - Récupération des touches
    - Mis à jour des éléments
    - Attente, selon le temps passé à faire ces 3 dernières choses

    Maintenant, le main ne gère plus que l'initialisation de la SDL (et de ses composants) ainsi que la création de la fenêtre.

    Dernier changement pour cette version:
    J'avais ce code là (pour la gestion des TileBar):
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
    if ( pBuildingTB->isOpened() )
    {
    	if ( pKB->isKey(SDLK_LEFT) )
    	{
    		pBuildingTB->moveLeft();
    	}
     
    	if ( pKB->isKey(SDLK_RIGHT) )
    	{
    		pBuildingTB->moveRight();
    	}
     
    	if ( pKB->isKey(SDLK_UP) )
    	{
    		pBuildingTB->moveUp();
    	}
     
    	if ( pKB->isKey(SDLK_DOWN) )
    	{
    		pBuildingTB->moveDown();
    	}
    }
    Mais pour la gestion du curseur, la chose suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    pEC->move(pKB->getDirectionPressed());
    Du coup, j'ai décidé d'unifier un peu le design, afin d'avoir la chose suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    if ( pBuildingTB->isOpened() )
    {
    	pBuildingTB->move(pKB->getDirectionPressed());
    }
    Bien entendu, les fonction moveUp, moveLeft, moveRight, moveDown, sont maintenant privées.

    Note: J'ai trouvé un bug assez spécial, qui crée un décalage sur les tuiles, lorsque je place un batiment plus grand que la taille des tuiles par défaut, sur la première colonne (tout à gauche). Vous pouvez le voir sur la capture d'écran.
    Images attachées Images attachées  
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  9. #49
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Tout d'abord j'ai corrigé le bug, qui faisait un décalage de tuiles sur une ligne, si on mettait une tuiles d'une dimension non standard dans la première colonne.
    Ceci était à cause de la ligne de code, qui faisait le saut d'une ligne à l'autre lors du dessin de la carte. Effectivement j'utilisait la valeur de la tuile qui se trouvait là, à la place de la valeur d'une tuile réglementaire.
    Tout simple, non?
    En capture d'écran vous pouvez voir mon test .

    En vue d'une prochaine mis à disposition pour le grand public (oui je parle de vous, cher lecteurs), j'ai décidé d'ajouter une prise en charge des arguments passé au programme.
    Effectivement, je n'ai pas encore prévu de menu ou autre pour gérer l'éditeur. Du coup tout se passe par la ligne de commande (qui n'est pas obligatoire).
    Les options suivantes ont été ajouté:
    --width resolution_en_pixel_pour_la_largeur
    --height resolution_en_pixel_pour_la_hauteur
    --fullscreen
    --mapWidth nombre_de_cases_en_largeur
    --mapHeight nombre_de_cases_en_hauteur
    --mapName nom_du_fichier_de_sauvegarde_de_la_carte

    Comme vous pouvez vous en douter, le --fullscreen met l'éditeur en plein écran.

    Voilà pour aujourd'hui, faut que j'aille lire un livre pour mieux programmer en C++.
    Images attachées Images attachées  
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  10. #50
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Cette fois, je commence par l'ajout d'une fonctionnalité pour le MapEditor. Effectivement, le MapEdit n'avait qu'un constructeur, qui permettait de crée une carte vide.
    Cette fois, je rajoute un constructeur, qui permet de charger une carte pour l'éditer (Je pense que c'est une bonne idée )
    Voilà le code ajouté:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    MapEditor :: MapEditor(SpriteManager& sm, const std::string& fileName):Map(sm,fileName) {}
    Simple, il appelle juste le constructeur de Map, qui lui chargera la carte, et nous aurons les fonctionnalités de MapEditor.

    Il faut aussi que je rajoute l'accès à cette fonctionnalité par la ligne de commande, accessible avec l'option --load nom_de_la_carte
    Mais du coup, l'EditorEngine doit avoir une nouvelle fonction de chargement.
    En fait, comme je commence avoir l'habitude de faire, je vais déplacer le code commun, dans une fonction privée, et mettre le chargement de la carte, dans chaque définissions de load().
    Voici un exemple:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    bool EditorEngine :: load(const std::string& mapName)
    {
    	pMap = new MapEditor(*pSM , mapName);
    	if ( !pMap->isValidMap() )
    	{
    		return false;
    	}
     
    	return this->load();
    }
    Voilà. Je suis sur que vous êtes trop heureux de cette fonctionnalité.

    Autre changement du jour, en vue de la mis en place d'une version "Release", qui je vous le rappelle, n'a aucun message de debug (elle est donc extrêmement rapide ), j'ai modifié la classe VTime.
    Cette fois, j'ai ajouté une fonction canUpdate() avec le code suivant:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    bool VTime :: canUpdate(void)
    {
    	int timeEllapsed = SDL_GetTicks() - lastTimeUpdate;
     
    	if ( msSecondsBetweenTwoUpdate < timeEllapsed )
    	{
    		lastTimeUpdate = SDL_GetTicks();
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    En fait, ma boucle de jeu devient la suivante:
    Tans que nous voulons jouer (pas d'appuis sur la touche échap)
    - On dessine
    - Si on doit mettre à jour (canUpdate)
    - - Nous mettons à jours (vérification clavier / déplacement curseur / ...)
    - On attend la prochaine image (synchronisation avec waitNextFrame())
    Ce qui veut dire, que nous mettons à jour moins souvent que nous affichons le jeu. La bonne nouvelle, c'est que malgré ce petit décalage, mes animations sont toujours synchronisées sur l'affichage et non sur cette nouvelle notion.
    Grace à cela, le curseur est ralenti, ce qui rend l'éditeur un peu plus agréable à l'utilisation.
    La vitesse de mis à jour est définie dans le constructeur, telle la vitesse de rafraichissement.

    Voilà pour aujourd'hui.

    Aujourd'hui est tout de même un grand jour. Non pas parce que Ubuntu 10.10 est de sorti, mais aussi car je mets en place la première version (dite "Beta") de l'éditeur en libre téléchargement.
    Veuillez lire le README_Editor.txt pour toute question (même si celui ci est en anglais). Le téléchargement ce fait ici: http://code.google.com/p/openawars/d...ditor_Beta.zip
    Ce n'est qu'une version Windows, mais dans la théorie, la version Linux arrivera bientôt, le temps que je fasse le makefile, que je corrige tout, et que j'installe mon Linux .
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  11. #51
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Nouvelle mis à jour pour un premier support de Linux (et autres).

    J'ai donc rajouté un Makefile pour compilé le projet à partir des sources. J'ai utilisé un vieux Makefile que j'utilsé dans mes anciens projets, et qui est loin d'être le meilleur. Mais bientôt, je vais faire en sorte de la faire généré par les autotools
    Il faut savoir, que d'utiliser un nouveau compilateur amène à faire quelques modifications dans le code (malheureusement), car Visual laisse passer des trucs que GCC n'aime pas vraiment (même pas du tout).
    La deuxième grosse modification, est le fait que certains fichiers ont été renommé car Linux est "case(sensitive" alors que Windows n'en à rien à faire, mais alors, il s'en moque complètement.

    Finalement, il faut savoir (et je l'avais prévu) que les switch case, que j'ai laissé à l'abandon (certains case non implémentés) sont reportées comme "Warnings". Du coup, la compilation sous Linux à tendance à généré un très grand nombre de messages.

    Le nouveau lien pour s'amuser aussi sous Linux est le suivant: http://code.google.com/p/openawars/d...r_Beta_src.tar
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  12. #52
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Citation Envoyé par LittleWhite Voir le message
    Finalement, il faut savoir (et je l'avais prévu) que les switch case, que j'ai laissé à l'abandon (certains case non implémentés) sont reportées comme "Warnings". Du coup, la compilation sous Linux à tendance à généré un très grand nombre de messages.
    C'est pour cela que je fais généralement :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    default:
      assert (0);
      break;
    [edit]
    Alors j'ai regardé ton éditeur, .

    Je me demande simplement :
    - Si je passe de terrain ('w') aux unités ('q'), j'aimerai le faire directement. Pour l'instant t'oblige qu'on séléctionne et qu'on aille vers l'autre...

    - Une petite aide avec F1 pour connaître les touches ? ;-)

    - Jolie animation d'ouverture/fermeture du tilebar

    re-

    Jc

  13. #53
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Je suis entierement d'accord et cela va etre fait dans la prochaine version lorsqu'elle sera la
    J'en avais deja parler et j'avais trouve suspicieux que VS ne me reporte pas les warnings ...
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  14. #54
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Citation Envoyé par LittleWhite Voir le message
    Je suis entierement d'accord et cela va etre fait dans la prochaine version lorsqu'elle sera la
    J'en avais deja parler et j'avais trouve suspicieux que VS ne me reporte pas les warnings ...

    Oui je pense que tu peux changer les options.

    Jc

    PS: regarde mes quelques remarques du post précédent (edit ;-))

  15. #55
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Par contre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
     
    unsigned char parseDefence(const TileType tileType)
     
    {
     
    	switch(tileType)
     
    	{
     
    		case TT_Beach_TL:
     
    		case TT_Beach_TL_R:
     
    		case TT_Beach_TL_B:
     
    		case TT_Beach_TL_2:
     
    		case TT_Beach_TR:
     
    		case TT_Beach_TR_B:
     
    		case TT_Beach_TR_L:
     
    		case TT_Beach_TR_2:
     
    		case TT_Beach_BL:
     
    		case TT_Beach_BL_T:
     
    		case TT_Beach_BL_R:
     
    		case TT_Beach_BL_2:
     
    		case TT_Beach_BR:
     
    		case TT_Beach_BR_L:
     
    		case TT_Beach_BR_T:
     
    		case TT_Beach_BR_2:
     
    		case TT_Beach_EL:
     
    		case TT_Beach_ER:
     
    		case TT_Beach_ET:
     
    		case TT_Beach_EB:
     
    		case TT_Beach_T:
     
    		case TT_Beach_T_L:
     
    		case TT_Beach_T_R:
     
    		case TT_Beach_T_2:
     
    		case TT_Beach_B:
     
    		case TT_Beach_B_R:
     
    		case TT_Beach_B_L:
     
    		case TT_Beach_B_2:
     
    		case TT_Beach_L:
     
    		case TT_Beach_L_T:
     
    		case TT_Beach_L_B:
     
    		case TT_Beach_L_2:
     
    		case TT_Beach_R:
     
    		case TT_Beach_R_T:
     
    		case TT_Beach_R_B:
     
    		case TT_Beach_R_2:
     
    		case TT_Bridge_H:
     
    		case TT_Bridge_V:
     
    		case TT_Coast:
     
    		case TT_Coast_ET:
     
    		case TT_Coast_EB:
     
    		case TT_Coast_EL:
     
    		case TT_Coast_ER:
     
    		case TT_Coast_TL:
     
    		case TT_Coast_TR:
     
    		case TT_Coast_BL:
     
    		case TT_Coast_BR:
     
    		case TT_Coast_RTL:
     
    		case TT_Coast_RTR:
     
    		case TT_Coast_RBL:
     
    		case TT_Coast_RBR:
     
    		case TT_Coast_L:
     
    		case TT_Coast_R:
     
    		case TT_Coast_B:
     
    		case TT_Coast_T:
     
    		case TT_Coast_H:
     
    		case TT_Coast_V:
     
    		case TT_Coast_T_L:
     
    		case TT_Coast_T_B:
     
    		case TT_Coast_T_R:
     
    		case TT_Coast_T_T:
     
    		case TT_Coast_T_TL:
     
    		case TT_Coast_T_TR:
     
    		case TT_Coast_T_BL:
     
    		case TT_Coast_T_BR:
     
    		case TT_Coast_T_LT:
     
    		case TT_Coast_T_RT:
     
    		case TT_Coast_T_LB:
     
    		case TT_Coast_T_RB:
     
    		case TT_Coast_X:
     
    		case TT_Coast_XL:
     
    		case TT_Coast_XR:
     
    		case TT_Coast_XB:
     
    		case TT_Coast_XT:
     
    		case TT_Coast_XTL:
     
    		case TT_Coast_XTR:
     
    		case TT_Coast_XBL:
     
    		case TT_Coast_XBR:
     
    		case TT_Coast_XTLBR:
     
    		case TT_Coast_XBLTR:
     
    		case TT_Sea:
     
    		case TT_Sea_TL:
     
    		case TT_Sea_TR:
     
    		case TT_Sea_BL:
     
    		case TT_Sea_BR:
     
    		case TT_Road_H:
     
    		case TT_Road_V:
     
    		case TT_Road_TL:
     
    		case TT_Road_TR:
     
    		case TT_Road_BL:
     
    		case TT_Road_BR:
     
    		case TT_Road_T_L:
     
    		case TT_Road_T_B:
     
    		case TT_Road_T_R:
     
    		case TT_Road_T_T:
     
    		case TT_Road_X:
     
    		case TT_River_H:
     
    		case TT_River_V:
     
    		case TT_River_T_L:
     
    		case TT_River_T_R:
     
    		case TT_River_T_T:
     
    		case TT_River_T_B:
     
    		case TT_River_TL:
     
    		case TT_River_TR:
     
    		case TT_River_BL:
     
    		case TT_River_BR:
     
    		case TT_River_See_T:
     
    		case TT_River_See_B:
     
    		case TT_River_See_L:
     
    		case TT_River_See_R:
     
    		case TT_River_X:
     
    			return 0;
     
    			break;
     
    		case TT_Plain:
     
    		case TT_Reef:
     
    			return 1;
     
    			break;
     
    		case TT_Tree:
     
    			return 2;
     
    			break;
     
    		case TT_Red_Factory:
     
    		case TT_Red_Port:
     
    		case TT_Red_Airport:
     
    		case TT_Red_City:
     
    		case TT_Blue_Factory:
     
    		case TT_Blue_Port:
     
    		case TT_Blue_Airport:
     
    		case TT_Blue_City:
     
    		case TT_Green_Factory:
     
    		case TT_Green_Port:
     
    		case TT_Green_Airport:
     
    		case TT_Green_City:
     
    		case TT_Yellow_Factory:
     
    		case TT_Yellow_Port:
     
    		case TT_Yellow_Airport:
     
    		case TT_Yellow_City:
     
    		case TT_Neutral_Factory:
     
    		case TT_Neutral_Port:
     
    		case TT_Neutral_Airport:
     
    		case TT_Neutral_City:
     
    			return 3;
     
    			break;
     
    		case TT_Mountain_1:
     
    		case TT_Mountain_2:
     
    		case TT_Red_HQ:
     
    		case TT_Blue_HQ:
     
    		case TT_Green_HQ:
     
    		case TT_Yellow_HQ:
     
    			return 4;
     
    			break;
     
    	}


    Si ton ordre est bien fait tu ne peux pas juste utiliser quelques <, > ?

    Jc

  16. #56
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    - Si je passe de terrain ('w') aux unités ('q'), j'aimerai le faire directement. Pour l'instant t'oblige qu'on séléctionne et qu'on aille vers l'autre...
    Ouep, cela serai bien ...

    Oui je pense que tu peux changer les options.
    Je crois que je suis deja en W4 (plus grand niveau de Warnings de VS ...)

    Si ton ordre est bien fait tu ne peux pas juste utiliser quelques <, > ?
    Ceci est a revoir, c'est sur ( je fais quand meme du code bien pourri ).
    J'ai comme projet de faire les chargement des parametre par les fichiers, mais depuis que j'ai repris l'universite, je remarque que je manque de temps pour tout faire ...
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  17. #57
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Enfin je peux retravailler un peu sur ce projet. L'université me prend tout le reste du temps.
    Du coup, ici, je vais décrire que deux tout petits changement.

    Si je passe de terrain ('w') aux unités ('q'), j'aimerai le faire directement. Pour l'instant t'oblige qu'on sélectionne et qu'on aille vers l'autre...
    C'est intégré et ça marche mieux que prévu (je m'attendais à voir des bugues sur certaines conditions, mais non)

    Deuxième changement:
    Pour ce qui avait essayé le jeu avec une grande résolution (je suis certainement le seul ) les TileBar sont lentes. Ceci était du au fait que la vitesse d'animation (X et Y) pour les barres étaient statique malgré le changement de résolution.
    Maintenant, les vitesse sont générés à la volée selon la résolution.

    Pour la prochaine fois, j'espère mettre en place:
    - Autotools pour la compilation Linux (et correction de tout les warnings, dans un second temps)
    - Chargements des paramètres des tuiles, à l'aide d'un fichier externe (pour m'enlever mes gros switch). (@fearyourself: Je vais regarder votre code pour comprendre la lecture des fichier 'LineParser' si je me rappelle bien. Je risque de m'en inspiré si cela me plait assez :p)

    Voilà pour aujourd'hui, demain je pense avoir une heure de plus, donc peut être les autotools (bien que ce ne soit pas le truc le plus facile).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  18. #58
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Citation Envoyé par LittleWhite Voir le message
    C'est intégré et ça marche mieux que prévu (je m'attendais à voir des bugues sur certaines conditions, mais non)


    Pour ce qui avait essayé le jeu avec une grande résolution (je suis certainement le seul ) les TileBar sont lentes. Ceci était du au fait que la vitesse d'animation (X et Y) pour les barres étaient statique malgré le changement de résolution.
    Maintenant, les vitesse sont générés à la volée selon la résolution.
    Oui j'ai aussi des effets comme cela qu'il va falloir que je gére. En principe, on le gére en définissant le temps de l'animation, avec cela on calcule le (dx,dy) de l'animation.
    Tu l'as fait comment?

    - Autotools pour la compilation Linux (et correction de tout les warnings, dans un second temps)
    Il faut aussi que je fasse ca (autotools, pas les warnings, j'en ai pas (ou juste deux "parameter unused")

    - Chargements des paramètres des tuiles, à l'aide d'un fichier externe (pour m'enlever mes gros switch). (@fearyourself: Je vais regarder votre code pour comprendre la lecture des fichier 'LineParser' si je me rappelle bien. Je risque de m'en inspiré si cela me plait assez :p)
    Vas-y, c'est une classe simpliste qui risque un jour de passer à une version plus "xml" d'ailleurs.

    Jc

  19. #59
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Citation Envoyé par fearyourself Voir le message

    Oui j'ai aussi des effets comme cela qu'il va falloir que je gére. En principe, on le gére en définissant le temps de l'animation, avec cela on calcule le (dx,dy) de l'animation.
    Tu l'as fait comment?
    Methode naive . Je n'ai pas change le temps des animations, juste la vitesse de celles ci. Pourquoi? Simplement car je considere que mes animations sont juste (synchronisation a 15 FPS), et puis, la TileBar (et autre) ont des tailles qui varie selon la resolution. Du coup, changer la frequence d'animation est un mauvais choix. Donc j'ai applique une vitesse (qui est variable selon la resolution du moment):
    http://code.google.com/p/openawars/s...ileBar.cpp#122
    Cette variable a ete applique dans le fonction update() (qui jusque la, n'utilisait que des constantes, en dur.
    Pour les divisions, j'ai juste pris la resolution actuelle, et j'ai fait, grace a une regle de trois, le calcul pour retrouver la vitesse que j'avais en dur.

    Vas-y, c'est une classe simpliste qui risque un jour de passer à une version plus "xml" d'ailleurs.

    Jc
    Merci
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  20. #60
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Premier changement: l'intégration d'un décalage de la carte pour qu'elle soit centrée sur l'écran.
    Comme vous avez pu remarquer, à cause du redimensionnement des sprites, la carte ne remplit pas l'extrême droite.
    La solution que j'utilise est de décaler la carte légèrement sur la droite, pour que l'on est deux petites bandes noirs des deux cotés.
    Même si le fossé n'existe pas sur les cotés haut / bas, la modification prend aussi en compte ce cas là.
    La modification est fait dans le Scaler. En effet, je vais calculer le décalage à appliquer directement lorsque je connaitrai le facteur de redimensionnement.
    Voici le calcul du décalage
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    offset.x = (win.getWidth() - (static_cast<unsigned int>(xScaleFactor * TILE_DEFAULT_WIDTH) * MAP_MIN_WIDTH ))/2;
    offset.y = (win.getHeight() - (static_cast<unsigned int>(yScaleFactor * TILE_DEFAULT_HEIGHT) * MAP_MIN_HEIGHT))/2;
    qui est appliqué lors du dessin de la carte . (On peut voir le résultat en capture d'écran )

    Maintenant je me suis attaqué à refaire le système de compilations pour les systèmes GNU/Linux et UNIX (et un peu tout ceux qui ont un système de Makefile)
    Comme je l'avais dit dans mon premier message, j'utilise les autotools, qui permettent de faire des fichiers Makefile multi plateforme, et des script configure qui crée ces makefiles.
    J'ai suivi principalement ce tutoriel: http://ymettier.free.fr/articles_lma...75/lmag75.html ainsi que la documentation officielle.

    Le principe, c'est de crée le fichier configure.ac (inclut sur le SVN maintenant) et quelques fichiers Makefile.am.
    Le configure.ac donne des indications pour faire le script 'configure'. Pour crée les Makefiles, le fichier configure.ac est aussi utilisé avec les fichier Makefile.am qui donne des règles complémentaires pour le Makefile final.
    Voici mon fichier configure.ac actuel:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
     
    #                                               -*- Autoconf -*-
    # Process this file with autoconf to produce a configure script.
     
    AC_PREREQ([2.65])
    AC_INIT(OpenAWars, 0.1, http://code.google.com/p/openawars/issues/list)
    AM_INIT_AUTOMAKE([-Wall])
    AC_CONFIG_SRCDIR([Sources/main.h])
     
    # Checks for programs.
    AC_PROG_CXX
    AC_PROG_CC
     
    # Checks for libraries.
    AC_SEARCH_LIBS(SDL_Init, SDL, [], [
    	AC_MSG_ERROR([SDL is needed for this project])
    ])
     
    AC_SEARCH_LIBS(IMG_Init, SDL_image, [], [
    	AC_MSG_ERROR([SDL_image is needed for this project])
    ])
    AC_SEARCH_LIBS(TTF_Init, SDL_ttf, [], [
    	AC_MSG_ERROR([SDL_ttf is needed for this project])
    ])
     
     
    # Checks for header files.
    AC_PATH_X
    AC_FUNC_ALLOCA
    AC_CHECK_HEADERS([inttypes.h malloc.h memory.h stddef.h stdint.h stdlib.h string.h strings.h])
     
    # Checks for typedefs, structures, and compiler characteristics.
    AC_HEADER_STDBOOL
    AC_TYPE_INT16_T
    AC_TYPE_INT32_T
    AC_TYPE_INT64_T
    AC_TYPE_INT8_T
    AC_TYPE_SIZE_T
    AC_TYPE_UINT16_T
    AC_TYPE_UINT32_T
    AC_TYPE_UINT64_T
    AC_TYPE_UINT8_T
    AC_CHECK_TYPES([ptrdiff_t])
     
    # Checks for library functions.
    AC_FUNC_MALLOC
     
    CPPFLAGS="$CPPFLAGS -Wall -Wextra"
     
    AC_CONFIG_FILES([
            Makefile
            Sources/Makefile
            ])
     
     
    AC_OUTPUT
    La moitié à été auto généré. Car les autotools simplifie énormément la tache, et permette même de faire des paquets pour la redistribution du programme.
    Le premier fichier Makefile.am est le suivant:
    Qui indique simplement où est le makefile intéressant .
    Le Makefile intéressant est le suivant:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
     
    bin_PROGRAMS = OpenAWars_Editor
    OpenAWars_Editor_SOURCES = 	Engine/Window.cpp Engine/Window.h \
    				Engine/Renderer.cpp Engine/Renderer.h \
    				Engine/Sprite.cpp Engine/Sprite.h \
    				Engine/AnimatedSprite.cpp Engine/AnimatedSprite.h \
    				Engine/VTime.cpp Engine/VTime.h \
    				Engine/Font.cpp Engine/Font.h \
    				Engine/Renderers/Renderer_sdl.cpp Engine/Renderers/Renderer.sdl.h \
    				Engine/Renderers/Renderer_opengl.cpp Engine/Renderers/Renderer_opengl.h \
    				Engine/ResourcesManager/SpriteManager.cpp Engine/ResourcesManager/SpriteManager.h \
    				Engine/ResourcesManager/FontManager.cpp Engine/ResourcesManager/FontManager.h \
    				Engine/Controls/Keyboard.cpp Engine/Controls/Keyboard.h \
    				Game/Tile.cpp Game/Tile.h Game/Map.cpp Game/Map.h Game/MapEditor.cpp Game/MapEditor.h \
    				Game/Cursor.cpp Game/Cursor.h Game/EditingCursor.cpp Game/EditingCursor.h \
    				Game/Camera.cpp Game/Camera.h \
    				Game/Unit.cpp Game/Unit.h \
    				Game/EditorEngine.cpp Game/EngitorEngine.h \
    				Utils/Logger.cpp Utils/Logger.h \
    				Utils/Scaler.cpp Utils/Scaler.h \
    				UI/TileBar.cpp UI/TaileBar.h UI/TileBarTiles.cpp UI/TileBarTiles.h UI/TileBarUnits.cpp UI/TileBarUnits.h \
    				UI/TileViewer.cpp UI/TileViewer.h \
    				main_editor.cpp main_editor.h globals.h
    OpenAWars_Editor_CPPFLAGS = -DEDITOR
    Qui indique les fichiers à compiler, le programme de sortie à faire et quelques (une) options à appliquer.

    Après, pour généré le script 'configure' et les Makefiles de base (et non finaux), il faut appliquer les commandes suivantes:
    aclocal
    autoconf
    automake --add-missings -c
    Automake se révèle assez pénible sur les fichiers qui manque, et je crois qu'il en manque encore quelques uns sur le SVN. Mais bon, comme habituellement je ne fais qu'un 'touch' pour les crée, il n'y a pas vraiment d'importance à les mettre.
    Finalement (une fois que automake réussi sans se plaindre)
    On peut faire les commandes classiques archi connues:
    ./configure
    make
    make install
    D'ailleurs, je n'ai jamais essayé le make install mais bon, le binaire sera dans le dossier source. Et ça marche \o/

    Bien sur, mes fichiers de configuration de système de fabrication sont loin d'être bon, ni efficace, mais pour le moment, cela fait ce qu'on demande . Après il faudra rajouter des options, il faudra aussi faire en sorte que l'on puisse construire le jeu + l'éditeur ...

    Voilà
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

Discussions similaires

  1. [Projet en cours] Strategy(nom provisoire) - Advance wars like
    Par TiranusKBX dans le forum Projets
    Réponses: 17
    Dernier message: 29/09/2016, 16h46
  2. [VB6] [ADO] Like sur base Access
    Par dlpxlid dans le forum VB 6 et antérieur
    Réponses: 9
    Dernier message: 24/01/2003, 12h03
  3. Créer un interpréteur de langage inspiré du Basic
    Par Picasso dans le forum Algorithmes et structures de données
    Réponses: 4
    Dernier message: 11/05/2002, 18h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo