Aide pour un projet en C++

Salut!
mon problème est dans ces trois classe...Player.cc qui ne m'affiche pas l'état du jouer, Setup.cc qui est appele dans jouer donc à le mème problème et dans ConfigFile.cc qui e lit jamais le ficher...
Ciao valde

Bonjour!
ça est ce que j'ai fait et ce qui mon donnée pour faire ce projet...
si vous voulez voir le site du projet lee site c'est cowww.epfl.ch/infgmel/et pas www. etc...salut et merci!
--------------------------------------------------------------------------------

#include <vector>
#include <iostream>
#include "Setup.h"
#include "Player.h"
#include "ConfigFile.h"
using namespace std;

//constructeur de la classe Setup

Setup::Setup(vector<Player>players, int difficulty)
{
int nbrplayer=2;
for(int o(0);o<nbrplayer;o++)
{
players.push_back(o);
}
this->difficulty=difficulty;
for(int i(0);i < players.size();i++)
{
this->players[i]=players[i];
};

}

//constructeur de copie de la même classe

Setup::Setup(const Setup& setup)
{

this->difficulty=setup.difficulty;

for(int j(0);j<players.size();j++)
{
this->players[j]=Setup.players[j];
};

}

//ici on surcharge l'operateur d'affectation (=)

Setup& Setup::operator=(const Setup& setup)
{
difficulty=setup.difficulty;

for(int k(0);k<players.size();k++)
{
players[k]=Setup.players[k];
};
}

//on défini le getter de la liste des joueurs

vector<Player>& Setup::getPlayers(){return players;}

//on défini le getter de la difficulte

int Setup::getDifficulty(){return difficulty;}

//on défini le set de la difficulte

void Setup::setDifficulty(int diff){difficulty=diff;}

//ici on surcharge l'operateur d'affichage (<<)

Setup ostream& Setup::operator<<(ostream& out, const Setup& setup)
{
out << "La difficulte est " << setup.difficulty << endl;
for(int l(0);l<players.size();l++)
{
out << setup.players[l] << endl;
};

return out;
}

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

#include "ConfigFile.h"
#include <iterator>

//constructeur
ConfigFile::ConfigFile(string fileName)
{
//ce methode va lire dans le fichier et "construit" la Map
ifstream read;
read.open(fileName.c_str());
if (read.fail())
{ cout << "Impossible to read" << fileName << endl; }
else
{
string cle;
string inutile;
string val;

while (!read.eof())
{read >>cle>>inutile>>val;
Map[cle] = atof(val.c_str());}
}
}

//Renvoi la valeur reél associe à la clef " name"

double ConfigFile::doubleValueOf(string name)
{
return Map.find(name)->second;
}

//Renvoi la valeur entier associe à la clef " name"

int ConfigFile::intValueOf(string name)
{
return (int)Map.find(name)->second;
}

//ça sert à faire retourner la table de définition

map<string, double> ConfigFile::getMap() const
{
return Map;
}

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

#ifndef __CONFIGFILE_H__
#define __CONFIGFILE_H__ 1

#include <iostream>
#include <fstream>
#include <string>
#include <map>

using namespace std;

// La classe ConfigFile permet d'aller lire un fichier de configuration.

class ConfigFile
{
public:
// constructeur
ConfigFile(string fileName);
// destructeur
~ConfigFile() {}

// retourne le double associé à la clef "name"
double doubleValueOf(string name);
// retourne l'entier associé à la clef "name"
int intValueOf(string name);
// retourne la table de définition
map<string, double> getMap() const;
// surcharge externe de l'opérateur <<
friend ostream& operator<<(ostream& sortie, const ConfigFile& config)
{
sortie << "Contenu de ConfigFile :" <<endl;
//parcours toute la table de définition à l'aide d'un itérateur => cours 18
for (map<string, double>::iterator mapIt(config.getMap().begin());
mapIt!=config.getMap().end(); mapIt++)
{
sortie << "\t" <<mapIt->first <<"="<< mapIt->second<< endl;
}

return sortie;
}

private:
// déclaration de la map
map <string, double> Map;
//declaration de la string qui est le nom du fichier de lecture
string fileName;

};

#endif

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

#include "GameScreen.h"

using namespace std;

// ça défini le getteur de l'hauteur
double GameScreen::getHeight()

{return height;}
//ça défini le getteur de largeur
double GameScreen:: getWidth()
{return width;}

//ça défini le constructeur
GameScreen::GameScreen(double width, double height)
{
this->width=width;
this->height=height;
}
//ça défini le constructeur de copie
GameScreen::GameScreen(const GameScreen& GameScreen)
{
height=GameScreen.height;

width=GameScreen.width;
}

//ça défoni la surcharge de =
GameScreen& GameScreen::operator=(const GameScreen& GameScreen)
{
this->height=GameScreen.height;
this->width=GameScreen.width;
return(*this);
}

//ça défini la surcharge de <<
ostream& operator<<(ostream& cout , const GameScreen& GameScreen)
{
cout << "L ecran a une hauteur de " << GameScreen.height << " pixels et une largeur de " << GameScreen.width << " pixels." << endl;
return cout;
}

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

#ifndef __GAME_SCREEN_H__
#define __GAME_SCREEN_H__ 1

#include <iostream>

using namespace std;

class GameScreen
{
public:
// constructeur
GameScreen(double width, double height);
// constructeur de copie
GameScreen(const GameScreen& GameScreen);
// destructeur
~GameScreen() {}

// surcharge de l'opérateur d'affectation
GameScreen& operator=(const GameScreen& gameScreen);

// retourne la hauteur
double getHeight();
// retourne la largeur
double getWidth();
// surcharge externe de l'opérateur <<
friend ostream& operator<<(ostream& cout, const GameScreen& GameScreen);

private:
//décalaration des variables
double height;
double width;
};

#endif

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

## MAKEFILE POUR LE PROJET SPACEROCK

CFLAGS = -g -Wall `pkg-config gtk+-2.0 --cflags`
CXXFLAGS = -g -Wall `pkg-config gtk+-2.0 --cflags` -I/usr/local/mysql/include/mysql
DB_LIBS = -L/usr/local/mysql/lib/mysql -lmysqlclient
CC = gcc
CXX = g++
GL_LIBS = /usr/openwin/lib/libGL.so.1 /usr/openwin/lib/libGLU.so.1
GLUT_DIR = /home/infgmel3/projet/demo
GLUT_LIBS = $(GLUT_DIR)/libglut.so -lXmu -lXext -lXi -lX11 -lm
INFGMELHOME = /home/infgmel/pub/projet

# objets de base
BASEHDRS = ConfigFile.h GameScreen.h Player.h Scores.h Setup.h
BASEOBJS = ConfigFile.o GameScreen.o Player.o Scores.o Setup.o

PARTICLEOBJS = Particle.o Foe.o Friend.o Ship.o Bullet.o Rock.o ParticleType.o
PARTICLEHDRS = Particle.h Foe.h Friend.h Ship.h Bullet.h Rock.h

GLLHDRS = gll/gllSprite.h gll/gllProcess.h gll/gllFont.h gll/gllLibrary.h gll/gllTextures.h gll/gllBMParser.h
GLLOBJS = gll/gllSprite.o gll/gllProcess.o gll/gllFont.o gll/gllLibrary.o gll/gllTextures.o gll/gllBMParser.o

## COMMANDE PAR DEFAUT: tout construire
all: test_base test_particle sprite level SpaceRock

