Partage
  • Partager sur Facebook
  • Partager sur Twitter

Capter un autre bord que top left ?

    10 novembre 2018 à 0:44:43

    Gros souci que je n'arrives pas a régler.

    J'aimerais créer un projectile qui tournes sur son patern.

    Mon idée était de faire un sprite (qui est invisible, png blanc quoi) qui rotate et qui part dans ma direction souhaitée que voici :

    positionspacer.y += 6;
    sfSprite_rotate(spspacer, -5);
    sfSprite_setPosition(spspacer, positionspacer);
    sfRenderWindow_drawSprite(window, spspacer, NULL);
    Ensuite je place mon autre sprite sur celui ci afin que lui soit fixe, mais tournes autour d'un point sans que l'image du sprite tournes et rendes un effet bizarre, de plus avec ça je peux rendre ma hitbox plus intéressante avec juste un petit point au lieu d'un grand sprite qui rotate.
    positiondot.x = hitboxspacer.left;
    positiondot.y = hitboxspacer.top;
    sfSprite_setPosition(spdot, positiondot);
    sfRenderWindow_drawSprite(window, spdot, NULL);
    Malheureusement même en faisait un +50 en x et y, le sprite "dot" ne bouges pas et reste fixe car la position donnée du spacer (sprite invisible qui tournes) ne changes pas en soi, même si le sprite tournes, il tournes autour de son origine et je places mon dot sur son origine, ce qui ne le fait pas tourner.

    Ma question est ducoup comment avoir le point d'un sprite qui ne soit pas son origine et sur laquelle je pourrais placer mon sprite ?
    Par exemple le coin en bas a droite pourrait marcher car lui tournes, vu que je peux pas faire "hitboxspacer.bottom" et "hitboxspacer.right" et qu'on est limités par top et left, je viens demander l'aider sur ce gentil forum.
    Merci !
    • Partager sur Facebook
    • Partager sur Twitter
      10 novembre 2018 à 0:52:57

      Hello,

      J'ai rien compris, mais si tu veux changer l'origine d'une forme ou d'un sprite avec la SFML, setOrigin(...) est ton ami.

      Et à la limite n'hésite pas à poster ton code, ça peut aider.

      -
      Edité par Guit0Xx 10 novembre 2018 à 0:54:08

      • Partager sur Facebook
      • Partager sur Twitter

      ...

        10 novembre 2018 à 1:01:09

        Guit0Xx a écrit:

        Hello,

        J'ai rien compris, mais si tu veux changer l'origine d'une forme ou d'un sprite avec la SFML, setOrigin(...) est ton ami.

        Et à la limite n'hésite pas à poster ton code, ça peut aider.

        -
        Edité par Guit0Xx il y a 5 minutes

        Dommage j'ai essayé d'être clair haha, mais c'est vrai pas facile a comprendre.

        Oui j'ai déjà set l'origine, mais même en la modifiant, le sprite "spacer" tournera toujours autour de la même origine, et donc ne bougera pas réellement.

        Mon code fait 500 lignes mais ceci en concernes pas énormément, mais je peux le poster si tu veux ;)

        • Partager sur Facebook
        • Partager sur Twitter
          10 novembre 2018 à 1:15:49

          MaximeMrht a écrit:

          Oui j'ai déjà set l'origine, mais même en la modifiant, le sprite "spacer" tournera toujours autour de la même origine, et donc ne bougera pas réellement.

          Que le sprite tourne autour de l'origine c'est normal. Mais si je comprends bien, c'est le mettre en mouvement qui te dérange ?

          MaximeMrht a écrit:

          Mon code fait 500 lignes mais ceci en concernes pas énormément, mais je peux le poster si tu veux ;)

          500 lignes c'est rien ^^. Vas-y poste-le, je le testerai de mon côté.

          -
          Edité par Guit0Xx 10 novembre 2018 à 1:20:41

          • Partager sur Facebook
          • Partager sur Twitter

          ...

            10 novembre 2018 à 1:21:43

            Pardon de faire le nul, mais comment je peux le poster? Juste un copié collé énervé ici ?

            Et en effet c'est normal qu'il tournes autour de ce point, mais j'arrives pas a mettre un autre sprite qui va suivre celui ci sur autre chôse qu'un point d'origine ^^

            #include <stdio.h>
            #include <Windows.h>
            #include <SFML\Graphics.h>
            #include "resource.h"
            #include <time.h> 
            #include <stdlib.h>
            
            enum deplacementennemi
            {
            	GAUCHE = 1,
            	DROITE
            };
            typedef enum deplacementennemi depla;
            
            struct orbs1
            {
            	int isdestroyed;
            	sfVector2f position;
            	float rotation;
            };
            
            void main()
            {
            	///////////////////////////////////////////////////////////////
            	/////   Initialisation des valeurs.                       
            	///////////////////////////////////////////////////////////////
            
            	srand(time(NULL));
            	int orbshot = 0;
            	int droneshot = 0;
            	int ennemis = 0;
            	int bump = 0;
            	depla direction = GAUCHE;
            	int ennemialive = 0;
            	int iskeypressed = 0;
            	int time = 0;
            	int lasershot = 0;
            	int vaisseaualive = 0;
            	int dotshot = 0;
            
            	///////////////////////////////////////////////////////////////
            	/////   Tableau pour les valeurs des tirs.                       
            	///////////////////////////////////////////////////////////////
            
            	sfVector2f orbs[999];
            	int orbcount = 0;
            
            	///////////////////////////////////////////////////////////////
            	/////   Création de la fenêtre.                         
            	///////////////////////////////////////////////////////////////
            
            	sfVideoMode mode = { 1000,1000,32 };
            	sfRenderWindow *window;
            	sfEvent event;
            	window = sfRenderWindow_create(mode, "Fenetre SFML", sfResize | sfClose, NULL);
            	if (!window)
            		return EXIT_FAILURE;
            
            	sfRenderWindow_setFramerateLimit(window, 60); //////////LIMITE DE FRAMES////////////
            
            	  ///////////////////////////////////////////////////////////////
            	  //////////   On crées les sprites.                      
            	  ///////////////////////////////////////////////////////////////
            
            	sfSprite *spvaisseau;
            	spvaisseau = CreateSprite("resources/textures/vaisseau.png");
            
            	sfSprite *sporb;
            	sporb = CreateSprite("resources/textures/orb.png");
            
            	sfSprite *spdrone;
            	spdrone = CreateSprite("resources/textures/drone.png");
            
            	sfSprite *spennemi;
            	spennemi = CreateSprite("resources/textures/ennemi.png");
            
            	sfSprite *spboom;
            	spboom = CreateSprite("resources/textures/boom.png");
            
            	sfSprite *spspace;
            	spspace = CreateSprite("resources/textures/space.jpg");
            
            	sfSprite *splaser;
            	splaser = CreateSprite("resources/textures/laser.png");
            
            	sfSprite *spdot;
            	spdot = CreateSprite("resources/textures/dot.png");
            
            	sfSprite *spspacer;
            	spspacer = CreateSprite("resources/textures/spacer.png");
            
            	///////////////////////////////////////////////////////////////
            	/////   Changement de l'origine du sprite pour qu'elle soit au centre.                         
            	///////////////////////////////////////////////////////////////
            
            	sfVector2f vaisseau = { sfSprite_getGlobalBounds(spvaisseau).width / 2,sfSprite_getGlobalBounds(spvaisseau).height / 2 };
            	sfSprite_setOrigin(spvaisseau, vaisseau);
            	 
            	sfVector2f orb = { sfSprite_getGlobalBounds(sporb).width / 2,sfSprite_getGlobalBounds(sporb).height / 2 };
            	sfSprite_setOrigin(sporb, orb);
            
            	sfVector2f drone = { sfSprite_getGlobalBounds(spdrone).width / 2,sfSprite_getGlobalBounds(spdrone).height / 2 };
            	sfSprite_setOrigin(spdrone, drone);
            
            	sfVector2f boom = { sfSprite_getGlobalBounds(spboom).width / 2,sfSprite_getGlobalBounds(spboom).height / 2 };
            	sfSprite_setOrigin(spboom, boom);
            
            	sfVector2f space = { sfSprite_getGlobalBounds(spspace).width / 2,sfSprite_getGlobalBounds(spspace).height / 2 };
            	sfSprite_setOrigin(spspace, space);
            
            	sfVector2f laser = { sfSprite_getGlobalBounds(splaser).width / 2,sfSprite_getGlobalBounds(splaser).height / 2 };
            	sfSprite_setOrigin(splaser, laser);
            
            	sfVector2f ennemi = { sfSprite_getGlobalBounds(spennemi).width / 2,sfSprite_getGlobalBounds(spennemi).height / 2 };
            	sfSprite_setOrigin(spennemi, ennemi);
            
            	sfVector2f spacer = { sfSprite_getGlobalBounds(spspacer).width / 2,sfSprite_getGlobalBounds(spspacer).height / 2 };
            	sfSprite_setOrigin(spspacer, spacer);
            
            	//sfVector2f dot = { sfSprite_getGlobalBounds(spdot).width / 2, sfSprite_getGlobalBounds(spdot).height / 2 };
            	//sfSprite_setOrigin(spdot, dot);
            
            	sfFloatRect hitboxennemi = sfSprite_getGlobalBounds(spennemi);
            
            	sfFloatRect hitboxvaisseau = sfSprite_getGlobalBounds(spvaisseau);
            
            	sfFloatRect hitboxspacer = sfSprite_getGlobalBounds(spspacer);
            
            	///////////////////////////////////////////////////////////////
            	/////   Positions des sprites.                        
            	///////////////////////////////////////////////////////////////
            
            	sfVector2f positionvaisseau = { 500,850 };
            	sfSprite_setPosition(spvaisseau, positionvaisseau);
            
            	sfVector2f positionorb = { 100,100 };
            	sfSprite_setPosition(sporb, positionorb);
            
            	sfVector2f positiondrone = { -100,-100 };
            	sfSprite_setPosition(spdrone, positiondrone);
            
            	sfVector2f positionennemi = { 460,150 };
            	sfSprite_setPosition(spennemi, positionennemi);
            
            	sfVector2f positionboom = { -200,-200 };
            	sfSprite_setPosition(spboom, positionboom);
            
            	sfVector2f positionspace = { 500,500 };
            	sfSprite_setPosition(spspace, positionspace);
            
            	sfVector2f positionlaser = { -100,-100 };
            	sfSprite_setPosition(splaser, positionlaser);
            
            	sfVector2f positiondot = { -100, -100 };
            	sfSprite_setPosition(spdot, positiondot);
            
            	sfVector2f positionspacer = { -100, -100 };
            	sfSprite_setPosition(spspacer, positionspacer);
            
            	///////////////////////////////////////////////////////////////
            	/////   On rescale la taille des sprites.                         
            	///////////////////////////////////////////////////////////////
            
            	sfVector2f vaisseauscale = { 0.5,0.5 };
            	sfSprite_setScale(spvaisseau, vaisseauscale);
            
            	sfVector2f orbscale = { 0.5,0.5 };
            	sfSprite_setScale(sporb, orbscale);
            
            	sfVector2f dronescale = { 0.5,0.5 };
            	sfSprite_setScale(spdrone, dronescale);
            
            	sfVector2f ennemiscale = { 0.8,0.8 };
            	sfSprite_setScale(spennemi, ennemiscale);
            
            	sfVector2f boomscale = { 0.7,0.7 };
            	sfSprite_setScale(spboom, boomscale);
            
            	sfVector2f spacescale = { 1.5,1.5 };
            	sfSprite_setScale(spspace, spacescale);
            
            	sfVector2f laserscale = { 0.7,0.7 };
            	sfSprite_setScale(splaser, laserscale);
            
            	sfVector2f dotscale = { 0.3,0.3 };
            	sfSprite_setScale(spdot, dotscale);
            
            	///////////////////////////////////////////////////////////////
            	/////   Boucle de jeu.                         
            	///////////////////////////////////////////////////////////////
            
            	while (sfRenderWindow_isOpen(window) && sfKeyboard_isKeyPressed(sfKeyEscape) == sfFalse)
            	{
            		sfRenderWindow_clear(window, sfBlack);
            		while (sfRenderWindow_pollEvent(window, &event))
            		{
            			if (event.type == sfEvtClosed)
            				sfRenderWindow_close(window);
            
            			///////////////////////////////////////////////////////////////
            			/////   If you press a button, it does something                         
            			///////////////////////////////////////////////////////////////
            
            			if (event.type == sfEvtKeyPressed)
            			{
            				if (event.key.code == sfKeySpace && orbshot == 0)
            				{
            					positionorb = sfSprite_getPosition(spvaisseau);
            					sfSprite_setPosition(sporb, positionorb);
            					orbshot = 1;
            					orbs[orbcount].x = positionvaisseau.x;
            					orbs[orbcount].y = positionvaisseau.y;
            					orbcount++;
            				}
            			}
            			else if (event.type == sfEvtKeyReleased)
            			{
            				if (event.key.code == sfKeySpace)
            				{
            					orbshot = 0;
            				}
            			}
            		}
            
            		///////////////////////////////////////////////////////////////
            		/////   Deplacement du sprite. (Vaisseau) Et l'espace qui bouge.                      
            		///////////////////////////////////////////////////////////////
            
            		sfRenderWindow_drawSprite(window, spspace, NULL);
            		sfSprite_rotate(spspace, 0.05);
            
            		if (vaisseaualive == 0)
            		{
            			if (sfMouse_isButtonPressed(sfMouseLeft) && positionvaisseau.x > 100)
            			{
            				positionvaisseau.x -= 8;
            				sfSprite_setPosition(spvaisseau, positionvaisseau);
            			}
            
            			if (sfMouse_isButtonPressed(sfMouseRight) && positionvaisseau.x < 900)
            			{
            				positionvaisseau.x += 8;
            				sfSprite_setPosition(spvaisseau, positionvaisseau);
            			}
            		}
            
            		///////////////////////////////////////////////////////////////
            		/////   Reaction des button pressed                       
            		///////////////////////////////////////////////////////////////
            
            		if (sfKeyboard_isKeyPressed(sfKeyE) == sfTrue && bump == 0 && droneshot == 0)
            		{
            			bump = 1;
            			droneshot = 1;
            		}
            		else if (sfKeyboard_isKeyPressed(sfKeyE) == sfTrue && bump == 1 && droneshot == 0)
            		{
            			bump = 0;
            			droneshot = 1;
            		}
            		else if (sfKeyboard_isKeyPressed(sfKeyE) == sfFalse)
            		{
            			droneshot = 0;
            		}
            
            		if (bump == 1)
            		{
            			positiondrone = sfSprite_getPosition(spvaisseau);
            			sfSprite_setPosition(spdrone, positiondrone);
            			sfSprite_rotate(spdrone, 5);
            		}
            		else if (bump == 0)
            		{
            			positiondrone.x = -100;
            			positiondrone.y = -100;
            			sfSprite_setPosition(spdrone, positiondrone);
            		}
            
            		///////////////////////////////////////////////////////////////
            		/////   Détection et déplacement des ennemis.                       
            		///////////////////////////////////////////////////////////////
            
            		if (ennemialive == 0)
            		{
            			if (positionennemi.x == 50)
            			{
            				direction = DROITE;
            			}
            			else if (positionennemi.x == 950)
            			{
            				direction = GAUCHE;
            			}
            
            			if (direction == GAUCHE)
            			{
            				positionennemi.x -= 5;
            				sfSprite_setPosition(spennemi, positionennemi);
            			}
            			else if (direction == DROITE)
            			{
            				positionennemi.x += 5;
            				sfSprite_setPosition(spennemi, positionennemi);
            			}
            		}
            
            		if (ennemialive == 1)
            		{
            			positionennemi.y -= 2;
            			sfSprite_rotate(spennemi, -10);
            			sfSprite_setPosition(spennemi, positionennemi);
            			positionboom = sfSprite_getPosition(spennemi);
            			sfSprite_rotate(spboom, 5);
            			sfSprite_setPosition(spboom, positionboom);
            		}
            
            		if (positionennemi.y == -100)
            		{
            			ennemialive = 0;
            			positionennemi.y = 150;
            			positionboom.x = -100;
            			positionboom.y = -100;
            			sfSprite_rotate(spennemi, 170);
            		}
            
            		///////////////////////////////////////////////////////////////
            		/////   Compte tours. (Faux temps). + Tirs ennemis.                        
            		///////////////////////////////////////////////////////////////
            
            
            		if (time == 50 || time == 100 || time == 150 || time == 200)
            		{
            			positionlaser.x = positionennemi.x;
            			positionlaser.y = positionennemi.y;
            			sfSprite_setPosition(splaser, positionlaser);
            			sfRenderWindow_drawSprite(window, splaser, NULL);
            			lasershot = 1;
            		}
            
            		if (time > 50 && time <= 275)
            		{
            			positionlaser.y += 16;
            			sfSprite_setPosition(splaser, positionlaser);
            			sfRenderWindow_drawSprite(window, splaser, NULL);
            		}
            
            		if (time == 275)
            		{
            			positionlaser.x = -100;
            			positionlaser.y = -100;
            			sfSprite_setPosition(splaser, positionlaser);
            			time = 0;
            			lasershot = 0;
            			time++;
            
            			///////////////////////////////////////////////////////////////
            			/////   Objet qui rotate.                      
            			///////////////////////////////////////////////////////////////
            
            			positionspacer.x = positionennemi.x;
            			positionspacer.y = positionennemi.y;
            			sfSprite_setPosition(spspacer, positionspacer);
            
            			positiondot.x = positionennemi.x;
            			positiondot.y = positionennemi.y;
            			sfSprite_setPosition(spdot, positiondot);
            			dotshot = 1;
            		}
            		else
            		{
            			printf("%d\n", time);
            			time++;
            
            			positionspacer.y += 6;
            			sfSprite_rotate(spspacer, -5);
            			sfSprite_setPosition(spspacer, positionspacer);
            			sfRenderWindow_drawSprite(window, spspacer, NULL);
            
            			positiondot.x = sfSprite_getGlobalBounds(spspacer).height + sfSprite_getGlobalBounds(spspacer).left;
            			positiondot.y = sfSprite_getGlobalBounds(spspacer).width + sfSprite_getGlobalBounds(spspacer).top;
            			sfSprite_setPosition(spdot, positiondot);
            			sfRenderWindow_drawSprite(window, spdot, NULL);
            		}
            
            		hitboxennemi = sfSprite_getGlobalBounds(spennemi);
            		hitboxvaisseau = sfSprite_getGlobalBounds(spvaisseau);
            
            		///////////////////////////////////////////////////////////////
            		/////   Drawing what we need in the right order.                         
            		///////////////////////////////////////////////////////////////
            
            		if (orbcount < 999)
            		{
            			for (int i = 0; i < orbcount; i++)
            			{
            				orbs[i].y -= 15;
            				sfSprite_setPosition(sporb, orbs[i]);
            				sfRenderWindow_drawSprite(window, sporb, NULL);
            
            				///////////////////////////////////////////////////////////////
            				/////   Hitbox des tirs.   (Dans l'ordre ci dessous pour bien capter.)                   
            				///////////////////////////////////////////////////////////////
            
            				if (orbs[i].x < hitboxennemi.width + hitboxennemi.left
            					&& orbs[i].y < hitboxennemi.height + hitboxennemi.top
            					&& orbs[i].x > hitboxennemi.left
            					&& orbs[i].y > hitboxennemi.top)
            				{
            					ennemialive = 1;
            				}
            			}
            		}
            
            		if (bump == 0)
            		{
            			if (positionlaser.x < hitboxvaisseau.width + hitboxvaisseau.left
            				&& positionlaser.y < hitboxvaisseau.height + hitboxvaisseau.top
            				&& positionlaser.x > hitboxvaisseau.left
            				&& positionlaser.y > hitboxvaisseau.top)
            			{
            				vaisseaualive = 1;
            			}
            		}
            
            		if (vaisseaualive == 1)
            		{
            			positionvaisseau.y += 3;
            			sfSprite_rotate(spvaisseau, -10);
            			sfSprite_setPosition(spvaisseau, positionvaisseau);
            			positionboom = sfSprite_getPosition(spvaisseau);
            			sfSprite_rotate(spboom, 5);
            			sfSprite_setPosition(spboom, positionboom);
            		}
            
            		if (positionvaisseau.y > 1000)
            		{
            			vaisseaualive = 0;
            			positionvaisseau.x = 500;
            			positionvaisseau.y = 850;
            			sfSprite_rotate(spvaisseau, 150);
            			positionboom.x = -100;
            			positionboom.y = -100;
            			sfSprite_setPosition(spvaisseau, positionvaisseau);
            			sfSprite_setPosition(spboom, positionboom);
            		}
            
            		sfRenderWindow_drawSprite(window, spennemi, NULL);
            		sfRenderWindow_drawSprite(window, spvaisseau, NULL);
            		sfRenderWindow_drawSprite(window, spboom, NULL);
            		sfRenderWindow_drawSprite(window, spdrone, NULL);
            
            		///////////////////////////////////////////////////////////////
            		/////   Update the window.                         
            		///////////////////////////////////////////////////////////////
            
            		sfRenderWindow_display(window);
            	}
            	///////////////////////////////////////////////////////////////
            	///// Destroy window.                 
            	///////////////////////////////////////////////////////////////
            
            	sfRenderWindow_destroy(window);
            }
            
            (Petite précision, je suis en CSFML)

            -
            Edité par MaximeMrht 10 novembre 2018 à 1:39:16

            • Partager sur Facebook
            • Partager sur Twitter
              10 novembre 2018 à 1:26:04

              Tu cliques sur ce bouton dans l'éditeur de message :

              Une boîte de dialogue s'ouvrira, puis tu sélectionnes C++ :

              Puis tu colles ton code :)

              -
              Edité par Guit0Xx 10 novembre 2018 à 1:26:12

              • Partager sur Facebook
              • Partager sur Twitter

              ...

                10 novembre 2018 à 1:42:28

                Pour me faire une idée, c'est quelque chose comme ça que tu souhaiterais faire :

                https://youtu.be/hiqNylaI0H8

                -
                Edité par Guit0Xx 10 novembre 2018 à 1:44:24

                • Partager sur Facebook
                • Partager sur Twitter

                ...

                  10 novembre 2018 à 1:44:12

                  Guit0Xx a écrit:

                  Pour me faire une idée, c'est quelque chose comme ça que tu souhaiterais faire :

                  https://youtu.be/hiqNylaI0H8

                  -
                  Edité par Guit0Xx il y a moins de 30s

                  Bingo ! Un rotate autour d'un rotate, enfin si c'est bien ce qui je vois !

                  • Partager sur Facebook
                  • Partager sur Twitter
                    10 novembre 2018 à 1:52:50

                    C'est bien ce que tu vois :).

                    Bon il y a plusieurs façon d'aborder le truc, le plus simple c'est de décaler l'origine du 2éme rectangle (celui qui est censé parcourir un cercle) et de le faire tourner en même temps que le rectangle central. Le code source qui correspond :

                    #include <SFML/Graphics.hpp>
                    
                    int main()
                    {
                        const unsigned WINDOW_WIDTH{1280};
                        const unsigned WINDOW_HEIGHT{720};
                        sf::RenderWindow window{sf::VideoMode{WINDOW_WIDTH, WINDOW_HEIGHT}, "Rotate"};
                    
                        sf::RectangleShape centralRect{sf::Vector2f{32.f, 32.f}};
                        centralRect.setOrigin(16.f, 16.f);
                        centralRect.setPosition(WINDOW_WIDTH/2.f, WINDOW_HEIGHT/2.f);
                    
                        sf::RectangleShape endRect{sf::Vector2f{32.f, 32.f}};
                        endRect.setOrigin(200.f - 16.f, 200.f - 16.f);
                        endRect.setPosition(centralRect.getPosition());
                    
                        sf::Clock clock{};
                        sf::Time dt{};
                        float elapsed{0.f};
                    
                        while(window.isOpen()){
                            sf::Event event{};
                            while(window.pollEvent(event)){
                                if(event.type == sf::Event::Closed)
                                    window.close();
                            }
                    
                            dt = clock.restart();
                    
                            elapsed += dt.asSeconds();
                            if(elapsed > 0.01f){
                                elapsed = 0.f;
                                centralRect.rotate(1.f);
                                endRect.rotate(1.f);
                            }
                    
                            window.clear();
                            window.draw(centralRect);
                            window.draw(endRect);
                            window.display();
                        }
                    
                        return 0;
                    }

                    Après il peut y avoir des approches mathématiques un peu plus complexes selon les besoins.

                    Dans l'exemple que je t'ai donné, les 2 rectangles tournent sur eux-même, c'est une approche simpliste et rapide. Mais si on veut éviter cela, il va falloir faire y aller à coup d'équations trigonométriques (déplacement d'un point sur un cercle) ;).

                    -
                    Edité par Guit0Xx 10 novembre 2018 à 1:56:07

                    • Partager sur Facebook
                    • Partager sur Twitter

                    ...

                      10 novembre 2018 à 1:55:14

                      On a pas encore vu la clock en cours (j'ai 1 mois d'experience avec 5h de cours par semaine, je suis en prépa, dans 4 semaines je passes en full prog sorry) 

                      Après il y a une ou deux fonctions que je ne comprends pas a vue d'oeil mais je pense pouvoir m'en sortir !

                      Je regardes ça demain, je suis vraiment trop fatigué, je te tiens au courant quand je serai frais et dispo demain dans la journée ;)

                      Merci beaucoup pour ton aide rapide, c'est super !

                      (PS : Par contre pour l'origine ça va faire que mon 2eme sprite va tourner aussi non? L'idéal serait que lui reste droit, ça fait plus joli ;) )

                      (Double PS: si tu saurait me le faire en CSFML ce serait parfait, sinon je vais me débrouiller durement pour traduire lol)

                      -
                      Edité par MaximeMrht 10 novembre 2018 à 1:57:27

                      • Partager sur Facebook
                      • Partager sur Twitter
                        10 novembre 2018 à 2:03:49

                        No problemo.

                        Par contre je viens de capter, tu codes en C, je sais pas si c'est voulu mais ce serait mieux de coder en C++ :lol:.

                        MaximeMrht a écrit:

                        On a pas encore vu la clock en cours

                        C'est le Clock de la SFML ;).

                        Sur ce, bonne nuit.

                        EDIT :

                        MaximeMrht a écrit:

                        (PS : Par contre pour l'origine ça va faire que mon 2eme sprite va tourner aussi non? L'idéal serait que lui reste droit, ça fait plus joli ;) )

                        Oui c'est ce que je disais dans le message précédent, dans ce cas là, va falloir sortir le grand jeu à coup d'équations ^^.

                        MaximeMrht a écrit:

                        (Double PS: si tu saurait me le faire en CSFML ce serait parfait, sinon je vais me débrouiller durement pour traduire lol)

                        Désolé ne compte pas sur moi, je n'ai jamais fait de C :D.

                        -
                        Edité par Guit0Xx 10 novembre 2018 à 2:10:43

                        • Partager sur Facebook
                        • Partager sur Twitter

                        ...

                          10 novembre 2018 à 7:44:42

                          Hello,

                          Juste une remarque rapide. 500 lignes de code c'est peut être rien, mais un main de 440 lignes c'est énorme par contre ^^". Prends le temps de découper ton code en fonctions, ça rendra tes futures modifications bien plus aisées :)

                          • Partager sur Facebook
                          • Partager sur Twitter
                            10 novembre 2018 à 19:49:36

                            Elried a écrit:

                            Hello,

                            Juste une remarque rapide. 500 lignes de code c'est peut être rien, mais un main de 440 lignes c'est énorme par contre ^^". Prends le temps de découper ton code en fonctions, ça rendra tes futures modifications bien plus aisées :)


                            Oui je suis au courant, mais c'est plus un test pour l'instant, je suis vraiment débutant en CSFML, ça doit faire une semaine, je prendrai bien le temps de tout mettre sous des fonctions externes plus tard ;) 

                            Guit0Xx a écrit:

                            Désolé ne compte pas sur moi, je n'ai jamais fait de C :D.

                            -
                            Edité par Guit0Xx il y a environ 17 heures

                            En effet, mais le language C est uniquement pour les premières années, mais merci de la précision je devrais poster en C++ ducoup x)



                            -
                            Edité par MaximeMrht 10 novembre 2018 à 23:27:21

                            • Partager sur Facebook
                            • Partager sur Twitter
                              11 novembre 2018 à 7:03:22

                              MaximeMrht a écrit:

                              Elried a écrit:

                              Hello,

                              Juste une remarque rapide. 500 lignes de code c'est peut être rien, mais un main de 440 lignes c'est énorme par contre ^^". Prends le temps de découper ton code en fonctions, ça rendra tes futures modifications bien plus aisées :)


                              Oui je suis au courant, mais c'est plus un test pour l'instant, je suis vraiment débutant en CSFML, ça doit faire une semaine, je prendrai bien le temps de tout mettre sous des fonctions externes plus tard ;) 

                              Ca c'est idiot.

                              1) Tu passes beaucoup plus de temps à relire du code que tu n'en passe à l'écrire. La lisibilité est donc primordiale, un code découpé est bien plus lisible qu'un code monobloc.

                              2) Le Processeur lui il s'en fout, que tu découpes ou pas ne change presque rien, c'est pour toi que c'est important, s'il y a la moindre coquille dans tes 500 lignes, tu vas galérer pour la trouver, si tu découpes, il est plus facile d'isoler le problème et donc de le corriger.

                              3) Le découpage amène souvent avec lui la factorisation, la factorisation implique moins de code à écrire, donc mécaniquement moins de risque de bug, car du code qui n'existe pas ne contient aucun bug ^^

                              4) Le SRP(Single Responsability Principle), diviser pour régner: plus je découpe, plus j'isole les difficultés. Du code qui respecte SRP est plus facile à écrire, je me concentre sur un truc très simple, vu que c'est très simple, je gagne à tout les coups et sur tous les tableaux. Le risque que je me trompe en l'écrivant est très faible et comme c'est très simple, c'est aussi très facile à tester. Une fonction de 500 lignes, c'est impossible à tester, une fonction de moins de 10 lignes peut facilement être testée dans tous les sens. Si j'assemble des blocs dont je suis sûr à 100%, il y a de très grandes chances pour que j'obtienne le résultat voulu à l'arrivée.

                              -
                              Edité par int21h 11 novembre 2018 à 7:19:04

                              • Partager sur Facebook
                              • Partager sur Twitter
                              Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug

                              Capter un autre bord que top left ?

                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                              • Editeur
                              • Markdown