Need a unique gift idea?
A Pastebin account makes a great Christmas gift
SHARE
TWEET

Untitled

a guest Nov 21st, 2018 87 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1. #include <SFML/Graphics.hpp>
  2. #include <SFML/Audio.hpp>
  3. #include <stdio.h>
  4. #include <time.h>
  5. #include "LevelMAPmatrice.hpp"
  6.  
  7. #define LARGEUR_FENETRE_MENUUN 1360
  8. #define HAUTEUR_FENETRE_MENUUN 800
  9. #define LARGEUR_FENETRE 1360
  10. #define HAUTEUR_FENETRE 800
  11. #define NB_CASE_LAGEUR 32
  12. #define NB_CASE_HAUTEUR 18
  13. #define TAILLE_CASE 40
  14. #define NOMBRE_TEXTURE 19
  15. #define PAS 5
  16. #define PAUSE 5
  17.  
  18. using namespace sf ;
  19.  
  20. typedef struct
  21. {
  22.     int x, y ;
  23. } Point ;
  24. typedef struct
  25. {
  26.     int l, h ;
  27. } Size ;
  28. typedef struct
  29. {
  30.     int r, g, b ;
  31. } CodeRGB ;
  32.  
  33. typedef struct
  34. {
  35.     Point position;
  36.     Point vitesse;
  37.     bool gauche;
  38. } PhysObj;
  39.  
  40. typedef struct
  41. {
  42.     char name[20] ;
  43.     Size t /* t = taille */;
  44.     Point p /* p = position */;
  45.     CodeRGB couleur ;
  46. } Button ;
  47.  
  48. typedef struct
  49. {
  50.     //Il ne doit exister que deux portails a la fois (un rose et un vert), l'autre doit etre efface des qu'un autre est fait
  51.     Point centre;
  52.     int taille;//D�pend de si au sol ou contre un mur
  53.     int isThereAPortal; //true= il y a le portail    false=il n'y a pas de portail
  54.     int coteBloc; //definit sur quel cote du bloc se trouve le portail
  55.     /*
  56.     0=vertical
  57.     1=horizontal
  58.     */
  59.     int couleur;
  60.     /*
  61.     0=vert
  62.     1=rose
  63.     */
  64. } Portail;
  65.  
  66. /* Fonction pour afficher le level */
  67. void importTexture(Texture tab[NOMBRE_TEXTURE]) ;
  68. void level ( int numeroLvl, Texture t[NOMBRE_TEXTURE]) ;
  69. void afficheCaseLvl ( RenderWindow * fenetre, int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], Texture t[NOMBRE_TEXTURE] ) ;
  70. void CopyMatrice(int m1[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], int m2[NB_CASE_HAUTEUR][NB_CASE_LAGEUR] ) ;
  71. void afficheObjet (RenderWindow * fenetre, PhysObj* p, Texture t[NOMBRE_TEXTURE] ) ;
  72. /* Fin fonction pour afficher le level */
  73.  
  74.  
  75. void Viseur(Point * PosVis, Event evenement);
  76. void Deplacement(Event evenement,int * affichagePlayerCote);
  77. void affichageViseur(RenderWindow * fenetre, Point PosVis, Texture t[]);
  78. void affichagePlayerDroit(RenderWindow * fenetre, Texture t[]);
  79. void affichagePlayerGauche(RenderWindow * fenetre, Texture t[]);
  80. void tombe(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], PhysObj* posObj);
  81. void spawn(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR]);
  82. void mur(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR]);
  83. int victoire(RenderWindow * fenetre,int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR]);
  84.  
  85. /*LES PORTAILS*/
  86. void lesPortails(Event evenement,int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Portail *vert,Portail *rose);
  87. int EqDroite(Point *viseur,int i);
  88. void affichePortail(RenderWindow * fenetre, Portail lePortail, Texture t[NOMBRE_TEXTURE]);
  89. int portailVH(Event evenement, int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Portail *lePortail);
  90. void positionPortail(int m[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Event *evenement,Portail *aCreer, Portail place);
  91. void oriPortail (int m[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Portail *aCreer);
  92. /*FIN LES PORTAILS*/
  93.  
  94. /* Fonction du menu */
  95. void DrawButton ( RenderWindow * fenetre, Button b[], int nbBouton, Font font ) ;
  96. void Drawfenetre( RenderWindow * fenetre, Texture texture) ;
  97. void ChoixLevel();
  98. void hoverButton(Event * evenement, Button b[], int n);
  99. int cliqueButton (Event * evenement, Button b[], int n);
  100. void colorButton ( Button * b, CodeRGB c);
  101. void menu2(RenderWindow * menu, int numeroMenu, Texture * fond, Font font) ;
  102. /*Fin fonction menu*/
  103.  
  104.  
  105. void mort(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],RenderWindow * fenJeu);
  106. void detectBouton (int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],PhysObj* posObj, int numeroLvl,int * boutton2);
  107. void porterCube(PhysObj* posObj, Event evenement, int * porter );
  108. void porteCubeEnCour(PhysObj* posObj);
  109.  
  110. PhysObj PosPla {0};
  111.  
  112. /* LE MENU, PAS TOUCHE SALOPE */
  113.  
  114. int main()
  115. {
  116.     int i, nbBouton = 4, nb;
  117.     RenderWindow fenetre (VideoMode(LARGEUR_FENETRE_MENUUN, HAUTEUR_FENETRE_MENUUN), "SFML window");
  118.     Font font;
  119.     font.loadFromFile("arial.ttf");
  120.  
  121.     Texture fondMenu;
  122.     fondMenu.loadFromFile("Fond-menu-1.png");
  123.  
  124.     Music fondMusique;
  125.     fondMusique.openFromFile("space.ogg");
  126.     fondMusique.play();
  127.  
  128.     SoundBuffer choixB;
  129.     choixB.loadFromFile("switch.ogg");
  130.     Sound choix;
  131.     choix.setBuffer(choixB);
  132.  
  133.     SoundBuffer clicB;
  134.     clicB.loadFromFile("clic.ogg");
  135.     Sound clic;
  136.     clic.setBuffer(clicB);
  137.  
  138.  
  139.     /*Cr�ation des boutons du menu*/
  140.     Button menu[nbBouton] ;
  141.     sprintf( menu[0].name, "LEVELS" ) ;
  142.     sprintf( menu[1].name, "CONTROLS" ) ;
  143.     sprintf( menu[2].name, "CREDITS" ) ;
  144.     sprintf( menu[3].name, "EXIT" ) ;
  145.     for ( i=0 ; i<nbBouton ; i++)
  146.     {
  147.         menu[i].couleur.r = 150 ;
  148.         menu[i].couleur.g = 150 ;
  149.         menu[i].couleur.b = 150 ;
  150.         menu[i].p.x = LARGEUR_FENETRE_MENUUN/2 ;
  151.         menu[i].p.y = 375 + 150 * (i-1) ;
  152.         menu[i].t.l = 300 ;
  153.         menu[i].t.h = 100 ;
  154.     }
  155.  
  156.     while (fenetre.isOpen())
  157.     {
  158.         Event evenement;
  159.         while (fenetre.pollEvent(evenement))
  160.         {
  161.             switch (evenement.type)
  162.             {
  163.             case Event::Closed :
  164.                 fenetre.close();
  165.                 break;
  166.             case  Event::MouseMoved :
  167.                 hoverButton(&evenement, menu, nbBouton);
  168.                 break;
  169.             case Event::MouseButtonPressed :
  170.                 choix.play();
  171.                 nb=cliqueButton(&evenement, menu, nbBouton) ;
  172.                 if ( nb != 0 )
  173.                     menu2(&fenetre, nb, &fondMenu, font) ;
  174.                 break;
  175.             }
  176.  
  177.         }
  178.  
  179.         fenetre.clear();
  180.         Drawfenetre(&fenetre, fondMenu);
  181.         DrawButton(&fenetre, menu, nbBouton, font);
  182.         fenetre.display();
  183.  
  184.  
  185.     }
  186.  
  187.  
  188.  
  189.  
  190.     return 0;
  191. }
  192.  
  193.  
  194. void DrawButton ( RenderWindow * fenetre, Button b[], int nbBouton, Font font )
  195. {
  196.     int i ;
  197.  
  198.     for ( i=0 ; i<nbBouton ; i++ )
  199.     {
  200.         RectangleShape buton ( Vector2f ( b[i].t.l, b[i].t.h ) ) ;
  201.         buton.setFillColor ( Color ( b[i].couleur.r, b[i].couleur.g, b[i].couleur.b ) ) ;
  202.         buton.setOrigin ( (b[i].t.l)/2, (b[i].t.h)/2 ) ;
  203.         buton.setPosition ( (b[i].p.x), (b[i].p.y) ) ;
  204.         Text text;
  205.         text.setFont(font);
  206.         text.setString(b[i].name);
  207.         text.setColor(Color::Red);
  208.         text.setOrigin(( text.getGlobalBounds().width)/2, (text.getGlobalBounds().height) );
  209.         text.setPosition( (b[i].p.x), (b[i].p.y) );
  210.         fenetre->draw(buton) ;
  211.         fenetre->draw(text);
  212.     }
  213. }
  214.  
  215. void Drawfenetre( RenderWindow * fenetre, Texture texture)
  216. {
  217.     Sprite sprite(texture);
  218.     fenetre->draw(sprite);
  219. }
  220.  
  221. void colorButton ( Button * b, CodeRGB c)
  222. {
  223.     b->couleur.r = c.r;
  224.     b->couleur.g = c.g;
  225.     b->couleur.b = c.b;
  226. }
  227.  
  228. void hoverButton(Event * evenement, Button b[], int n)
  229. {
  230.  
  231.  
  232.     int i, res=0;
  233.     for (i=0 ; i<n ; i++)
  234.     {
  235.         if ( evenement->mouseMove.x >= (b[i].p.x-(b[i].t.l/2)) && evenement->mouseMove.x <= (b[i].p.x + (b[i].t.l/2))
  236.                 && evenement->mouseMove.y >= (b[i].p.y-(b[i].t.h/2)) && evenement->mouseMove.y <= (b[i].p.y + (b[i].t.h/2)) )
  237.             colorButton(&b[i], {55,65,66});
  238.  
  239.  
  240.         else
  241.             colorButton(&b[i], {150,150,150});
  242.  
  243.     }
  244. }
  245.  
  246.  
  247. int cliqueButton(Event * evenement, Button b[], int n)
  248. {
  249.     int i, res=0;
  250.     if (evenement->mouseButton.button == Mouse::Left)
  251.     {
  252.         for (i=0 ; i<n ; i++)
  253.         {
  254.             if ( evenement->mouseButton.x >= (b[i].p.x-(b[i].t.l/2)) && evenement->mouseButton.x <= (b[i].p.x + (b[i].t.l/2))
  255.                     && evenement->mouseButton.y >= (b[i].p.y-(b[i].t.h/2)) && evenement->mouseButton.y <= (b[i].p.y + (b[i].t.h/2)) )
  256.                 res=i+1;
  257.         }
  258.     }
  259.     return res ;
  260. }
  261.  
  262. void menu2(RenderWindow * menuF, int numeroMenu, Texture * fond, Font font)
  263. {
  264.     int i, nbBouton, nb;
  265.     Texture texture[NOMBRE_TEXTURE] ;
  266.     importTexture(texture);
  267.  
  268.     Texture fondCredit;
  269.     fondCredit.loadFromFile("Credits.png");
  270.     Texture fondControl;
  271.     fondControl.loadFromFile("controle.png");
  272.  
  273.     /* /!\ DEBUT DE CREATION DES PAGES DU MENU /!\ */
  274.  
  275.     nbBouton = 8 ;
  276.     Button menu[nbBouton] ;
  277.     switch (numeroMenu)
  278.     {
  279.     case 1 :
  280.         sprintf( menu[0].name, "LEVEL 1" ) ;
  281.         sprintf( menu[1].name, "LEVEL 2" ) ;
  282.         sprintf( menu[2].name, "LEVEL 3" ) ;
  283.         sprintf( menu[3].name, "LEVEL 4" ) ;
  284.         sprintf( menu[4].name, "LEVEL 5" ) ;
  285.         sprintf( menu[5].name, "LEVEL 6" ) ;
  286.         sprintf( menu[6].name, "LEVEL 7" ) ;
  287.         sprintf( menu[7].name, "BACK" ) ;
  288.         for ( i=0 ; i<nbBouton ; i++)
  289.         {
  290.             menu[i].couleur.r = 150 ;
  291.             menu[i].couleur.g = 150 ;
  292.             menu[i].couleur.b = 150 ;
  293.             if (nbBouton>4)
  294.             {
  295.                 menu[i].p.x = (i/4)*LARGEUR_FENETRE_MENUUN/3 +LARGEUR_FENETRE_MENUUN/3 ;
  296.                 menu[i].p.y = 375 + 150 * (i%4 -1) ;
  297.             }
  298.             else
  299.             {
  300.                 menu[i].p.x = LARGEUR_FENETRE_MENUUN/2 ;
  301.                 menu[i].p.y = 375 + 150 * (i-1) ;
  302.             }
  303.             menu[i].t.l = 300 ;
  304.             menu[i].t.h = 100 ;
  305.         }
  306.         break ;
  307.     case 4 :
  308.         menuF->close();
  309.         break ;
  310.     default :
  311.         nbBouton = 0;
  312.         break;
  313.     }
  314.  
  315.  
  316.  
  317.     /* /!\ FIN DE CREATION DES PAGES DU MENU /!\ */
  318.  
  319.  
  320.     while (menuF->isOpen())
  321.     {
  322.         Event evenement;
  323.         while (menuF->pollEvent(evenement))
  324.         {
  325.             switch (evenement.type)
  326.             {
  327.             case Event::Closed :
  328.                 menuF->close();
  329.                 break;
  330.             case  Event::MouseMoved :
  331.                 hoverButton(&evenement, menu, nbBouton);
  332.                 break;
  333.             case Event::MouseButtonPressed :
  334.                 if (nbBouton != 0)
  335.                 {
  336.                     nb=cliqueButton(&evenement, menu, nbBouton) ;
  337.                     if ( nb != 0 && nb < nbBouton)
  338.                         level(nb, texture);
  339.                     if ( nb == 8 )
  340.                         return;
  341.                 }
  342.                 else if (evenement.mouseButton.button == Mouse::Left)
  343.                     return;
  344.                 break;
  345.             }
  346.  
  347.         }
  348.         menuF->clear();
  349.         switch (numeroMenu)
  350.         {
  351.         case 2 :
  352.             Drawfenetre(menuF, fondControl);
  353.             break;
  354.         case 3 :
  355.             Drawfenetre(menuF, fondCredit);
  356.             break;
  357.         default :
  358.             Drawfenetre(menuF, *fond);
  359.             break;
  360.         }
  361.         if (nbBouton != 0)
  362.             DrawButton(menuF, menu, nbBouton, font);
  363.         menuF->display();
  364.  
  365.     }
  366.  
  367.  
  368. }
  369.  
  370. /* LE MENU, PAS TOUCHE SALOPE */
  371.  
  372.  
  373.  
  374. void level(int numeroLvl, Texture t[NOMBRE_TEXTURE])
  375. {
  376.     PhysObj posObj= {{500,160}};
  377.     Point posVis = {0,0};
  378.     Sprite fond ;
  379.     fond.setTexture(t[8]);
  380.     char nomLvl[10] ;
  381.  
  382.     int matrice[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], a;
  383.     Portail rose = {{400,400},1,1,1,1},vert = {{550,350},1,1,1,0};
  384.  
  385.     //initialise qu'il n'y a pas de portail
  386.     /*
  387.         rose.isThereAPortal=0;
  388.         vert.isThereAPortal=0;
  389.     */
  390.  
  391.     int porter = 0, boutton2 = 0, affichagePlayerCote = 1;
  392.  
  393.     int sortiePortailVertical = 0;
  394.  
  395.  
  396.  
  397.  
  398.     {
  399.         /* Selection du niveau selon le chiffre */
  400.         sprintf(nomLvl, "Niveau %i", numeroLvl) ;
  401.         switch (numeroLvl)
  402.         {
  403.         case 1 :
  404.             CopyMatrice(matrice,LEVELTUTO1) ;
  405.             break ;
  406.         case 2 :
  407.             CopyMatrice(matrice,LEVELTUTO2) ;
  408.             break ;
  409.         case 3 :
  410.             CopyMatrice(matrice,LEVEL3) ;
  411.             break ;
  412.         case 4 :
  413.             CopyMatrice(matrice,LEVEL4) ;
  414.             break ;
  415.         case 5 :
  416.             CopyMatrice(matrice,LEVEL5) ;
  417.             break ;
  418.         case 6 :
  419.             CopyMatrice(matrice,LEVEL6) ;
  420.             break ;
  421.         case 7 :
  422.             CopyMatrice(matrice,LEVEL7) ;
  423.             break ;
  424.         }
  425.         /*fin de selection*/
  426.     }
  427.     spawn(matrice);
  428.     {
  429.         /* Fenetre du niveau */
  430.         RenderWindow app(VideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE), nomLvl);
  431.         app.setMouseCursorVisible(false);
  432.  
  433.         while (app.isOpen())
  434.         {
  435.             Event event;
  436.             while (app.pollEvent(event))
  437.             {
  438.                 if (event.type == Event::Closed || (event.type == Event::KeyPressed && event.key.code == Keyboard::Escape ) )
  439.                     app.close();
  440.                 if(event.type==Event::MouseButtonPressed)
  441.                 {
  442.                     switch (event.mouseButton.button)
  443.                     {
  444.                     case Mouse::Left :
  445.                         positionPortail(matrice,&event,&vert, rose);
  446.                         break ;
  447.                     case Mouse::Right :
  448.                         positionPortail(matrice,&event,&rose, vert);
  449.                         break ;
  450.                     }
  451.                 }
  452.  
  453.                 switch (event.key.code)
  454.                 {
  455.                 case Keyboard::LControl:
  456.                     porter = 0;
  457.                 }
  458.  
  459.                 if (event.type == Event::KeyPressed)
  460.                 {
  461.                     Deplacement(event,&affichagePlayerCote);
  462.                 }
  463.  
  464.                 Viseur(&posVis, event);
  465.                 //lesPortails(event,matrice,&vert,&rose);
  466.             }
  467.             porterCube(&posObj,event,&porter);
  468.             if(porter == 0)
  469.                 tombe(matrice,&posObj);
  470.             if(porter == 1)
  471.                 porteCubeEnCour(&posObj);
  472.  
  473.             mur(matrice);
  474.             tombe(matrice, &PosPla);
  475.  
  476.             if(sortiePortailVertical == 1)
  477.             {
  478.  
  479.             }
  480.  
  481.  
  482.             mort(matrice,&app);
  483.             detectBouton(matrice,&posObj,numeroLvl,&boutton2);
  484.             app.clear();
  485.             app.draw(fond);
  486.             afficheCaseLvl( &app, matrice, t );
  487.             a = victoire(&app,matrice);
  488.  
  489.  
  490.             /* C'EST ICI QU'IL FAUT RAJOUTER VOS FONCTIONS QUI AFFICHENT DE NOUVEAUx SPRITEs SUR LA FENETRE /!\ NE RIEN MODIFIER AILLEURS !!! */
  491.  
  492.  
  493.             affichePortail(&app,vert,t);
  494.             affichePortail(&app,rose,t);
  495.  
  496.  
  497.  
  498.             if (affichagePlayerCote == 1)
  499.                 affichagePlayerDroit(&app,t);
  500.             if (affichagePlayerCote == 0)
  501.                 affichagePlayerGauche(&app,t);
  502.  
  503.  
  504.  
  505.  
  506.             if (numeroLvl==1 || numeroLvl==3 || boutton2==1)
  507.             {
  508.                 afficheObjet(&app,&posObj,t);
  509.                 tombe(matrice,&posObj);
  510.             }
  511.             affichageViseur(&app,posVis,t);
  512.  
  513.             /* fin */
  514.  
  515.             app.display();
  516.             if (a == 1)
  517.             {
  518.                 sleep(seconds(2));
  519.                 app.close();
  520.             }
  521.         }
  522.         /*fin fenetre*/
  523.     }
  524. }
  525.  
  526.  
  527.  
  528. /* PAS TOUCHE A MES FONCTIONS S'IL VOUS PLAIT */
  529.  
  530. // Fonction qui permet d'afficher chaque case en fonction de son nombre dans la matrice
  531. void afficheCaseLvl ( RenderWindow * fenetre, int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], Texture t[NOMBRE_TEXTURE] )
  532. {
  533.     int i, j, nb ;
  534.     for (i=0 ; i<NB_CASE_HAUTEUR; i++)
  535.     {
  536.         for (j=0 ; j<NB_CASE_LAGEUR ; j++)
  537.         {
  538.             Sprite carre ;
  539.             carre.setPosition((j+1)*TAILLE_CASE,(i+1)*TAILLE_CASE) ;
  540.             switch ( matCases[i][j] )
  541.             {
  542.             case 0 :
  543.                 carre.setTexture(t[0]);
  544.                 break ;
  545.             case 1 :
  546.                 carre.setTexture(t[1]);
  547.                 break ;
  548.             case 2 :
  549.                 carre.setTexture(t[2]);
  550.                 break ;
  551.             case 3 :
  552.                 carre.setTexture(t[3]);
  553.                 break ;
  554.             case 4 :
  555.                 carre.setTexture(t[4]);
  556.                 break ;
  557.             case 5 :
  558.                 carre.setTexture(t[5]);
  559.                 break ;
  560.             case 6 :
  561.                 carre.setTexture(t[6]);
  562.                 break ;
  563.             case 7 :
  564.                 carre.setTexture(t[7]);
  565.                 break ;
  566.             case 9 :
  567.                 carre.setTexture(t[9]);
  568.                 break ;
  569.             }
  570.  
  571.             fenetre->draw(carre);
  572.         }
  573.     }
  574. }
  575.  
  576. /* Liste des def de blocs
  577. 0=bloc null
  578. 1=bloc sans portail
  579. 2=bloc portail
  580. 3=kill
  581. 4=bloc reset portail
  582. 5=bouton
  583. 6=arrivee
  584. 7=spawn
  585. 8=bordure
  586. 9=cubeLave
  587. 10=curseur
  588. 11=player
  589. 12=TirV
  590. 13=TirR
  591. 14=cube
  592. 15=portailBleu
  593. 16=portailBleu - Cote
  594. 17=portailOrange
  595. 18=portailOrange - Cote
  596. */
  597.  
  598. // Fonction qui permet de copier une matrice dans une autre
  599. void CopyMatrice(int m1[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], int m2[NB_CASE_HAUTEUR][NB_CASE_LAGEUR] )
  600. {
  601.     int i, j ;
  602.     for (i=0 ; i<NB_CASE_HAUTEUR ; i++)
  603.     {
  604.         for (j=0 ; j<NB_CASE_LAGEUR ; j++)
  605.             m1[i][j]=m2[i][j];
  606.     }
  607. }
  608.  
  609. void afficheObjet (RenderWindow * fenetre, PhysObj* p, Texture t[NOMBRE_TEXTURE] )
  610. {
  611.     Sprite cube ;
  612.     cube.setTexture(t[14]) ;
  613.     cube.setOrigin(0,TAILLE_CASE-10);
  614.     cube.setPosition(p->position.x,p->position.y);
  615.     fenetre->draw(cube);
  616. }
  617.  
  618. void importTexture(Texture tab[NOMBRE_TEXTURE])
  619. {
  620.     tab[0].loadFromFile("vide.png");
  621.     tab[1].loadFromFile("blockNon.png");
  622.     tab[2].loadFromFile("blockOui.png");
  623.     tab[3].loadFromFile("deathBlock.png");
  624.     tab[4].loadFromFile("barrier.png");
  625.     tab[5].loadFromFile("bouton.png");
  626.     tab[6].loadFromFile("fin.png");
  627.     tab[7].loadFromFile("spawn.png");
  628.     tab[8].loadFromFile("bordure.png");
  629.     tab[9].loadFromFile("lave.png");
  630.     tab[10].loadFromFile("curseur.png");
  631.     tab[11].loadFromFile("player.png");
  632.     tab[12].loadFromFile("TirV.png");
  633.     tab[13].loadFromFile("TirR.png");
  634.     tab[14].loadFromFile("cube.png");
  635.     tab[15].loadFromFile("portailBleu.png");
  636.     tab[16].loadFromFile("portailBleu - Cote.png");
  637.     tab[17].loadFromFile("portailOrange.png");
  638.     tab[18].loadFromFile("portailOrange - Cote.png");
  639. }
  640.  
  641. void Viseur(Point * PosVis, Event evenement)
  642. {
  643.     if (evenement.type == Event::MouseMoved)
  644.     {
  645.         PosVis->x=evenement.mouseMove.x;
  646.         PosVis->y=evenement.mouseMove.y;
  647.     }
  648. }
  649.  
  650. void Deplacement(Event evenement,int * affichagePlayerCote)
  651. {
  652.     if (evenement.key.code == Keyboard::Left || evenement.key.code == Keyboard::Q)
  653.     {
  654.         PosPla.position.x-=PAS;
  655.         *affichagePlayerCote = 0;
  656.     }
  657.     if (evenement.key.code == Keyboard::Right || evenement.key.code == Keyboard::D)
  658.     {
  659.         PosPla.position.x+=PAS;
  660.         *affichagePlayerCote = 1;
  661.     }
  662.  
  663. }
  664.  
  665. void affichageViseur(RenderWindow * fenetre, Point PosVis, Texture t[])
  666. {
  667.     Sprite viseur;
  668.     viseur.setTexture(t[10]);
  669.     viseur.setOrigin(Vector2f(TAILLE_CASE/2,TAILLE_CASE/2));
  670.     viseur.setPosition(PosVis.x,PosVis.y);
  671.     fenetre->draw(viseur);
  672. }
  673. void affichagePlayerDroit(RenderWindow * fenetre, Texture t[])
  674. {
  675.     Sprite player;
  676.     player.setTexture(t[11]);
  677.     player.setOrigin(0,TAILLE_CASE*2);
  678.     player.setPosition(PosPla.position.x,PosPla.position.y);
  679.     fenetre->draw(player);
  680. }
  681.  
  682. void affichagePlayerGauche(RenderWindow * fenetre, Texture t[])
  683. {
  684.     Sprite player;
  685.     player.setTexture(t[11]);
  686.     player.setOrigin(0,TAILLE_CASE*2);
  687.     player.setPosition(PosPla.position.x,PosPla.position.y);
  688.     player.setTextureRect(IntRect(40, 0, -40, 80));
  689.     fenetre->draw(player);
  690. }
  691.  
  692. void tombe(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], PhysObj* posObj)
  693. {
  694.     Point positionMap ;
  695.     positionMap.x = posObj->position.x/40;
  696.     positionMap.y = posObj->position.y/40;
  697.     if ((matCases[positionMap.y-1][positionMap.x] == 0 && matCases[positionMap.y-1][positionMap.x-1] == 0) || (matCases[positionMap.y-1][positionMap.x-1]==7))
  698.        {
  699.  
  700.     posObj->position.y++;
  701.     printf("AHAHAH");}
  702. }
  703.  
  704. void spawn(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR])
  705. {
  706.     int i, j ;
  707.     for (i=0 ; i<NB_CASE_HAUTEUR; i++)
  708.     {
  709.         for (j=0 ; j<NB_CASE_LAGEUR ; j++)
  710.         {
  711.             if ( matCases[i][j]==7)
  712.             {
  713.                 PosPla.position.x=((j+1)*40)+20;
  714.                 PosPla.position.y=((i+2)*40);
  715.             }
  716.         }
  717.     }
  718.  
  719. }
  720.  
  721. //COLLISIONS MUR
  722. void mur(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR])
  723. {
  724.     Point positionMap ;
  725.     positionMap.x = PosPla.position.x/40;
  726.     positionMap.y = PosPla.position.y/40;
  727.  
  728.     if ((matCases[positionMap.y-2][positionMap.x-1] != 0) && (matCases[positionMap.y-2][positionMap.x-1] != 7) && (matCases[positionMap.y-2][positionMap.x-1] != 5) && (matCases[positionMap.y-2][positionMap.x-1] != 6))
  729.         PosPla.position.x++;
  730.     if ((matCases[positionMap.y-2][positionMap.x] != 0) && (matCases[positionMap.y-2][positionMap.x] != 7) && (matCases[positionMap.y-2][positionMap.x] != 5) && (matCases[positionMap.y-2][positionMap.x] != 6))
  731.         PosPla.position.x--;
  732. }
  733.  
  734.  
  735.  
  736.  
  737. /*-------------------------------------------------------------------------------------------------------------
  738.  
  739. Mettre la fonction portail dans deplacement ou comme fonction apr�s mur et tomb?
  740.  
  741. ---------------------------------------------------------------------------------------------------------------*/
  742.  
  743. /* ***********************************************************************************************************************************************
  744. **************************************************************************************************************************************************
  745. ****************************************LA PARTIE D'EMMY***AVEC LA PARTICIPATION EXHAUSTIVE D'ULYSSE**********************************************
  746. **************************************************************************************************************************************************
  747. *********************************************************************************************************************************************** */
  748.  
  749.  
  750.  
  751. void affichePortail(RenderWindow * fenetre, Portail lePortail, Texture t[NOMBRE_TEXTURE])
  752. {
  753.     if(lePortail.isThereAPortal==1)
  754.     {
  755.         Sprite lePortailImage ;
  756.         if(lePortail.coteBloc==0)
  757.         {
  758.             lePortailImage.setTexture(t[15+lePortail.couleur*2]) ;
  759.             lePortailImage.setOrigin(Vector2f(TAILLE_CASE/4,TAILLE_CASE));
  760.         }
  761.         else
  762.         {
  763.             lePortailImage.setTexture(t[16+lePortail.couleur*2]);
  764.             lePortailImage.setOrigin(Vector2f(TAILLE_CASE,TAILLE_CASE/4));
  765.         }
  766.         lePortailImage.setPosition(lePortail.centre.x,lePortail.centre.y);
  767.         fenetre->draw(lePortailImage);
  768.     }
  769. }
  770.  
  771. void positionPortail(int m[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Event *evenement,Portail *aCreer, Portail place)
  772. {
  773.     Point v,port;
  774.     v.x=(evenement->mouseButton.x)/TAILLE_CASE -1;
  775.     v.y=(evenement->mouseButton.y)/TAILLE_CASE -1;
  776.     port.x=(place.centre.x)/TAILLE_CASE -1;
  777.     port.y=(place.centre.y)/TAILLE_CASE -1;
  778.     if(m[v.y][v.x]==2)
  779.     {
  780.         if((v.y != port.y && (v.y +1) != port.y ) || v.x != port.x)
  781.         {
  782.             if (m[(v.y +1)][v.x] == 2)
  783.             {
  784.                 aCreer->centre.x=(v.x +1)*40 +20;
  785.                 aCreer->centre.y=(v.y +2)*40;
  786.             }
  787.             else if (m[(v.y -1)][v.x] == 2)
  788.  
  789.             {
  790.                 aCreer->centre.x=(v.x +1)*40 +20;
  791.                 aCreer->centre.y=(v.y +1)*40;
  792.             }
  793.             else
  794.             {
  795.                 aCreer->centre.x=(v.x +1)*40 +20;
  796.                 aCreer->centre.y=(v.y +1)*40 +20;
  797.             }
  798.             oriPortail (m, aCreer);
  799.         }
  800.     }
  801. }
  802.  
  803. void oriPortail (int m[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],Portail *aCreer)
  804. {
  805.     Point v,port;
  806.     v.x=(aCreer->centre.x)/TAILLE_CASE -1;
  807.     v.y=(aCreer->centre.y)/TAILLE_CASE -1;
  808.     if(m[(v.y-1)][v.x]==0||m[(v.y+1)][v.x]==0)
  809.     {
  810.         aCreer->coteBloc=1;
  811.     }
  812.     else
  813.     {
  814.         aCreer->coteBloc=0;
  815.     }
  816. }
  817.  
  818.  
  819.  
  820. /*
  821. portails fonctionnels
  822. a travers les murs impossible
  823. */
  824.  
  825.  
  826.  
  827. /*
  828. int EqDroite(Point *posPlayer,Point *viseur,int i){
  829.     int coeff,ord;
  830.     coeff=(viseur->y-posPlayer->y)/(viseur->x-posPlayer->x);
  831.     ord=viseur->y-coeff*viseur->x;
  832.     return coeff*i+ord;
  833. }
  834. */
  835. /* ***********************************************************************************************************************************************
  836. **************************************************************************************************************************************************
  837. ***************************************************FIN DE LA PARTIE D'EMMY************************************************************************
  838. **************************************************************************************************************************************************
  839. *********************************************************************************************************************************************** */
  840.  
  841.  
  842. void porterCube(PhysObj* posObj, Event evenement, int * porter )
  843. {
  844.     int un = 1;
  845.     int zero = 0;
  846.  
  847.     int diffx = posObj->position.x - PosPla.position.x;
  848.     int diffy = posObj->position.y - PosPla.position.y;
  849.  
  850.     if (diffx < 0)
  851.         diffx = diffx * (-1);
  852.     if (diffy < 0)
  853.         diffy = diffy * (-1);
  854.  
  855.  
  856.  
  857.     if ( (diffx <= 30) && (diffy <= 60) )
  858.     {
  859.  
  860.         if (evenement.key.code == Keyboard::Space)
  861.         {
  862.             *porter = un;
  863.         }
  864.     }
  865. }
  866.  
  867. void porteCubeEnCour(PhysObj* posObj)
  868. {
  869.     posObj->position.x = PosPla.position.x;
  870.     posObj->position.y = PosPla.position.y-40;
  871. }
  872.  
  873. void mort(int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR], RenderWindow * fenJeu)
  874. {
  875.     Point positionMap ;
  876.     positionMap.x = PosPla.position.x/40;
  877.     positionMap.y = PosPla.position.y/40;
  878.  
  879.     if ((matCases[positionMap.y-1][positionMap.x] == 3 && matCases[positionMap.y-1][positionMap.x-1] == 3) )
  880.     {
  881.         RenderWindow ecranMort(VideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE), "ECRAN MORT");
  882.         Texture Mortwallpaper ;
  883.         Mortwallpaper.loadFromFile("ecranMort.jpg");
  884.         Sprite mortWalp;
  885.         mortWalp.setTexture(Mortwallpaper);
  886.         ecranMort.draw(mortWalp);
  887.         ecranMort.display();
  888.         fenJeu->close();
  889.         sleep(seconds(3));
  890.         ecranMort.close();
  891.     }
  892. }
  893.  
  894. void detectBouton (int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR],PhysObj* posObj, int numeroLvl,int * boutton2)
  895. {
  896.     Point positionMap ;
  897.     positionMap.x = PosPla.position.x/40;
  898.     positionMap.y = ((PosPla.position.y-45)/40);
  899.  
  900.     Point positionMapCube;
  901.     positionMapCube.x = posObj->position.x/40;
  902.     positionMapCube.y = ((posObj->position.y-45)/40);
  903.     int i;
  904.     if ((matCases[positionMap.y+0][positionMap.x] == 5) || (matCases[positionMap.y][positionMap.x-1] == 5) || (matCases[(positionMapCube.y)][positionMapCube.x] == 5) || (matCases[(positionMapCube.y+1)][positionMapCube.x-1] == 5))
  905.     {
  906.         switch (numeroLvl)
  907.         {
  908.         case 1 :
  909.             for (i=7; i<12; i++)
  910.             {
  911.                 matCases[i][16]=0;
  912.             }
  913.             break ;
  914.         case 3 :
  915.             for (i=13 ; i<21; i++)
  916.             {
  917.                 matCases[13][i] = 2;
  918.             }
  919.             break ;
  920.         case 4 :
  921.  
  922.  
  923.  
  924.             if (*boutton2==0)
  925.             {
  926.                 matCases[12][3]=5;
  927.                 matCases[16][9]=0;
  928.                 matCases[0][3]=2;
  929.                 matCases[0][2]=2;
  930.                 *boutton2=1;
  931.                 //PosPla->x=180;
  932.                 //PosPla->y=180;
  933.  
  934.             }
  935.             else
  936.             {
  937.                 matCases[0][27]=2;
  938.                 matCases[0][28]=2;
  939.                 //printf("AHAH");
  940.             }
  941.  
  942.             break ;
  943.         }
  944.     }
  945.     else
  946.     {
  947.         switch (numeroLvl)
  948.         {
  949.         case 1 :
  950.             for (i=11; i>6; i--)
  951.             {
  952.                 matCases[i][16]=1;
  953.             }
  954.             break ;
  955.         case 3 :
  956.             for (i=21 ; i<12; i--)
  957.             {
  958.                 matCases[13][i] = 2;
  959.             }
  960.             break ;
  961.         case 4 :
  962.  
  963.             if (*boutton2==1)
  964.             {
  965.                 matCases[0][27]=1;
  966.                 matCases[0][28]=1;
  967.             }
  968.  
  969.             break;
  970.         }
  971.     }
  972. }
  973.  
  974. int victoire(RenderWindow * fenetre,int matCases[NB_CASE_HAUTEUR][NB_CASE_LAGEUR])
  975. {
  976.     int res = 0;
  977.     Point positionMap ;
  978.     positionMap.x = PosPla.position.x/40;
  979.     positionMap.y = ((PosPla.position.y-45)/40);
  980.  
  981.     if ((matCases[positionMap.y+0][positionMap.x] == 6) || (matCases[positionMap.y][positionMap.x-1] == 6) )
  982.     {
  983.         printf("GAGNE");
  984.  
  985.  
  986.         Texture Victoire ;
  987.         Victoire.loadFromFile("victoire.png");
  988.         Sprite winEZ;
  989.         winEZ.setTexture(Victoire);
  990.         winEZ.setOrigin(Vector2f(450,100));
  991.         winEZ.setPosition(LARGEUR_FENETRE-(LARGEUR_FENETRE/4)-50,HAUTEUR_FENETRE/2);
  992.         fenetre->draw(winEZ);
  993.  
  994.         res = 1 ;
  995.  
  996.     }
  997.     return res;
  998. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top