static void couleurFeu(TypeZone tz, Colors couleur)
// Mode d'emploi :
// Méthode permettant d'afficher la couleur du feu sur une zone donnée, à partir de
// l'énumération <couleur>
// <tz> : le type de zone où écrire (COULEUR_AXE_NS ou COULEUR_AXE_EO)
// <couleur> : La couleur du feu (VERT, ORANGE ou ROUGE)
//
// Contrat : tz est l'une des 2 zones sus-citées
{
switch (couleur)
{
case VERT:
Afficher(tz, "Vert ", GRAS);
break;
case ORANGE:
Afficher(tz, "Orange", GRAS, INVERSE);
break;
case ROUGE:
Afficher(tz, "Rouge ", GRAS, INVERSE);
break;
}
} // fin de couleurFeu
void Commande ( TypeVoie entree, TypeVoie sortie )
{
//gérer le numero de la voiture
//création de la voiture
struct Voiture voitureManuelle ={entree, sortie, numVoiture};
//création et envoit du message
struct MsgVoiture message={(long)(entree), voitureManuelle};
msgsnd(balVoiture, &message, sizeof (MsgVoiture), 0);
//Modification de l'affichage
Effacer(MESSAGE);
OperationVoie(PLUS,entree);
Afficher(MESSAGE,"Votre nouvelle voiture a été ajouté");
Effacer(NUMERO);
Afficher(NUMERO,numVoiture,GRAS);
Effacer(ENTREE);
Afficher(ENTREE,entree,GRAS);
Effacer(SORTIE);
Afficher(SORTIE,sortie,GRAS);
//incremente le numero de voiture
if (numVoiture>numeroMaxManuel) numVoiture=1;
else numVoiture++;
}
void Commande (char code, unsigned int valeur)
{
fichier << "Début commande" << std::endl;
switch(code)
{
case 'E':
{
Afficher(MESSAGE, "case E");
fichier << "Case 'E'" << std::endl;
destruction();
break;
}
case 'A':
{
Afficher(MESSAGE, "case A");
fichier << "Case 'A'" << std::endl;
Voiture voiture = {TypeUsager::AUTRE, compteurImmatriculation, -1};
compteurImmatriculation = (compteurImmatriculation++) % IMMATRICULATION_MAX;
if (valeur == 1)
{
write(descEcritureCanauxBarriereEntree[AUTRE_BLAISE_PASCAL - 1], &voiture, sizeof(Voiture));
}
else
{
write(descEcritureCanauxBarriereEntree[ENTREE_GASTON_BERGER - 1], &voiture, sizeof(Voiture));
}
break;
}
case 'P':
{
Afficher(MESSAGE, "case P");
fichier << "Case 'P'" << std::endl;
Voiture voiture = {TypeUsager::PROF, compteurImmatriculation, -1};
compteurImmatriculation = (compteurImmatriculation++) % IMMATRICULATION_MAX;
if (valeur == 1)
{
write(descEcritureCanauxBarriereEntree[PROF_BLAISE_PASCAL - 1], &voiture, sizeof(Voiture));
}
else
{
write(descEcritureCanauxBarriereEntree[ENTREE_GASTON_BERGER - 1], &voiture, sizeof(Voiture));
}
break;
}
case 'S':
{
Afficher(MESSAGE, "case S");
fichier << "Case 'S'" << std::endl;
write(descEcritureCanalBarriereSortie, &valeur, sizeof(unsigned int));
break;
}
default:
fichier << "default" << std::endl;
Afficher(MESSAGE, "Commande: code inconnue");
}
fichier << "Fin commande" << std::endl;
}
int main()
{
int x,y; // position joueur
int touche;
x = y = 1;
touche = 0;
while(touche!=27) // ECHAP
{
Afficher(x,y);
touche = MyGetch();
switch(touche)
{
case 'q':
TryMove(&x,&y,0,-1);
break;
case 'd':
TryMove(&x,&y,0,1);
break;
case 'z':
TryMove(&x,&y,-1,0);
break;
case 's':
TryMove(&x,&y,1,0);
default:
break;
}
}
return 0;
}
int main(int argc, char *argv[])
{
ITEM items[MAX_ITEM];
int *nb_items;
FILE *f;
nb_items = malloc(sizeof(int));
*nb_items = 0;
printf("%d\n", *nb_items);
Lire(items, nb_items);
printf("%d\n", *nb_items);
while(TRUE){
f = fopen("file.txt", "r");
if(*nb_items>0)
while( fread(items+(*nb_items), sizeof(ITEM), 1, f) )
(*nb_items)++;
printf("%d", *nb_items);
fclose(f);
Choix(items, *nb_items);
Afficher(items, *nb_items);
printf("%d\n", *nb_items);
f = fopen("file.txt", "w");
fwrite(items, *nb_items, sizeof(ITEM), f);
fclose(f);
}
//printf("%d", *nb_items);
//f = fopen("file.txt", "w");
//fwrite(items, *nb_items, sizeof(ITEM), f);
//fclose(f);
exit(0);
}
static void SignalVoitureSortie ( int noSignal )
// Algorithme :
//
{
int pid;
int numeroPlace = -1;
int statut;
if ((pid = wait(&statut)) == -1)
{ Afficher(TypeZone::MESSAGE, "Erreur wait pid" );
}
numeroPlace = WEXITSTATUS(statut);
for(unsigned int i=0;i<NB_PLACES;i++) {
if(pidVoituriers[i].numeroPlace == pid)
{ struct sembuf op;
op.sem_num = 0;
op.sem_op = -1;
op.sem_flg = 0;
while(semop(idSemaphoreContenuParking,&op,1) == -1 && errno == EINTR);
Effacer((TypeZone)numeroPlace);
AfficherSortie(parking->voitures[numeroPlace].usager, parking->voitures[numeroPlace].numeroPlaque, parking->voitures[numeroPlace].heureArrivee, time(NULL));
parking->voitures[numeroPlace] = {0,0,TypeUsager::AUCUN,0};
op.sem_op = 1;
semop(idSemaphoreContenuParking, &op, 1);
pidVoituriers[i].numeroPlace = -1;
GereRequete();
}
}
} //----- fin de SignalVoitureGaree
void Clavier()
{
Afficher(MESSAGE, "DEBUG 4");
arrivee_voiturePBP = open(pathPipeArriveePBP, O_WRONLY);
arrivee_voitureABP = open(pathPipeArriveeABP, O_WRONLY);
arrivee_voitureGB = open(pathPipeArriveeGB, O_WRONLY);
sortie_voiture = open(pathPipeSortie, O_WRONLY);
Afficher(MESSAGE, "DEBUG 5");
for(;;)
{
// Moteur
Menu();
}
}
int main(int argc, char** argv)
{
SDL_Surface* screen, *tileset;
SDL_Event event;
s_map *map;
(void)argc;
map = init_map(argv);
SDL_Init(SDL_INIT_VIDEO);
screen = SDL_SetVideoMode(LARGEUR_TILE * map->sizeX, \
HAUTEUR_TILE * map->sizeY, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
tileset = SDL_LoadBMP("tileset1.bmp");
if (!tileset)
{
printf("Echec de chargement tileset1.bmp\n");
SDL_Quit();
exit(-1);
}
Afficher(screen, tileset, map);
while (event.type!=SDL_KEYDOWN)
SDL_WaitEvent(&event);
SDL_FreeSurface(tileset);
SDL_Quit();
free(map);
return 0;
}
static void EffacerPlace (unsigned int num) {
switch(num) {
case 1:
Effacer(ETAT_P1);
break;
case 2:
Effacer(ETAT_P2);
break;
case 3:
Effacer(ETAT_P3);
break;
case 4:
Effacer(ETAT_P4);
break;
case 5:
Effacer(ETAT_P5);
break;
case 6:
Effacer(ETAT_P6);
break;
case 7:
Effacer(ETAT_P7);
break;
case 8:
Effacer(ETAT_P8);
break;
default :
Afficher(MESSAGE, "Erreur de num");
}
}
void Commande ( TypeVoie voie, unsigned int duree )
{
/** structures pour les opérations sur la durée (lecture) */
struct sembuf getDLock;
getDLock.sem_num = dureesLoc;
getDLock.sem_op = -1;
getDLock.sem_flg = 0;
struct sembuf releaseDLock;
releaseDLock.sem_num = dureesLoc;
releaseDLock.sem_op = 1;
releaseDLock.sem_flg = 0;
if( ( voie == OUEST ) || ( voie == EST ))
{
//Ecriture sur la memoire paratagée, protégée par semaphore
semop(dureesLoc,&getDLock,1);
dureeFeux->dureeEO = duree;
semop(dureesLoc,&releaseDLock,1);
//Modification de l'affichage
Effacer(MESSAGE);
Afficher(MESSAGE,"La durée des feux de l'axe EO a changé");
}
if( ( voie == SUD ) || ( voie == NORD ))
{
//Ecriture sur la memoire partagée, protégée par semaphore
semop(dureesLoc,&getDLock,1);
dureeFeux->dureeNS = duree;
semop(dureesLoc,&releaseDLock,1);
//Modification de l'affichage
Effacer(MESSAGE);
Afficher(MESSAGE,"La durée des feux de l'axe NS a changé");
}
}
int main(int argc, char *argv[])
{
unsigned long long e = 64889485484;
unsigned long long b = e & (e-1);
int i;
int n = atoi(argv[1]);
int **T = CreerTab(n);
Afficher(n,T);
int *C = Coords(T, n, 5);
printf("ok");
int *Z = Ligne(T, n, C);
int *D = Colonne(T, n, C);
return 0;
}
void Grille::LancerJeu (){
unsigned int x,y;
// initialise et affiche la grille
InitialiserCases();
Afficher();
// tant que le trésor n'est pas trouvé
while(!(*cases[tresorX][tresorY]).EstDecouverte()){
//le joueur selectionne une case
/*try{
x=joueur.DemanderX(20);
}
catch(string e){
cout << "erreur : " << e;
}*/
x=joueur.DemanderX(20);
y=joueur.DemanderY(20);
// découvre la case sélectionnée
(*cases[x][y]).Decouvrir();
// affiche la grille
Afficher();
// si le trésor n'est pas touvé, on affiche l'indice
if(!(*cases[tresorX][tresorY]).EstDecouverte())
Distance(x,y);
}
cout << "Vous avez trouve le tresor !! Bravo !!" << endl;
}
void Commande ( char code )
{
if(code == 'Q'){
// Si le generateur est etteint à la fin, on a un waitpid infini
if (!generateurActif)
kill(pidGenerateur,SIGCONT);
//Detachement de la mémoire partagée
shmdt(dureeFeux);
exit(0);
}
if (code=='G')
{
if (generateurActif)
{
kill(pidGenerateur,SIGSTOP);
generateurActif=false;
//Modification de l'affichage
Effacer(MESSAGE);
Effacer(ETAT_GENERATEUR);
Afficher(ETAT_GENERATEUR,"OFF",GRAS);
Afficher(MESSAGE,"Le generateur a été eteint");
}
else
{
kill(pidGenerateur,SIGCONT);
generateurActif=true;
//Modification de l'affichage
Effacer(MESSAGE);
Effacer(ETAT_GENERATEUR);
Afficher(ETAT_GENERATEUR,"ON",GRAS);
Afficher(MESSAGE,"Le generateur a été activé");
}
}
}
static void Moteur()
// Algorithme :
{
int index = 0;
for(;;)
{ StructDemandeSortie demande;
if(msgrcv(idBal, &demande, sizeof(StructDemandeSortie), 1, MSG_NOERROR) > 0)
{ index = getVoiturier();
if(index == -1)
{ Afficher(TypeZone::MESSAGE, "Attention plus de voiturier" );
}
else
{ if(voitureExiste(demande.place))
{ if((pidVoituriers[index].numeroPlace = SortirVoiture(demande.place)) < 0)
{ Afficher(TypeZone::MESSAGE, "Erreur : Impossible de sortir une voiture" );
}
}
else
{ Afficher(TypeZone::MESSAGE, "La voiture n'existe pas" );
}
}
}
}
} //Fin de Moteur
void BasicEntite::Afficher_Entite(){
glPushMatrix();
glMatrixMode (GL_MODELVIEW);
glTranslatef(position.x, position.y, position.z);
glRotated (anglesEuler.x, 1, 0, 0);
glRotated (anglesEuler.y, 0, 1, 0);
glRotated (anglesEuler.z, 0, 0, 1);
glScalef(echelle.x, echelle.y, echelle.z);
Afficher();
glPopMatrix();
}
void Commande (char code, unsigned int valeur)
{
switch(code)
{
case 'E':
{
destruction();
break;
}
case 'A':
{
Voiture voiture = {TypeUsager::AUTRE, compteurImmatriculation, -1};
compteurImmatriculation = (compteurImmatriculation + 1) % IMMATRICULATION_MAX;
if (valeur == 1)
{
write(descEcritureCanauxBarriereEntree[AUTRE_BLAISE_PASCAL - 1], &voiture, sizeof(Voiture));
}
else
{
write(descEcritureCanauxBarriereEntree[ENTREE_GASTON_BERGER - 1], &voiture, sizeof(Voiture));
}
break;
}
case 'P':
{
Voiture voiture = {TypeUsager::PROF, compteurImmatriculation, -1};
compteurImmatriculation = (compteurImmatriculation + 1) % IMMATRICULATION_MAX;
if (valeur == 1)
{
write(descEcritureCanauxBarriereEntree[PROF_BLAISE_PASCAL - 1], &voiture, sizeof(Voiture));
}
else
{
write(descEcritureCanauxBarriereEntree[ENTREE_GASTON_BERGER - 1], &voiture, sizeof(Voiture));
}
break;
}
case 'S':
{
write(descEcritureCanalBarriereSortie, &valeur, sizeof(unsigned int));
break;
}
default:
Afficher(MESSAGE, "Commande: code inconnue");
}
}
pid_t CreerEtInitialiserFeux(int mtxFeux, int mColor, int mDuree)
// Mode d'emploi :
// <mtxFeux> : Identifiant du tableau de sémaphore permettant la mise en place d'un mutex
// <mColor> : L'identifiant de la mémoire partagée contenant la couleur des feux
// <mDuree> : L'identifiant de la mémoire partagée contenant la durée
// Contrat :
// - <mtxFeux> est un tableau de sémaphores de 2 cases, dont la première sert de mutex
// à <mColor>, et la seconde à <mDuree>
// - <mColor> est l'ID d'un mémoire partagée contenant 2 entiers
// - <mDuree> est l'ID d'un mémoire partagée contenant 2 entiers
{
pid_t pFeux;
if((pFeux = fork()) == 0)
{
/** structures pour les opérations sur la durée (lecture) */
struct sembuf getDLock;
getDLock.sem_num = dureesLoc;
getDLock.sem_op = 1;
getDLock.sem_flg = 0;
struct sembuf releaseDLock;
releaseDLock.sem_num = dureesLoc;
releaseDLock.sem_op = -1;
releaseDLock.sem_flg = 0;
/** structures pour les opérations sur la couleur (écriture) */
struct sembuf getCLock;
getCLock.sem_num = colorsLoc;
getCLock.sem_op = 4;
getCLock.sem_flg = 0;
struct sembuf releaseCLock;
releaseCLock.sem_num = colorsLoc;
releaseCLock.sem_op = -4;
releaseCLock.sem_flg = 0;
/** Initialisation des variables locales */
int tempsNS = 0;
int tempsEO = 0;
Colors couleurNS = ROUGE;
Colors couleurEO = ROUGE;
bool lastNS = false; // booléen permettant de savoir qui doit passer au vert
couleursFeux = (couleurs*)shmat(mColor, NULL, 0);
dureesFeux = (durees*)shmat(mDuree, NULL, 0);
/** Mappage des signaux */
struct sigaction action;
action.sa_handler = handleEnd;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
sigaction(SIGUSR2, &action, NULL);
for(;;)
{
/** Gestion de l'axe NS */
if(tempsNS <= 0)
{
switch (couleurNS)
{
case ROUGE:
if(!lastNS)
{
couleurNS = VERT;
lastNS = !lastNS;
/** Récupération des durées, avec mutex */
semop(mtxFeux, &getDLock, 1);
tempsNS = dureesFeux->dureeNS;
tempsEO = dureesFeux->dureeEO;
semop(mtxFeux, &releaseDLock, 1);
Afficher(DUREE_AXE_NS, tempsNS);
Afficher(DUREE_AXE_EO, tempsEO);
tempsEO = tempsNS + 5;
}
break;
case VERT:
couleurNS = ORANGE;
tempsNS = 3;
break;
case ORANGE:
couleurNS = ROUGE;
tempsNS = 2;
break;
}
}
/** Gestion de l'axe EO */
if(tempsEO <= 0)
{
switch (couleurEO)
{
case ROUGE:
if(lastNS)
{
couleurEO = VERT;
lastNS = !lastNS;
/** Récupération des durées, avec mutex */
semop(mtxFeux, &getDLock, 1);
tempsNS = dureesFeux->dureeNS;
tempsEO = dureesFeux->dureeEO;
semop(mtxFeux, &releaseDLock, 1);
Afficher(DUREE_AXE_NS, tempsNS);
Afficher(DUREE_AXE_EO, tempsEO);
tempsNS = tempsEO + 5;
}
break;
case VERT:
couleurEO = ORANGE;
tempsNS = 3;
break;
case ORANGE:
couleurEO = ROUGE;
tempsNS = 2;
break;
}
}
Afficher(TEMPS_AXE_NS, tempsNS);
Afficher(TEMPS_AXE_EO, tempsEO);
couleurFeu(COULEUR_AXE_NS, couleurNS);
couleurFeu(COULEUR_AXE_EO, couleurEO);
/** Ecriture des couleurs des feux, avec mutex */
semop(mtxFeux, &getCLock, 1);
couleursFeux->colNS = couleurNS;
couleursFeux->colEO = couleurEO;
semop(mtxFeux, &releaseCLock, 1);
tempsNS--;
tempsEO--;
sleep(1);
}
}
else
{
return pFeux;
}
} //----- fin de CreerEtInitialiserFeux
int main (void) // Fonction principale
{
int Ht16k, Mcp, EtatLed, EtatBTN ; // Declaration des variables.
int i = 1 ;
pthread_t Thread_Jeux;
Ht16k = wiringPiI2CSetup (0x70) ;
if ((Mcp = wiringPiI2CSetup (0x20)) == -1)
{
fprintf (stderr, "Mcp: impossible d'initialiser l'I2C: %s\n", strerror (errno)) ; return 1 ; // Si impossible a initialiser.
}
wiringPiI2CWriteReg8 (Mcp, IODIR, 0xC0) ; // Toutes les broches en OUTPUT sauf broches 6 et 7 en input.
wiringPiI2CWriteReg8 (Mcp, GPIO, LEDNOT) ; // Eteindre toutes les LEDs
wiringPiI2CWrite (Ht16k, 0x21) ;
wiringPiI2CWrite (Ht16k, 0x81) ;
Afficher (Ht16k, 0) ;
EtatLed = LEDNOT ; // Par defaut les LEDs sont eteintes.
struct arg_jeux TypeDeJeu = {Mcp, 0, &EtatLed, Ht16k} ;
for (;;)
{
debut: //Etiquette goto je ne sai pas faire autrement..
wiringPiI2CWrite (Ht16k, 0x81) ;
EtatBTN = (wiringPiI2CReadReg8 (Mcp, GPIO) - EtatLed) ;
if (EtatBTN == BTNG) // Si bouton gauche presser alors...
{
delay (200); // On attend 10ms puis on fait une relecture pour etre sur que ce n'est pas un parasite
if ((wiringPiI2CReadReg8 (Mcp, GPIO) - EtatLed) == BTNG) // Si bouton gauche presser..
{
wiringPiI2CWrite (Ht16k, 0x83);
BtnAppuiLong (Mcp, &EtatLed) ;
while ((wiringPiI2CReadReg8 (Mcp, GPIO) - EtatLed) != BTND)
{
delay (20) ;
if ((wiringPiI2CReadReg8 (Mcp, GPIO) - EtatLed) == BTNG)
{
Afficher (Ht16k, i) ;
i++ ;
if (i == 10) {i =0 ;}
BtnAppuiLong (Mcp, &EtatLed) ;
TypeDeJeu.J = (i-1) ;
TypeDeJeu.EtatLed = &EtatLed ;
}
}
pthread_cancel(Thread_Jeux);
pthread_create (&Thread_Jeux, NULL, Jeux, &TypeDeJeu);
printf("coucou\n") ;
}
}
delay (100); // Vitesse de la boucle
}
return 0 ;
}
int main(int argc, char *argv[])
{
// Variables
SDL_Surface *ecran = NULL, *imgFond = NULL, *imgSapin = NULL, *tileset = NULL, *imgtrain = NULL;
SDL_Rect pFond;
SDL_Event event;
T_VOIT car[SIZE];
int continuer;
int res;
int arret=0;
// Variables du Timer
SDL_TimerID idTimer, idTimer2,idTimer3; // code à améliorer : utiliser 1 seul timer
int periode = 10;
// initialisation
continuer = 1;
setParamVoiture(&car[2],1,358,0,arret);
setParamVoiture(&car[0],2,0,230,arret); // premiere voiture plus rapide
setParamVoiture(&car[1],3,0,320,arret);
affichageParamVoiture(car[0]);
affichageParamVoiture(car[1]);
affichageParamVoiture(car[2]); // code à amélioreR
//SDL_RemoveTimer(idTimer)
// chargement de la map
tileset = SDL_LoadBMP("route.bmp");
// SDL init
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
idTimer = SDL_AddTimer(periode,affiche,car);
idTimer2 = SDL_AddTimer(periode,affiche,&car[1]);
idTimer3 = SDL_AddTimer(periode,affiche1,&car[2]);
ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Premiere collision de vehicules ...", NULL);
imgSapin = SDL_LoadBMP("voiture.bmp");
imgtrain = SDL_LoadBMP("train.bmp");
Afficher(ecran,tileset,table,LARGEUR_FENETRE/LARGEUR_TILE,HAUTEUR_FENETRE/HAUTEUR_TILE);
SDL_BlitSurface(imgSapin, NULL, ecran, &car[0].pos); // code à améliorer
SDL_BlitSurface(imgSapin, NULL, ecran, &car[1].pos);
SDL_BlitSurface(imgtrain, NULL, ecran, &car[2].pos);
SDL_Flip(ecran);
while (continuer) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
continuer = 0;
break;
}
}
res=test(&car[2]);
if(res==1)
{
arret=1;
}
else
{
arret=0;
}
/*load(&car[0],arret);
load(&car[1],arret);*/
Afficher(ecran,tileset,table,LARGEUR_FENETRE/LARGEUR_TILE,HAUTEUR_FENETRE/HAUTEUR_TILE);
Afficher1(ecran,tileset,table,LARGEUR_FENETRE/LARGEUR_TILE,HAUTEUR_FENETRE/HAUTEUR_TILE,arret);
ControleArretVoitures(car,2,arret);
SDL_BlitSurface(imgSapin, NULL, ecran, &car[0].pos);
SDL_BlitSurface(imgSapin, NULL, ecran, &car[1].pos);
SDL_BlitSurface(imgtrain, NULL, ecran, &car[2].pos);
SDL_Flip(ecran);
}
SDL_FreeSurface(imgFond); /* On libère la surface */
SDL_Quit();
return EXIT_SUCCESS;
}
void Ligne::Sauvegarder(ofstream& f){
streambuf *file_buffer = f.rdbuf();
streambuf *old_cout_buffer = cout.rdbuf(file_buffer);
Afficher();
cout.rdbuf(old_cout_buffer);
}