## MAKE SPACEROCK: pour construire le programme SpaceRock
SpaceRock: gllib $(BASEOBJS) $(PARTICLEOBJS) Game.o Level.o SetupPanel.o SpaceRock.o
$(CXX) $(CXXFLAGS) $(GL_LIBS) $(GLUT_LIBS) $(DB_LIBS) $(BASEOBJS) $(PARTICLEOBJS) $(GLLOBJS) Game.o Level.o\
$(INFGMELHOME)/objs/Database.o SetupPanel.o SpaceRock.o -o SpaceRock

## NETTOYAGE
clean:
rm -f core gll/*.o
rm -f core *.o SpaceRock test_base test_particle test_sprite test_level

## MAKE BASE: pour construire le programme test_base
test_base: $(BASEOBJS) test_base.o
$(CXX) $(CXXFLAGS) $(BASEOBJS) test_base.o -o test_base
test_base.o: $(BASEHDRS) test_base.cc

## MAKE PARTICLE: pour construire le programme test_particle
## attention, ce programme ne compilera plus tel quel lorsque vous aurez implémenté gllSprite
test_particle: $(PARTICLEOBJS) test_particle.o
$(CXX) $(CXXFLAGS) $(PARTICLEOBJS) $(BASEOBJS) test_particle.o -o test_particle
test_particle.o: $(PARTICLEHDRS) ConfigFile.h test_particle.cc

## MAKE SPRITE: pour construire le programme test_sprite
sprite: gllib $(BASEOBJS) $(PARTICLEOBJS) test_sprite.o
$(CXX) $(CXXFLAGS) $(GL_LIBS) $(GLUT_LIBS) $(GLLOBJS) $(BASEOBJS) $(PARTICLEOBJS) test_sprite.o -o test_sprite
test_sprite.o: $(BASEHDRS) $(PARTICLEHDRS) $(GLLHDRS) test_sprite.cc

## MAKE LEVEL: pour construire le programme test_level
level: gllib $(BASEOBJS) $(PARTICLEOBJS) Level.o test_level.o
$(CXX) $(CXXFLAGS) $(GL_LIBS) $(GLUT_LIBS) $(BASEOBJS) $(PARTICLEOBJS) $(GLLOBJS) Level.o test_level.o -o test_level
test_level.o: $(BASEHDRS) Particle.h $(GLLHDRS) test_level.cc

## REGLES POUR GLLIB
gllib: $(GLLOBJS)
gll/gllSprite.o: gll/gllSprite.cc $(GLLHDRS)
gll/gllProcess.o: gll/gllProcess.cc $(GLLHDRS)
gll/gllFont.o: gll/gllFont.cc $(GLLHDRS)
gll/gllLibrary.o: gll/gllLibrary.cc $(GLLHDRS)
gll/gllBMParser.o: gll/gllBMParser.cc $(GLLHDRS)
gll/gllTextures.o: gll/gllTextures.cc $(GLLHDRS)

## REGLES POUR LES FICHIERS STANDARDS
Bullet.o: Bullet.cc $(PARTICLEHDRS)
ConfigFile.o: ConfigFile.cc ConfigFile.h
Game.o: Game.cc Game.h $(BASEHDRS) $(PARTICLEHDRS) $(GLLHDRS)
GameScreen.o: GameScreen.cc GameScreen.h
Foe.o: Foe.cc Foe.h Particle.h
Friend.o: Friend.cc Friend.h Particle.h Player.h
Level.o: Level.cc Level.h GameScreen.h $(PARTICLEHDRS) $(GLLHDRS)
Particle.o: Particle.cc Particle.h GameScreen.h
ParticleType.o: ParticleType.cc ParticleType.h
Rock.o: Rock.cc Rock.h Particle.h ParticleType.h Foe.h ConfigFile.h
Player.o: Player.cc Player.h
Setup.o: Player.h Setup.h Scores.h ConfigFile.h Setup.cc
Scores.o: Player.h Setup.h Scores.h Scores.cc
SetupPanel.o: SetupPanel.cc SetupPanel.h Game.h
Ship.o: Ship.cc Ship.h Particle.h Friend.h ParticleType.h ConfigFile.h
SpaceRock.o: SpaceRock.cc Game.h SetupPanel.h HighScores.h $(INFGMELHOME)/include/Database.h

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

#include "Particule.h"
#include <cmath>
using namespace std;

//constructeur
Particule::Particule(double coordx, double coordy, double vitesse, double direction,
double taille, double angleRotation,
GameScreen* ecran)
{
this->coordx = coordx;
this->coordy = coordy;
this->vitesse = vitesse;
this->direction = direction;
this->taille = taille;
this->angleRotation = angleRotation;
this->ecran = ecran;
}

//les getteurs:
double Particule::getCoordx(){return coordx;}
double Particule::getCoordy(){return coordy;}
double Particule::getVitesse(){return vitesse;}
double Particule::getDirection(){return direction;}
double Particule::getTaille(){return taille;}
double Particule::getAngleRotation(){return angleRotation;}
GameScreen* Particule::getEcran(){return ecran;}

//setteurs:
void Particule::setCoordx(double coordx){this->coordx = coordx;}
void Particule::setCoordy(double coordy){this->coordy = coordy;}
void Particule::setVitesse(double vitesse){this->vitesse = vitesse;}
void Particule::setDirection(double direction){this->direction = direction;}
void Particule::setTaille(double taille){this->taille = taille;}
void Particule::setAngleRotation(double angleRotation){this->angleRotation = angleRotation;}
void Particule::setEcran(GameScreen* ecran){this->ecran = ecran;}

//collision!!
bool Particule::Collision(Particule& a)
{
double distance;
distance = sqrt(pow(a.coordx-this->coordx , 2)+pow(a.coordy-this->coordy , 2));
if (distance<= ((0.8)*(a.taille+this->taille)))
return true;
else
return false;
}
//step
void Particule::Step (double t)
{
double deplacex;
double deplacey;

deplacex =coordx+ vitesse*t*cos(direction);

if ((deplacex) >(*ecran).getWidth())
coordx =deplacex-(*ecran).getWidth();
else if (deplacex < 0)
coordx = deplacex + (*ecran).getHeight();
else
coordx= deplacex;

deplacey = coordy +vitesse*t*sin(direction);

if (deplacey > (*ecran).getHeight())
coordy = deplacey - (*ecran).getHeight();
else if (deplacey<0)
coordy = deplacey + (*ecran).getHeight();
else
coordy = deplacey;
}

//surcharge externe de <<

ostream& operator << (ostream& out, const Particule* particle)
{
out << (*particle).coordx << (*particle).coordy;
out << (*particle).vitesse << (*particle).direction << (*particle).taille;
out << (*particle).angleRotation << (*particle).ecran <<endl;
}

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

#include <iostream>
#include "GameScreen.h"

using namespace std;

class Particule
{protected:
//Constructeur et distructeur
Particule(double coordx, double coordy, double vitesse, double direction,
double taille, double angleRotation,
GameScreen* ecran);
~Particule(){}
//getteurs:
double getCoordx();
double getCoordy();
double getVitesse();
double getDirection();
double getTaille();
double getAngleRotation();
GameScreen* getEcran();

//et les setteurs
void setCoordx(double coordx);
void setCoordy(double coordy);
void setVitesse(double vitesse);
void setDirection(double direction);
void setTaille(double taille);
void setAngleRotation(double angleRotation);
void setEcran(GameScreen* ecran);

//methodes particuliérs:

//collision entre deux particules
bool Collision(Particule& a);

//step:celui qui calcule la nouvelle position, angluation, ecc
virtual void Step(double t);

//display qui est virtuel
virtual ostream& display (ostream& out)const =0;

//methodes Virtuelles:isFriend et getType
virtual bool isFriend();
virtual int getType();

//fonction virtuelle qui affichera:

virtual ostream display (ostream& out);

//surcharge externe de l'operateur <<

friend ostream& operator<< (ostream& , const Particule*);

private:
//declaration des attributs
//coordonnes
double coordx;
double coordy;
//vitesse linéaire
double vitesse;
//direction de mouvement
double direction;
//rayon de la taille de la particule
double taille;
//vitesse de rotation
double angleRotation;
//pointer sur l'ecran
GameScreen* ecran;

};

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

#include "ParticleType.h"

ParticleType::ParticleType (){
Ship = 0 ;
Bullet = 1 ;
Rock = 2 ; }

bool ParticleType::isShip (int Var)
{

if ( Var == 0 )
return true;
else
return false;
}
bool ParticleType::isBullet (int Var)
{
if (Var == 1)
return true;
else
return false;
}
bool ParticleType::isRock (int Var)
{
if (Var ==2)
return true;
else
return false;

}

// getteur

int ParticleType::getShip ()
{
return 0;
}

int ParticleType::getBullet ()
{
return 1;
}

int ParticleType::getRock ()
{
return 2;
}

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

#include <iostream>
using namespace std;

class ParticleType
{

public:
//constructeur
ParticleType();

// vérificateur

bool isShip (int Var);
bool isBullet(int Var);
bool isRock(int Var);

//déclaration de getteurs

int getShip ();
int getBullet();
int getRock();

protected:

// attribution d'un éntier au trois type de particule

int Ship ;
int Bullet ;
int Rock ;
};

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

#include "Player.h"
#include <iostream>
#include <string>
using namespace std;

//constructeur de la classe Player

Player::Player(string name, Scores* scores)
{

this->name=name;
this->scores= new(Scores);
this->scores = scores;
}

//constructeur de copie de la classe Player

Player::Player(const Player& player)
{
this->name=player.name;
this->scores=player.scores;
}

//destructeur de la classe Player

Player::~Player()
{
delete scores;
}

//ici on fait une surcharge de l operateur =

Player& Player::operator=(const Player& player)
{
this->name=player.name;
this->scores=player.scores;
}

// killer du player

void Player::setAlive(bool alive)
{
this->alive=alive;
}

//assigne un nom au joueur

string Player::getName(){return name;}

// verifeie si le vasseau du jouer est en vie

bool Player::isAlive()
{
return alive;
}

//retourne l'objet scores

Scores* Player::getScores(){return scores;}

//definition de l'attribut scores

void Player::setScores(Scores* s)
{ scores=s;}

// surcharge d'operateur <<
ostream& operator<<(ostream& out,const Player& player)
{ out << "Nom du joueur " << player.name << endl << player.scores << endl;
return out;
}

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

#ifndef __PLAYER_H__
#define __PLAYER_H__ 1

#include <string>
#include <iostream>
#include "Scores.h"

using namespace std;

class Player
{
public:
// constructeur
Player(string name, Scores* scores = new Scores());
// constructeur de copie
Player(const Player& player);
// destructeur
~Player();

// surchage interne de l'opérateur d'affectation
Player& operator=(const Player & player);

// indique que le vaisseau du joueur est mort
void setAlive(bool alive);
// verifie si le vaisseau du joueur est en vie
bool isAlive();
// retourne le nom du joueur
string getName();
// retourne l'objet Scores
Scores* getScores();
// definit l'attribut scores
void setScores(Scores* s);
// surcharge externe de <<
friend ostream& operator<<(ostream& out, const Player& player);

private:
//déclaration des variables
string name;
bool alive;
Scores* scores;
};
#endif

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

#include "Scores.h"
#include <iostream>
using namespace std;

// Constructeur de la classe scores

Scores::Scores(int lastLevelReached, int score)
{
this->lastLevelReached=lastLevelReached;
this->score=score;
}

//constructeur par defaut de la classe scores

Scores::Scores(){}

//constructeur de copie tousjours de la classe scores

Scores::Scores(const Scores& scores)
{
this->lastLevelReached=scores.lastLevelReached;
this->score=scores.score;
}

//ici on surcharge l'operateur d'affectation (=)

Scores& Scores::operator=(const Scores& scores)
{
this->lastLevelReached=scores.lastLevelReached;
this->score=scores.score;
return(*this);
}

//on définit le getter du dernier niveau atteint

int Scores::getLastLevelReached(){return lastLevelReached;}

//on définit le set du niveau atteint

void Scores::setLastLevelReached(int lastLevelReached){this->lastLevelReached=lastLevelReached;}

//on définit le getter du score

int Scores::getScore(){return score;}

//on définit le set du score

void Scores::setScore(int score){this->score=score;}

//ici on surcharge l' operateur d'affichage (<<)

ostream& operator<<(ostream& out, const Scores& scores)
{
out << "Scores: " << scores.score << endl << "Dernier niveau atteint: "
<< scores.lastLevelReached << endl;
return out;
}

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

#ifndef __SCORES_H__
//Pour verifier qu'il n'y ait qu'une inclusion du fichier.
#define __SCORES_H__ 1

#include <iostream>

using namespace std;

/*
* Cette classe contient toutes les informations sur les scores
* d'un joueur:
* - son niveau maximum atteint a cette partie;
* - son score.
*/

