Meteroid iii (faut attendre un peu pour le 6)

Commenter

Contenu du snippet

Jeux d'avion en mode texte. pas encore termine mais "moteur au point" . Mais en fait je ne pense pas le finir alors si ca tente quelqu'un de le faire pas de probleme je rajouterais des commentaires pour que ce soit plus lisible.

Source / Exemple : 


#include <iostream>
// #include <conio.c> pour ceux qui ont dev C++ faut le rajouter 
#include <conio.h> 
#include <stdio.h> 
#include <stdlib.h> 
// #include <string.h> pas encore utiliser

using namespace std;

////////////////////////// CLASS ENNEMI ET VAISSEAU /////////////////////////

int i;                              // VARIABLES GLOBALES
int p=1;
int tir;

class ennemi 

{
protected :

        
        int e_pos_x;
        int e_pos_y;
                        
        int e_skin;
        
public :

    ennemi( int x , int y , int sk);
    ennemi();
    
    void e_afficher(void);
    
    void e_afficherhaut(void);
    void e_afficherbas(void);
    void e_affichergauche(void);
    void e_afficherdroite(void);
           
    void e_tirer(void);
        
    void e_tirerhaut(void);
    void e_tirerbas(void);
    void e_tirergauche(void);
    void e_tirerdroite(void);
    
    void e_initialisation ();
    
        
};

/////////////////////////////////////////////////////////////////////////

class vaisseau 

{
protected :
                      
        int pos_x;
        int pos_y;
        
        int skin;
        
        int couleur;
        
        int energie;
                       
        int argent;
        
public :
        
        vaisseau(int x , int y , int sk , int ener , int arg);
        
        
        void afficher(void);
        
        void afficherhaut(void);
        void afficherbas(void);
        void affichergauche(void);
        void afficherdroite(void);
        
        
        void deplacer(void);
        
        void deplacerhaut(void);
        void deplacerbas(void);
        void deplacergauche(void);
        void deplacerdroite(void);
        
        
        void tirer(void);
        
        void tirerhaut(void);
        void tirerbas(void);
        void tirergauche(void);
        void tirerdroite(void);
        
        void changement_de_couleur();
                     
        // void sauvegarder(void);   pour plus tard.....
        // void charger(void);
        
};

///////////////////////// CONSTRUCTEURS ////////////////////////////////////

ennemi::ennemi( int e_x , int e_y , int e_sk)
{
e_pos_x = e_x;
e_pos_y = e_y;
e_skin = e_sk;
}

ennemi::ennemi()
{
}

vaisseau::vaisseau(int x , int y , int sk , int ener , int arg)
{
pos_x = x;
pos_y = y;
skin = sk;
energie = ener;
argent = arg;
}

///////////////////// FIN DES CONSTRUCTEURS //////////////////////////////

/////////////////////FONCTIONS DEPLACER (VAISSEAU) ///////////////////////

void vaisseau::deplacer(void)
{
gotoxy(1 , 1);
tir=0;
int c;
c = getch();
        
        switch (c)
        
        {
        case 56 :  deplacerhaut(); break;
        case 53 :  deplacerbas(); break;
        case 52 :  deplacergauche(); break;
        case 54 :  deplacerdroite(); break;
        case 57 :  tirer(); break;
        case 32 :  tirer(); break;
        case 48 : changement_de_couleur(); break;
        case 27 : exit(0);
        }
        
}

void vaisseau::deplacerhaut(void)
{
pos_y-- ;
skin = 8;
}

void vaisseau::deplacerbas(void)
{
pos_y++ ;
skin = 5;
}

void vaisseau::deplacergauche(void)
{
pos_x-- ;
skin = 4;
}

void vaisseau::deplacerdroite(void)
{
pos_x++ ;
skin = 6;
}

//////////////////////////FIN DES FONCTIONS DEPLACER//////////////////////

////////////////////////////FONCTION TIRER (ENNEMI)///////////////////////

void ennemi::e_tirer(void)

{
tir=1;
switch (e_skin)
    {
    case 8 :  e_tirerbas(); break ;
    case 5 :  e_tirerhaut(); break ;
    case 6 :  e_tirergauche(); break ;
    case 4 :  e_tirerdroite(); break ;
    }
}

void ennemi::e_tirerbas()
{
gotoxy(1 , 1);
    for (i = 25 - e_pos_y , p=0; i>1 ; i-- , p++)
    {
    gotoxy(e_pos_x + 1 , e_pos_y + p );
    cout << "|";
    }
gotoxy(1 , 1);
}

