Magicien::Magicien() : Personnage()
{
m_vie = nombreAleatoire(110, 90);
m_mana = nombreAleatoire(70, 50);
m_sort = new Sort(40, 30);
m_nom = attribuerNom();
}
ElementNiveau *operator()(Niveau *n) const {
if(!_nbNonNuls)
return 0;
int nbAlea = nombreAleatoire(_nbNonNuls * NB_VALEURS_PROBA_ENTITES);
for(ElementNiveau::elementNiveau_t e = ElementNiveau::premierTypeElement; e != ElementNiveau::nbTypesElement; ++e) {
if(nbAlea < _probasCumulees[e]) {
ElementNiveau *retour = ElementNiveau::elementNiveau(true, n, nombreAleatoire(static_cast<int>(ElementNiveau::nombreEntites(e))), e);
return retour;
}
}
return 0;
}
void Niveau::afficher() {
glm::vec2 cam = _perso->positionAffichage();
if(_perso->inventaireAffiche())
cam = _perso->positionAffichage() - glm::vec2(Ecran::largeur() / 4, 0);
cam -= (glm::vec2(Ecran::dimensions()) - _perso->dimensions() * static_cast<coordonnee_t>(LARGEUR_CASE)) / 2.0f - glm::vec2(0, 80);
cam.x = std::floor(cam.x);
cam.y = std::floor(cam.y);
this->afficherCouche(cn_sol, cam);
this->afficherTransitionsSol(cam);
this->afficherBordure(DROITE, cam);
this->afficherBordure(HAUT, cam);
// Sert à afficher la grille de case, inutile sauf en cas de test
/*for(index_t y = 0; y <= _dimY; ++y) {
Ecran::afficherLigne(referentielNiveauVersEcran(Coordonnees(0, y) * static_cast<coordonnee_t>(LARGEUR_CASE)) - cam, referentielNiveauVersEcran(Coordonnees(_dimX, y) * static_cast<coordonnee_t>(LARGEUR_CASE)) - cam, Couleur::rouge, 1.0);
}
for(index_t x = 0; x <= _dimX; ++x) {
Ecran::afficherLigne(referentielNiveauVersEcran(Coordonnees(x, 0) * static_cast<coordonnee_t>(LARGEUR_CASE)) - cam, referentielNiveauVersEcran(Coordonnees(x, _dimY) * static_cast<coordonnee_t>(LARGEUR_CASE)) - cam, Couleur::rouge, 1.0);
}*/
for(Niveau::couche_t c = premiereCouche + 1; c != nbCouches; ++c) {
if(c == cn_objetsInventaire)
this->afficherObjetsInventaire(cam);
else
this->afficherCouche(c, cam);
}
this->afficherBordure(BAS, cam);
this->afficherBordure(GAUCHE, cam);
static float tonnerre = 0;
if(horloge() - tonnerre > nombreAleatoire(5) + 1) {
if(tonnerre > 0)
Audio::jouerSon(_tonnerre);
tonnerre = horloge() + 15 + nombreAleatoire(60);
}
_pluie.activer();
_pluie.definirParametre("temps", horloge());
_pluie.definirParametre("cam", glm::vec2(cam.x, cam.y));
_pluie.definirParametre("tonnerre", tonnerre);
_pluie.activer();
Affichage::afficherRectangle(Ecran::ecran(), Couleur::blanc);
Shader::desactiver();
}
std::string Sort::attribuerNom()
{
std::string retourNom = "Sort name attribution malfunction";
int retourNomEpee = nombreAleatoire(6,1);
switch(retourNomEpee)
{
case 1:
retourNom = "Iiz Slen Nus";
break;
case 2:
retourNom = "Yol Toor Shul";
break;
case 3:
retourNom = "Hun Kaal Zoor";
break;
case 4:
retourNom = "Joor Zah Frul";
break;
case 5:
retourNom = "Od Ah Viing";
break;
case 6:
retourNom = "Fus Roh Dah";
break;
default:
retourNom = "Sort name attribution malfunction";
break;
}
return retourNom;
}
std::string Arme::attribuerNom()
{
std::string retourNom = "";
int retourNomEpee = nombreAleatoire(6,1);
switch(retourNomEpee)
{
case 1:
retourNom = "Master Sword";
break;
case 2:
retourNom = "Tranch'Bite";
break;
case 3:
retourNom = "Diamond Sword";
break;
case 4:
retourNom = "Heaven's Sword of Hell";
break;
case 5:
retourNom = "Hearth Destroyer";
break;
case 6:
retourNom = "Head Hunter";
break;
default:
retourNom = "Arme name attribution malfunction";
break;
}
return retourNom;
}
int main(int argc, char *argv[])
{
FILE *fichierMot = NULL;
int nombreMot = 0, positionMot = 0, longeurMot = 0, mot[15];
int motDeviner[15];
int entre = 0, positionCaractere = 0, j = 0, i = 0;
int essaiRestant = 10, nombreEssai = 0;
fichierMot = fopen("mot", "r"); /* On ouvre le fichier */
if (fichierMot == NULL) { /* On teste pour savoir si tou c'est bien passé */
printf("Le fichier \"mot\" ne peut être ouvert\n");
return 1;
}
nombreMot = compterMot(fichierMot); /* Compte le nombre de mot */
/* Ceci est uniquement pour le debugage. */
printf("Ceci est le nombre de mot dans le fichier 'mot' %d\n",
nombreMot);
/* Position du mot dans la liste de tout les mots. */
positionMot = nombreAleatoire(nombreMot);
/* Longeur du mot en caractere. */
/* On sort la longeur du mot en même temps */
longeurMot = lireMot(fichierMot, positionMot, mot);
/* On affiche ensuite la longeur du sus-choisi mot */
printf("Ceci est la longeur en caractere du mot %d\n", longeurMot);
/* Initialisation du tableau */
for (i = 0; i <= longeurMot; i++) {
motDeviner[i] = '*';
}
/* Démarrage du jeu a proprement parler. */
printf("\nBienvenue dans mon pendu.\n");
printf("Un mot a été choisi, vous avez 10 chances.\n");
printf("Bonne chance !\n");
while (essaiRestant > 0) { /* Boucle principale */
int j = 0, k = 0; /* Afficher le nombre de caractere restant. */
for (j = 0; j < longeurMot; j++) {
printf("%c", motDeviner[j]);
}
/* On affiche le prompt. */
printf("\n> ");
entre = lireCaractere();
positionCaractere =
comparerCaractere(entre, mot, motDeviner, longeurMot);
if (positionCaractere != entre) {
essaiRestant--;
printf
("Il reste %d essai restant avant une mort certaine...\n",
essaiRestant);
}
/* Donc on compare les deux tableau de "mot" et
on incrémente k a chaque caractere valide */
for (j = 0; j < longeurMot; j++) {
if (mot[j] == motDeviner[j])
k++;
}
/* Si k est égual à longeurMot cela veux dire
que les deux chaines sont identiques.
Donc, victoire! */
if (k == longeurMot) {
printf("Vous avez gagner! En %d coups!\n", nombreEssai);
fclose(fichierMot);
return 0;
}
nombreEssai++;
}
fclose(fichierMot);
return 0;
}
Sort::Sort(int nbDegatsMax, int nbDegatsMin) : Arme()
{
m_nom = attribuerNom();
m_degats = nombreAleatoire(nbDegatsMax, nbDegatsMin);
}
Sort::Sort() : Arme()
{
m_degats = nombreAleatoire(45, 60);
m_nom = attribuerNom();
}
EntiteMobile::EntiteMobile(bool decoupagePerspective, Niveau *n, uindex_t index, ElementNiveau::elementNiveau_t cat) : ElementNiveau(decoupagePerspective, n, index, cat), _tempsPrecedent(0), _images(), _cadres(), _tempsAffichage(), _nbImages(), _imageActuelle(0), _action(a_immobile), _direction(gauche), _mort(false), _mortTerminee(false) {
std::memset(_nbImages, 0, nbActions * sizeof(size_t));
for(action_t a = premiereAction; a != nbActions; ++a) {
std::memset(_cadres[a], 0, 8 * sizeof(Rectangle *));
}
TiXmlElement *e = ElementNiveau::description(index, cat);
char const *img = e->Attribute("image");
if(img) {
for(action_t a = premiereAction; a != nbActions; ++a) {
_images[a] = Image(Session::cheminRessources() + img);
}
}
size_t dimX = 128, dimY = 128;
if(e->Attribute("blocX"))
e->Attribute("blocX", &dimX);
if(e->Attribute("blocY"))
e->Attribute("blocY", &dimY);
size_t premiereImage[nbActions] = {0};
for(action_t a = premiereAction; a != nbActions; ++a) {
TiXmlElement *action = e->FirstChildElement(EntiteMobile::transcriptionAction(a));
if(action) {
action->Attribute("nbPoses", &_nbImages[a]);
if(action->Attribute("image")) {
_images[a] = Image(Session::cheminRessources() + action->Attribute("image"));
}
if(action->Attribute("premiere"))
action->Attribute("premiere", &premiereImage[a]);
else if(a != premiereAction) {
premiereImage[a] = premiereImage[a - 1] + _nbImages[a - 1];
}
int temps;
action->Attribute("tempsAttente", &temps);
_tempsAffichage[a] = temps / 1000.0f;
if(a == a_attaquer) {
if(action->Attribute("attaque")) {
action->Attribute("attaque", &_imageAttaque);
}
else {
_imageAttaque = _nbImages[a_attaquer] - 1;
}
}
if(!_images[a].chargee()) {
throw ElementNiveau::Exc_DefinitionEntiteIncomplete();
}
}
}
for(int direction = 0; direction < 8; ++direction) {
for(action_t a = premiereAction; a != nbActions; ++a) {
index_t x = premiereImage[a];
_cadres[a][direction] = new Rectangle[_nbImages[a]];
for(int p = 0; p < _nbImages[a]; ++p) {
_cadres[a][direction][p] = Rectangle(x * dimX, direction * dimY, dimX, dimY);
++x;
}
}
}
this->definirAction(EntiteMobile::a_immobile);
_direction = direction_t(nombreAleatoire(8));
}