class Scores
{
public:
// constructeur
Scores(int lastLevelReached, int score);
//constructeur par defaut
Scores();
// constructeur de copie
Scores(const Scores& scores);
// destructeur
~Scores();

// operateur d'affectation.
Scores& operator=(const Scores& scores);

// retourne le niveau maximal atteint
int getLastLevelReached();
// met à jour le dernier niveau atteint
void setLastLevelReached(int lastLevelReached);
// retourne le score
int getScore();
// met à jour le score
void setScore(int score);
// surcharge externe de <<
friend ostream& operator<<(ostream& out, const Scores& scores);

private:
//déclaration des variables
int lastLevelReached;
int score;
};
#endif

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

#include <vector>
#include <iostream>
#include "Setup.h"
#include "Player.h"
#include "ConfigFile.h"
using namespace std;
//constructeur de la classe Setup

Setup::Setup(vector<Player>players, int difficulty)
{
this-> players=players;
this-> difficulty=difficulty;
}

//constructeur de copie de la même classe

Setup::Setup(const Setup& setup)
{

this->difficulty=setup.difficulty;

for(int j(0);j<players.size();j++)
{
this->players[j]=Setup.players[j];
};

}

//ici on surcharge l'operateur d'affectation (=)

Setup& Setup::operator=(const Setup& setup)
{
difficulty=setup.difficulty;

for(int k(0);k<players.size();k++)
{
players[k]=Setup.players[k];
};
}

//on défini le getter de la liste des joueurs

vector<Player>& Setup::getPlayers(){return players;}

//on défini le getter de la difficulte

int Setup::getDifficulty(){return difficulty;}

//on défini le set de la difficulte

void Setup::setDifficulty(int diff){difficulty=diff;}

//ici on surcharge l'operateur d'affichage (<<)