void ennemi::e_tirerhaut(void)
{
gotoxy(1 , 1);
for (i=e_pos_y , p=0 ; i>0 ; i-- , p++)
{
gotoxy(e_pos_x + 1 , e_pos_y - p );
cout << "|";
}
gotoxy(1 , 1);
}

void ennemi::e_tirergauche(void)
{
gotoxy(1 , 1);
for (i=e_pos_x , p=0 ; i>0 ; i-- , p++)
{
gotoxy(e_pos_x - p , e_pos_y + 1);
cout << "-";
}
gotoxy(1 , 1);
}

void ennemi::e_tirerdroite(void)
{
gotoxy(1 , 1);
for (i= 25 - e_pos_x , p=0 ; i>0 ; i-- , p++)
{
gotoxy(e_pos_x + p , e_pos_y + 1 );
cout << "-";
}
gotoxy(1 , 1);
}

/////////////////////// FIN DES FONCTIONS TIRER (ENNEMI) ////////////////

////////////////////////// FONCTIONS TIRER (VAISSEAU) ///////////////////

void vaisseau::tirer(void)

{
tir = 1;
switch (skin)
    {
    case 8 :  tirerbas(); break ;
    case 5 :  tirerhaut(); break ;
    case 6 :  tirergauche(); break ;
    case 4 :  tirerdroite(); break ;
    }
}

void vaisseau::tirerhaut(void)
{
gotoxy(1 , 1);
for (i= 22 - pos_y , p=0 ; i>1 ; i-- , p++)
{
gotoxy(pos_x + 1 , pos_y + p + 3 );
textcolor(1);
cout << "|" ;
textcolor(0);
}
gotoxy(1 , 1);
}

void vaisseau::tirerbas(void)
{
gotoxy(1 , 1);
for (i=pos_y-3 , p=0 ; i>1 ; i-- , p++)
{
gotoxy(pos_x + 1 , pos_y - p - 3  );
textcolor(1);
cout << "|" ;
textcolor(0);
}
gotoxy(1 , 1);
}

void vaisseau::tirergauche(void)
{
gotoxy(1 , 1);
for (i= 77-pos_x , p=0 ; i>1 ; i-- , p++)
{
gotoxy(pos_x + p + 4 , pos_y );
textcolor(1);
cout << "-";
textcolor(0);
}
gotoxy(1 , 1);
}

void vaisseau::tirerdroite(void)
{
gotoxy(1 , 1);
for (i= pos_x , p=0 ; i>1 ; i-- , p++)
{
gotoxy(pos_x - p - 4 ,pos_y );
textcolor(1);
cout << "-";
textcolor(0);
}
gotoxy(1 , 1);
}

////////////////////////// FIN DES FONCTIONS TIRER////////////////////////

//////////////////////// FONCTION AFFICHER (ENNEMI) //////////////////////

void ennemi::e_afficher(void)

{
    
    switch (e_skin)
    {
    case 8 :  e_afficherhaut(); break ;
    case 5 :  e_afficherbas(); break ;
    case 6 :  e_afficherdroite(); break ;
    case 4 :  e_affichergauche(); break ;
    }
}

void ennemi::e_afficherhaut(void)
{
gotoxy(e_pos_x , e_pos_y);
cout << "|-|" ;
}

void ennemi::e_afficherbas(void)
{
gotoxy(e_pos_x , e_pos_y);
cout << "|-|" ;
}

void ennemi::e_affichergauche(void)
{
gotoxy(e_pos_x , e_pos_y);
cout << "-" ;
gotoxy(e_pos_x , e_pos_y - 1);
cout << "|" ;
gotoxy(e_pos_x , e_pos_y - 1);
cout << "-" ;
}

void ennemi::e_afficherdroite(void)
{
gotoxy(e_pos_x , e_pos_y);
cout << "-" ;
gotoxy(e_pos_x , e_pos_y - 1);
cout << "|" ;
gotoxy(e_pos_x , e_pos_y - 1);
cout << "-" ;
}

///////////////////////FIN DES FONCTIONS AFFICHER (ENNEMI) ////////////////

///////////////////////FONCTION AFFICHER (VAISSEAU) /////////////////////// 

void vaisseau::afficher(void)
{
    
    switch (skin)
    {
    case 8 : afficherhaut(); break ;
    case 5 : afficherbas(); break ;
    case 6 : afficherdroite(); break ;
    case 4 : affichergauche(); break ;
    }
}

void vaisseau::afficherhaut(void)
{
textcolor(couleur);
gotoxy(pos_x , pos_y);
cout << "|+|";
gotoxy(pos_x + 1 , pos_y -1);
cout << "|" ;
textcolor(0);
}

