Je ne l’ai pas encore testé sous Linux.
Pour le code source, voilà les codes sources des fonctions (et des entêtes qui vont avec):
Code de la fonction AfficherResultat (celle que le compilateur confond avec celle qui gère les corrections barométriques):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "MenuPrincipal.h"
#include "utils.h"
#include "GererTables.h"
#include "GererTablesMarees.h"
#include "GestionTablesMarees.h"
#include "Structures.h"
#include "VariablesGlobales.h"
#include "AffichageTablesMarees.h"
#include "AfficherResultat.h"
#include "Calculs.h"
void AfficherResultat()
{
float HeureArrivee=0.0;
float DistanceKm=0.0;
float DureeTrajet=0.0;
float Marnage=0.0;
float DureeDuFlot=0.0;
float HeureMaree=0.0;
int PositionPort=0.0;
float HauteurArrivee=0.0;
float VitesseMaxBateau=0.0, VitesseMaxKmh=0.0;
int ChiffresHeureDepart=0, ChiffresMinutesDepart=0;
double LambdaLongitudesDegres=0.0;
double LambdaLongitudesRadians=0.0;
double LatitudeBateauRadians=0.0, LatitudePortRadians=0.0, LongitudeBateauRadians=0.0, LongitudePortRadians=0.0;
caracteristiqueMaree IntervalleMaree1;
caracteristiqueMaree IntervalleMaree2;
char* NomPortArrivee=NULL;
int Cpt=0;
float PressionAtmospheriquePort=0.0;
int ResultatScanf=1;
Booleen PortTrouve;
NomPortArrivee=DemanderNomDuPort("Veuillez saisir le nom du port dans lequel vous souhaiteriez accoster : ");
do
{
if (strcmp(TMaree[Cpt].nomDuPort, NomPortArrivee)==0)
{
PortTrouve=TRUE;
PositionPort=Cpt;
}
else
{
PortTrouve=FALSE;
Cpt++;
}
}
while(PortTrouve==FALSE && Cpt<4);
printf("Calcul de la distance entre le port et votre bateau en cours...\n");
printf("Veuillez patienter...\n");
LambdaLongitudesDegres = CalculDifferenceLongitudes(CaracteristiquesDuBateau.longitude,TMaree[Cpt].longitude);
LambdaLongitudesRadians = LongitudeRadians(LambdaLongitudesDegres);
LongitudeBateauRadians = LongitudeRadians(CaracteristiquesDuBateau.longitude);
LatitudeBateauRadians = LatitudeRadians(CaracteristiquesDuBateau.latitude);
LatitudePortRadians = LatitudeRadians(TMaree[Cpt].latitude);
LongitudePortRadians = LongitudeRadians(TMaree[Cpt].longitude);
DistanceKm = CalculDistance(LatitudeBateauRadians, LatitudePortRadians, LambdaLongitudesRadians);
printf("Vous etes a %.2lf kilometres du port de %s.\n",DistanceKm,TMaree[Cpt].nomDuPort);
do
{
(ResultatScanf && ChiffresHeureDepart >= 0 && ChiffresHeureDepart <= 23 && ChiffresMinutesDepart >= 0 && ChiffresMinutesDepart <= 59) ? 0: printf("Heure saisie incorrecte. Veuillez recommencer.\n");
printf("Heure de depart au format HH MM : ");
ResultatScanf = scanf("%d %d",&ChiffresHeureDepart,&ChiffresMinutesDepart);
viderTampon();
}
while(ResultatScanf != 1 || ChiffresHeureDepart < 0 || ChiffresHeureDepart > 23 || ChiffresMinutesDepart < 0 || ChiffresMinutesDepart > 23);
CaracteristiquesDuBateau.heureDepart = ConversionHeure(ChiffresHeureDepart, ChiffresMinutesDepart);
do
{
(ResultatScanf && VitesseMaximaleDuBateau > 0 && VitesseMaximaleDuBateau <= 30) ? 0: printf("Vitesse saisie incorrecte. Veuillez recommencer.\n");
printf("Vitesse maximale du bateau en noeuds : ");
ResultatScanf = scanf("%f",&VitesseMaximaleDuBateau);
viderTampon();
}
while(ResultatScanf != 1 || VitesseMaximaleDuBateau <= 0 || VitesseMaximaleDuBateau > 30);
CaracteristiquesDuBateau.vitesseBateau = VitesseMaximaleDuBateau;
printf("Calcul de l'heure d'arrivee...\n");
VitesseMaximaleDuBateauEnKmH = ConversionVitesse(CaracteristiquesDuBateau.vitesseBateau);
DureeTrajet = CalculTempsTrajet(VitesseMaximaleDuBateauEnKmH, DistanceKm);
HeureArrivee = CalculHeureArrivee(DureeTrajet, CaracteristiquesDuBateau.heureDepart);
CalculIntervalle(&IntervalleMaree1, &IntervalleMaree2, HeureArrivee, PositionPort);
DureeDuFlot = fabs(IntervalleMaree1.heure - IntervalleMaree2.heure);
Marnage = fabs(IntervalleMaree1.hauteur - IntervalleMaree2.hauteur);
HeureMaree = DureeDuFlot / 6;
HauteurArrivee = CalculHauteurAlArriveeDansLePort(Marnage, IntervalleMaree1.heure, DureeDuFlot, HeureArrivee);
if (IntervalleMaree1.hauteur > IntervalleMaree2.hauteur)
{
HauteurArrivee -= IntervalleMaree1.hauteur;
}
else
{
HauteurArrivee += IntervalleMaree1.hauteur;
}
printf("Hauteur de la mer a votre arrivee dans le port : %f metres.\n",HauteurArrivee);
if(TMaree[PositionPort].estUnPortPrincipal == 0)
{
do
{
(ResultatScanf && PressionAtmospheriquePort >= 963 && PressionAtmospheriquePort <= 1033) ? 0:printf("Pression atmospherique incorrecte. Veuillez reessayer.\n");
printf("Pression atmospherique dans le port : ");
ResultatScanf = scanf("%d",&PressionAtmospheriquePort);
viderTampon();
}
while(ResultatScanf !=1 || PressionAtmospheriquePort < 963 || PressionAtmospheriquePort > 1033);
CaracteristiquesDuBateau.tirantDeau = CalculCorrectionBarometrique(PressionAtmospheriquePort, CaracteristiquesDuBateau.tirantDeau);
}
if (fabs(HauteurArrivee) > CaracteristiquesDuBateau.tirantDeau)
{
printf("Vous pouvez accoster dans ce port sans crainte. Il y a assez d'eau.\n");
}
else
{
printf("Impossible d'accoster dans ce port. Il n'y aura pas assez d'eau.\n");
}
EcrireMenu();
}
Prototype de la fonction:
[code]#ifndef AFFICHERRESULTAT_H_INCLUDED
#define AFFICHERRESULTAT_H_INCLUDED
#include “Structures.h”
void AfficherResultat();
#endif // AFFICHERRESULTAT_H_INCLUDED[/code]
Code des autres fonctions mentionnées dans le code ci-dessus:
include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "MenuPrincipal.h"
#include "utils.h"
#include "GererTables.h"
#include "GererTablesMarees.h"
#include "GestionTablesMarees.h"
#include "Structures.h"
#include "VariablesGlobales.h"
#include "AffichageTablesMarees.h"
#include "AfficherResultat.h"
#include "Calculs.h"
double LatitudeRadians(double LatDd)
{
double resultat_radians=0.00;
resultat_radians=LatDd*(M_PI/180);
return(resultat_radians);
}
double LongitudeRadians(double LonDd)
{
double resultat_radians=0.00;
resultat_radians=LonDd*(M_PI/180);
return(resultat_radians);
}
double CalculDistance(double LatBateau, double LatPort, double DifferenceDesLongitudes)
{
double Difference_Radians;
double Distance_Radians, Distance_Metres;
double Distance_Kilometres;
Difference_Radians=DifferenceDesLongitudes*(M_PI)/180;
Distance_Radians=acos((sin(LatBateau)*sin(LatPort))+(cos(LatBateau)*cos(LatPort)*cos(Difference_Radians)));
Distance_Metres=Distance_Radians*RAYON_TERRE;
Distance_Kilometres=Distance_Metres/1000;
return Distance_Kilometres;
}
double CalculDifferenceLongitudes(double LonBateau, double LonPort)
{
double difference;
difference=fabs(LonBateau-LonPort);
return difference;
}
double ConversionVitesse (double VitesseNoeuds)
{
double Vitesse_kmh;
Vitesse_kmh=(VitesseNoeuds*MILLEMARIN)/1000;
return Vitesse_kmh;
}
double CalculTempsTrajet(double VitesseKmH, double DistanceKilometres)
{
double Temps_Trajet;
Temps_Trajet=DistanceKilometres/VitesseKmH;
return Temps_Trajet;
}
void CalculIntervalle(caracteristiqueMaree* Heure1, caracteristiqueMaree* Heure2, float HeureArrivee, int PositionDuPort)
{
if(TMaree[PositionDuPort].tableauMaree[0].heure <= HeureArrivee && TMaree[PositionDuPort].tableauMaree[1].heure >= HeureArrivee)
{
Heure1->heure = TMaree[PositionDuPort].tableauMaree[0].heure;
Heure2->heure = TMaree[PositionDuPort].tableauMaree[1].heure;
Heure1->hauteur = TMaree[PositionDuPort].tableauMaree[0].hauteur;
Heure2->hauteur = TMaree[PositionDuPort].tableauMaree[1].hauteur;
}
else if(TMaree[PositionDuPort].tableauMaree[1].heure <= HeureArrivee && TMaree[PositionDuPort].tableauMaree[2].heure >= HeureArrivee)
{
Heure1->heure = TMaree[PositionDuPort].tableauMaree[1].heure;
Heure2->heure = TMaree[PositionDuPort].tableauMaree[2].heure;
Heure1->hauteur = TMaree[PositionDuPort].tableauMaree[1].hauteur;
Heure2->hauteur = TMaree[PositionDuPort].tableauMaree[2].hauteur;
}
else if(TMaree[PositionDuPort].tableauMaree[2].heure <= HeureArrivee && TMaree[PositionDuPort].tableauMaree[3].heure >= HeureArrivee)
{
Heure1->heure = TMaree[PositionDuPort].tableauMaree[2].heure;
Heure2->heure = TMaree[PositionDuPort].tableauMaree[3].heure;
Heure1->hauteur = TMaree[PositionDuPort].tableauMaree[2].hauteur;
Heure2->hauteur = TMaree[PositionDuPort].tableauMaree[3].hauteur;
}
else
{
printf("Aucun intervalle d'heure maree ne peut contenir l'heure d'arrivee que vous avez specifiee.\n");
printf("Veuillez noter que l'heure d'arrivee doit etre comprise entre la maree 1 et la maree 4.\n");
printf("Elle doit donc etre comprise pour le port que vous avez specifie entre %d heures et %d heures.\n",(int) TMaree[PositionDuPort].tableauMaree[0].heure, (int) TMaree[PositionDuPort].tableauMaree[3].heure);
printf("Vous allez etre redirige vers le menu principal afin de modifier la table des marees.\n");
EffacerEcran();
EcrireMenu();
}
}
float CalculHauteurAlArriveeDansLePort(float marnage,float HeureDerniereMaree,float DureeFlot,float HeureArrivee)
{
float HauteurRetournee=0.0;
int TableauDouziemes[]={1,2,3,3,2,1};
float DureeQueLaMerMonte;
float Sum;
int CompteurDouziemes;
float Minutes;
DureeQueLaMerMonte = (HeureArrivee-HeureDerniereMaree) / (DureeFlot/6);
Minutes = (DureeQueLaMerMonte - (int) DureeQueLaMerMonte);
for(CompteurDouziemes=0;CompteurDouziemes<(int) DureeQueLaMerMonte;CompteurDouziemes++)
{
Sum += TableauDouziemes[CompteurDouziemes];
}
Sum += (TableauDouziemes[CompteurDouziemes+1])*Minutes;
HauteurRetournee = (Sum*Marnage) / 12;
return HauteurRetournee;
}
float CalculCorrBarometr(float PressAtmo, float TirantDEau)
{
Booleen PressionTrouvee;
int CompteurCorrections=0;
do
{
if(TableCorrections[CompteurCorrections].PressionAtmospherique==PressAtmo)
{
PressionTrouvee=TRUE;
}
else
{
PressionTrouvee=FALSE;
CompteurCorrections++;
}
}
while(PressionTrouvee==FALSE && Compteur<71);
if (PressionTrouvee==TRUE)
{
return TirantDEau-TableCorrections[CompteurCorrections].CorrectionBarometrique;
}
}
float CalculHeureArrivee(float Heure, float HeureDepart)
{
int Minutes,Heure_Entiere;
Heure_Entiere=(int) (HeureDepart+Heure);
Minutes=(((Heure+HeureDepart)-Heure_Entiere)*60);
if(Heure+HeureDepart > 24)
{
printf("Attention : votre voyage va durer plus d'une journee.\n");
printf("La table des marees risque d'etre invalide dans %d jour(s).\n",Heure_Entiere/24);
Heure_Entiere -= ((Heure_Entiere)/24 * 24);
}
printf("a %d heures ",Heure_Entiere);
if(Minutes > 0)
{
printf("%d minutes",Minutes);
}
return(Heure_Entiere+(float) Minutes/60);
}
float ConversionHeure(int Heures, int Minutes)
{
float ResultatDecimal;
ResultatDecimal = ((Heures*60) + Minutes);
return ResultatDecimal;
}
Prototypes de ces fonctions:
[code]#ifndef CALCULS_H_INCLUDED
#define CALCULS_H_INCLUDED
#include “Structures.h”
double LatitudeRadians(double LatDd);
double LongitudeRadians(double LonDd);
double CalculDistance(double LatBateau, double LatPort, double DifferenceDesLongitudes);
double CalculDifferenceLongitudes(double LonBateau, double LonPort);
double ConversionVitesse (double VitesseNoeuds);
double CalculTempsTrajet(double VitesseKmH, double DistanceKilometres);
void CalculIntervalle(caracteristiqueMaree* Heure1, caracteristiqueMaree* Heure2, float HeureArrivee, int PositionDuPort);
float CalculHauteurAlArriveeDansLePort(float Marnage, float HeureDerniereMaree, float DureeFlot, float HeureArrivee);
float CalculCorrBarometr(float PressAtmo, float TirantDEau)
float CalculHeureArrivee(float Heure, float HeureDepart);
float ConversionHeure(int Heures, int Minutes);
#endif // CALCULS_H_INCLUDED
[/code]
Définition des structures (fichier .h):
[code]#ifndef STRUCTURES_H_INCLUDED
#define STRUCTURES_H_INCLUDED
typedef struct structureBateau structureBateau ;
struct structureBateau
{
float tirantDeau ;
float vitesseBateau ;
float longitude;
float latitude ;
float heureDepart ;
};
typedef struct caracteristiqueMaree caracteristiqueMaree;
struct caracteristiqueMaree
{
float heure ;
float hauteur ;
};
typedef struct structureTableMaree structureTableMaree;
struct structureTableMaree
{
char* nomDuPort ;
int estUnPortPrincipal ;
caracteristiqueMaree tableauMaree[4] ;/*Heure de la pleine mer 1 et de la hauteur. */
float pressionAtmospherique ;
float longitude ;
float latitude ;
};
typedef enum Booleen Booleen;
enum Booleen
{
FALSE=0, TRUE=1
};
typedef struct Occurrences Occurrences;
struct Occurrences
{
int NumeroOccurrence;
int PositionOccurrence;
};
typedef struct CorrectionsBarometrique CorrectionsBarometrique;
struct CorrectionsBarometrique
{
int PressionAtmospherique;
int CorrectionBarometrique;
};
#endif // STRUCTURES_H_INCLUDED
[/code]
Variables utilisées (globales):
#ifndef VARIABLESGLOBALES_H_INCLUDED
#define VARIABLESGLOBALES_H_INCLUDED
#define RAYON_TERRE 6378000
#define MILLEMARIN 1852
#include "Structures.h"
structureTableMaree TMaree[4];
CorrectionsBarometrique TableCorrections[70];
structureBateau CaracteristiquesDuBateau;
#endif // VARIABLESGLOBALES_H_INCLUDED
C’est tout.
.