Setup ostream& Setup::operator<<(ostream& out, const Setup& setup)
{
out << "La difficulte est " << setup.difficulty << endl;
for(int l(0);l<players.size();l++)
{
out << setup.players[l] << endl;
};

return out;
}

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

#ifndef __SETUP_H__
#define __SETUP_H__ 1

#include <vector>
#include <iostream>
#include "Player.h"
#include "ConfigFile.h"

using namespace std;

class Setup
{
public:
/*
* Pourquoi utiliser un vecteur de joueurs alors que le jeu en
* possede seulement deux? Tout simplement pour faciliter
* eventuelle extension: si l'on decide soudain que l'on veut
* pouvoir jouer a 4 joueurs, il ne sera pas necessaire de
* modifier le code de gestion de joueurs puisque le vecteur est
* dynamique.
*/
//constructeur
Setup(vector<Player> players, int difficulty);
// constructeur de copie
Setup(const Setup& setup);
// destructeur
~Setup();

// surcharge de l'operateur d'affectation
Setup& operator=(const Setup& setup);

// retourne la liste des joueurs
vector<Player>& getPlayers();
// retourne le niveau de jeu actuel
int getDifficulty();
// definit le niveau de jeu actuel
void setDifficulty(int diff);
// surcharge externe de <<
friend ostream& operator<<(ostream& out, const Setup& setup);

private:
//déclaration des variables
int nbrPlayer;
vector <Player> players;
int difficulty;
};

#endif

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

#include "Scores.h"
#include "Setup.h"
#include "Player.h"
#include "ConfigFile.h"
#include "GameScreen.h"
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
cout << "***Testing GameScreen******************************"<<endl;
GameScreen* gs = new GameScreen(1280,768);
cout << (*gs) << endl;
GameScreen gs_2 = *gs;
cout << "Width= "<<gs_2.getWidth()<<endl;
cout << "height= "<<gs_2.getHeight()<<endl;
cout << gs_2 <<endl;
cout << "***End Testing GameScreen**************************\n\n"<<endl;

cout << "***Testing Scores******************************"<<endl;
Scores score(3,500);
cout << score<<endl;
score.setLastLevelReached(10);
score.setScore(1000);
cout << "score.last level:=" << score.getLastLevelReached()<<endl;
cout << "score.score:=" << score.getScore()<<endl;
cout << score<<endl;
Scores score_2=score;
cout << "Score #2= " << score_2<<endl;
cout << "***End Testing Scores**************************\n\n"<<endl;

cout << "***Testing Player******************************"<<endl;
Scores* score_3= new Scores(score_2);
Player player("Vincent",score_3);
cout << player<<endl;
Player player_1=player;
cout << "Player #1" << player_1 <<endl;
Player player_2("Basile",player.getScores());
player_2.setAlive(false);
cout << "Player #2 " <<"state:=" << player_2.isAlive()<<endl;
cout << "Player #2 " <<"name:=" <<player_2.getName()<<endl;
player_2.setScores(new Scores(5,200));
cout << "Player #2 " <<"score:="<<*player_2.getScores()<<endl;
cout << "Player #2 " <<player_2<<endl;
cout << "***End Testing Player**************************\n\n"<<endl;

cout << "***Testing Setup*******************************"<<endl;
vector<Player> joueurs;
joueurs.push_back(player);
joueurs.push_back(player_2);
Setup setup(joueurs,0);
cout << setup<<endl;

Setup setup_2=setup;
setup_2.setDifficulty(20);
cout <<"Setup #2 " <<setup_2<<endl;

setup.getPlayers()[0].getScores()->setLastLevelReached(8);
cout << "Level =" << setup.getPlayers()[0].getScores()->getLastLevelReached()<<endl;
setup.getPlayers()[0].getScores()->setScore(101);
cout << "Score =" << setup.getPlayers()[0].getScores()->getScore()<<endl;
setup.getPlayers()[0].setAlive(true);
cout << "isAlive =" <<setup.getPlayers()[0].isAlive()<<endl;
cout<<setup<<endl;
cout << "***End Testing Setup***************************\n\n"<<endl;

cout << "***Testing ConfigFile****************************"<<endl;
ConfigFile cf("Rock.conf");
cout << cf;
cout << "Value of damage:= "<<cf.doubleValueOf("damage")<<endl;
cout << "***End Testing ConfigFile************************\n\n"<<endl;
}

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

#include "gll/gllLibrary.h"

#include <iostream>

#include "Setup.h"
#include "Level.h"
#include "GameScreen.h"
#include "Rock.h"
#include "Ship.h"
#include "Bullet.h"

using namespace std;

GameScreen gs(640, 480);
Setup *setup;
Level *level;

// Boucle principale
void test_levelIdleFunc()
{
// A FAIRE : implémenter le comportement de ce processus
double dt = gllTimer(TIMER_GETELAPSEDTIME);
if (dt == 0.0)
{
gllout << gllsetup(16,11,640,480);
gllTimer(TIMER_RESET);
gllTimer(TIMER_START);
}

level->step(dt);

Level::LEVEL_OVER state;
if (state = level->isOver())
{
if (state == Level::ALL_SHIPS_DEAD)
{

delete level;
delete setup;
exit(0);
}
else{
gllTimer(TIMER_STOP);
level = new Level(level);
}

}

// Demande à glut de redessiner la fenêtre graphique
glutPostRedisplay();
}

// Fonction d'affichage
void test_levelDisplayFunc()
{
// Efface le contenu de la fenêtre
glClear(GL_COLOR_BUFFER_BIT);

// A FAIRE : Appeler les fonctions d'affichage
level->show();

// Met à jour le contenu de la fenêtre
glutSwapBuffers();
}

// FONCTION MAIN
int main(int argc, char *argv[])
{
// Processus gllib
gllProcessInformation *pi = new gllProcessInformation();
pi->name = "test_level_process";
pi->realTime = true;
pi->idleFunc = test_levelIdleFunc;
pi->displayFunc = test_levelDisplayFunc;
gllRegisterProcess(pi);

vector<Player> players;
players.push_back(Player("jean-claude"));
players.push_back(Player("popeye"));
setup = new Setup(players, 1);
level = new Level(setup, &gs);

// Démarre gllib
// Le processus donnée en dernier argument sera activé
// Les autres arguments servent à donner un nom à la fenêtre graphique
// ainsi que ses dimensions
gllMainLoop(argc, argv, argv[0], 640, 480, "test_level_process");

return 0;
}

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

#include "Particle.h"
#include "Foe.h"
#include "Friend.h"
#include "Ship.h"
#include "Bullet.h"
#include "Rock.h"
#include "ConfigFile.h"
#include <vector>
#include <iostream>
using namespace std;

//le temps
const double dt=0.5;

