Language de programmation ??

Discussion dans 'Web, design' créé par Androalphus666, 12 Juin 2003.

Statut de la discussion:
Fermée.
  1. Offline
    Hacko Elite
    Et je comprends pas le "allez-y pour faire des exe" quand tu parles du cobol. J'en ai fais à la pelle depuis que je suis au cours, tout des exe...
    Hacko, 12 Juin 2003
    #41
  2. Offline
    titloup Elite
    Didju... et t'as fait comment pour avoir ton EXE? t'as fait comment pour installer ce truc? T'as quoi comme interface déjà :p? Comme fonctions? Comme aide? Comme debugger? Comme composants?... ... ... ... ...

    Cobol c'est le langage des années 80, on ne touche pas aux poussiéres :D
    titloup, 12 Juin 2003
    #42
  3. Offline
    MoTh Elite
    C'est très bien de mélanger portabilité, compatibilité et standard.
    Va pas balancer ce genre de remarque lors d'un entretient d'embauche, car dans mon cas je t'engage vraiment pas .....


    Si je me souviens bien la question originale était quelle language utiliser pour faire des EXE, alors bon je vois pas trop ce que linux vient la dedans.
    MoTh, 12 Juin 2003
    #43
  4. Offline
    THiBOo Elite
    Bin d'accord avec Wolf :p

    le C est très bien, mais restrictif, et un peu vieu... cependant si tu désires programmer des progs pour Linux, le C est encore fort répandu.

    le C++ est tiré du C, et possède toute les fonctionnalité du C plus des fonctionnalité bien à lui dont d'ailleurs la "fameuse" i++ ou ++i, qui permet d'incrémenter i ( qui doit être déclaré comme variable ). ( c'est un exemple parmis tant d'autres ) la véritable nouveauté du C++ c'est qu'il est plus orienté objet que le C ( apparition de l'idée de classe )

    le java, très bien, mais assez lent je dirais ... très bien pour des application graphique ...

    l'assembleur :D alalalaa les joies de l'assembleur ou comment rendre compliquer les choses simple :), dépassé, archaïque, mais rapide et performant, foutre une petite fonction asm peut bien aléger votre programme, et c'est parfois très utile, voir indispensable ...

    le COBOL pas un système de programmation ça, tu parle à ton ordi en lui demande gentiment de faire qqc, et il comprend jamais lol ( ceux qui connaissent comprendront ;) )

    le Delphi connait pas :-( ( de nom seulement )

    le FORTRAN moouahahahahah dépassé :p

    Visual Basic, sympa pour commencer ;) permet de vite faire des ptit truc sympa, et tout ...

    exemple des différent langage :

    C :

    Code:
    # <iostream.h>
    
    void main ( )
    
    {
    
    int i, j;
    
    cout << "Introduisez un nombre entier :";
    cin >> i;
    cout << "Introduisez un deuxième nombre entier :";
    cin >> j;
    cout << "La somme est :" << ( i+j ) << endl;
    
    cout << "Tapez sur une touche pour stopper";
    cin >> i;
    
    }
    travaillant la plupart du temps en C++ j'ai fait un ptit prog vite fait :p

    C++ :

    Code:
    #include <iostream.h>
    #include <stdlib.h>
    #include <time.h>
    #include <limits.h>
    
    int vx[4]={0,1,0,-1}; //vecteurs de directions possibles
    int vy[4]={1,0,-1,0};
    int sol=INT_MAX; // prend la valeur maximale possible, c'est la solution finale
    int sol_part=0; // solution partielle
    int cpt_key=0; // compteur de clé possédées
    
    //----------------------------------------------------------------------------------------------
    // Classe Elem
    //----------------------------------------------------------------------------------------------
    class Elem
    {
    private :
    	bool debut; // permet juste de savoir si l'on est au début ou pas
    	bool fin; // idem pour la fin
    	bool key; // idem pour une clé
    	bool teleport; // idem pour teleporteur
    	int ligne;
    	int colonne; // coordonnées du point
    	int cpt; // sauve le nbr de clés lors de chaque passage
    public :
    	Elem();
    	friend class Labyrinthe;
    };
    
    //----------------------------------------------------------------------------------------------
    // Constructeur d'elem
    //----------------------------------------------------------------------------------------------
    Elem::Elem()
    {   // tous les param sont par défaut
    	debut=false;
    	fin=false;
    	key=false;
    	teleport=false;
    	ligne=-1;
    	colonne=-1;
    	cpt=-5; // on doit juste initaliser à une valeur inférieure à 0
    }
    
    //----------------------------------------------------------------------------------------------
    // Class Labyrinthe
    //----------------------------------------------------------------------------------------------
    class Labyrinthe
    { 
    private:
    	int n; // ligne 
    	int m; // colonne
    	int cle; // nb de clefs dans le labyrinthe
    	int tel; // nb de teleporteurs dans le labyrinthe
    public:
    	int in_x, in_y; // sauvegarde juste les coordonnées de l'entrée
    	Labyrinthe(int,int, int, int); // constructeur
    	~Labyrinthe(); // destructeur
    	Elem** M; // pointeur de pointeur d'elem permet d'accéder à la matrice
    	void Init_Lab(); // initialise le labyrinthe
    	void in_out();
    	void Key();
    	void Teleporter();
    	void Print();
    	void BB(int, int);
    
    };
    
    //----------------------------------------------------------------------------------------------
    // Constructeur
    //----------------------------------------------------------------------------------------------
    Labyrinthe::Labyrinthe(int x,int y, int c, int t)
    {
    	n=x;
    	m=y;
    	cle=c;
    	tel=t;
    	M=new Elem* [n]; // création dynamique
    	for ( unsigned short i=0; i<n; i++ )
    		M[i]=new Elem [m];
    	Init_Lab(); // appel de la fonction initialisation labyrinthe
    }
    
    //----------------------------------------------------------------------------------------------
    // Destructeur
    //----------------------------------------------------------------------------------------------
    Labyrinthe::~Labyrinthe ()
    {
    	for (unsigned short i=0; i<n; i++ )
    		delete M[i];
    	delete M;
    }
    
    //----------------------------------------------------------------------------------------------
    // Fonction Init_Lab
    //----------------------------------------------------------------------------------------------
    void Labyrinthe::Init_Lab ()
    {
    	in_out(); // mise en place de l'entrée et de la sortie
    	Key(); // mise en place des clefs
    	Teleporter(); // mise en place des teleporteur
    }
    
    //----------------------------------------------------------------------------------------------
    // Fonction In_out
    //----------------------------------------------------------------------------------------------
    void Labyrinthe::in_out ()
    {
    	unsigned seed = time(NULL);
    	srand (seed); // utilisation du random
    	int i,j;
    	i=rand()%n;
    	M[0][i].debut=true; // on place le debut sur la première ligne
    	in_x=0; // sauvegarde des coord du début
    	in_y=i;
    	j=rand()%n;
    	M[n-1][j].fin=true; // et la fin sur la dernière ligne
    }
    
    //----------------------------------------------------------------------------------------------
    
    void Labyrinthe::Key()
    {
    	unsigned seed = time(NULL);
        srand(seed);
    	int h=0; // nbr de clefs placées dans le labyrinthe
    	while (h<cle)
    	{
    		int i,j;
    		i=rand()%n;
    		j=rand()%m;
    		if (!M[i][j].key && !M[i][j].debut && !M[i][j].fin )
    		// la case ne peut pas déjà posséder une clef, ni être le début ou la fin du
            // labyrinthe, ni un teleport, mais il ne sert à rien de tester ça pour le
            // moment, aucun teleport n'a déjà été placé
    		{
            	M[i][j].key=true;
    			h++;
    		}
    	}
    }
    
    //----------------------------------------------------------------------------------------------
    // Fonction Teleporter
    //----------------------------------------------------------------------------------------------
    void Labyrinthe::Teleporter()
    {
    	unsigned seed = time(NULL);
    	srand(seed);
    	int h=0; // cpt de teleporter déjà placé
    	while (h<tel)
    	{
    		int i,j;
    		i=rand()%n;
    		j=rand()%m;
    		if (!M[i][j].key && !M[i][j].debut && !M[i][j].fin && !M[i][j].teleport )
            // la case ne peut être ni une clef, ni le début, ni la fin, ni un teleport
    		{
    			M[i][j].teleport=true;
    			M[i][j].ligne=rand()%n; // il faudrait bcp de malchance pour que 
    			M[i][j].colonne=rand()%m; // les teleport fassent des cycles ...
    			h++;
    		}
    	}
    }
    
    //----------------------------------------------------------------------------------------------
    // Fonction Print
    //----------------------------------------------------------------------------------------------
    void Labyrinthe::Print()
    // uniquement des artifices d'affichage
    {
    	for (int i=0; i<n; i++ )
    	{
    		cout << "-";
    		for (int j=0; j<m; j++)
    			cout<< "--";
    	    cout << endl;
    	    for (int j=0; j<m; j++)
    		{
    			cout << "|";
    			if (M[i][j].debut)
    				cout << "D";
    			else if (M[i][j].fin)
    				cout << "F";
    			else if (M[i][j].key)
    				cout << "K";
    			else if (M[i][j].teleport)
    				cout << "T";
    			else 
    				cout << " ";
    		}
    		cout << "|";
    		cout << endl;
    	}
    	cout << "-";
    	for (int j=0; j<m; j++)
    
    		cout<< "--";
    }
    
    //----------------------------------------------------------------------------------------------
    // Fonction BB ( branch and bound )
    //----------------------------------------------------------------------------------------------
    void Labyrinthe::BB(int line,int column)
    {
    	int x1, y1;
        if( M[line][column].fin && cpt_key==cle) // si on arrive sur la case fin et que l'on a
                                                 // toutes les clefs, c'est fini
    	{
    		if(sol_part<sol)
    			sol=sol_part;
    	}
    	else
    	{
            for (int i=0; i<4 ; i++) // sinon on teste les 4 direction possible
    		{
                x1=line+vx[i];
                y1=column+vy[i];
    			if ((x1>=0 && x1<n) && (y1>=0 && y1<m) && (M[x1][y1].cpt<cpt_key))
    			{
                    int j=cpt_key; // sauvegarde du nbr de clé
    				if(M[x1][y1].key) // cas d'une case cle
    				{
    					cpt_key++; // augmentation du compteur de cle
    					M[x1][y1].key=false; // la cle disparait -> booleen passe a false
    				}
    				sol_part++; // on avance d'une case
    				int save=M[x1][y1].cpt; // sauvegarde du nbr de clé lors du dernier
                                            // passage sur la case
                    M[x1][y1].cpt=cpt_key; // on assigne à cette valeur le nbr de cle actuel
    				if(sol_part<=sol) // si le nbr de case n'a pas dépassé de le nbr de case max
    				{
    					if(M[x1][y1].teleport) // cas d'un teleporteur
    					{
    						x1=M[x1][y1].ligne;
    						y1=M[x1][y1].colonne;  // on sauve les coord, qui seront notre
                                                   // prochain point
    					}
    					BB(x1,y1); // appel récursif
    				}
                    sol_part--;
    				M[x1][y1].cpt=save;
    				if(cpt_key>j)
    				{
    					cpt_key--;
    					M[x1][y1].key=true;
    				}
    			}
    		}
    	}
    }
    
    
    
    //----------------------------------------------------------------------------------------------
    		
    void main()
    {
    	int x, y, c, t, q;
    	cout << "Entrez le nombre de lignes souhaitees :" << endl;
    	cin >> x;
    	cout << endl << "Entrez le nombre de colonnes souhaitees :" << endl;
    	cin >> y;
    	cout << endl << "Entrez le nombre de clefs souhaitees :" << endl;
    	cin >> c;
    	cout << endl << "Entrez le nombre de teleporteurs souhaitees :" << endl;
    	cin >> t;
    	Labyrinthe L (x,y,c,t);
    	cout << endl << endl;
    	L.Print();
    	L.BB(L.in_x,L.in_y);
    	if (sol==INT_MAX)
    		cout << endl << endl << "Pas de solution";
    	else 
    		cout << endl << endl << sol;
    	
    	cout << endl << "Appuyez sur une touche pour quitter :" << endl;
    	cin >> q;
    }
    
    créé un labyrinthe avec un système de case clé et téléporteurs et trouve la maniere la plus courte d'en sortir

    Assembleur :

    Code:
    XOR EAX,EAX ;mise à 0
    XOR ESI,ESI  ; mise à 0
    MOV ECX,[m] ; m = nb colonne
    MOV EDI,[n]   ; n = nb ligne
    MOV EBP,1
    
    Bcle1:
    MOV EBX,EDI        ; on assigne le nb de ligne à EBX
    XOR ESI,ESI         ; on met à 0
    ADD ESI,EAX        ; on avance d'une colonne
    XOR [A+ESI*4], EBP ; on est sur la case a la ligne 0 et on fait le XOR avec la colonne exposant 0 cad tjr 1
    ADD ESI,ECX        ; on avance d'une ligne
    DEC EBX              ; on décrémente EBX ( le nb de ligne )
    XOR [A+ESI*4],EAX ; on est sur la case à la ligne 1 et on fait le XOR avec la colonne exposant 1 cad la                                 ; colonne elle-meme
    ADD ESI,ECX        ; on avance d'une ligne
    DEC EBX              ; on décrémente EBX ( le nb de ligne )
    MOV EDX,EAX       ; on assigne le numéro de la colonne
    
    Bcle2:
    IMUL EDX,EAX           ; on multiplie le numéro de la colonne par lui meme
    XOR [A+ESI*4],EDX ; XOR avec la colonne exposant la ligne
    ADD ESI,ECX        ; on avance d'une ligne
    DEC EBX               ; on décrémente EBX
    JNZ Bcle2              ; lorsque EBX ( les lignes ) vaut 0 on sort de la 
    boucle
    INC EAX                ; on incrémente EAX de 1
    LOOP Bcle1            ; tant que ECX ( les colonnes ) ne vaut pas 0 on continue
    ça décryptait un message donné ...

    Visual Basic :

    Code:
    Dim strmot As String, strlettre As String * 1, strletmot As String * 1
    Dim strletprec As String, strletinter As String * 1, stretap As String
    Dim intlmot As Integer, inti As Integer, interreur As Integer
    Dim blntrouve As Boolean
    Const PENDU = 8
    
    Private Sub Form_Load()
    
    'le bonhomme est tout caché
    Shape1.Visible = False
    Shape2.Visible = False
    Shape3.Visible = False
    Shape4.Visible = False
    Shape5.Visible = False
    Line8.Visible = False
    Line9.Visible = False
    Line10.Visible = False
    End Sub
    
    Private Sub Command1_Click()
    
    'le bonhomme est re-tout caché lorsqu'on clique sur démarrer
    Shape1.Visible = False
    Shape2.Visible = False
    Shape3.Visible = False
    Shape4.Visible = False
    Shape5.Visible = False
    Line8.Visible = False
    Line9.Visible = False
    Line10.Visible = False
    
    'entrer le mot
    strmot = InputBox("Entrez le mot a découvrir", "JOUEUR 1", "*^*^*^*^*^*^*", 5000, 8000)
    intlmot = Len(strmot)
    stretap = ""
    For inti = 1 To intlmot Step 1
       stretap = stretap & "-"
    Next inti
    Text1.Text = stretap
    interreur = 0
    
    'entrer lettre par lettre
    Do
        strlettre = InputBox("Découvrez une lettre du mot caché", "JOUEUR 2", , 5000, 8000)
        strprec = stretap
        stretap = ""
        blntrouve = False
        For inti = 1 To intlmot Step 1
            strletmot = Mid(strmot, inti, 1)
            If strletmot = strlettre Then
                stretap = stretap & strlettre
                blntrouve = True
            Else
                strletint = Mid(strprec, inti, 1)
                stretap = stretap & strletint
            End If
        Next inti
        If blntrouve = False Then
            interreur = interreur + 1
        End If
        
        'apparition du bonhomme successivement
        Select Case interreur
            Case 1
            Shape1.Visible = True
            Case 2
            Shape2.Visible = True
            Case 3
            Shape3.Visible = True
            Case 4
            Shape4.Visible = True
            Case 5
            Shape5.Visible = True
            Case 6
            Line8.Visible = True
            Case 7
            Line9.Visible = True
            Case 8
            Line10.Visible = True
        End Select
            Text1.Text = stretap
    Loop Until interreur = PENDU Or strmot = stretap
    
    'message de fin
    If interreur = PENDU Then
        MsgBox ("Looser")
    Else
        MsgBox ("congratulations")
    End If
    
    End Sub
    un petit bonhomme pendu :D

    vala vala :p
    THiBOo, 12 Juin 2003
    #44
  5. Offline
    titloup Elite
    LoL

    Kekum... c'était un exemple de portabilité... vois-tu s'il veut utiliser ses EXE sous LINUX depuis WINDOWS... il n'a que 1 seul choix :arrow: DELPHI et inversément :arrow: KYLIX

    Maintenant s'il veut se compliquer la vie il fait du Assembleur sous Mainframe... mais là ce sera un tit peu plus compliqué pour avoir la machine qui va avec... :twisted:
    titloup, 12 Juin 2003
    #45
  6. Offline
    ProfX Elite
    qu est ce que c est que ces conneries de dire que le quickbasic c etait depasse ??????????

    je te pondd n importe quoi comme prog de gestion de base de donnee la dessus
    et tu vera si c est depâsse bande de newbies pffffffffffffff

    si tu veut aller vers le vb moi je ne te conseille pas le quick avant . y a plein de petite fonction tellement pratique sous quick qui n ont pas ete reprise sous vb
    le swap par exemple snif
    moi je m en fout je l ai recree mais bon y a surement d autre fonction qui ont ete abandonnee , mais je les ai pas en tete pour le moment

    perso quand j ai besoin d un petit truc rapide sans interface ecran , je taf en quick
    et si j ai besoin d une interface un peu compliquee , je prend le vb
    ProfX, 12 Juin 2003
    #46
  7. Offline
    titloup Elite
    GG les exemples... mais faut lui dire qu'il faut un minimum de connaissance pour n'importe quel langage :wink:

    Mais n'empêche l'assembleur ROXE... j'ai même fait un jeu graphique avec ce machin... avec seulement 3000 lignes :D

    Mais quand on voit les DEMOS de certains http://www.assembly.org
    titloup, 12 Juin 2003
    #47
  8. Offline
    THiBOo Elite
    C++ c'est tout :p

    Nan y en a d'autre hin mais C++ c'est tellement bien :D
    THiBOo, 12 Juin 2003
    #48
  9. Offline
    THiBOo Elite
    heu clair faut un minimum de connaissance :shock: les cours restent ce qui se fait de mieux ... si tu t'en sens le courage achète un bouquin 'programmation en C++' au édition Schaum's est un très bon début ( mon premier bouquin :cry: :oops: ) tu verras si t'y arrive ou pas ;)

    pour l'assembleur pas mal le truc de 3000 lignes :D et clair y en a qui font de ces truc :shock: faudra m'expliquer :D déjà que j'ai jamais assez avec mes 7 registre :p

    pour C++ aussi y a des exemples, regarde tout les jeux auxquel tu joue ... regarde hlguard, regarde wwcl ... du C++ :D

    j'ai matté un peu le source de wwcl et hlguard :shock: omg

    captais rien :D
    THiBOo, 12 Juin 2003
    #49
  10. Offline
    titloup Elite
    Mais c'est pas parce que tu fais du QBasic qu'on peut dire que tout le monde fait ça :p

    Ajourd'hui on n'utilise que des langages OO, et je ne pense pas que Qbasic en soit une... tout comme pour le C et le Pascal...

    Chacun développe dans ce qu'il veut... mais je préfére de loin mon environnement RAD pour me faire vite mon tit programme et avoir toute l'aide et DEBUGGER dérriére... :wink:
    titloup, 12 Juin 2003
    #50
  11. Offline
    ProfX Elite
    si il veut faire des petit truc sans pretentions avec le quick basic c est fastoche a mort
    et parfaitement lisible comme language c est pratiquement de la langue parlee
    en plus tu as une aide pas mal faite dedans
    ProfX, 12 Juin 2003
    #51
  12. Offline
    titloup Elite
    Erf... il n'y a pas 12 registres? Je pense que oui... dois aller vérifier :wink:
    titloup, 12 Juin 2003
    #52
  13. Offline
    titloup Elite
    Un tit programme en assembleur qui affiche des LEDS à l'écran

    Code:
    .MODEL SMALL
    
    .STACK 100h
    
    .486     
    
    .DATA
    
    MENU    DB  '  * CHOISISSEZ LA SEQUENCE 1, 2, 3 OU 0 POUR ARRETER: ','$'
    NOEL    DB  '* MERCI ET AU REVOIR *'
    
    POS     DW  ?                       ; VARIABLE POUR L'IMPRESSION DE "NOEL"
    SAUV    DW  ?                       ; SAUVEGARDE (BX) POUR LA SEQUENCE 2
    TEMPS   DD  600                     ; "PARAMETRE TEMPS" - VITESSE AFFICHAGE 
    
    .CODE
    	    ; ***********************************************************
    	    ; *    ADRESSE DES VARIABLES DANS LE REGISTRE SEGMENT DS    *
    	    ; ***********************************************************
    
                    MOV AX,@DATA        ; AX <= ADRESSE DES VARIABLES DE "DATA" 
                    MOV DS,AX           ; DS <= AX                
    
    	    ; ***********************************************************
    	    ; *  NETTOYAGE DE L'ECRAN, PASSAGE A LA LIGNE SUIVANTE POUR *  
    	    ; *   AFFICHAGE DU MENU DES SEQUENCES ET DES LEDS ETEINTS   *                
    	    ; ***********************************************************
    
          PROPRE:
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV DX,378h         ; DX <= 378h
                    MOV AL,00000000b    ; AL <= 00000000b
                    OUT DX,AL           ; AFFICHAGE SUR LA CARTE DE AL
    
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV AH,0            ; AH <= 0         
                    MOV AL,3            ; AL <= 3
                    INT 10h             ; INTERRUPTION - NETTOYAGE DE L'ECRAN 
    
                    MOV AH,0Eh          ; AH <= 0Eh
                    MOV AL,0Ah          ; AL <= 0Ah
                    INT 10h             ; INTERRUPTION - SAUT DE LIGNE
                    MOV AL,0Dh          ; AL <= 0Dh
                    INT 10h             ; INTERRUPTION - RETOUR DU CHARIOT
    
                    MOV DX,OFFSET MENU  ; DX <= ADRESSE DE LA VARIABLE "MENU"         
                    MOV AX,DX           ; AX <= DX
                    MOV AH,09h          ; AH <= 09h
                    INT 21h             ; INTERRUPTION - AFFICHAGE DE "MENU"
    				       
                    MOV AX,0B800h       ; AX <= 0B800h
                    MOV ES,AX           ; ES <= AX
    
                    MOV BX,2144         ; BX <= 2144    
                    MOV ES:[BX],WORD PTR 04DBh    ; AFF POSITON BX 1 LED FONCE
    
         AFFREDF:                      
                    CMP BX,2172         ; COMPARAISON DE BX A 2172 
                    JE  CHOIX           ; SI BX = 2172 ALORS BRANCHEMENT "CHOIX"
                    ADD BX,4            ; BX <= BX + 4 
                    MOV ES:[BX],WORD PTR 04DBh    ; AFF POSITION BX 1 LED FONCE
                    JMP AFFREDF         ; BRANCHEMENT A "AFFREDF"
    
    	    ; ***********************************************************
    	    ; *       TRAITEMENT DU CHOIX FAIT PAR L'UTILISATEUR        *
    	    ; ***********************************************************
    
           CHOIX:           
                    MOV BX,2144         ; BX <= 2144
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV AH,1            ; AH <= 1
                    INT 21h             ; INTERRUPTION - CARACTERE ASCII DANS AL
          DIRECT:                      
                    CMP AL,'1'          ; COMPARAISON AL A '1'
                    JE  SEQ1            ; SI AL = 1 ALORS BRANCHEMENT "SEQ1"
                    CMP AL,'2'          ; COMPARAISON AL A '2'
                    JE  SEQ2            ; SI AL = 2 ALORS BRANCHEMENT "SEQ2"
                    CMP AL,'3'          ; COMPARAISON AL A '3'
                    JE  SEQ3            ; SI AL = 3 ALORS BRANCHEMENT "SEQ3"
                    CMP AL,'0'          ; COMPARAISON AL A '0'
                    JE  FERMER          ; SI AL = 0 ALORS BRANCHEMENT "FERMER"
                    JMP PROPRE          ; BRANCHEMENT "DIRECT" CODE ASCII INCONNU
    
    	    ; ***********************************************************
                ; *  RETOUR DE LA$BOUCLE "FREIN" ET RETOUR A LA BONNE PLACE *
    	    ; ***********************************************************
    
           SUITE:
                    CMP AL,'1'          ; COMPARAISON AL A '1' 
                    JE  REDVIF1         ; SI AL = 1 ALORS BRANCHEMENT "REDVIF1"
                    CMP AL,'2'          ; COMPARAISON AL A '2'
                    JE  REDVIF2         ; SI AL = 2 ALORS BRANCHEMENT "REDVIF2"
                    CMP AL,'3'          ; COMPARAISON AL A '3'
                    JE  REDVIF3         ; SI AL = 3 ALORS BRANCHEMENT "REDVIF3"
                    CMP AL,'W'          ; COMPARAISON AL A 'W'
                    JE  RAINBOW         ; SI AL = W ALORS BRANCHEMENT "RAINBOW" 
    
    	    ; ***********************************************************
    	    ; *        DEBUT DU TRAITEMENT DE LA SEQUENCE NOEL 1        *
    	    ; ***********************************************************
    
    	SEQ1:
                    MOV ES:[BX],WORD PTR 0CDBh    ; AFF POSITION BX 1 LED VIF
                    JMP CARTE           ; BRANCHEMENT "CARTE"
         REDVIF1:
                    MOV ES:[BX],WORD PTR 04DBh    ; AFF POSITION BX 1 LED FONCE
                    CMP BX,2172         ; COMPARAISON DE BX AVEC 2172
                    JE  PROPRE          ; SI BX = 2172 BRANCHEMENT "PROPRE"
                    ADD BX,4            ; BX <= BX + 4
                    MOV ES:[BX],WORD PTR 0CDBh    ; AFF POSITION BX 1 LED VIF
                    JMP CARTE           ; BRANCHEMENT "CARTE"
    
    	    ; ***********************************************************
    	    ; *        DEBUT DU TRAITEMENT DE LA SEQUENCE NOEL 2        *
    	    ; ***********************************************************
    
    	SEQ2:
                    MOV  ES:[BX],WORD PTR 0CDBh   ; AFF POSITION BX 1 LED VIF
                    MOV  ES:[2172],WORD PTR 0CDBh ; AFF POSITION BX 1 LED VIF
                    MOV  SAUV,2172      ; SAUV <= 2172
                    JMP  CARTE          ; BRANCHEMENT "CARTE"
         REDVIF2:
                    MOV  ES:[BX],WORD PTR 04DBh   ; AFF POSITION BX 1 LED FONCE
                    PUSH BX             ; LIFO <= BX
                    MOV  BX,SAUV        ; BX  <= SAUV
                    MOV  ES:[BX],WORD PTR 04DBh   ; AFF POSITION BX 1 LED FONCE
                    POP  BX             ; BX  <= LIFO
                    CMP  BX,2172        ; COMPARAISON BX AVEC 2172
                    JE   PROPRE         ; SI BX = 2172 ALORS BRANCHEMENT "PROPRE"      
                    ADD  BX,4           ; BX <= BX + 4
                    MOV  ES:[BX],WORD PTR 0CDBh   ; AFF POSITION BX 1 LED VIF
                    PUSH BX             ; LIFO <= BX
                    MOV  BX,SAUV        ; BX <= SAUV
                    SUB  BX,4           ; BX <= BX + 4                      
                    MOV  ES:[BX],WORD PTR 0CDBh   ; AFF POSITION BX 1 LED VIF
                    MOV  SAUV,BX        ; SAUV <= BX
                    POP  BX             ; BX <= LIFO
                    JMP  CARTE          ; BRANCHEMENT "CARTE"
    
    	    ; ***********************************************************
    	    ; *    DEBUT DU TRAITEMENT DE LA SEQUENCE SPECIAL NOEL 3    *
    	    ; ***********************************************************
    
    	SEQ3:
                    MOV ES:[BX],WORD PTR 02DBh    ; AFF POSITION BX 1 LED VERT               
                    JMP CARTE           ; BRANCHEMENT "CARTE"
         REDVIF3:
                    MOV ES:[BX],WORD PTR 01DBh    ; AFF POSITION BX 1 LED BLEU
                    CMP BX,2172         ; COMPARAISON BX AVEC 2172
                    JE  ARRIERE         ; SI BX = 2172 ALORS BRANCHEMENT "ARRIERE"      
                    ADD BX,4            ; BX <= BX + 4
                    MOV ES:[BX],WORD PTR 02DBh    ; AFF POSITION BX 1 LED VERT
                    JMP CARTE           ; BRANCHEMENT "CARTE"
         ARRIERE:
                    MOV AL,'W'          ; AL <= 'W' 
                    MOV ES:[BX],WORD PTR 02DBh    ; AFF POSITION BX 1 LED VERT
                    JMP CARTE           ; BRANCHEMENT "CARTE"
         RAINBOW:
                    MOV ES:[BX],WORD PTR 05DBh    ; AFF POSITION BX 1 LED MAGENTA
                    CMP BX,2144         ; COMPARAISON BX AVEC 2144
                    JE  PROPRE          ; SI BX = 2144 ALORS BRANCHEMENT "PROPRE"
                    SUB BX,4            ; BX <= BX - 4
                    MOV ES:[BX],WORD PTR 02DBh    ; AFF POSITION BX 1 LED MAGENTA
                    JMP CARTE           ; BRANCHEMENT "CARTE"
    
    	    ; ***********************************************************
    	    ; *      AFFICHAGE DES LEDS DE LA CARTE SUR " LPT1 "        *
    	    ; ***********************************************************
    
           CARTE:      
                    PUSH AX             ; LIFO <= AX
                    MOV  DX,378h        ; DX <= 378h 
                    CMP  BX,2144        ; COMPARAISON BX AVEC 2144
                    JE   LED1           ; SI BX = 2144 ALORS BRANCHEMENT "LED1"
                    CMP  BX,2148        ; COMPARAISON BX AVEC 2148
                    JE   LED2           ; SI BX = 2148 ALORS BRANCHEMENT "LED2"
                    CMP  BX,2152        ; COMPARAISON BX AVEC 2152
                    JE   LED3           ; SI BX = 2152 ALORS BRANCHEMENT "LED3"
                    CMP  BX,2156        ; COMPARAISON BX AVEC 2156
                    JE   LED4           ; SI BX = 2156 ALORS BRANCHEMENT "LED4"
                    CMP  BX,2160        ; COMPARAISON BX AVEC 2160
                    JE   LED5           ; SI BX = 2160 ALORS BRANCHEMENT "LED5"
                    CMP  BX,2164        ; COMPARAISON BX AVEC 2164
                    JE   LED6           ; SI BX = 2164 ALORS BRANCHEMENT "LED6"
                    CMP  BX,2168        ; COMPARAISON BX AVEC 2168
                    JE   LED7           ; SI BX = 2168 ALORS BRANCHEMENT "LED7"
                    CMP  BX,2172        ; COMPARAISON BX AVEC 2172
                    JE   LED8           ; SI BX = 2172 ALORS BRANCHEMENT "LED8"
    
    	LED1:
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM1          ; SI AL # '2' ALORS BRANCHEMENT NORM1
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,10000001b   ; AL <= 10000001b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL 
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM1:   
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,10000000b   ; AL <= 10000000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
    	LED2:
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM2          ; SI AL # '2' ALORS BRANCHEMENT NORM2
                    SUB  AX,AX          ; AX <= AX - 1 (= 0)
                    MOV  AL,01000010b   ; AL <= 01000010b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM2:   
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,01000000b   ; AL <= 01000000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED3:                       
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM3          ; SI AL # '2' ALORS BRANCHEMENT NORM3
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00100100b   ; AL <= 00100100b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM3:     
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00100000b   ; AL <= 00100000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED4:                       
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM4          ; SI AL # '2' ALORS BRANCHEMENT NORM4
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00011000b   ; AL <= 00011000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM4:    
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00010000b   ; AL <= 00010000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED5:                       
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM5          ; SI AL # '2' ALORS BRANCHEMENT NORM5
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00011000b   ; AL <= 00011000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM5:     
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00001000b   ; AL <= 00001000b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED6:                       
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM6          ; SI AL # '2' ALORS BRANCHEMENT NORM6
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00100100b   ; AL <= 00100100b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM6:   
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00000100b   ; AL <= 00000100b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED7:                       
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM7          ; SI AL # '2' ALORS BRANCHEMENT NORM7
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,01000010b   ; AL <= 01000010b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM7:   
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00000010b   ; AL <= 00000010b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
    
            LED8:
                    CMP  AL,'2'         ; COMPARAISON AL AVEC '2'
                    JNE  NORM8          ; SI AL # '2' ALORS BRANCHEMENT NORM1
                    SUB  AX,AX          ; AX <= AX - AX (= 0) 
                    MOV  AL,10000001b   ; AL <= 10000001b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"
           NORM8:    
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,00000001b   ; AL <= 00000001b
                    OUT  DX,AL          ; AFFICHAGE SUR LA CARTE DE AL
                    JMP  FREIN          ; BRANCHEMENT A "FREIN"             
    
    	    ; ***********************************************************
    	    ; *             BOUCLE POUR LA TEMPORISATION                *
    	    ; ***********************************************************
         
           FREIN:
                    SUB  DX,DX          ; DX <= DX - DX (= 0)
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    POP  AX             ; AX <= LIFO 
            LENT:
                    MOV  ECX,TEMPS      ; ECX <= TEMPS
          BOUCLE:
                    LOOP BOUCLE         ; TANT QUE ECX > 0 ALORS ECX <= ECX - 1 
                    INC  DX             ; DX <= DX + 1
                    CMP  DX,11000       ; COMPARAISON DX AVEC 11000
                    JNE  LENT           ; SI DX # 11000 ALORS BRANCHEMENT "LENT"
                    SUB  DX,DX          ; DX <= DX - DX (= 0)          
                    JMP  SUITE          ; BRANCHEMENT "SUITE"
    
    	    ; ***********************************************************
    	    ; *            ARRET ET FERMETURE DU PROGRAMME              *
    	    ; ***********************************************************
    
          FERMER:      
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV AH,0            ; AH <= 0          
                    MOV AL,3            ; AL <= 3
                    INT 10h             ; INTERRUPTION - NETTOYAGE DE L'ECRAN
    
                    MOV AH,0Eh          ; AH <= 0Eh
                    MOV AL,0Dh          ; AL <= 0Dh
                    INT 10h             ; INTERRUPTION - RETOUR DU CHARIOT
                    MOV AL,0Ah          ; AL <= 0Ah
                    SUB CX,CX           ; CX <= CX -CX (= 0) 
           INTER:
                    INT 10h             ; INTERRUPTION - SAUT DE LIGNE
                    INC CX              ; CX <= CX + 1 
                    CMP CX,28           ; COMPARAISON CX AVEC 28
                    JNE INTER           ; SI CX # 28 ALORS BRANCHEMENT "INTER"
    			    
                    SUB BX,BX           ; BX <= BX - BX (= 0)       
                    MOV POS,1494        ; POS <= 1494
                                        
    	COLOR:
                    SUB  AX,AX          ; AX <= AX - AX (= 0)
                    MOV  AL,NOEL[BX]    ; AL <= CODE ASCII DE NOEL[BX]
                    ADD  AX,500h        ; AX <= AX + 500h (= COULEUR MAGENTA)
                    PUSH BX             ; LIFO <= BX
                    MOV  BX,POS         ; BX <= POS
                    MOV  ES:[BX],WORD PTR AX      ; AFF POSITION BX CODE DANS AX
                    ADD  BX,2           ; BX <= BX + 2
                    MOV  POS,BX         ; POS <= BX
                    POP  BX             ; BX <= LIFO
                    ADD  BX,1           ; BX <= BX + 1
                    CMP  BX,22          ; COMPARAISON BX AVEC 22     
                    JB   COLOR          ; SI BX < 22 BRANCHEMENT "COLOR"
    
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV AH,1            ; AH <= 1
                    INT 21h             ; INTERRUPTION - CARACTERE ASCII DANS AL
    
                    IN  AL,60h          ; LIT LE PORT 60h
                    CMP AL,1            ; COMPARAISON DE AL AVEC 1
                    JE  PROPRE          ; SI AL = 1 ALORS BRANCHEMENT "PROPRE"
                                        
                    SUB AX,AX           ; AX <= AX - AX (= 0)
                    MOV AH,0            ; AH <= 0          
                    MOV AL,3            ; AL <= 3
                    INT 10h             ; INTERRUPTION - NETTOYAGE DE L'ECRAN
    						 
                    MOV AX,4C00h        ; PREPARATION DE L'ARRET DU PGM
                    INT 21h             ; INTERRUPTION 21h -> ARRET DU PGM     
     END                                ; FERMETURE                                  
    titloup, 12 Juin 2003
    #53
  14. Offline
    THiBOo Elite
    EAX
    EBX
    ECX
    EDX
    ESI
    EDI
    EBP

    J'en vois pas d'autre :eek: les autres sont surtout ESP ( stack pointer et des registre de segment ... mais ceux là je sais pas trop à quoi ils servent :p
    THiBOo, 12 Juin 2003
    #54
  15. Offline
    titloup Elite
    Je ne sais plus... mais je me demande si AX est la moitié de EAX ou si c'est un autre à part... enfin soit... je me suis bien amusé avec ce truc... :D
    titloup, 12 Juin 2003
    #55
  16. Offline
    THiBOo Elite
    Ca c'est du beau prog wolf :D mais si on commence à sortir nos compostions on va pas en sortir :p

    Code:
    // Programme fait par Vandevoorde Thibault groupe informatique : 3
    
    
    # include <iostream.h>
    # include <stdlib.h>
    # include <time.h>
    
    const int taille = 152;
    typedef int matrice3D [3] [taille] [taille];
    void bombe ( matrice3D, int, int, int );
    void matrice_solution ( matrice3D, int, int, int );
    void placement ( matrice3D, int, int );
    void zero ( matrice3D, int, int );
    void affiche ( matrice3D, matrice3D, int, int );
    void rien ( matrice3D, int, int );
    
    // note : l = navigateur du vecteur, h = navigateur de ligne, k = navigateur de colonne
    // j'ai créé une matrice de 2 cases plus grande que celle demandée par l'utilisateur,
    // cela permet d'incrémenter tout autour des bombes de manière aisée. Et aussi de ne pas
    // devoir a chaque fois décrémenter de 1 la valeur entrée par l'utilisateur ( sauf pour le
    // vecteur )
    
    int main ( )
    
    {
    char rep;    // déclaration d'une variable de type charactère
    int nbr , longueur, largeur, l2, h2, k2, cpt=0, cptX=0, q;
    bool die = false, test = false;
    matrice3D M3D, M3D2;     // création de 2 matrice3D
    
    cout << " !!!! Bienvenue dans le fabuleux DEMINEUR 3D tm !!!! " << endl << endl;
    cout << "Entrez le nombre de bombes souhaitees : " << endl << endl;
    cin >> nbr;
    cout << "Entrez le nombre de lignes souhaitees (max 150): " << endl << endl;
    cin >> longueur;
    cout << "Entrez le nombre de colonnes souhaitees (conseil : max 19) : " << endl << endl;
    // si on entre une valeur supérieur à 19, la matrice sera affiché sur plusieurs ligne -> illisible
    cin >> largeur;
    cout << endl << endl;
    zero ( M3D, longueur, largeur );   // initialisation  de ma matrice solution à 0
    matrice_solution ( M3D, longueur, largeur, nbr ); // crée les valeurs de ma matrice solution
    rien ( M3D2, longueur, largeur );  // initialise ma matrice de jeu à inconnue partout ( 555 )
    affiche ( M3D, M3D2, longueur, largeur ); // affiche la matrice jeu
    
    while ( die == false && test == false ) // dès qu'une case retournée est une bombe ou que
                                             // le nombre de drapeaux égale le nbr de bombe et
                                             // sont correctement placés
       {
       cout << "Entrez le numero de la grille : " << endl;
       cin >> l2;
       l2 = l2-1; //permet d'entrer des valeurs comme 1, 2 ou 3 car vecteur est de 0 à 2
       cout << "Entrez le numero de la ligne : " << endl;
       cin >> h2;
       cout << "Entrez le numero de la colonne : " << endl;
       cin >> k2;
       cout << "Cette case est-elle une bombe ?   ( y/n )" << endl;
       cin >> rep;
    
       if ( rep == 'y' ) // si c'est une bombe on initialise la case a drapeau ( 444 )
         {
         M3D2 [l2] [h2] [k2] = 444;
         cptX ++;   // et on incrémente le compteur drapeau de 1
         }
       else if ( M3D [l2] [h2] [k2] == 666 ) // si la case retournée est une bombe
         {
         M3D2 [l2] [h2] [k2] = 777; // init a 777 ( = erreur )
         die = true;      // et die passe à true
         }
       else
         M3D2 [l2] [h2] [k2] = M3D [l2] [h2] [k2];  // sinon la case retournée prend
                                     // la valeur de la case de la matrice solution
       if ( cptX >= nbr )   // test permettant de voir si les drapeaux ont été correctement
                            // placé, et ce test ne commencera qu'après un certain nombre de
         {                  // de drapeaux placés
         for ( int l1=0; l1 < 3; l1++ )
           {
           for ( int h1=1; h1 < longueur+1; h1++ )
             {
             for ( int k1=1; k1 < largeur+1; k1++ )
               {
               if ( M3D [l1] [h1] [k1] == 666 )  // si une case de la matrice solution est une
                 {                               // bombe
                 if ( M3D2 [l1] [h1] [k1] == 444 ) // et si la case de la matrice jeu est un
                   cpt++;   // drapeau, on augmente le compteur de 1.
                 }
               }
             }
           }
         }
       if ( cpt == nbr )  // si le nbr de drapeau = le nbr de bombe
         test = true;     // test passe à true et c'est gagné
       affiche ( M3D, M3D2, longueur, largeur ); // et on affiche a chaque tour la matrice
       }                                         // jeu modifié
    
      if ( die == true ) // si la boucle s'est arreté car die est passé à true
        {
        cout << "Dommage, essayez encore une fois..." << endl; // message d'encouragement
        affiche ( M3D, M3D, longueur, largeur ); // affichage de la solution
        }
      else if ( test == true ) // si la boucle s'est arreté car test est passé à true
        cout<<"BRAVO, vous avez GAGNE !!! reessayez avec plus de bombes... ;-)"<< endl;
      cout << "Appuyer sur une touche pour quitter :" << endl;
      cin >> q;
      return 0;
    
    }
    
    
    
    
    
    
    void matrice_solution ( matrice3D M3D, int longueur, int largeur, int nbr )
    
    {
    bombe ( M3D, nbr, longueur, largeur );  // appel de la fonction bombe
    placement ( M3D, longueur, largeur );   // appel de la fonction placement
    }
    
    void zero ( matrice3D M3D, int longueur, int largeur )
    // initialise toute la matrice à zéro
    {
    for ( int h=0; h <= (longueur+2); h++ )
       {
       for ( int k=0; k <= (largeur+2); k++ )
         {
         M3D [0] [h] [k] = 0;
         M3D [1] [h] [k] = 0;
         M3D [2] [h] [k] = 0;
         }
       }
    }
    
    void bombe ( matrice3D M3D, int nbr, int longueur, int largeur )
    // fonction random
    {
    unsigned seed = time(NULL);
    srand(seed);
    for ( int cpt=0; cpt < nbr;  ) // le compteur ne peut pas etre supérieur au nbr de bombe
       {
       int l, h, k;
       l = rand()%3;    // l = navigateur de vecteur ( de 0 à 2 )
       h = 1+rand()%longueur;   // h = navigateur de lignes ( de 1 à longueur )
       k = 1+rand()%largeur;    // k = navigateur de colonnes ( de 1 à largeur )
       if ( M3D [l] [h] [k] != 666 ) // si la case n'est pas encore une bombe
         {
         M3D [l] [h] [k] = 666; // cette case devient une bombe
         cpt++; // et on augmente compteur de 1
         }
       }
    }
    
    void placement ( matrice3D M3D, int longueur, int largeur )
    // incrémentation des cases autour des bombes
    {
    for ( int l=0; l < 3; l++ )
       {
       if ( l == 0 ) // si on est dans la première grille
         {
         for ( int h=1; h < (longueur+1); h++ )
           {
           for ( int k=1; k < (largeur+1); k++ )
             {
             if ( M3D [0] [h] [k] == 666 )
               {
               for ( int l1 = l; l1 < (l+2); l1++ )
                 {
                 for ( int h1 = (h-1); h1 < (h+2); h1++ )
                   {
                   for ( int k1 = (k-1); k1 < (k+2); k1++ )
                   // incrémentation tout autour de la bombe et dans la grille suivante aussi
                     {
                     if ( M3D [l1] [h1] [k1] != 666 )
                       M3D [l1] [h1] [k1] +=1;
                     }
                   }
                 }
               }
             }
           }
         }
       else if ( l == 1 ) // si on est dans la 2eme grille
         {
         for ( int h=1; h < (longueur+1); h++ )
           {
           for ( int k=1; k < (largeur+1); k++ )
             {
             if ( M3D [1] [h] [k] == 666 )
               {
               for ( int l1 = (l-1); l1 < (l+2); l1++ )
                 {
                 for ( int h1 = (h-1); h1 < (h+2); h1++ )
                   {
                   for ( int k1 = (k-1); k1 < (k+2); k1++ )
                   // incrémentation tout autour de la bombe et dans la grille suivante et précédante
                     {
                     if ( M3D [l1] [h1] [k1] != 666 )
                       M3D [l1] [h1] [k1] += 1;
                     }
                   }
                 }
               }
             }
           }
         }
       else if ( l == 2 )  // si on est dans la 3eme grille
         {
         for ( int h=1; h < (longueur+1); h++ )
           {
           for ( int k=1; k < (largeur+1); k++ )
             {
             if ( M3D [2] [h] [k] == 666 )
               {
               for ( int l1 = ( l-1 ); l1 < (l+1); l1++ )
                 {
                 for ( int h1 = (h-1); h1 < (h+2); h1++ )
                   {
                   for ( int k1 = (k-1); k1 < (k+2); k1++ )
                   // incrémentation tout autour de la bombe et dans la grille précédante
                     {
                     if ( M3D [l1] [h1] [k1] != 666 )
                       M3D [l1] [h1] [k1] += 1;
    
                     }
                   }
                 }
               }
             }
           }
         }
       }
    
    }
    
    void affiche ( matrice3D M3D, matrice3D M3D2, int longueur, int largeur )
    // permet d'afficher la matrice et aussi de faire de jolies petites cases autour ...
    {
    int cpt;
    for ( int l=0; l < 3; l++ )    // permet d'afficher la matrice de manière lisible
       {
       cout << l+1 << "." << endl << endl;
       for ( cpt = 1; cpt < (largeur+1); cpt++ )
         if ( cpt <= 9 )
           cout << " " << cpt << "  ";
         else if ( cpt <= 99 )
           cout << " " << cpt << " ";
    
       cout << endl;
       for ( cpt = 1; cpt < (largeur+1); cpt++ )
         cout << "----";
       cout << endl;
    
       for ( int h=1; h < (longueur+1); h++ )
         {
         for ( int k=1; k < (largeur+1); k++ )
           {
           if ( M3D2 [l] [h] [k] == 444 ) // 444 = drapeau
             cout << " " << "x" << " ";
           else if ( M3D2 [l] [h] [k] == 555 )  // 555 = inconnue
             cout << " " << "?" << " ";
           else if ( M3D2 [l] [h] [k] == 666 ) // 666 = BOMBE
             cout << " " << "B" << " ";
           else if ( M3D2 [l] [h] [k] == 777 ) // 777 = erreur
             cout << " " << "!" << " ";
           else if ( M3D2 [l] [h] [k] <= 9 )
             cout << " " << M3D2 [l] [h] [k] << " ";
           else
             cout << " " << M3D2 [l] [h] [k];
           cout << "|";
           }
         cout << " " << h;
         cout << endl;
         for ( k=1; k < (largeur+1); k++ )
           cout << "----";
         cout << endl;
         }
       cout << endl;
       }
    
    }
    
    
    void rien ( matrice3D M3D2, int longueur, int largeur )
    // initialise une matrice à la valeur 555 = inconnue = ?
    {
    for ( int h=0; h <= (longueur+2); h++ )
       {
       for ( int k=0; k <= (largeur+2); k++ )
         {
         M3D2 [0] [h] [k] = 555;
         M3D2 [1] [h] [k] = 555;
         M3D2 [2] [h] [k] = 555;
         }
       }
    }
    
    
    un joli démineur codé en 3D mais affiché en 2 :p ( suffit de supperposer mentalement les 3 tableaux ;) )
    THiBOo, 12 Juin 2003
    #56
  17. Offline
    THiBOo Elite
    AX c'est sur 16 bits
    EAX sur 32 ;)

    AX est composé de AH ( partie haute, les 8 premiers bit ) et AL ( partie basse, les 8 derniers bits ), ça permet de travailler en 8 bits si il le faut ;) :D
    THiBOo, 12 Juin 2003
    #57
  18. Offline
    titloup Elite
    Ben EAX c'est à part alors... car il n'y a pas de partie haut dans EAX... lol j'en sais plus rien :p

    Vais aller faire dodo :D
    titloup, 13 Juin 2003
    #58
  19. Offline
    RBC9 Elite
    tiens juste pour rire , et puisqu on joue au malin avec Linux ,
    Ton Delphi , tu programmes pour MaC aussi , tant qu on est a faire le con ...

    Juste pour savoir , car entre les théories vaseuses et la réalité , y a une marge .. par exmple , certains corps de metier sont a 90 % en Mac , et ne sont pas pret d en changer ...

    alors tant qu a dire celui la est mieux pour faire joujou et frimer sur Linul ..

    Now , pour je sais plus lequel qui viens lacher "moi j aime pas crosoft je prefere le C++ le trucmuche .. "
    dis mon gars , le c++ Crosoft , et celui de Borland , tu y vois Bcp de diff toi ?
    moi pas . c est le meme language ... une interface et quelques library les separent .

    [/quote]
    Ajourd'hui on n'utilise que des langages OO, et je ne pense pas que Qbasic en soit une... tout comme pour le C et le Pascal...
    [/quote]

    celle là c est le comble .. alors la ... cette info , tu la tiens de ton prof d info , un gars ayant du se recycler dans l enseignement face a son incapacite de se mettre sur le marché ?

    tu seras mort et moi complement pourri , le jour ou les applis de par le monde ecrite dans ces languages OO depasseront les appli existante et tournant a ce jour en vieux "Brol" comme certain disent.
    Des grosses boites en Cobol , ASM370 , voir Fortran , y en a plus que tu ne crois.
    DEs appli en Cliiper (Dbase compilé) , y en a des miliers.


    Alors oui , les nouvelles appli sont crées avec les languages actuels , mais ,c est pas demain qu on aura plus ces vieux languages.


    Pour finir , venir lacher VB c est de la merde , alors que la question est comment faire facilement et rapidement un exe ...

    l'interface VB est simple et accessible , le language est facile , il inculque les regles de bases de la programmation sans en imposer les rigueurs et complexités que l on rencontre souvent en c++

    le Vb est également tout aussi "Puissant" qu le C++ quand a ce que l on peut gerer , creer etc
    par bien des coté il "ressemble" au C, le seul point noir qu on puisse lui reprocher etant sa "lenteur" ...

    PS : Linul , rien a battre , le jour ou j aurai rien a foutre de mes journées , peut être envisagerai de perdre mon temps avec ça ..
    mais a ce jour , j ai un OS , Windows , qui fonctionne correctement , qui ne plante pas pluys ni moins qu un Linul, mais qui a l avantage d être plus rependu , ou tout au moins de beneficier d un parc info bcp plus grand.
    Cet Os , me permet de faire toute les taches nécessaires , cet OS correpond au besoin bureautique de la plupart des sociétés , je te parle pas de serveur , mais de poste de travail
    , ou cet os me permet de faire des tas de choses qu avc Linul je ne opeut meme pas envisager , car inexistant.

    Demain , ou après demain , peut être ...
    mais aujourd hui , faut arreter de venir nous faire chier avec ce truc , sans avoir d autres argumentation que :
    "Moi je Own , j ai Linul .............. Windaube Sux"
    RBC9, 13 Juin 2003
    #59
  20. Offline
    spawny Elite
    Moi je Own , j ai Linul .............. Windaube Sux
    spawny, 13 Juin 2003
    #60
Statut de la discussion:
Fermée.