void vaisseau::afficherbas(void)
{
textcolor(couleur);
gotoxy(pos_x , pos_y);
cout << "|+|";
gotoxy(pos_x + 1 , pos_y +1);
cout << "|" ;
textcolor(0);
}

void vaisseau::affichergauche(void)
{
textcolor(couleur);
gotoxy(pos_x , pos_y - 1);
cout << "-" ;
gotoxy(pos_x - 1 , pos_y);
cout << "-+" ;
gotoxy(pos_x , pos_y + 1);
cout << "-";
textcolor(0);
}

void vaisseau::afficherdroite(void)
{
textcolor(couleur);
gotoxy(pos_x, pos_y - 1);
cout << "-" ;
gotoxy(pos_x, pos_y);
cout << "+-" ;
gotoxy(pos_x, pos_y + 1);
cout << "-";
textcolor(0);
}       
//////////////////////////FIN DES FONCTIONS AFFICHER///////////////////////

///////////////////////// FONCTIONS changement_de_couleur /////////////////////////

void vaisseau::changement_de_couleur ()
{
gotoxy (20 , 15);
textcolor(6);
cout << "Choisissez une couleur pour votre vaisseau...\n"<<endl;
gotoxy (23 , 16);
cout << " 1 = bleu , 4 rouge... " << endl;
int u;
cin >> u;
    switch (u)
    {
    case 1 : couleur=1 ; break ;
    case 3 : couleur=3 ; break ;
    case 4 : couleur=4 ; break ;
    case 5 : couleur=5 ; break ;
    case 6 : couleur=6 ; break ;
    case 7 : couleur=7 ; break ;
    case 8 : couleur=8 ; break ;
    case 9 : couleur=9 ; break ;
    case 10 : couleur=10 ; break ;
    case 11 : couleur=11 ; break ;
    case 12 : couleur=12 ; break ;
    default : couleur = 4 ; break ;
    }
textcolor(0);
}
/////////////////////////////////FIN/////////////////////////////////////
///////////////////////////FONCTION D'INITIALISATION/////////////////////
void ennemi::e_initialisation ()
{
ennemi gauche[2];
int y_g;
for (i=0 , y_g=4 ; i<sizeof(gauche) ; i++ , y_g+8 )
    {
    gauche[i].e_pos_y = y_g ;
    gauche[i].e_pos_x = 5 ;
    gauche[i].e_skin = 4 ;
    }
ennemi droite[2];
int y_d;
for (i=0 , y_d=4 ; i<sizeof(droite) ; i++ , y_d+8 )
    {
    droite[i].e_pos_y = y_d ;
    droite[i].e_pos_x = 65 ;
    droite[i].e_skin = 6 ;
    }
ennemi haut[2];
int x_h;
for (i=0 , x_h = 15 ; i<sizeof(gauche) ; i++ , x_h + 20)
    {
    haut[i].e_pos_y = 3 ;
    haut[i].e_pos_x = x_h;
    haut[i].e_skin = 8;
    }
ennemi bas[2];
int x_b;
for (i=0 , x_b = 15 ; i<sizeof(bas) ; i++ , x_b + 20)
    {
    bas[i].e_pos_y = 22 ;
    bas[i].e_pos_x = x_h;
    bas[i].e_skin = 5;
    }
}

//////////////////////////////FIN FONCTION INIT//////////////////////////

////////////////////////FONCTION TOUR DES ENNEMIS////////////////////////

/*void tour_des_ennemis ()
{
while (kbhit==0)
    {
        for (i=0 ; i<sizeof(gauche) ; i++)
            {
            }
            
    }
}*/

///////////////////////FIN FONCTION TOUR DES ENNEMIS/////////////////////

////////////////////////////DEBUT FONCTION TEST//////////////////////////

int main (void)
{
textcolor(0);
//ennemi init;
//init.e_initialisation();
vaisseau player(10,10,8,10,10);
player.changement_de_couleur();
while (1)
      {
      if (tir==1)               //sinon ca ralenti tout
      {
      Sleep(125);
      }
      clrscr();
      player.afficher();
      //tour_des_ennemis();
      player.deplacer();
      }
}

Conclusion :


Manque pour l'instant les ennemis mais ca va venir dans pas longtemps du tout....
Laissez des commentaires svp !

PS : je sais qu'il aurait mieu fallu faire une relation d'heritage du type
class vaisseau : public ennemi
et apres polymorpher toutes les fonctions membres mais la au moins , ca marche.....

Il reste une fonction qui resoudrait les combats du type :
"si ennemi est sur la meme abscisse que vaisseau alors detruire ennemi.."

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (kenjimax)