int main(int argc, char *argv[])
{
Player* p1 = new Player("Vincent",new Scores(5,100));
Player* p2 = new Player("Basile",new Scores());

cout << "***Testing GameScreen******************************"<<endl;
GameScreen* gs = new GameScreen(1280,768);
cout << (*gs) << endl;
cout << "***End Testing GameScreen**************************\n\n"<<endl;

//contains the particles
vector<Particle *> particles;

cout << "***Testing Ship**********************************"<<endl;
Ship* s1= new Ship(gs,p1);
particles.push_back(s1);
cout << s1 <<endl;
Ship* s2= new Ship(gs,p2);
particles.push_back(s2);
cout << s2 <<endl;
cout << "***End Testing Ship******************************\n\n"<<endl;

cout << "***Testing Bullet**********************************"<<endl;
Bullet* b1= new Bullet(s1,gs);
particles.push_back(b1);
cout << b1 <<endl;
Bullet* b2= new Bullet(s2,gs);
particles.push_back(b2);
cout << b2 <<endl;
cout << "***End Testing Bullet******************************\n\n"<<endl;

cout << "***Testing Rock************************************"<<endl;
// le premier paramètre de Rock est le niveau de difficulté,
// qui est utilisé pour calculer leur vitesse
Rock* r1= new Rock(3,gs);
particles.push_back(r1);
cout << r1 <<endl;
cout << "***End Testing Rock******************************\n\n"<<endl;

cout << "***Testing virtual method step*******************"<<endl;
cout << "Timestamp= "<<dt << endl;
for (int i=0;i<particles.size();i++)
{
particles[i]->step(dt);
if (particles[i]->isFriend())
cout<<"Allie (type "<<particles[i]->getType()<<")=>" ;
else
cout<<"Ennemie (type "<<particles[i]->getType()<<")=>" ;
cout << particles[i] << endl;
}
//fait avancer seulement la particule 0
for (int i=0;i<500;i++)
{
particles[0]->step(dt);
}
cout << particles[0] << endl;
cout << "***End Testing step******************************\n\n"<<endl;

cout << "***Testing method colision***********************"<<endl;
for (int i=0;i<particles.size()-1;i++)
{
if (particles[i]->collision(*particles[i+1]))
cout << "Particles "<<i<< " en collision avec particles "<<i+1<<endl;
if (particles[i]->collision(*particles[i]))
cout << "Particles "<<i<< " en collision avec elle meme "<<endl;

}
cout << "***End Testing collision******************************\n\n"<<endl;

}

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

#include "gll/gllLibrary.h"

#include <iostream>

#include "GameScreen.h"
#include "Rock.h"
#include "Ship.h"
#include "Bullet.h"

using namespace std;

gllSprite sprite(10.0, -1);
double x_pos = 0.0;

GameScreen gs(320, 240);
Rock rock(0, &gs);
Scores scores;
Player player("a_player",&scores);
Ship ship(&gs, &player);
Bullet bullet(&ship, &gs);

// Boucle principale
void test_spriteIdleFunc()
{
// A FAIRE : implémenter le comportement de ce processus
double dt = gllTimer(TIMER_GETELAPSEDTIME);
x_pos += 40.0 * dt;
while (x_pos > 320.0)
x_pos -= 320.0;
sprite.translate(x_pos, 120.0);
rock.step(dt);
ship.step(dt);
bullet.step(dt);

// Demande à glut de redessiner la fenêtre graphique
glutPostRedisplay();
}

// Fonction d'affichage
void test_spriteDisplayFunc()
{
// Efface le contenu de la fenêtre
glClear(GL_COLOR_BUFFER_BIT);

// A FAIRE : Appeler les fonctions d'affichage
glColor4f(0.1,0.3,0.2,0.7);
gllDrawRect(0,20,320,200,-1);

sprite.blit();

rock.blit();
ship.blit();
bullet.blit();

// Met à jour le contenu de la fenêtre
glutSwapBuffers();
}

// FONCTION MAIN
int main(int argc, char *argv[])
{
// Processus gllib
gllProcessInformation *pi = new gllProcessInformation();
pi->name = "test_sprite_process";
pi->realTime = true;
pi->idleFunc = test_spriteIdleFunc;
pi->displayFunc = test_spriteDisplayFunc;
gllRegisterProcess(pi);

sprite.color(1.0, 0.0, 0.0, 0.6);
ship.x = 160;
ship.y= 120;
ship.direction = PI/2.0;
bullet.x = 160;
bullet.y = 110;
bullet.direction = PI/2.0;

gllTimer(TIMER_START);

// Démarre gllib
// Le processus donnée en dernier argument sera activé
// Les autres arguments servent à donner un nom à la fenêtre graphique
// ainsi que ses dimensions
gllMainLoop(argc, argv, argv[0], 320, 240, "test_sprite_process");

return 0;
}

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

/*---------------------------------------------------------------------*\
| GLLIB : FONCTIONS GRAPHIQUES / ENTREES / TEMPS REEL |
| |
| Fichier: gllBMParser.bmp |
\*---------------------------------------------------------------------*/

/*
BMParser.cpp
Copyright (c) 2003 Thibault Genessay

See the header 'gllBMParser.h' for informations
*/

#ifdef WIN32
#include "windows.h"
#endif

#include <GL/gl.h>
#include <GL/glut.h>
#include "stdio.h"
#include "math.h"
#include <string.h>

#include "gllBMParser.h"

BMParser::BMParser(const char* bitmap) {
iErrors = 0;
strcpy(filename,bitmap);
pBitmap = NULL;
file = NULL;
if (strcmp(bitmap, "") == 0)
{
printf("BMP loader error : no file name specified\n");
iErrors++;
}else
if ((file = fopen(bitmap, "rb"))==NULL)
{
printf("BMP loader error : could not open file\n");
iErrors++;
}
sz = 0;
}

BMParser::~BMParser() {
if (file != NULL)
fclose(file);
}

void BMParser::Read(void* lpBuf, UINT nCount, bool inverse) {
if (fread(lpBuf, nCount, 1, file) != 1)
error("unexpected end of file");
#ifndef WIN32
if (inverse)
{
// inverse data for non x86 processors
char* begin = (char*)lpBuf, *end = (char*)lpBuf+nCount-1;
while (begin < end)
{
char tmp = *begin;
*begin = *end;
*end = tmp;
begin++;
end--;
}
}
#endif
sz+= nCount;
}

Bitmap* BMParser::Parse()
{
try {
// printf("reading header\n");
if (iErrors)
error("file is not open");
pBitmap = new Bitmap;
Read(pBitmap->sIdentifier, 2);
Read(&pBitmap->dwFileSize, sizeof(DWORD));
Read(&pBitmap->dwReserved, sizeof(DWORD));
Read(&pBitmap->dwDataOffset, sizeof(DWORD));
Read(&pBitmap->dwHeaderSize, sizeof(DWORD));
Read(&pBitmap->dwWidth, sizeof(DWORD));
Read(&pBitmap->dwHeight, sizeof(DWORD));
Read(&pBitmap->wPlanes, sizeof(WORD));
// printf("# of planes : %d\n", pBitmap->wPlanes);
if (pBitmap->wPlanes != 1)
error("only one plane supported, multiple encountered");
Read(&pBitmap->wBpp, sizeof(WORD));
Read(&pBitmap->dwCompression, sizeof(DWORD));
Read(&pBitmap->dwDataSize, sizeof(DWORD));
pBitmap->dwPitch = (pBitmap->wBpp / 8) * pBitmap->dwWidth;
if (pBitmap->dwPitch%4 != 0)
pBitmap->dwPitch += 4-pBitmap->dwPitch%4;
if (pBitmap->dwDataSize == 0) // if size is not present, compute it
pBitmap->dwDataSize = pBitmap->dwPitch * pBitmap->dwHeight;
else
if (pBitmap->dwDataSize != pBitmap->dwPitch * pBitmap->dwHeight)
error("scan-line width * height != bitmap size !! <- this is an unexpected error, probably due to an incorrect file format");
Read(&pBitmap->dwHRes, sizeof(DWORD));
Read(&pBitmap->dwVRes, sizeof(DWORD));
Read(&pBitmap->dwColors, sizeof(DWORD));
Read(&pBitmap->dwImportantColors, sizeof(DWORD));
// printf("reading palette\n");
ReadPalette();
// printf("reading data\n");
ReadData();
return pBitmap;
} catch (BMError* e) {
printf("BMP parser error : %s\n", e->msg);
if (pBitmap)
delete pBitmap;
return NULL;
}
}

