Bonjour, je reviens vers vous car je n'arrive pas à trouver une solution pour utiliser les évènements en fonction(d'ailleurs, je ne sais pas si c'est possible...)
De plus je vous transmet mon code, car depuis que j'ai transféré les évènements clavier dans la fonction main.c , je n'ai plus de visuel sur l'image PNG du tank, alors qu'en fonction je l'avais...
Je recherche pourquoi, peut être que je n'y arrive plus parce-que j'ai été dessus toute la journée et que mon cerveau est en train de griller.
Voila le code :
#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <SDL_image.h>
#include "main.h"
int main(int argc, char *argv[])
{
/* INITIALISATION */
int statut = EXIT_FAILURE;
SDL_bool quit = SDL_FALSE;
SDL_Window *window = NULL;
SDL_Renderer *render = NULL;
SDL_Surface *screen = NULL;
if(Init(&window, &render, &screen, LARGEUR, HAUTEUR) != 0)
goto Quit;
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,40,0,0));
SDL_UpdateWindowSurface(window);
if(0 > load_logo("images/logo.bmp", window))
goto Quit;
SDL_Rect position;
pos_init(&position);
/* KEYBOARD USER & SURFACE ACTUALIZATION */
SDL_Event event;
int up = 0, down = 0, right = 0, left = 0;
while(!quit)
{
SDL_PollEvent(&event);
SDL_UpdateWindowSurface(window);
switch(event.type)
{
case SDL_QUIT:
quit = SDL_TRUE;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_UP:
up = 1;
break;
case SDLK_DOWN:
down = 1;
break;
case SDLK_RIGHT:
right = 1;
break;
case SDLK_LEFT:
left = 1;
break;
}
break;
case SDL_KEYUP:
switch(event.key.keysym.sym)
{
case SDLK_UP:
up = 0;
break;
case SDLK_DOWN:
down = 0;
break;
case SDLK_RIGHT:
right = 0;
break;
case SDLK_LEFT:
left = 0;
break;
}
break;
SDL_Delay(35);
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,40,0,0));
usr_pos(&position, &up, &down, &right, &left);
if(0 > user_tank("images/tank_r_2.png", window, screen, position))
goto Quit;
SDL_UpdateWindowSurface(window);
}
}
/* EXIT PROGRAM */
SDL_FreeSurface(screen);
statut = EXIT_SUCCESS;
Quit:
destroy_all(&window,&render);
SDL_Quit();
return statut;
/* END MAIN.C */
}
int user_tank(const char path[], SDL_Window *window, SDL_Surface *screen, SDL_Rect position)
{
SDL_Surface *tank = NULL;
tank = IMG_Load(path);
if (NULL == tank)
{
fprintf(stderr, "Erreur chargement texture tank : %s", SDL_GetError());
return -1;
}
SDL_BlitScaled(tank, NULL, screen, &position);
SDL_UpdateWindowSurface(window);
return 0;
}
int load_logo(const char path[], SDL_Window *window)
{
SDL_Surface *logo = NULL;
logo = IMG_Load(path);
if(NULL == logo)
{
fprintf(stderr, "Erreur logo : %s", SDL_GetError());
return -1;
}
SDL_SetWindowIcon(window, logo);
SDL_FreeSurface(logo);
return 0;
}
void usr_pos(SDL_Rect *position, int *up, int *down, int *right, int *left)
{
if (up)
{position->y -= 5;}
if (down)
{position->y += 5;}
if (right)
{position->x += 5;}
if (left)
{position->x -= 5;}
}
void pos_init(SDL_Rect *position)
{
position->x = INIT_X;
position->y = INIT_Y;
position->w = INIT_W;
position->h = INIT_H;
}
int destroy_all(SDL_Window **window, SDL_Renderer **render)
{
if (NULL != *render)
SDL_DestroyRenderer(*render);
if (NULL != *window)
SDL_DestroyWindow(*window);
return 0;
}
int Init(SDL_Window **window, SDL_Renderer **render, SDL_Surface **screen, int largeur, int hauteur)
{
*window = SDL_CreateWindow("Torq", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, largeur, hauteur, SDL_WINDOW_SHOWN);
if (NULL == *window)
{
fprintf(stderr, "Erreur init window : %s", SDL_GetError());
return -1;
}
*render = SDL_CreateRenderer(*window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (NULL == *render)
{
fprintf(stderr, "Erreur init render : %s", SDL_GetError());
return -1;
}
*screen = SDL_GetWindowSurface(*window);
if (NULL == *screen)
{
fprintf(stderr, "Erreur init screen : %s", SDL_GetError());
return -1;
}
return 0;
}
Header :
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED
/* SCREEN DIMENSIONS */
#define HAUTEUR 864
#define LARGEUR 1024
#define SCREEN_RESOLUTION_W 1920
#define SCREEN_RESOLUTION_H 1080
/* TANK TEXTURE DIMENSIONS */
#define TANK_W 75
#define TANK_H 85
/* TANKS POSITIONS CONSTANT VALUES */
#define INIT_X 100
#define INIT_Y 100
#define INIT_W TANK_W
#define INIT_H TANK_H
typedef struct usr_guide usr_guide;
struct usr_guide
{
int up;
int down;
int right;
int left;
};
usr_guide moove;
int Init(SDL_Window **window, SDL_Renderer **render, SDL_Surface **screen, int largeur, int hauteur);
int destroy_all(SDL_Window **window, SDL_Renderer **render);
int load_logo(const char path[], SDL_Window *window);
void pos_init(SDL_Rect *position);
void usr_pos(SDL_Rect *position, int *up, int *down, int *right, int *left);
int user_tank(const char path[], SDL_Window *window, SDL_Surface *screen, SDL_Rect position);
#endif // MAIN_H_INCLUDED
Bon vous verrez des vestiges de mes tentatives pour créer une fonction des évènement clavier afin de l'utiliser dans le main (comme la structure usr_guide qui n'est plus utilise dans le code actuel (mais que je garde encore néanmoins.)
Avec ce code, je n'ai plus le tank qui s'affiche, est-ce que vous pouvez m'aider à ce sujet ?
J'ai tenté, de remodeler le code en enlevant certaines fonctions , etc etc, mais la j'avoue que j'aurai surment besoin d'un coup de pouce.
P.S: Mon petit doigt me dit que mon problème me viens des pointeurs... peut être pas.
EDIT : Le de Build log m'indique ni erreur ni avertissement.
je regarde rapidement ton code et un truc me chagrinne :
void usr_pos(SDL_Rect *position, int *up, int *down, int *right, int *left)
{
if (up)
{position->y -= 5;}
if (down)
{position->y += 5;}
if (right)
{position->x += 5;}
if (left)
{position->x -= 5;}
}
tu demande des pointeur (ce qui n'est pas utile) et tu regarde pas leur valeur mais si on t'as bien donnée des pointeurs... en gros tu passe dans tous tes tests y-5, y+5, x+5, x-5 ce qui revient à faire 0
dans ton cas la fonction devrait s'ecrire comme ça : si tu garde les pointeurs
void usr_pos ( SDL_Rect *position, const int * const up, const int * const down, const int * const right, const int * const left )
{
if ( up && *up )
{
position->y -= 5;
}
if ( down && *down )
{
position->y += 5;
}
if ( right && *right )
{
position->x += 5;
}
if ( left && *left )
{
position->x -= 5;
}
}
on paye pas les espaces alors autant rendre ton code plus facile à lire, dans le prototype j'ai rajouté les consts car ters variables ne sont la que pour etre lu donc autant les placer en const, et dans les if tu verifie que le pointeur est valide puis tu verifie qu'il pointe pas sur un zero
mais dans ton cas un fonction sans pointeur aurai parfaitement fonctionné
Edit : pour rappel :
int var = 1;
int *pVar = &var;
// pVar = adresse en memoire de var
// *pVar = valeur contenue à l'adresse de var (donc la valeur de var)
// if ( pVar ) = tu test si pVar pointe vient sur une variable et donc si le pointeur a été initialisé
- Edité par ox223252 26 octobre 2021 à 11:42:51
la connaissance est une chose qui ne nous appauvrit pas quand on la partage.
void usr_pos ( SDL_Rect *position, const int * const up, const int * const down, const int * const right, const int * const left )
{
if ( up && *up )
{
position->y -= 5;
}
if ( down && *down )
{
position->y += 5;
}
if ( right && *right )
{
position->x += 5;
}
if ( left && *left )
{
position->x -= 5;
}
}
Les yeux m'en tombent. Par rapport au style :
Pourquoi mettre des espaces avant et après l'étoile ? On dirait visuellement une multiplication, ce qui rend la lecture difficile
Rajouter const partout, surtout pour des variables locales ou paramètres passés par valeur, ça alourdit énormément la lecture des paramètres, pour absolument aucun bénéfice (votre chat ne va pas sur le clavier modifier par erreur les variables que je sache), et pire que ça, certains, en voyant des variables "const" lors d'une session de débugage, se disent inconsciemment "cette variable ne peut pas être modifié" et font le raccourci foireux de dire "le problème ne vient pas de là", donc on peut passer à côté du vrai bug. Et quand on lit du code, il faut comprendre le code, ce qu'il fait, etc, et pas se demander si "il est possible de modifier telle ou telle variable", ça c'est quelque chose qu'on voit directement quand on lit l'algorithme.
Il ne faut pas mettre d'espace après une parenthèse ouvrante ou avant une parenthèse fermante. Non ça ne facilite pas la lecture, au contraire. En faisant ça, vous placez le contenu du groupe (délimité par les parenthèses) à égale distance de tout ce qu'il y a autour ! Et donc on perd la notion visuelle de "regroupement"
Et par rapport à la fonction en elle-même, bien évidemment qu'il ne faut pas utiliser de pointeurs. Il faut passer directement les int :
void usr_pos(SDL_Rect *position, int up, int down, int right, int left)
{
if (up) position->y -= 5;
if (down) position->y += 5;
if (right) position->x += 5;
if (left) position->x -= 5;
}
Là si j'avais mis des const partout ça serait beaucoup moins lisible puisque on voit en un coup d'oeil toute la fonction et on n'a pas besoin de se demander, lors de la relecture, si les variables "peuvent être modifiées". Et quand bien même elles auraient été modifiées, ça reste dans le cadre de cette fonction, et ça ne va pas affecter qui que ce soit d'autre (ce qui ne serait pas le cas avec des pointeurs, pour lesquels le premier const avant l'étoile se justifie)
Voilà c'est tout pour moi n'oubliez pas de vous abonner et laisser un pouce bleu
Dans le cas de gestion d'erreur, c'est une méthode propre. ça aide a assurer que toute les ressources allouées sont libérées, et ceux à un seul endroit.
Les pointeurs sur pointeurs ne sont inutiles dans sa fonction init. Et ça va, gérer deux niveaux de pointeurs, c'est pas la mort, faut arréter avec le "les pointeurs c'est dur".
Pourquoi faire simple quand on peut faire compliqué ... Pour moi le fait que le PO utilise des pointeurs sur pointeur prouve que qqchose lui échappe : On a déjà un pointeur sur SDL_Window donc autant l'utiliser pour modifier les paramètres de la fenêtre, c'est fait pour ça. On ne cherche pas à modifier le pointeur lui-même mais ce sur quoi il pointe.
Pourquoi mettre des espaces avant et après l'étoile ? On dirait visuellement une multiplication, ce qui rend la lecture difficile
Rajouter const partout, surtout pour des variables locales ou paramètres passés par valeur, ça alourdit énormément la lecture des paramètres, pour absolument aucun bénéfice (votre chat ne va pas sur le clavier modifier par erreur les variables que je sache), et pire que ça, certains, en voyant des variables "const" lors d'une session de débugage, se disent inconsciemment "cette variable ne peut pas être modifié" et font le raccourci foireux de dire "le problème ne vient pas de là", donc on peut passer à côté du vrai bug. Et quand on lit du code, il faut comprendre le code, ce qu'il fait, etc, et pas se demander si "il est possible de modifier telle ou telle variable", ça c'est quelque chose qu'on voit directement quand on lit l'algorithme.
Il ne faut pas mettre d'espace après une parenthèse ouvrante ou avant une parenthèse fermante. Non ça ne facilite pas la lecture, au contraire. En faisant ça, vous placez le contenu du groupe (délimité par les parenthèses) à égale distance de tout ce qu'il y a autour ! Et donc on perd la notion visuelle de "regroupement"
bon alors tu ne dois pas savoit a quoi sert le const car ça sert aussi au compilateur, et oui c'est utile de savoir ce qui est censé changer ou non... mais bon, quand au style d'ecriture si tu trouve des multiplication dans une declaration de fonction tu peux m'appeller :'(, et enfin les parenthaises avec ou sans espace, ce n'est que de la convention donc calme toi, chez nous on utilise cette notation et personne ne c'est jamais trompé donc tu es peut etre un peu trop sensible.
JadeSalina a écrit:
Et par rapport à la fonction en elle-même, bien évidemment qu'il ne faut pas utiliser de pointeurs. Il faut passer directement les int :
void usr_pos(SDL_Rect *position, int up, int down, int right, int left)
{
if (up) position->y -= 5;
if (down) position->y += 5;
if (right) position->x += 5;
if (left) position->x -= 5;
}
Là si j'avais mis des const partout ça serait beaucoup moins lisible puisque on voit en un coup d'oeil toute la fonction et on n'a pas besoin de se demander, lors de la relecture, si les variables "peuvent être modifiées". Et quand bien même elles auraient été modifiées, ça reste dans le cadre de cette fonction, et ça ne va pas affecter qui que ce soit d'autre (ce qui ne serait pas le cas avec des pointeurs, pour lesquels le premier const avant l'étoile se justifie)
-
Edité par JadeSalina 26 octobre 2021 à 14:41:54
et apres avoir ecrit ce code tu critique mon style ? des blocs de codes non definis par des acolades ? mais ça fait combient de temps que tu code ? quand je faisiat ça a mes debut je me faisais passer un savont par n'importe quel codeur. je sais pas pour qui tu code, mais ça ne suis aucune regles de qualité logiciel qui soit un peu exigente. bref avant de chercher la paille chez le voisin regarde la poutre que tu as dans ton oeil.
pour info l'idée qu'on peut voir d'un silmple coup d'oeil si les variables peuvent etre modifier, c'est pas valide comme argument, car les bugs trouvent toujours leur source dans l'interface cahise clavier.
- Edité par ox223252 4 novembre 2021 à 10:50:45
la connaissance est une chose qui ne nous appauvrit pas quand on la partage.
et apres avoir ecrit ce code tu critique mon style ? des blocs de codes non definis par des acolades ?
Je suis d'accord, vous noterez que j'ai mis l'instruction sur la même ligne que le if, et non pas à la ligne suivante sans accolades, ce qui est absolument abjecte. Là vu qu'il n'y a qu'une instruction et que les 4 sont finalement assez similaires, on peut les voir comme ça d'un coup d'oeil sur la même ligne sans avoir à scroller son écran.
Et les const pour les paramètres genre "const int foo" ou "int *const foo" je ne sais pas dans quel monde ça facilite la lecture ou apporte quelque information que ce soit. Mais à la limite chacun son truc pourquoi pas. Mais par contre pourquoi le laisser dans les interfaces publiques (dans les .h) ? Qu'es-ce que l'utilisateur en a à faire que la fonction ne va pas modifier son paramètre passé par valeur ? Vous avez déjà vu des documentation où les paramètres sont spécifiés const ? L'utilisateur veut juste savoir si l'objet pointé va être modifié ou pas, mais pas les autres paramètres passés par valeur
JadeSalina : en terme de facilité de lecture, pour moi ce que tu as fait est top. (Et puis je ne suis pas très partisan des règles dogmatiques. J'ai cru comprendre que dans un contexte professionnel il y a souvent des règles strictes, mais je me suis inscrit du temps du Site du Zéro et j'ai du mal à considérer que les discussions de ce forum doivent concerner uniquement le contexte professionnel.)
Le style est important, dans un contexte pro ou non. L'indentation, comment et où on place la ponctuation, la cohérence dans le nommage, le découpage du code … tout ça permet non seulement d'éviter certaines fautes à la con, mais facilite grandement la lecture. Nous le faisons tous lorsque nous écrivons, du code ou non.
De plus, les éditeurs modernes proposent tous des facilités de mise en forme ; ce serait bête,surtout lorsqu'on débute et que l'on doit aussi prendre quelques bonnes habitudes, de s'en priver.
Je suis d'accord, vous noterez que j'ai mis l'instruction sur la même ligne que le if, et non pas à la ligne suivante sans accolades, ce qui est absolument abjecte.
Alors je code de manière abjecte, car j'écris
if(....)
a=b;
else
a=c;
Edit: et dans le contexte où tu l'écris, abject ne prend pas de e
- Edité par edgarjacobs 4 novembre 2021 à 16:07:25
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Je suis d'accord, vous noterez que j'ai mis l'instruction sur la même ligne que le if, et non pas à la ligne suivante sans accolades, ce qui est absolument abjecte.
Alors je code de manière abjecte, car j'écris
if(....)
a=b;
else
a=c;
- Edité par edgarjacobs il y a 2 minutes
Ah mince désolée x) Après selon les gouts et les couleurs chacun fait ce qu'il veut mais si on le met sur sa propre ligne sans accolades et que tout d'un coup on veut rajouter une instruction, il va falloir penser implicitement à rajouter des accolades alors que si c'est sur la même ligne ça saute aux yeux qu'il faut rajouter les accolades
Je pense que le style d'écriture du code ne dépend que du codeur (ou de la société pour laquelle il travaille). wikipédia en recence déjà pas mal, mais il y a les manières personnelles d'écrire le code. Tant que la chatte y retrouve ses chatons, c'est bon.
Et pour moi aussi, le style est un automatisme.
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Gestion des évènement
× 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.
la connaissance est une chose qui ne nous appauvrit pas quand on la partage.
Mon GitHub
la connaissance est une chose qui ne nous appauvrit pas quand on la partage.
Mon GitHub
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent