Problème de C

[PrépaQuébec]

Bonjour,

je commence bientôt mon premier trimestre en école d'ingé; cette école se destine non seulement aux étudiants ayant suivi un cursus normal, mais aussi aux personnes, dont je fais parti, qui font un retour aux études après quelques années de pratique comme technicien.
Mon souci est que j'ai travaillé dans un environnement où la technologie a été conçue il y a 30 ans, à base de logique à relais, la programmation en C est donc toute nouvelle pour moi...
Sauf qu'à la rentrée ça attaque dur dès le départ:
Voici un exemple de premier travail que je pourrait être amené à résoudre:

"Description du problème : Propagation des ondes
Votre tâche consiste à écrire un programme permettant de simuler la propagation d’une onde (ou de
plusieurs ondes) à la surface d’un liquide quelconque. Au départ, le liquide est stagnant. Si l’on
applique une poussée en un point, une onde se crée et se propage de chaque coté de la poussée."

"Stratégie à utiliser
Pour réaliser cette simulation, on commence par fractionner le liquide en N segments (rectangles
verticaux). Pour chacun d’eux, on conserve la hauteur, la vitesse et l’accélération du liquide à cet
endroit. Au départ la hauteur de tous les segments est la même (par exemple, 100) et la vitesse de
chaque segment est nulle. Tant que l’utilisateur ne souhaite pas terminer le programme, on réalise les
étapes suivantes :
1. Si l’utilisateur le souhaite, on ajoute une onde à la position demandée.
2. On met à jour l’accélération de tous les segments.
3. On met à jour la vitesse de tous les segments.
4. On met à jour la hauteur de tous les segments.
5. On affiche la hauteur de tous les segments."

"Introduction de nouvelles notations
Pour simplifier les expressions à venir, nous posons que :
i a = l’accélération du ième segment,
i v = la vitesse du ième segment et
i y = la hauteur du ième segment,
où i est un entier dans l’intervalle [1, N] ."

Ensuite j'ai 3 formules pour la mise à jour de l'accélération, de la vitesse et de la hauteur.

Puis une grosse formule décrivant la formation d'une onde.

"Recommandations et exigences supplémentaires
1) Vous n’avez besoin de créer qu’un seul fichier : Votre tâche consiste à écrire un
programme permettant de gérer la simulation. Pour vous aider, on vous fournit l’interface
graphique que vous devez utiliser sans la modifier.
2) Votre programme doit contenir un maximum de constantes de compilation : À chaque
fois que vous écrivez un nombre dans votre programme, posez-vous la question : « Puis-je
en faire une constante ? ».
3) Toutes les fonctions doivent être très courtes : Pour ce programme, une fonction faisant
plus de 15 lignes est nécessairement mal découpée."


Aucune variable globale acceptée, etc, etc.

Je ne sais vraiment pas par quel bout prendre ce problème. J'ai des notions de C, je connais les fonctions, variables, pointeur, différentes librairies de base, les tableaux... j'ai déjà fait quelques petits programmes, mais jamais de graphique (si ce n'est quelques rectangles sous SDL), et jamais plus que que deux ou trois fonction en plus de Main (aucun header...)
Quel librairie me conseillez-vous?
Quelle serait votre démarche?

Toute aide sera grandement appréciée, je dois dire que je panique un peu présentement.

Je peux vous envoyer l'énoncé sous pdf le cas échéant.

Merci, Stef

[Patastronch]

La méthode proposée est tres bourrine a mon gout :s Mettre a jour tous les rectangles alors que la plupart ne changent pas d'état c'est un tas de calculs innutile ... mais passons c'est pas le plus important :p

Pour faire simple :

Commence par créer ton objet environnement (un struct vu que c'est du C et non du C++) qui représentera ton étendu d'eau. Un des atributs de cet environnement sera l'ensemble des cases modélisant ta flotte. Donc c'est un tableau de pointeurs pointant vers un struct rectangle (voir plus loin). Ensuite a cet objet environnement tu lui ajoutes une méthode de mise à jour de l'état des rectangles.

L'objet rectangle devra avoir comme attribut la hauteur, la vitesse ainsi que tous les paramêtres permettant de définir son état. Tu lui ajoute une méthode d'affichage selon son état.

Enfin tu ajoutes une méthode a ton objet environnement qui appellera pour chaque rectangle sa méthode d'affichage.

Enfin pour achever le tout une fonction main qui instancie ton objet environnement, ainsi qu'une interface permettant l'ajout d'une onde (qui appelle une méthode de l'objet environnement qui mettra a jour l'état des rectangles concernés). Et enfin une boucle qui permet de lancer la méthode de mise a jour de chaque rectangle de l'objet environnement ainsi qu'une possibilité de sortie de la boucle pour stopper le programme.

Bon courage ! Mais c'est pas si compliqué t'inquietes pas.

[PrépaQuébec]

Merci Patastronch,
tu ferais ça sous quoi? SDL?

Stef

[Patastronch]

Merci Patastronch,
tu ferais ça sous quoi? SDL?

Stef

Pouruqoi utiliser une librairie graphique ? Tu n'en a pas besoin pour le moment, fait un affichage console pour les rectangles au début et apres tu rajoutera du SDL si tu tiens vraiment a le rendre plus joli (c'es tl'interet de faire une méthode d'affichage, ca permet de lam ettre a jour facilement). Mais dans l'ennoncé que tu nous donne on te demande pas de faire des graphismes spécialement. DOnc pour le moment t'encombre pas du rendu graphique et fait ua plus simple.

Un affichage console possible :
pour l'eau stagnante :
--------------------------------------------------
--------------------------------------------------
--------------------------------------------------



pour une eau non stagnante :

----*********-------*********************
---------**--------------------------------------
--------------------------------------------------
--------------------------------------------------

Où les étoiles représentent des espaces.

[PrépaQuébec]

Si, je ne l'ai pas précisé, mais au vu du résultat final sur mon pdf c'est une librairie graphique qu'il me faut. D'après moi SDL devrait suffir puisqu'il ne s'agit que d'une succession de rectangles, et en fait ça tombe bien car je l'ai déjà installée avec codeblocks.

Si cela t'intéresse d'avoir le pdf patastronch tu peux prendre contacte avec moi par MP?

En tout cas, j'ai tout imprimé je vais essayer de me fixer une structure sur papier en appliquant tes conseils...

Stef

[Patastronch]

Oh tu sais, avoir le pdf ca m'interesse pas vraiment :) Mais hésite pas si t'as besoin d'aide.

Sinon oui SDL est largement suffisant pour tes besoins. Mais oublie pas d'ajouter les dll apres pour que l'executable puisse fonctionner (enfin si tu codes pour windows, mais comme tu parles de codeblock j'en déduis que oui).

[PrépaQuébec]

Oui je suis sous windows, j'ai pas vraiment les moyens de m'offrir le luxe d'apprendre à faire fonctionner ma double installe de Ubuntu (ça m'avait pris trois jours pour savoir comment faire un copier/coller hi hi hi), déjà assez de boulot avec le C. :we:

Ce TP je ne le sens pas, mais pas du tout; tu as vu mes codes pour le robot, ce n'était pas folichon, alors maintenant passer à ça je le vois comme mission impossible... :briques:

Je crois que je vais te l'envoyer, ce pdf... :cry:

Stef

[PrépaQuébec]

Voilà où j'en suis, ce n'est pas encore parfait mais...

#include
#include
#include
#include

#define SEGMENT 64
#define LARGEUR_SEGMENT 10
#define HAUTEUR_NULL 100
#define ANTI_DEBORDEMENT 1
#define FROTTEMENT 0.01
#define LARGEUR_ONDE 20
#define COURBURE_POUSSE 50
#define PROFONDEUR_ONDE 25

typedef struct Segment Segment;
struct Segment
{
double hauteur;
double vitesse;
double acceleration;
};

void calculAcceleration(Segment segment[]);
void calculVitesse(Segment segment[]);
void calculHauteur(Segment segment[]);
void creerSegment(Segment segment[], int segmentChoisis);
void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
void afficherSegment(SDL_Surface *ecran, Segment segment[]);

int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_VIDEO);
SDL_Surface* ecran = NULL;

Segment segment[SEGMENT + ANTI_DEBORDEMENT * 2] = {100, 0, 0};

ecran = SDL_SetVideoMode(SEGMENT * LARGEUR_SEGMENT+1, HAUTEUR_NULL * 2+1, 32, SDL_HWSURFACE);
int i;
for (i = 0; i 0 && i = 0 && i + k + (i-1) * LARGEUR_SEGMENT w && HAUTEUR_NULL * 2 - j >= 0 && HAUTEUR_NULL * 2 - j h)
setPixel(ecran, i + k + i * LARGEUR_SEGMENT, HAUTEUR_NULL * 2 - j, SDL_MapRGB(ecran->format, 0, 0, 255));
}
}
for (j = segment[i].hauteur; j = 0 && i + k + (i-1) * LARGEUR_SEGMENT w && HAUTEUR_NULL * 2 - j >= 0 && HAUTEUR_NULL * 2 - j h)
setPixel(ecran, i + k + i * LARGEUR_SEGMENT, HAUTEUR_NULL * 2 - j, SDL_MapRGB(ecran->format, 0, 0, 0));
}
}
}
SDL_UnlockSurface(ecran);
SDL_Flip(ecran);
}

void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
int bpp = surface->format->BytesPerPixel;

Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

switch(bpp) {
case 1:
*p = pixel;
break;

case 2:
*(Uint16 *)p = pixel;
break;

case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
p[0] = (pixel >> 16) & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = pixel & 0xff;
} else {
p[0] = pixel & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = (pixel >> 16) & 0xff;
}
break;

case 4:
*(Uint32 *)p = pixel;
break;
}
}

Stef