void BMParser::ReadPalette()
{
if (pBitmap->wBpp == BPP_MONOCHROME)
error("unsupported format : monochrome BMP");
if (pBitmap->wBpp == BPP_16COLORS)
error("unsupported format : 4 bpp BMP");
if (pBitmap->wBpp == BPP_256COLORS)
{
/* pBitmap->pPalette = new DWORD[256];
Read(pBitmap->pPalette, pBitmap->dwColors*sizeof(DWORD));*/
error("unsupported format : 8 bpp BMP");
}
if (pBitmap->wBpp == BPP_HIGHCOLOR)
error("unsupported format : 16 bpp BMP");
// 24 bpp and 32 bpp bitmaps do not contain any palette entriy if dwCompression is BI_RGB
// which is always the case here since other compression formats are not supported
}

void BMParser::ReadData()
{
if (pBitmap->dwCompression != BI_RGB)
{
char buf[64];
strcpy(buf, "unsupported compressed format : ");
if (pBitmap->dwCompression == BI_RLE4)
strcat(buf, "BI_RLE4");
if (pBitmap->dwCompression == BI_RLE8)
strcat(buf, "BI_RLE8");
if (pBitmap->dwCompression == BI_BITFIELDS)
strcat(buf, "BI_BITFILEDS");
error(buf);
}
pBitmap->pData = new unsigned char[pBitmap->dwDataSize];
// bmp files are stored bottom-up, so we need to invert the scan-lines
// i.e. the first line in the file is the bottom line of the image
for (DWORD i=0;i<pBitmap->dwHeight;i++)
{
fseek(file, pBitmap->dwDataOffset+(pBitmap->dwHeight-i-1)*pBitmap->dwPitch, SEEK_SET);
Read(&pBitmap->pData[i*pBitmap->dwPitch], pBitmap->dwPitch, false);
}

if (pBitmap->wBpp == BPP_TRUECOLOR)
{ // in this format, a line is a sequence of triplets (b,g,r), so we invert them to get (r,g,b)
for (DWORD i=0;i<pBitmap->dwDataSize;i+=3)
{
char tmp = pBitmap->pData[i];
pBitmap->pData[i] = pBitmap->pData[i+2];
pBitmap->pData[i+2] = tmp;
}
}
if (pBitmap->wBpp == BPP_32)
{ // in this format, a line is a sequence of triplets (b,g,r,a), so we invert them to get (r,g,b,a)
for (DWORD i=0;i<pBitmap->dwDataSize;i+=4)
{
char tmp = pBitmap->pData[i];
pBitmap->pData[i] = pBitmap->pData[i+2];
pBitmap->pData[i+2] = tmp;
}
}

}

bool BMParser::Failed(char *reason)
{
if (reason != NULL)
{
if (iErrors)
strcpy(reason, lastError);
else
strcpy(reason, "No error");
}
return iErrors == 0;
}

bool Bitmap::ColorKey(unsigned char key_r, unsigned char key_g, unsigned char key_b)
{
// Make a few checks first
if (pData == NULL)
{
printf("ColorKey() failed : image is empty !\n");
return false;
}
if (wBpp != BPP_TRUECOLOR)
{
printf("ColorKey() failed : keying is only available for 24 bpp images\n");
return false;
}

// Kepp the old pitch value, we'll need it to index the old data
DWORD oldPitch = dwPitch;
// Set new file format (24->32bpp)
wBpp = BPP_32;
// Recompute the image pitch and size
dwPitch = 4*dwWidth;
dwDataSize = dwPitch * dwHeight;
// Allocate new memory
unsigned char *newData = new unsigned char[dwDataSize];
// The key to look for
unsigned int key = (key_r<<16) + (key_g<<8) + key_b;
// Loop through all the pixels
for (DWORD line=0;line<dwHeight;line++)
{
for (DWORD c=0;c<dwWidth;c++)
{
unsigned int ir,ig,ib;
// The color of the current pixel
ir = pData[line*oldPitch+3*c];
ig = pData[line*oldPitch+3*c+1];
ib = pData[line*oldPitch+3*c+2];
// Compare it with the key
bool isKey = ((ir<<16) + (ig<<8) + ib) == key;
int offset = line*dwPitch + 4*c;
// Fill in new values. Set to black all transparent pixels
newData[ offset ] = isKey ? 0 : ir;
newData[offset + 1] = isKey ? 0 : ig;
newData[offset + 2] = isKey ? 0 : ib;
newData[offset + 3] = isKey ? 0 : 0xFF;
}
}
// Update the pData pointer
delete[] pData;
pData = newData;
return true;
}

inline void Bitmap::ColorAt(unsigned int x, unsigned int y, unsigned char* r, unsigned char* g, unsigned char* b, unsigned char* a)
{
int offset = y*dwPitch+(wBpp/8)*x;
*r = pData[offset];
*g = pData[offset+1];
*b = pData[offset+2];
if (wBpp == 32)
*a = pData[offset+3];
}

inline void Bitmap::ColorAt(unsigned int x, unsigned int y, unsigned char rgba[])
{
int offset = y*dwPitch+(wBpp/8)*x;
for (int i=0;i<wBpp/8;i++)
rgba[i] = pData[offset+i];
}

void Bitmap::Filter(int filter[3][3])
{
unsigned char* newData = new unsigned char[dwDataSize];
for (DWORD l=0;l<dwHeight;l++)
{
for (DWORD c=0;c<dwWidth;c++)
{
int rgba_dest[4];
unsigned char rgba_src[4];
if (c>0&&c<dwWidth-1&&l>0&&l<dwHeight-1)
{
for (int x=-1;x<=1;x++)
{
for (int y=-1;y<=1;y++)
{
int factor = filter[x+1][y+1];
ColorAt(c+x,l+y,rgba_src);
for (int i=0;i<wBpp/8;i++)
{
rgba_dest[i] += factor*rgba_src[i];
}
}
}
for (int i=0;i<wBpp/8;i++)
{
rgba_dest[i] /= 9;
if (rgba_dest[i]<0)
rgba_src[i] = 0;
else if (rgba_dest[i]>255)
rgba_src[i] = 255;
else rgba_src[i] = rgba_dest[i];
}
memcpy(&newData[l*dwPitch+(wBpp/8)*c], rgba_src, wBpp/8*sizeof(unsigned char));
}else{
memcpy(&newData[l*dwPitch+(wBpp/8)*c], &pData[l*dwPitch+(wBpp/8)*c], wBpp/8*sizeof(unsigned char));
}
}
}
delete[] pData;
pData = newData;
}

void Bitmap::Smooth()
{
int filter[3][3] = {{1,1,1},{1,1,1},{1,1,1}};
Filter(filter);
}

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

/*---------------------------------------------------------------------*\
| GLLIB : FONCTIONS GRAPHIQUES / ENTREES / TEMPS REEL |
| |
| Fichier: gllBMParser.h |
| Description: |
| Voir ci-dessous (en anglais) |
\*---------------------------------------------------------------------*/

