int main(void)
{
initialisation();
do
{
//attendre que la minuterie soit expiree ou que le boutton soit relacher
} while ( minuterieExpiree == 0);
// Une interruption s'est produite. Arreter toute
// forme d'interruption. Une seule reponse suffit.
cli ();
//Faire clignoter la couleur rouge sur un intervalle de 1/2 seconde
clignoter(500,RED);
//Etteindre la LED et attendre 2 seconde
defineColor(NOTHING);
_delay_ms(2000);
//Faire clignoter la couleur rouge compteur/2 fois avec une frequence de 2 fois par seconde
clignoter(RED,compteur/2,2);
//Allumer la LED en vert pour une seconde
defineColor(GREEN);
_delay_ms(1000);
//Finalement ettiendre la LED
defineColor(NOTHING);
return 0;
}
Favoris::Favoris(QWidget *parent=0) : QTabWidget(parent), pr(parent){
if(!QFile::exists("settingFavoris.ini")){
setting=new QSettings("settingFavoris.ini", QSettings::IniFormat, parent);
initialisation();}
else setting=new QSettings("settingFavoris.ini", QSettings::IniFormat, parent);
QStringList favorisAdresse=setting->value("favorisAdresse").toStringList();
QStringList favorisName=setting->value("favorisName").toStringList();
QFile file("listIcon.ico", pr);
QDataStream in(&file);
file.open(QIODevice::ReadOnly);
QScrollArea *area=new QScrollArea;
addTab(area, "Favoris");
favoris=new QWidget;
layoutFavoris=new QVBoxLayout;
layoutFavoris->setSpacing(0);
favoris->setLayout(layoutFavoris);
area->setWidget(favoris);
area->setBackgroundRole(QPalette::Light);
favoris->setFixedWidth(225);
for(int i=0; i<favorisName.count(); i++){
QIcon icon;
in>>icon;
addFavoris(QUrl(favorisAdresse[i]), favorisName[i], icon);
connect(listLien[i], SIGNAL(suppr()), this, SLOT(supprFavoris()));
connect(listLien[i], SIGNAL(openPage(QUrl)), this, SLOT(openPageS(QUrl)));
connect(listLien[i], SIGNAL(openNewPage(QUrl)), this, SLOT(openNewPageS(QUrl)));
}
setVisible(false);
}
/**
* The main function. It does the logic.
*/
int main()
{
initialisation();
_delay_ms(1000);
lightOnRed();
_delay_ms(100);
lightOff();
partirMinuterie(7812);
//minuterieExpiree = 1;
do {
// attendre qu'une des deux variables soit modifiée
// par une ou l'autre des interruptions.
} while ( minuterieExpiree == 0 && boutonPoussoir == 0 );
// Une interruption s'est produite. arreter toute
// forme d'interruption. Une seule reponse suffit.
cli ();
// Verifier la reponse
if ( minuterieExpiree == 1 ) {
for(;;) {
lightOnRed();
}
} else {
for(;;) {
lightOnGreen();
}
}
return 0;
}
int main( int argc, char *argv[] )
{
// initialisation de GLUT
glutInit( &argc, argv );
// paramétrage de l'affichage
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
// taille de la fenetre
glutInitWindowSize( g_largeur, g_hauteur );
// création de la fenêtre
g_feneID = glutCreateWindow( "INF2705" );
// référencement de la fonction de rappel pour l'affichage
glutDisplayFunc( afficherScene );
// référencement de la fonction de rappel pour le redimensionnement
glutReshapeFunc( redimensionnement );
// référencement de la fonction de gestion des touches
glutKeyboardFunc( clavier );
// référencement de la fonction de gestion des touches spéciales
glutSpecialFunc( clavierSpecial );
// référencement de la fonction de rappel pour le mouvement de la souris
glutMotionFunc( sourisMouvement );
// référencement de la fonction de rappel pour le clic de la souris
glutMouseFunc( sourisClic );
initialisation();
// boucle principale de gestion des evenements
glutMainLoop();
// le programme n'arrivera jamais jusqu'ici
return EXIT_SUCCESS;
}
/******************************************************************************
* Initialisation simple avec un sens de communication
* (si reception == 1 cote reception sinon cote emission)
*/
void init_physique(int reception)
{
float proba_perte = 0;
float proba_erreur = 0;
unsigned short port_local;
unsigned short port_distant;
#ifdef UNIX
uid_t uid = getuid();
#else
int uid = 1;
#endif
if (reception) {
proba_perte = conf_proba_perte(RECEPTION);
proba_erreur = conf_proba_erreur(RECEPTION);
perte_connexion = conf_perte_connexion(PERTE_CONNEXION_REP);
perte_deconnexion = conf_perte_connexion(PERTE_DECONNEXION_ACK);
port_local = (short) (uid % 60000 + 2000);
port_distant = (short) (uid % 60000 + 3000);
} else {
proba_perte = conf_proba_perte(EMISSION);
proba_erreur = conf_proba_erreur(EMISSION);
perte_connexion = conf_perte_connexion(PERTE_CONNEXION_REQ);
perte_deconnexion = conf_perte_connexion(PERTE_DECONNEXION);
port_local = (short) (uid % 60000 + 3000);
port_distant = (short) (uid % 60000 + 2000);
}
printf("[PHY] On utilise le port local %d et le port distant %d\n",
port_local, port_distant);
initialisation(proba_perte, proba_erreur, port_local, "localhost", port_distant);
}
int main( int argc, char ** argv )
{
unsigned iLargeur = 0, iHauteur = 0;
unsigned int iNbSnake = 0;
unsigned int isFini = 0;
unsigned int iTemps = 0;
if( argc < 4 )
{
printf( "Mauvaise utilisation du programme\n" );
printf( "snake <LARGEUR>x<HAUTEUR> <NB_SERPENTS> <TEMPS>\n" );
return EXIT_FAILURE;
}
sscanf( argv[1], "%dx%d", &iLargeur, &iHauteur );
char cPlateau[iHauteur*iLargeur];
sscanf( argv[2], "%d", &iNbSnake );
Tete tTete[iNbSnake];
sscanf( argv[3], "%d", &iTemps );
initialisation( (char * const)cPlateau, iHauteur, iLargeur, tTete , iNbSnake );
srand( time( NULL ) );
system( "clear" );
while( !isFini )
{
attendre( iTemps );
system( "clear" );
afficher_cadre( (char * const)cPlateau, iHauteur, iLargeur );
isFini = evolution( (char * const)cPlateau, iHauteur, iLargeur, tTete, iNbSnake );
}
statistiques( (char * const)cPlateau, iHauteur, iLargeur );
return EXIT_SUCCESS;
}
int main () {
initialisation();
_delay_ms (2000); //Attendre 2 seconde avant le jeu
PORTD = 0x02;//0000 0001
_delay_ms (100);
PORTD = 0x00;//0000 0000
partirMinuterie(7812); // 8M / 1024
do {
} while (minuterieExpiree == 0 && boutonPoussoir == 0);
cli ();
if (boutonPoussoir == 1)
PORTD = 0x01;//0000 0001
else
PORTD = 0x02;//0000 0010
}
int main(int argc, char const *argv[])
{
int j,i,nbenreg;
liste *list=malloc(26*sizeof(liste));
liste *list_aux=malloc(26*sizeof(liste));
char **mat;
int l,c;
initialisation_n();
mat = (char **)malloc(n*sizeof(char*));
for (i = 0; i < n; ++i){
mat[i] = (char *)malloc(n*sizeof(char));
}
initialisation(mat);
conversion_mat_vers_tabdenregistrement(mat,&list,&nbenreg);
lecture_d_fichier(list,nbenreg,4);
printf("%s\n", matp);
free(list);
for ( i = 0; i < 1; ++i)
{
free(*(mat+i));
}
free(mat);
return 0;
}
int main(int argc,char *argv[] )
{
// initialisation de GLUT
glutInit(&argc, argv);
// parametrage de l'affichage
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
// taille de la fenetre
glutInitWindowSize(g_largeur, g_hauteur);
// creation de la fenetre
g_feneID = glutCreateWindow("INF2705");
// referencement de la fonction de rappel pour l'affichage
glutDisplayFunc(dessinerScene);
// referencement de la fonction de gestion des touches
glutKeyboardFunc(keyboard);
// referencement de la fonction de gestion spéciale des touches extended
glutSpecialFunc(keyboardSpecial);
// referencement de la fonction de rappel pour le redimensionnement
glutReshapeFunc(resize);
// référencement de la fonction de rappel pour le mouvement de la souris
glutMotionFunc(mouseMove);
// référencement de la fonction de rappel pour le clic de la souris
glutMouseFunc(mouseClick);
glewInit();
// initialisation de variables d'état openGL et création des listes
initialisation();
// boucle principale de gestion des evenements
glutMainLoop();
// le programme n'arrivera jamais jusqu'ici
return EXIT_SUCCESS;
}
void editer (void)
{
initialisation();
while (touch)
{
event_screen(&rouge, &vert, &bleu);
draw(trace, rouge, vert, bleu);
}
}
int main(int argc, char *argv[])
{
program *prog = (program *) malloc(sizeof(program));
player *user = (player *) malloc(sizeof(player));
whitespace_info *whitespace_prog = (whitespace_info *) malloc(sizeof(whitespace_info));
printing_board *first_board = (printing_board *) malloc(sizeof(printing_board));
password_info *pw_info = (password_info *) malloc(sizeof(password_info));
SDL_Simplewin sw;
other_arg_type argument_indicator;
check_initialisation(prog, user, whitespace_prog, first_board, pw_info);
password_check(pw_info);
if(pw_info -> pw_indicator == accept){
check_command_line_arguments(user, argc, &argument_indicator, argv, pw_info);
initialisation(prog, user, first_board);
if(argument_indicator == secret){
whitespace_functions(argv[1], whitespace_prog);
open_program_file("ws_to_reg_translation.txt", prog);
}
else if(argument_indicator == combine_files){
combine_ws_reg_files(prog, whitespace_prog, argv[1], argv[2]);
}
else if(argument_indicator != password_change){
open_program_file(argv[1], prog);
}
if(argument_indicator == regular || argument_indicator == secret){
parse_text_and_interpret(prog, user, first_board);
printing(user, first_board, &sw);
}
else if(argument_indicator != password_change){
write_file_to_whitespace(prog);
}
}
free_components(first_board, prog, user, whitespace_prog, pw_info);
return(0);
}
int main(int argc, char* argv[]) {
int passerTour(int table[8][8], int couleur);
void ordinateur(int table[8][8]);
void initialisation(int table[8][8]) ;
void dessin(int table[8][8], SDL_Surface* spiece[3], SDL_Surface* sfenetre);
int fin=0, n;
int table[8][8];
SDL_Surface* sfenetre;
SDL_Surface* spiece[3];
SDL_Event evenement;
SDL_Init(SDL_INIT_VIDEO);
SDL_WM_SetCaption("Reversi", NULL);
sfenetre=SDL_SetVideoMode(8*klCase, 8*khCase, 32, SDL_HWSURFACE);
spiece[kblanche]=SDL_LoadBMP("Images/blanche.bmp");
spiece[knoire]=SDL_LoadBMP("Images/noire.bmp");
spiece[kneutre]=SDL_LoadBMP("Images/neutre.bmp");
initialisation(table);
dessin(table, spiece, sfenetre);
SDL_Flip(sfenetre);
while ( !fin ) {
SDL_WaitEvent(&evenement);
switch ( evenement.type ) {
case SDL_QUIT:
fin=1;
break;
case SDL_KEYDOWN:
if ( evenement.key.keysym.sym==SDLK_ESCAPE )
fin=1;
break;
case SDL_MOUSEBUTTONDOWN:
if ( !passerTour(table, kblanche) ) {
if ( positionnement(table, kblanche, evenement.button.y/khCase,
evenement.button.x/klCase)==kcorrect ) {
dessin(table, spiece, sfenetre);
SDL_Flip(sfenetre);
SDL_Delay(1000);
if ( !passerTour(table, knoire) )
ordinateur(table);
}
}
else if ( !passerTour(table, knoire) )
ordinateur(table);
dessin(table, spiece, sfenetre);
SDL_Flip(sfenetre);
break;
}
}
for ( n=0; n<3; n++ )
SDL_FreeSurface(spiece[n]);
SDL_Quit();
return 0;
}
IS::GameObject::Component::Rule::Rule(IS::Scene::Scene *scene, IS::Scene::SceneManager *sceneManager, int nbLife, int nbPlayer)
{
_scene = scene;
_sceneManager = sceneManager;
_nbLife = nbLife;
_victory = true;
_nbPlayer = nbPlayer;
_isPlaying = false;
_done = false;
initialisation();
}
static ssize_t open(struct inode *inode, struct file *filp)
{
struct devInfo *dev;
initialisation();
dev -> x = 0;
dev -> y = 0;
dev -> pressure = 0;
filp-> private_data = dev;
return 0;
}
int main()
{
Liste *maListe = initialisation();
insertion(maListe, 4);
insertion(maListe, 8);
insertion(maListe, 15);
suppression(maListe);
afficherListe(maListe);
return 0;
}
int main (void)
{
initialisation();
tasks_create_tasks();
while (1 == 1)
{
scheduler_update(¢ral_data->scheduler);
}
return 0;
}
int main(void) {
int n=0;
int m=0;
dimensionnement(&n, &m);
int **tab=calloc(n, sizeof(int*));
for(int i=0;i<n;++i) {
tab[i]=calloc(m, sizeof(int));
}
initialisation(tab, n, m);
int nbgen=nb_generation();
printf("Vous avez demandé %d générations.\n", nbgen);
int B[9];
for(int i=0;i<9;++i) {
B[i]=0;
}
int S[9];
for(int i=0;i<9;++i) {
S[i]=0;
}
saisie_B_M(B);
saisie_S_M(S);
for(int i=0;i<9;++i) {
printf("%d ", i);
}
printf("\n");
printf("B :\n");
for(int i=0;i<9;++i) {
printf("%d ", B[i]);
}
printf("\n");
printf("S :\n");
for(int i=0;i<9;++i) {
printf("%d ", S[i]);
}
printf("\n");
printf("génération n°1 :\n");
affiche(tab, n, m);
/**/
int **tab_t=calloc(n, sizeof(int*));
for(int i=0;i<n;++i) {
tab_t[i]=calloc(m, sizeof(int));
}
_initialisation2(tab_t, n, m);
/**/
int **tmp;
for(int i=2;i<=nbgen;++i) {
printf("génération n°%d :\n", i);
generation_suivante_M(tab, tab_t, n, m, B, S);
tmp=tab;tab=tab_t;tab_t=tmp;
affiche(tab, n, m);
}
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
int error;
error = 0;
error = initialisation (argc, argv);
#if defined(GTK)
if (!error)
{
if (game_asked ())
{
while (play_game ());
}
else
{
build_gtk_interface (argc, argv);
}
}
#else // not defined(GTK)
RomSelectStart();
if (!error)
{
if (game_asked ())
{
while (1)
{
fprintf(stderr,"EMU START:\n");
play_game();
fprintf(stderr,"EMU END:\n");
}
}
else
{
printf ("No game specified\n");
}
}
#endif
fprintf(stderr,"HuGo says bye!\n");
cleanup ();
return 0;
}
// le main
int main(int argc,char *argv[])
{
// initialisation de GLUT
glutInit(&argc, argv);
// parametrage de l'affichage
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
// taille de la fenetre
glutInitWindowSize(800, 800);
// creation de la fenetre
g_nWindowID = glutCreateWindow("TP1v1");
// referencement de la fonction de rappel pour l'affichage
glutDisplayFunc(affichage);
// referencement de la fonction de rappel pour l'attente
glutIdleFunc(attente);
// referencement de la fonction de gestion des touches
glutKeyboardFunc(clavier);
// referencement de la fonction de gestion spéciale des touches extended
glutSpecialFunc(clavierSpecial);
// referencement de la fonction de rappel pour le redimensionnement
glutReshapeFunc (redimensionnement);
// référencement de la fonction de rappel pour le mouvement de la souris
glutMotionFunc (mouvementSouris);
// référencement de la fonction de rappel pour le click de la souris
glutMouseFunc (sourisClickee);
// vérification de la présence des extensions
// ou de la version 2.0 d'openGL
glewInit();
if (glewIsSupported("GL_VERSION_2_0"))
printf("Ready for OpenGL 2.0\n");
else {
printf("OpenGL 2.0 not supported\n");
exit(1);
}
// compiler et linker les shaders
initialiserNuanceurs();
// creer les vbos
initialiserVBO();
// initialisation de variables d'état openGL et création des listes
initialisation();
// boucle principale de gestion des evenements
glutMainLoop();
// le programme n'arrivera jamais jusqu'ici
return EXIT_SUCCESS;
}
//LUDO:
int
main_hugo (int argc, char** argv)
{
int error = initialisation (argc, argv);
psp_sdl_clear_screen(0);
psp_sdl_flip();
psp_sdl_clear_screen(0);
psp_sdl_flip();
while (1) {
play_game ();
}
}
int main()
{
Liste *maListe = initialisation();
printf("%d\n", compteur(maListe));
insertion(maListe, 4);
insertion(maListe, 8);
insertion(maListe, 15);
insertion(maListe, 6);
insertion(maListe, 9);
insertion(maListe, 18);
// suppression(maListe);
printf("%d\n", compteur(maListe));
insertdebut(maListe,1);
insertfin(maListe, 99);
afficherListeAvant(maListe);
printf("===\n");
afficherListeArriere(maListe);
courantavant(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
remplcourav(maListe, 666);
insertcourav(maListe, 888);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
remplcourar(maListe, 999);
insertcourar(maListe, 777);
printf("%d-", maListe->courant->nombre);
courantavant(maListe);
printf("%d-", maListe->courant->nombre);
courantavant(maListe);
printf("%d\n\n", maListe->courant->nombre);
afficherListeAvant(maListe);
printf("%d\n", compteur(maListe));
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout << "Enter n: ";
cin >> n;
list *first;
first = new list[n];
initialisation(first);
read (first);
int d;
cout << "num del: ";
cin >> d;
remove (first, d);
print(first);
return 0;
}
/**
* The main function. It does the logic.
*
* COMMENT BRANCHER LES FILS:
* Del libre + sur PORTA<0>
* Del libre - sur PORTA<1>
* Output du bread board sur PORTD<2>
* N'importe quel vcc et gnd de la carte sur le vcc et gnd du breadboard
*/
int main()
{
initialisation();
for(;;) {
do {
// attendre qu'une des deux variables soit modifiée
// par une ou l'autre des interruptions.
//(PIND & _BV(PORTD2)) == true if button is not pressed
// We want to interate as long as the button is pressed, if it has been pressed (compteur > 1)
} while (compteur <= 120 && (!(PIND & _BV(PORTD2)) || compteur == 0));
arreterMinuterie();
// Une interruption s'est produite. Arreter toute
// forme d'interruption. Une seule reponse suffit.
cli ();
// Blink green for 1/2 seconds, at 2 Hz
lightOnGreen();
msleep(500);
// Wait 2 seconds
lightOff();
msleep(2000);
// Blink red (counter/2) times at 2 Hz
for (uint8_t i = 0; i < compteur/2; i++) {
lightOnRed();
msleep(250);
lightOff();
msleep(250);
}
// Turn on green light for a second
lightOnGreen();
msleep(1000);
lightOff();
compteur = 0;
// Réactive les interruptions
sei ();
}
return 0;
}
void programmeTest(){
int i,j;
unsigned char buffer[HDA_SECTORSIZE];
initialisation();
printf("Test de dmps() : \n");
for(i=0;i<HDA_MAXCYLINDER;i++)
for(j=0;j<HDA_MAXSECTOR;j++)
dmps(i,j);
printf("\nTest de frmt() : \n");
for(i=0;i<HDA_MAXCYLINDER;i++)
for(j=0;j<HDA_MAXSECTOR;j++)
dmps(i,j);
init_hardware("hardware.ini");
printf("\n\n Réinitialisation du disque... \n");
printf("\n\nTest de read_sector() : \n");
for(i=0;i<HDA_MAXCYLINDER;i++){
for(j=0;j<HDA_MAXSECTOR;j++){
read_sector(i,j,buffer);
}
for(j=0;j<HDA_SECTORSIZE;j++)
printf("%x ",buffer[i]);
printf("\n");
}
printf("\n\nTest de write_sector() : \n");
for(i=0;i<HDA_MAXCYLINDER;i++){
for(j=0;j<HDA_MAXSECTOR;j++){
write_sector(i,j,buffer);
}
for(j=0;j<HDA_SECTORSIZE;j++)
printf("%x ",buffer[i]);
printf("\n");
}
printf("\n\nTest de format_sector() : \n");
for(i=0;i<HDA_MAXCYLINDER;i++){
for(j=0;j<HDA_SECTORSIZE;j++)
buffer[j]=i;
for(j=0;j<HDA_MAXSECTOR;j++){
write_sector(i,j,buffer);
}
for(j=0;j<HDA_SECTORSIZE;j++)
printf("%x ",buffer[i]);
printf("\n");
}
}
void algo_principal(int parallelism, int *tableau, int taille, char *arg)
{
void *args_algo;
arguments_t args;
(void) parallelism;
args_algo = initialisation(0, tableau, taille, arg);
args.num = 0;
args.inf = 0;
args.sup = taille-1;
args.tableau = tableau;
args.taille = taille;
args.args_algo = args_algo;
traitement(&args);
traitement_resultats(0, &args);
}
int main()
{
//Initialisation des variables
int mode, maxi;
char terrain [20][38];
char pseudo[100][4]; //Les deux tableaux suivants servent à l'affichage des meilleurs scores
int score[100];
coordonees PacMan;
coordonees fantomeA;
coordonees fantomeB;
coordonees fantomeC;
coordonees fantomeD;
SetWindow(70,26); //On redimentionne la fenêtre (c'est le seul réglage faisable automatiquement)
srand(time(NULL)); //On initialise les nombres aléatoires
do
{
menu(&mode);
switch(mode)
{
case 1 :
initialisation(terrain, &PacMan, &fantomeA, &fantomeB, &fantomeC, &fantomeD); //On génère l'arène
renduarene(terrain); //On effectue un rendu sur l'arène précédement générée afin d'avoir un résultat plus joli
affichage(terrain, 0, 0, 0, 3); //On affiche une première fois le terrain
deplacements(terrain, &PacMan, &fantomeA, &fantomeB, &fantomeC, &fantomeD); //On lance la gestion des déplacements
break;
case 2:
system("CLS");
maxi = lectureScore(pseudo, score);
triScore(pseudo, score, maxi);
break;
default:
break;
}
}while(mode>0 && mode<3);
return 0;
}
int main(){
Tclasse *tabtemp;
char *fitexte[6]; // Nom du fichier texte utilisé
char *fibinaire[6]; // Nom du fichier binaire utilisé
char section; // Section de la classe
int annee,nbCours; // Année de la classe, Nombre de cours de l'année/section
int nbClassesMtn; // Nombre de classe à l'ouverture et en traitement
int i,j;
system("color f0");
initialisation(&annee,§ion);
// Création des noms des fichiers utiles pour la suite du programme
fichierbinaire(fibinaire,annee,section);
fichiertexte(fitexte,annee,section);
if(fichiers_existent(fibinaire,fitexte)==0){
creation_texte_init(&nbClassesMtn,&nbCours,fitexte);
printf("\n\n => NbClassesMtn : %d",nbClassesMtn);
tabtemp = encodage(nbClassesMtn,nbCours,annee,section);
recapitulatif(tabtemp,nbCours,nbClassesMtn);
// Essai ecriture sur fichier binaire
FILE *F;
F=fopen(fibinaire,"wb+");
// fwrite(tabtemp,renvoi_memoire(nbCours),nbClassesMtn,F);
fwrite(tabtemp,sizeof(Tclasse),nbClassesMtn,F);
fclose(F);
getch();
free(tabtemp);
}
}
int main()
{
initialisation ();
// for(;;) // boucle sans fin
// {
for(int i = 0; i < 100; i++)
_delay_ms(100);
PORTA = 0x02;
_delay_ms(100);
PORTA = 0x00;
partirMinuterie(7812);
do {
// attendre qu'une des deux variables soit modifiée
// par une ou l'autre des interruptions.
} while ( minuterieExpiree == 0 && boutonPoussoir == 0 );
// Une interruption s'est produite. arreter toute
// forme d'interruption. Une seule reponse suffit.
cli ();
// Verifier la reponse
if(minuterieExpiree == 0 && boutonPoussoir == 1)
PORTA = 0x01;
else if ( minuterieExpiree == 1 )
PORTA = 0x02;
else
{}
return 0;
}
int main()
{
t_list *newlist;
t_listel *elem;
struct termios term;
elem = xmalloc(sizeof(*elem));
tcgetattr(0, &term);
term.c_lflag &= ~ECHO;
term.c_lflag &= ~ICANON;
term.c_cc[VMIN] = 1;
term.c_cc[VTIME] = 0;
tcsetattr(0, TCSANOW, &term);
my_clean();
newlist = initialisation();
open_file(newlist, "./");
afflistsel(newlist);
fleches(term, &newlist, elem);
return (0);
}
int main()
{
t_data data;
if ((data.map = bunny_malloc(sizeof(t_map))) == NULL)
return (-1);
if ((data.pl = bunny_malloc(sizeof(t_player))) == NULL)
return (-1);
data.music_play = 0;
data.ini = bunny_load_ini("ress/map/level0.ini\0");
initialisation(&data);
if (data.ini == NULL)
return (0);
if ((get_map(&data)) == -1)
return (-1);
bunny_set_loop_main_function(mainloop);
bunny_loop(data.win, 25, &data);
bunny_stop(data.win);
clean(&data);
return (0);
}