/*
BMParser.h
Copyright (c) 2003 Thibault Genessay

Defines the BMParser class which allows to load bitmaps for easy use with OpenGL
It supports both Unix/Linux and Win32 platforms

It only supports a few formats because I don't have enough time to complete it
Feel free to add the lacking functionalities
Supported BMP formats:
True Color (24 bpp, RGB)
True Color with transparency (32 bpp, RGBA)
Unsupported formats:
monochrome BMP (1 bpp)
16 color BMP (4 bpp)
256 color BMP (8 bpp)
65536 color BMP (16 bpp)
and any compressed format

Usage:
Create a BMParser instance with the filename as the constructor's parameter
Call BMParser::Parse()
- if the call succeeds, it returns a Bitmap structure. The bitmap data
is stored in the pData field of this structure
- if any kind of error occured, it returns NULL

Notes:
- it is your responsibility to delete the Bitmap structure when
you don't need it anymore
- the constructor call cannot fail, hence if the file was not found, you
won't be notified until you call Parse() or Failed()
*/

#ifndef __BMPARSER_H
#define __BMPARSER_H

typedef unsigned long DWORD;
typedef unsigned short WORD;

#define ID_WINDOWS "BM"
#define ID_OS2_ARRAY "BA"
#define ID_OS2_COLORICON "CI"
#define ID_OS2_COLORPOINTER "CP"
#define ID_OS2_ICON "IC"
#define ID_OS2_POINTER "PT"

#define BPP_MONOCHROME 1
#define BPP_16COLORS 4
#define BPP_256COLORS 8
#define BPP_HIGHCOLOR 16
#define BPP_TRUECOLOR 24
#define BPP_32 32

#ifndef WIN32 // already defined in windows GDI
#define BI_RGB 0 // no compression
#define BI_RLE8 1 // 8-bit RLE
#define BI_RLE4 2 // 4-bit RLE
#define BI_BITFIELDS 3 // rarely used format
#define UINT unsigned int // Windows doesn't like unsigned ints, but loves UINTs
#endif //WIN32

// Represents a BMP file
struct Bitmap
{
char sIdentifier[2]; // a member of ID_XXX
DWORD dwFileSize; // file size in bytes
DWORD dwReserved; // reserved for later use
DWORD dwDataOffset; // offset to the data
DWORD dwHeaderSize; // may be 28h for windows, OCh for OS/2 1.x and F0h for OS/2 2.x
DWORD dwWidth; // width of the bitmap in pixels
DWORD dwHeight; // height
WORD wPlanes; // 1
WORD wBpp; // a member of BPP_XXX
DWORD dwCompression; // a member of BI_XXX
DWORD dwDataSize; // 32-bit aligned size of the data
DWORD dwHRes, dwVRes; // resolutions in pixel/meter
DWORD dwColors; // # of colors used in the bitmap
DWORD dwImportantColors;// # of important colors
DWORD *pPalette; // palette: for each entry, 4 bytes R,G,B,X (X is a filler set to 0) if appliable (1,4,and 8 bpp; no palette for 16, 24 and 32 bpp)
unsigned char *pData; // actual bitmap data
DWORD dwPitch; // actual scan-line width (32-bit aligned value of dwWidth)

Bitmap() {
pData = NULL;
pPalette = NULL;
}
~Bitmap() {
if (pData)
delete[] pData;
if (pPalette)
delete[] pPalette;
}

inline void ColorAt(unsigned int x, unsigned int y, unsigned char* r, unsigned char* g, unsigned char* b, unsigned char* a=NULL);
inline void ColorAt(unsigned int x, unsigned int y, unsigned char rgba[]);

bool ColorKey(unsigned char key_r, unsigned char key_g, unsigned char key_b);
void Filter(int filter[3][3]);
void Smooth();
};

// The parser itself
class BMParser
{
protected:
int iErrors;
struct BMError {
BMError(const char* _msg) {
strcpy(msg, _msg);
}
char msg[256];
};
void error(const char* msg) {
strcpy(lastError, msg);
iErrors++;
throw new BMError(msg);
}
int sz;
char filename[256];
FILE* file;
Bitmap* pBitmap;
void Read(void* lpBuf, UINT nCount, bool inverse = true);
void ReadPalette();
void ReadData();

char lastError[128];
public:
BMParser(const char* bitmap);
~BMParser();

Bitmap* Parse();
Bitmap* GetBitmap() { return pBitmap; };

bool Failed(char *reason);
};

#endif

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

#include "gllFont.h"

gllFont gllout;

const int gllFont::bmpLines = 4;
const int gllFont::bmpColumns = 26;

gllFont::gllFont()
{
active = false;
for (int i=0;i<4;i++) color[i]=1.0f;
}

gllFont::CharPos gllFont::getCharPos(char ch)
{
int l,c;
if (ch >= 'a' && ch <= 'z')
{
l=0;
c=ch-'a';
}else if (ch >= 'A' && ch <= 'Z')
{
l=1;
c=ch-'A';
}else if (ch >= '0' && ch <= '9')
{
l=2;
c=ch-'0';
}else{
l=2;
switch (ch)
{
case 'à': c=10; break;
case 'â': c=11; break;
case '.': c=12; break;
case 'é': c=13; break;
case 'è': c=14; break;
case 'ê': c=15; break;
case 'ë': c=16; break;
case 'î': c=17; break;
case 'ï': c=18; break;
case 'ô': c=19; break;
case ',': c=20; break;
case 'ù': c=21; break;
case 'û': c=22; break;
case 'ü': c=23; break;
case '!': c=24; break;
case '?': c=25; break;
default:
{
l=3;
switch (ch) {
case '+': c=0; break;
case '-': c=1; break;
case '_': c=2; break;
case '=': c=3; break;
case '\'': c=4; break;
case '\"': c=5; break;
case ';': c=6; break;
case '^': c=7; break;
case '~': c=8; break;
case '*': c=9; break;
case 'ç': c=10; break;
case '%': c=11; break;
case '&': c=12; break;
case '/': c=13; break;
case '\\': c=14; break;
case '<': c=15; break;
case '>': c=16; break;
case '(': c=17; break;
case ')': c=18; break;
case '[': c=19; break;
case ']': c=20; break;
case '{': c=21; break;
case '}': c=22; break;
case '@': c=23; break;
case '#': c=24; break;
case ':': c=25; break;
}
}
}
}

return CharPos(l,c);
}

const float gllFont::TexCoords::tc_delta = 0.003f;
gllFont::TexCoords gllFont::getTexCoords(CharPos pos)
{
return TexCoords((float)pos.column/(float)bmpColumns,
(float)pos.line/(float)bmpLines,
(float)(pos.column+1)/(float)bmpColumns,
(float)(pos.line+1)/(float)bmpLines);
}

gllFont& gllFont::operator<<(FormatToken& token)
{
token.execute(*this);
return (*this);
}
#ifndef WIN32
gllFont& gllFont::operator<<(gllcolor token)
{
token.execute(*this);
return (*this);
}
gllFont& gllFont::operator<<(gllalign token)
{
token.execute(*this);
return (*this);
}
gllFont& gllFont::operator<<(gllgoto token)
{
token.execute(*this);
return (*this);
}
gllFont& gllFont::operator<<(gllsetup token)
{
token.execute(*this);
return (*this);
}
gllFont& gllFont::operator<<(gllskipl token)
{
token.execute(*this);
return (*this);
}
#endif

gllFont& gllFont::operator<<(const char* text)
{
int l = strlen(text);
// glBegin(GL_QUADS);
glColor4fv(color);
for (int i=0;i<l;i++)
{
if (text[i] == ' ') {
if (++column > maxColumns)
{
line++;
column = 0;
}
continue;
}

glPushMatrix();
glTranslatef((float)(column*columnSize)+hcs, (float)(screenHeight-line*lineSize)-hls,0.0f);
if (align == gllRIGHT)
glTranslatef((float)(screenWidth-l*columnSize),0.0f,0.0f);
else if (align == gllMIDDLE)
glTranslatef((float)(screenWidth-l*columnSize)/2.0f,0.0f,0.0f);
glBegin(GL_POLYGON);
// glRotatef(75,0,0,1);
gllFont::TexCoords tc = getTexCoords(getCharPos(text[i]));
glTexCoord2f(tc.u_min,tc.v_min);
glVertex2f(-hcs, hls);
glTexCoord2f(tc.u_max,tc.v_min);
glVertex2f(hcs,hls);
glTexCoord2f(tc.u_max,tc.v_max);
glVertex2f(hcs,-hls);
glTexCoord2f(tc.u_min,tc.v_max);
glVertex2f(-hcs,-hls);
if (++column > maxColumns)
{
line++;
column = 0;
}
glEnd();
glPopMatrix();
}
// glEnd();
return (*this);
}

gllFont& gllFont::operator<<(const string& str)
{
return this->operator<<(str.c_str());
}

gllFont& gllFont::operator<<(char c)
{
char buf[4];
sprintf(buf, "%c", c);
return this->operator <<(buf);
}

gllFont& gllFont::operator<<(int i)
{
char buf[32];
sprintf(buf, "%d", i);
return this->operator <<(buf);
}

gllFont& gllFont::operator<<(double d)
{
char buf[32];
sprintf(buf, "%f", d);
return this->operator <<(buf);
}

_gllendl gllendl;
void _gllendl::execute(gllFont& font)
{
font.line++;
font.column = 0;
}
_glltab glltab;
void _glltab::execute(gllFont& font)
{
font.column = (font.column/4)*5;
}
void gllskipl::execute(gllFont& font)
{
if (!noCR)
font.column = 0;
font.line += number;
}
void gllgoto::execute(gllFont& font)
{
font.line = l;
font.column = c;
}
void gllsetup::execute(gllFont& font)
{
font.lineSize = sl;
font.columnSize = sc;
font.hls = (float)font.lineSize/2.0f;
font.hcs = (float)font.columnSize/2.0f;
font.maxLines = h / sl;
font.screenHeight = h;
font.maxColumns = w / sc;
font.screenWidth = w;
font.line = 0;
font.column = 0;
}
_gllstart gllstart;
void _gllstart::execute(gllFont& font)
{
font.active = true;
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textureNames[TEX_FONT]);
font << gllcolor(1,1,1,1);
font << gllgoto(0,0);
font << gllalign(gllLEFT);
}
_gllend gllend;
void _gllend::execute(gllFont& font)
{
glDisable(GL_TEXTURE_2D);
font.active = false;
}
void gllcolor::execute(gllFont& font)
{
memcpy(font.color, col, 4*sizeof(float));
}
void gllalign::execute(gllFont& font)
{
font.align = type;
font.column = 0;
}

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

/*---------------------------------------------------------------------*\
| GLLIB : FONCTIONS GRAPHIQUES / ENTREES / TEMPS REEL |
| |
| Fichier: gllFont.h |
| Description: |
\*---------------------------------------------------------------------*/

#ifndef __GLL_FONT_H__
#define __GLL_FONT_H__

#include "gllLibrary.h"

using namespace std;

class gllFont;
extern gllFont gllout;

struct FormatToken {
FormatToken() {}
virtual void execute(gllFont& font) = 0;
};

enum gllalign_type {
gllLEFT,
gllMIDDLE,
gllRIGHT
};

class gllFont
{
static const int bmpLines;
static const int bmpColumns;
struct CharPos {
CharPos(int l, int c) : line(l), column(c) {}
int line, column;
};
struct TexCoords {
static const float tc_delta;
TexCoords(float umin, float vmin, float umax, float vmax) :
u_min(umin+tc_delta), v_min(vmin+tc_delta), u_max(umax-tc_delta),v_max(vmax-tc_delta) {}
float u_min, v_min, u_max, v_max;
};
int line, column, maxLines, maxColumns, lineSize, columnSize, screenHeight, screenWidth;
float hls, hcs;
bool active;

float color[4];
gllalign_type align;
public:
gllFont();

int getLine() { return line; }
int getColumn() { return column; }
int getMaxLines() { return maxLines; }
int getMaxColums() { return maxColumns; }
public:
friend struct _gllendl;
friend struct _glltab;
friend struct gllgoto;
friend struct gllsetup;
friend struct gllskipl;
friend struct _gllstart;
friend struct _gllend;
friend struct gllcolor;
friend struct gllalign;

// void print(const char* text, ...);
// void printxy(int x, int y, const char* text, ...);

gllFont& operator<<(FormatToken& token);
#ifndef WIN32 // gcc n'accepte pas les commandes glout << glcolor directement
//il faut lui spécifier chaque classe ARRGGG !
// sous windows avec cl.exe (VC6) , pas de problème
gllFont& operator<<(gllcolor token);
gllFont& operator<<(gllgoto token);
gllFont& operator<<(gllalign token);
gllFont& operator<<(gllsetup token);
gllFont& operator<<(gllskipl token);
#endif
gllFont& operator<<(const char* text);
gllFont& operator<<(const string& str);
gllFont& operator<<(char c);
gllFont& operator<<(int i);
gllFont& operator<<(double d);

private:
CharPos getCharPos(char ch);
TexCoords getTexCoords(CharPos pos);
};

struct _gllendl : public FormatToken {
void execute(gllFont& font);
};
extern _gllendl gllendl;

struct _glltab : public FormatToken {
void execute(gllFont& font);
};
extern _glltab glltab;

struct gllskipl : public FormatToken {
int number;
bool noCR;
gllskipl(int nb, bool noCR = false) {
number = nb;
this->noCR = noCR;
}
void execute(gllFont& font);
};

struct gllgoto : public FormatToken {
int l,c;
gllgoto(int line, int col) {
l = line;
c = col;
}
void execute(gllFont& font);
};

struct _gllstart : public FormatToken {
void execute(gllFont& font);
};
extern _gllstart gllstart;

struct _gllend : public FormatToken {
void execute(gllFont& font);
};
extern _gllend gllend;

struct gllsetup : public FormatToken {
int w,h,sl,sc;
gllsetup(int linSize, int colSize, int screenWidth, int screenHeight) {
sl = linSize;
sc = colSize;
h = screenHeight;
w = screenWidth;
}
void execute(gllFont& font);
};

struct gllcolor : public FormatToken {
float col[4];
gllcolor(float r, float g, float b, float a) {
col[0]=r;col[1]=g;col[2]=b;col[3]=a;
}
void execute(gllFont& font);
};
struct gllalign : public FormatToken {
gllalign_type type;
gllalign(gllalign_type t) {
type = t;
}
void execute(gllFont& font);
};

#endif

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

/*---------------------------------------------------------------------*\