void init_programme(int argc, char **argv)
{
if(argc != 2)
{
printf("USAGE: %s port_num\n\tExemple : %s 9000\n", argv[0], argv[0]);
exit(EXIT_FAILURE);
}
struct sockaddr_in6 my_addr;
if((sockfd = socket(AF_INET6, SOCK_STREAM, 0)) == -1)
quitter("socket");
my_addr.sin6_family = AF_INET6;
my_addr.sin6_port = htons(atoi(argv[1]));
my_addr.sin6_addr = in6addr_any;
addrlen = sizeof(struct sockaddr_in6);
memset(buf,'\0',TAILLE_BUFFER);
if(bind(sockfd, (struct sockaddr *)&my_addr, addrlen) == -1)
{
close(sockfd);
quitter("bind");
}
if(listen(sockfd, LISTEN_BACKLOG) == -1)
{
close(sockfd);
quitter("listen");
}
FD_ZERO(&masterfds);
printf( "Début du programme.\n"
"\033[36m Pour quitter : ^D\033[00m \n");
}
/* main program. Creates the philosophers and the waiter and waits for termination of its children. */
void
dinner(int num_philo, int num_cycles)
{
if (num_philo < 2 || num_cycles < 1)
{
ecrire("Parameters with impossible values\n");
quitter(FAILURE);
}
int *philos; //to store the philosophers' pid
int waiter;
int my_prio = obtenir_priorite(obtenir_pid());
int child_prio = (my_prio == MAX_PRIORITY ? my_prio : my_prio + 1); //let's give an lower priority to the children in order to minimize the number of preemptions before the start of the dinner.
int status;
int args[4] = { 0, 0, 0, 0 };
philos = allouer(num_philo * sizeof(int));
if (philos == NULL)
{
ecrire("Allouer philos failed\n");
quitter(FAILURE);
}
int i, j;
ecrire("The dining philosophers. \nBon appétit !\n");
// we need to spawn the waiter first
args[0] = num_philo;
waiter = fourchette(child_prio, "waiter", args);
if (waiter < 1)
{
ecrire("An error occured. The program will stop.\n");
quitter(FAILURE);
}
args[0] = waiter; //the waiter's pid is a parameter of the philosophers
args[2] = num_cycles;
// spawns the philosophers
for (i = 0; i < num_philo; i++)
{
args[1] = i; //philosopher's id
philos[i] = fourchette(child_prio, "philosopher", args);
if (philos[i] < 1)
{
ecrire
("An error occured. Impossible to create the philosophers. The process will exit now.\n");
//clean up
for (j = 0; j < i; j++)
tuer(philos[j], FAILURE);
tuer(waiter, FAILURE);
quitter(FAILURE);
}
}
//everything's done, let's wait for the end
for (i = 0; i < num_philo; i++)
attendre(philos[i], &status);
//the waiter can stop
envoyer_entier(waiter, END_OF_DINNER, 10);
attendre(waiter, &status);
ecrire("The dinner ends.\n");
quitter(SUCCESS);
}
//c'est le vrai main. le coeur du service
void lancement_service(int ta_socket) {
int n;
int choix;
choix = 1;
char mMessage[TLIM] = "";
char reponse[TLIM] = "";
char nom[TLIM] = "";
if ((n=read(ta_socket, nom, TLIM-1))>0);
else strcpy(nom,"sombre inconnu");
liste_referentiel(ta_socket);
while (choix) {
n = lecture_s(ta_socket);
if (sscanf(get_message(),"%s",mMessage)>0) {
while ((n=lecture(mMessage))==1) {
ecriture_s(ta_socket);
}
if (n<0) {
creation_message_erreur(mMessage);
diffusion_erreur(ta_socket);
//while (lecture("erreur.txt") == 1) ecriture_s(ta_socket);
}
}
if (!strcmp(mMessage,"q") || !strcmp(mMessage,"Q")) {
choix = 0;
quitter(ta_socket);
}
}
}
void FlouDialog::flou()
{
if(rgbbase.imgexe != NULL)
{
int imgheight=rgbbase.imgexe->height();
int imgwidth=rgbbase.imgexe->width();
float taille = spinBox->value();
Flou *f = new Flou(taille,imgheight,imgwidth);
int i,j;
for(i=0; i < imgheight; i++)
{
for(j=0; j < imgwidth; j++)
{
f->calculMoy(i,j,rgbbase);
}
}
affiche_flou->refresh();
}
else
{
QMessageBox::warning(this,"Attention","Veuillez choisir une image !" );
}
quitter();
}
void guerison(long int emplacement)
{
long int max = 100;
long int min = 1;
long int pv, pv_total, alea, choix;
alea = (rand() % (max - min + 1)) + min;
pv = appel_carac_joueur(emplacement, 8);
pv_total = appel_carac_joueur(emplacement, 9);
pv += alea;
if(pv > pv_total)
pv = pv_total;
printf("Vous avez regagné %ld points de vie !\n", alea);
sauvegarde_carac(emplacement, 8, pv);
printf("\nVoulez-vous continuer à jouer (1), ou arrêter (2) ?\n");
scanf("%ld", &choix);
if(choix == 1)
game(emplacement);
else
{
quitter();
}
}
/*
bool IsTargetLocal() const
@case 2 this is initialized to local target with preferred handler
@results should return true.
*/
void TargetTester::IsTargetLocalTest2()
{
status_t result = B_OK;
BLooper *looper = new BLooper;
looper->Run();
LooperQuitter quitter(looper);
BMessenger messenger(NULL, looper, &result);
CHK(messenger.IsTargetLocal() == true);
}
/*
* Méthode qui affiche les différents éléments de contrôles du Pac-Man et de la partie
*/
void UI::dessinerBoutons() {
vue2D();
parallele();
perspective();
rejouer();
quitter();
zoomPlus();
zoomMoins();
}
/**
* @brief Serpent::move
* @param x
* @param y
*/
void Serpent::move(int x,int y){
int posx = tete->getPosx();
int posy = tete->getPosy();
int new_x=posx + x;
int new_y=posy + y;
int q_x = corps.back()->getPosx();
int q_y = corps.back()->getPosy();
if(ref_map->grille[new_x][new_y]->getEtatCourant()->isBordure()){
quitter();
}else{
mangerPomme(new_x,new_y,q_x,q_y,nbBlocs);
mangerBonus(new_x,new_y);
//-----------------------------------------
tete->setPosx(new_x);
tete->setPosy(new_y);
//La queue devient un terrain
//On recherche s'il n'y a pas de coordonnées identiques à la queue du serpent autre que ceux de la queue
bool ok = true;
for(std::size_t i=0;i<corps.size()-1;++i){
if( corps[i]->getPosx()==corps.back()->getPosx() && corps[i]->getPosy()==corps.back()->getPosy() ) {
ok=false;
}
}
//Si ce n'est pas le cas on transforme la case de la map en texture terrain
if(ok)
ref_map->grille[corps.back()->getPosx()][corps.back()->getPosy()]->getEtatCourant()->terrain();
//On sauvegarde les coordonnées de la queue si jamais le serpent a mangé une pomme
corps.pop_back();
corps.back()->setApres(NULL);
//La case de l'ancienne tete devient forcément un corps
ref_map->grille[posx][posy]->getEtatCourant()->serpentCorps();
//On avance la tete d'un cran en fonction des directions
if(x==1 && y ==0){
ref_map->grille[new_x][new_y]->getEtatCourant()->serpentTeteDroite();
}else if (x==-1 && y==0){
ref_map->grille[new_x][new_y]->getEtatCourant()->serpentTeteGauche();
}else if (x==0 && y==1){
ref_map->grille[new_x][new_y]->getEtatCourant()->serpentTeteBas();
}else if ( x==0 && y==-1){
ref_map->grille[new_x][new_y]->getEtatCourant()->serpentTeteHaut();
}
Texture_serpent * t = new Texture_serpent(tete,corps.front(),posx,posy);
std::vector<Texture_serpent *>::iterator it;
corps.front()->setAvant(t);
it = corps.begin();
it = corps.insert( it , t );
//----------------------
//----------------------
}
}
/*
BHandler *Target(BLooper **looper) const
@case 2 this is initialized to local target with preferred handler,
looper is NULL
@results should return NULL.
*/
void TargetTester::TargetTest2()
{
status_t result = B_OK;
BLooper *looper = new BLooper;
looper->Run();
LooperQuitter quitter(looper);
BMessenger messenger(NULL, looper, &result);
CHK(messenger.Target(NULL) == NULL);
}
int choix_joueur(int nb_All, int *cont, SDL_Surface *ecran, SDL_Surface *allumette, SDL_Rect posAllumette[], int nb_t, int nb_j, int info_ia[3])
{
SDL_Event event ;
int cont2 = 1, nb_enl = 40 ;
while ((cont2 || (nb_All<=nb_enl)) && *cont)
{
afficher_jeu(ecran, nb_All, allumette, posAllumette, nb_t, nb_j, info_ia) ;
SDL_WaitEvent(&event) ;
switch (event.type)
{
case SDL_QUIT : quitter(cont, ecran) ;
break ;
case SDL_KEYDOWN : switch (event.key.keysym.sym)
{
case SDLK_ESCAPE : quitter(cont, ecran) ;
break ;
case SDLK_KP1 : nb_enl = 1 ;
cont2 = 0 ;
break ;
case SDLK_KP2 : nb_enl = 2 ;
cont2 = 0 ;
break ;
case SDLK_KP3 : nb_enl = 3 ;
cont2 = 0 ;
break ;
case SDLK_1 : nb_enl = 1 ;
cont2 = 0 ;
break ;
case SDLK_2 : nb_enl = 2 ;
cont2 = 0 ;
break ;
case SDLK_3 : nb_enl = 3 ;
cont2 = 0 ;
break ;
default : break ;
}
break ;
default : break ;
}
}
return nb_enl ;
}
void attendre_utilisateur(void)
{
int i;
for(i = 0 ; i < NB_CLIENTS ; i++)
if(client[i].fd <= 0)
break;
if((client[i].fd = accept(sockfd, (struct sockaddr *) &client[i].adr, &addrlen)) == -1)
quitter("accept");
FD_SET(client[i].fd, &masterfds);
printf("Connexion à l'emplacement %d\n", i);
}
void recevoir_utilisateur(int nclient)
{
int rt;
rt = recv(client[nclient].fd, buf, TAILLE_BUFFER, 0);
if(rt < 0) // Erreur sur la réception
quitter("recv");
else if(rt == 0) // On ne reçoit rien, il s'est déconnecté
supprimer_client(nclient);
else // On a reçu, on renvoie aux autres clients
renvoyer_message(nclient);
}
/*
bool operator==(const BMessenger &other) const
bool operator!=(const BMessenger &a, const BMessenger &b)
@case 1 this (a) is initialized, other (b) is uninitialized,
and vice versa
@results should return false/true.
*/
void MessengerComparissonTester::ComparissonTest2()
{
// create looper
BLooper *looper = new BLooper;
looper->Run();
LooperQuitter quitter(looper);
// create messenger
BMessenger a(NULL, looper);
BMessenger b;
CHK(a != b);
CHK(b != a);
CHK(!(a == b));
CHK(!(b == a));
}
void sauvegarderEtQuitterNiveau(void)
{
unsigned int choixJoueur;
effacer();
titre("Sauvegarder et Quitter", VERT);
choixJoueur = demanderConfirmation("Voulez-vous vraiment sauvegarder et quitter le niveau ici ? (0/1)", PAS_SEPARATION);
if(choixJoueur == OUI)
{
sauvegarderNiveauActuel();
coloration("\nSauvegarde terminee...\n", VERT);
quitter();
}
}
bool AutoMenu::gererEvenementsSDL() {
SDL_Event evenement;
while (SDL_PollEvent(&evenement)) {
if (evenement.type == SDL_QUIT) {
quitter();
return false;
} else if (evenement.type == SDL_MOUSEBUTTONDOWN) {
int sourisX, sourisY;
bool clic = SDL_GetMouseState(&sourisX, &sourisY) & SDL_BUTTON(SDL_BUTTON_LEFT);
menu->souris(sourisX/2, sourisY/2, clic);
}
}
return true;
}
/*
bool IsTargetLocal() const
@case 3 this is initialized to local target with specific handler
@results should return true.
*/
void TargetTester::IsTargetLocalTest3()
{
// create looper and handler
status_t result = B_OK;
BLooper *looper = new BLooper;
looper->Run();
LooperQuitter quitter(looper);
BHandler *handler = new BHandler;
HandlerDeleter deleter(handler);
CHK(looper->Lock());
looper->AddHandler(handler);
looper->Unlock();
// create the messenger and do the checks
BMessenger messenger(handler, NULL, &result);
CHK(messenger.IsTargetLocal() == true);
}
void sauvegarde(void)
{
int choixJoueur;
char baseNomSauvegarde[NB_SAUVEGARDE][TAILLE_MAX];
titre("Sauvegarde", VERT);
afficherMenuSauvegarde(baseNomSauvegarde);
choixJoueur = choisirMenu(NB_SAUVEGARDE);
if(choixJoueur == REVENIR_ARRIERE)
menuPrincipal();
else if(choixJoueur == QUITTER)
quitter();
else
actionSauvegarde(baseNomSauvegarde, choixJoueur - 1);
}
/**
* @brief survivalsquare::survivalsquare
* @param parent
*/
survivalsquare::survivalsquare(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::survivalsquare)
{
ui->setupUi(this);
connect(ui->actionChat_en_ligne, SIGNAL(triggered()), this, SLOT(Chat()));
connect(ui->actionFacile, SIGNAL(triggered()), this, SLOT(Facil()));
connect(ui->actionNormal, SIGNAL(triggered()), this, SLOT(Moyen()));
connect(ui->actionDifficile, SIGNAL(triggered()), this, SLOT(Difficil()));
connect(ui->actionServeur, SIGNAL(triggered()), this, SLOT(CreateServer()));
ui->actionArret->setEnabled(false);
QObject::connect(ui->actionArret,SIGNAL(triggered()),this,SLOT(quitter()) );
regles = new Regles();
setCentralWidget(regles);
//Insérer le texte de première page.
}
void actionSauvegarde(char baseNomSauvegarde[NB_SAUVEGARDE][TAILLE_MAX],
const unsigned int indexSauvegarde)
{
if(strcmp(baseNomSauvegarde[indexSauvegarde], "Vide") == 0)
nouvelleSauvegarde(indexSauvegarde);
else
{
int choixJoueur;
unsigned int compteurErreur;
compteurErreur = 0;
separationTexte();
do
{
if(compteurErreur > 0)
printf("Veuillez entrer un nombre correct !\n");
printf("Que souhaitez-vous faire ?\n\n");
printf("\t1 - Charger\n");
printf("\t2 - Supprimer\n\n");
choixJoueur = choisirMenu(NB_ACTION_SAUVEGARDE);
++compteurErreur;
} while (choixJoueur != QUITTER &&
choixJoueur != REVENIR_ARRIERE &&
choixJoueur != CHARGER &&
choixJoueur != SUPPRIMER);
if(choixJoueur == QUITTER)
quitter();
else if(choixJoueur == REVENIR_ARRIERE)
sauvegarde();
else if(choixJoueur == CHARGER)
chargerSauvegarde(baseNomSauvegarde[indexSauvegarde]);
else
supprimerSauvegarde(baseNomSauvegarde[indexSauvegarde]);
}
}
void Inscription::confirmation(){
grbConfirm = new QGroupBox("Confirmation", this);
hboxConfirm = new QHBoxLayout(this);
grbConfirm->setLayout(hboxConfirm);
btnConfirmConfirmer = new QPushButton("Confirmer", this);
hboxConfirm->addWidget(btnConfirmConfirmer);
connect(btnConfirmConfirmer, SIGNAL(clicked()), this, SLOT(confirmer()));
btnConfirmVerifier = new QPushButton("Vérifier", this);
hboxConfirm->addWidget(btnConfirmVerifier);
connect(btnConfirmVerifier, SIGNAL(clicked()), this, SLOT(verifier()));
btnConfirmSortir = new QPushButton("Sortir", this);
hboxConfirm->addWidget(btnConfirmSortir);
connect(btnConfirmSortir, SIGNAL(clicked()), this, SLOT(quitter()));
vboxMain->addWidget(grbConfirm);
}
ResultatPartie::ResultatPartie() : QWidget()
{
layoutVertical = new QVBoxLayout();
layoutBoutons = new QHBoxLayout();
boutonQuitter = new QPushButton("Quitter");
boutonRecommencer = new QPushButton("Rejouer");
connect(boutonQuitter,SIGNAL(clicked()),this,SLOT(quitter()));
connect(boutonRecommencer,SIGNAL(clicked()),this,SLOT(recommencer()));
layoutBoutons->addWidget(boutonRecommencer);
layoutBoutons->addWidget(boutonQuitter);
layoutVertical->addLayout(layoutBoutons);
setLayout(layoutVertical);
std::cout << "Fenêtre de résultat créée\n";
}
/*
Le "main"
Affichage du menu, selection de l'option, execution de l'operation choisie
*/
int main(int argc, char * argv[])
{
if (argc > 1)
{
fprintf(stderr, "%s: usage incorrect!\n", argv[0]);
fprintf(stderr, "Aucun argument permis.\n");
return 1;
}
mkdir( rep_travail, 0777 );
mkdir( rep_client, 0777 );
int option;
do
{
option = afficherMenu();
switch(option)
{
case 1:
listerFichier();
break;
case 2:
chercherFichierStocke();
break;
case 3:
afficherFichierResultat(0);
break;
case 4:
livrerFichierCommande();
break;
case 5:
quitter();
break;
}
sleep(3); // pause
} while(option != 5);
return 0;
}
/* Sauvegarde le niveau et quitte le jeu */
void sauvegarderEtQuitterNiveau(void)
{
unsigned int choixJoueur;
effacer();
titre("Sauvegarder et Quitter", VERT);
/* On demande la confirmation du joueur */
choixJoueur = demanderConfirmation("Voulez-vous vraiment sauvegarder et quitter le niveau ici ? (0/1)", PAS_SEPARATION);
/* S'il veut bien sauvegarder et quitter le niveau */
if(choixJoueur == OUI)
{
/* On sauvegarde le niveau */
sauvegarderNiveauActuel();
/* On affiche un texte indiquant la fin de la sauvegarde */
coloration("\nSauvegarde terminee...\n", VERT);
/* On quitte */
quitter();
}
}
int serveur (void)
{
int sock_contact;
int sock_connectee;
struct sockaddr_in adresse;
socklen_t longueur;
sock_contact = cree_socket_stream(NULL, NULL, "UDP");
if (sock_contact < 0)
return -1;
listen(sock_contact, 5);
fprintf(stdout, "Mon adresse >>\n");
affiche_adresse_socket(sock_contact);
while(! quitter())
{
longueur = sizeof(struct sockaddr_in);
sock_connectee = accept(sock_contact, (struct sockadrr *)& adresse, & longueur);
if(sock_connectee < 0)
{
perror ("accpet");
return -1;
}
switch (fork())
{
case 0:
close(sock_contact);
connexion(sock_connectee);
exit(EXIT_SUCCESS);
case -1:
perror("fork");
return -1;
default:
close(sock_connectee);
}
}
return 0;
}
void Inscription::confirmer(){
if(verifierInformations()){
ecrireFichier();
quitter();
}
}
void PixEditor::addMenu()
{
//Fichier
precedent_action=new QAction(tr("&Precedent"),this);
precedent_action->setIcon(QIcon("./icones/precedent.jpg"));
precedent_action->setStatusTip(tr("Precedent"));
QObject::connect(precedent_action,SIGNAL(triggered()),&widgetcentral,SLOT(precedent()));
//
nouveau_action = new QAction(tr("&Nouveau"), this);
nouveau_action->setIcon(QIcon("./icones/window-new-3.png"));
nouveau_action->setShortcut(tr("Ctrl+N"));
nouveau_action->setStatusTip(tr("Nouvelle image"));
QObject::connect(nouveau_action, SIGNAL(triggered()), &widgetcentral, SLOT(nouveau()));
ouvrir_action = new QAction(tr("&Ouvrir"), this);
ouvrir_action->setShortcut(tr("Ctrl+O"));
ouvrir_action->setIcon(QIcon("./icones/OpenButton.png"));
ouvrir_action->setStatusTip(tr("Charger une image"));
QObject::connect(ouvrir_action, SIGNAL(triggered()), &widgetcentral, SLOT(ouvrir()));
sauver_action = new QAction(tr("&Sauvegarder"), this);
sauver_action->setShortcut(tr("Ctrl+S"));
sauver_action->setIcon(QIcon("./icones/enregistrer.png"));
sauver_action->setStatusTip(tr("Sauvegarder l'image"));
QObject::connect(sauver_action, SIGNAL(triggered()), &widgetcentral, SLOT(sauvegarder()));
sauversous_action = new QAction(tr("S&auvegarder sous..."), this);
sauversous_action->setShortcut(tr("Ctrl+Shift+S"));
sauversous_action->setIcon(QIcon("./icones/enregistrer-sous.png"));
sauversous_action->setStatusTip(tr("Sauvegarder l'image sous..."));
connect(sauversous_action, SIGNAL(triggered()), &widgetcentral, SLOT(sauvegarderSous()));
quitter_action = new QAction(tr("&Quitter"), this);
quitter_action->setStatusTip(tr("Quitter le programme"));
quitter_action->setIcon(QIcon("./icones/icone-infos.png"));
QObject::connect(quitter_action, SIGNAL(triggered()), &widgetcentral, SLOT(quitter()));
menu_fichier = new QMenu(tr("&Fichier"), this);
menu_fichier->addAction(precedent_action);
menu_fichier->addAction(nouveau_action);
menu_fichier->addAction(ouvrir_action);
menu_fichier->addAction(sauver_action);
menu_fichier->addAction(sauversous_action);
menu_fichier->addAction(quitter_action);
// Filtre
flou_action = new QAction(tr("&F&lou"), this);
flou_action->setStatusTip(tr("Appliquer un flou l'image"));
flou_action->setIcon(QIcon("./icones/flou.gif"));
QObject::connect(flou_action, SIGNAL(triggered()), &widgetcentral, SLOT(loadflou()));
fusion_action = new QAction(tr("&F&usion"), this);
fusion_action->setStatusTip(tr("Fusionner l'image avec une autre"));
QObject::connect(fusion_action, SIGNAL(triggered()), &widgetcentral, SLOT(loadfusion()));
gris_action = new QAction(tr("&Gris"),this);
gris_action->setStatusTip("Appliquer un gris l'image");
QObject::connect(gris_action,SIGNAL(triggered()),&widgetcentral,SLOT(gris()));
rehaussement_action = new QAction(tr("&Rehaussement de contraste"),this);
rehaussement_action->setStatusTip("Rehausser le contraste");
QObject::connect(rehaussement_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadrehausseur()));
detection_action = new QAction(tr("&Detecter les contours"),this);
detection_action->setStatusTip("Detection de contour");
QObject::connect(detection_action,SIGNAL(triggered()),&widgetcentral,SLOT(loaddetection()));
gradient_action = new QAction(tr("&Gradient"),this);
gradient_action->setStatusTip("Gradient");
QObject::connect(gradient_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadgradient()));
perso_action = new QAction(tr("&Personnaliser"),this);
perso_action->setStatusTip("Personnaliser le filtre");
QObject::connect(perso_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadperso()));
accent_action = new QAction(tr("&Accentuer"),this);
accent_action->setStatusTip("Accentuer l'image");
QObject::connect(accent_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadaccentuer()));
menu_outils = new QMenu(tr("&F&iltre"), this);
menu_outils->addAction(flou_action);
menu_outils->addAction(fusion_action);
menu_outils->addAction(gris_action);
menu_outils->addAction(rehaussement_action);
menu_outils->addAction(detection_action);
menu_outils->addAction(gradient_action);
menu_outils->addAction(perso_action);
menu_outils->addAction(accent_action);
//histogramme
histo_menu=new QMenu(tr("&Histogramme"),this);
histoRGB_action = new QAction(tr("&RGB"),this);
QObject::connect(histoRGB_action, SIGNAL(triggered()), &widgetcentral, SLOT(histogrammeRGB()));
histo_menu->addAction(histoRGB_action);
histoHSV_action = new QAction(tr("&HSV"),this);
QObject::connect(histoHSV_action, SIGNAL(triggered()), &widgetcentral, SLOT(histogrammeHSV()));
histo_menu->addAction(histoHSV_action);
egalise_action = new QAction(tr("&Egaliser"),this);
QObject::connect(egalise_action, SIGNAL(triggered()), &widgetcentral, SLOT(egalisation()));
histo_menu->addAction(egalise_action);
linearise_action = new QAction(tr("&Lineariser"),this);
QObject::connect(linearise_action, SIGNAL(triggered()), &widgetcentral, SLOT(linearisation()));
histo_menu->addAction(linearise_action);
negatif_action = new QAction(tr("&Negatif"),this);
QObject::connect(negatif_action, SIGNAL(triggered()), &widgetcentral, SLOT(negatif()));
histo_menu->addAction(negatif_action);
seuillage_action = new QAction(tr("&Seuillage"),this);
QObject::connect(seuillage_action, SIGNAL(triggered()), &widgetcentral, SLOT(seuillage()));
histo_menu->addAction(seuillage_action);
//color_picker
picker_action = new QAction(tr("&P&i&xelColor"),this);
picker_action->setStatusTip("Pixel valeur");
picker_action->setIcon(QIcon("./icones/icones/pixelcolor.jpg"));
QObject::connect(picker_action, SIGNAL(triggered()), widgetcentral.affichage, SLOT(pixelColor()));
color_picker = new QMenu(tr("&Picolor"),this);
color_picker->addAction(picker_action);
//Selection
menu_selection = new QMenu(tr("&Se&lection"),this);
selection_action=new QAction(tr("&selection"),this);
QObject::connect(selection_action, SIGNAL(triggered()), widgetcentral.affichage, SLOT(selection()));
menu_selection->addAction(selection_action);
//redimension
redim_action = new QAction(tr("&R&edimension"),this);
redim_action->setStatusTip("Appliquer le redimensionnement l'image");
QObject::connect(redim_action,SIGNAL(triggered()),&widgetcentral,SLOT(redimension()));
seam_action = new QAction(tr("&Seam Carving"),this);
seam_action->setStatusTip("Redimensionnement intelligent");
QObject::connect(seam_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadseam()));
menu_redimension = new QMenu (tr ("&R&e&dimension"), this);
menu_redimension->addAction(redim_action);
menu_redimension->addAction(seam_action);
barre_menu = new QMenuBar(this);
barre_menu->addMenu(menu_fichier);
barre_menu->addMenu(menu_outils);
barre_menu->addMenu(histo_menu);
barre_menu->addMenu(color_picker);
barre_menu->addMenu(menu_selection);
barre_menu->addMenu(menu_redimension);
setMenuBar(barre_menu);
}
void combat (emplacement)
{
//variables
FILE* fichier = NULL;
char path[50];
long int nombre = 0;
long int choix = 1;
char nom[35];
long int alea = 1;
long min = 1;
long max = 0;
float degat = 0;
float nbaleatoire = 0;
long int i = 0;
//caracs monstre & joueurs
long int monstre_attaque, monstre_endu, monstre_pv, monstre_exp;
long int joueur_force, joueur_intelligence, joueur_endurance, joueur_pv, joueur_pv_total;
long int joueur_classe = 0;
long int joueur_attaque = 0;
long int joueur_niv;
long int new_niveau = 1;
long int niv_actuel = 1;
fichier = fopen("monstres/liste.ars", "r+");
fscanf(fichier, "%ld", &nombre);
max = nombre;
alea = (rand() % (max - min + 1)) + min; //Alea indique le numero du monstre !
// printf("Nombre : %ld\n", alea);
sprintf(path, "monstres/monstre%ld.ars", alea);
fichier = fopen(path, "r+");
fgets(nom, 35, fichier);
printf("Il s\'agit d\'un %s", nom);
//Maintenant qu'on a le nom du monstre, on prend ses caracs
monstre_attaque = appel_carac_monstre (alea, 2); //INVOCATIOOOOOOOOOOOOOOOOOOOOOOOONNNNNNNN !!!!!!
monstre_endu = appel_carac_monstre(alea, 3); //INVOCATION 2222222222222222222222222222222222 !!!!!!!!!!!!!!
monstre_pv = appel_carac_monstre(alea, 4); //KAMAHAMEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!!!!!!
monstre_exp = appel_carac_monstre(alea, 5);
// printf("Attaque : %ld\nEndu: %ld\npv:%ld\nexp : %ld\n", monstre_attaque, monstre_endu, monstre_pv, monstre_exp);
// printf("Attaque : %ld\n", monstre_attaque);
//On prend les caracs du persos
joueur_force = appel_carac_joueur(emplacement, 5);
joueur_intelligence = appel_carac_joueur(emplacement, 6);
joueur_endurance = appel_carac_joueur(emplacement, 7);
joueur_pv = appel_carac_joueur(emplacement, 8);
joueur_pv_total = appel_carac_joueur(emplacement, 9);
joueur_niv = appel_carac_joueur(emplacement, 10);
joueur_classe = appel_carac_joueur(emplacement, 4);
// printf("Attaque : %ld\n", joueur_niv);
fclose(fichier);
if (joueur_classe == 1)
{
joueur_attaque = joueur_force ;
}
else
{
joueur_attaque = joueur_intelligence ;
}
printf("\n%s vous attaque !\n",nom);
while ((monstre_pv > 0) && (joueur_pv > 0))
{
nbaleatoire = floor(((rand() % ((joueur_attaque*5) - 1 + 1)) + 1)/50);
degat = (joueur_attaque + nbaleatoire) - monstre_endu;
if(degat < 0)
degat = 0;
printf("Vous attaquez %s et lui infligez %0.0f points de dégats\n", nom, degat);
monstre_pv = monstre_pv - degat;
nbaleatoire = floor(((rand() % ((monstre_attaque*5) - 1 + 1)) + 1) / 50);
degat = (monstre_attaque + nbaleatoire) - joueur_endurance;
if(degat < 0)
degat = 0;
printf("%s vous attaque et vous inflige %0.0f points de dégats\n", nom, degat);
joueur_pv = joueur_pv - degat;
}
if ((monstre_pv <= 0) && (joueur_pv > 0))
{
printf("\nVous avez vaincu %s !!! \n", nom);
monstre_exp *= 4;
printf("\nVous gagnez %ld points d'experience !\n\n", monstre_exp);
niv_actuel = joueur_niv; //sauvegarde des xp du joueur
// printf("niv_actuel : %ld", niv_actuel);
niv_actuel = conversion_xp(niv_actuel); //conversion des xp en niveau avant nouveaux xp
joueur_niv = joueur_niv + monstre_exp; //gain de xp du monstre
sauvegarde_carac(emplacement, 10, joueur_niv); //On sauvegarde le nombre de xp
sauvegarde_carac(emplacement, 8, joueur_pv);
//
new_niveau = conversion_xp(joueur_niv); //On genere le lvl du perso avec ses nouveaux xp
if(niv_actuel < new_niveau)
lvl_up(emplacement, new_niveau);
}
else if((joueur_pv <= 0) && (monstre_pv > 0))
{
printf("\nVous avez été vaincu par %s ...\n\n",nom);
mort(emplacement);
}
else
{
printf("\n Dans une lutte sanglante, vous et %s vous êtes entretués, . \n\n", nom);
mort(emplacement);
}
printf("\nVoulez-vous continuer à jouer (1), ou arrêter (2) ?\n");
scanf("%ld", &choix);
if(choix == 1)
game(emplacement);
else
{
quitter();
}
}
void
waiter(int num_philo)
{
int i, j, code, philo_pid, philo_id, in, do_packing, end = 0;
int *forks, *philos_pid; //the waiter knows the status of each fork. Will contain FORK_TAKEN or FORK_FREE
message_t temp, recv, *buffer; //the waiter will need to buffer the requests that can't be satisfied when he gets the message. At most num_philo-1 messages can be buffered at the same time. One more and it's a deadlock.
int forks_taken = 0; //counts the number of forks taken
//let's allocate the arrays
forks = allouer(num_philo * sizeof(int));
if (forks == NULL)
{
ecrire("Allouer forks failed\n");
quitter(FAILURE);
}
philos_pid = allouer(num_philo * sizeof(int));
if (philos_pid == NULL)
{
ecrire("Allouer philos_pid failed\n");
quitter(FAILURE);
}
buffer = allouer((num_philo - 1) * sizeof(message_t));
if (buffer == NULL)
{
ecrire("Allouer buffer failed\n");
quitter(FAILURE);
}
//we mark the forks as being free
for (i = 0; i < num_philo; i++)
{
forks[i] = FORK_FREE;
}
//first, each philosopher sends its philo_id (NOT its pid) to the waiter
for (i = 0; i < num_philo; i++)
{
recevoir_premier(&recv);
philo_id = message_get_int_value(recv);
philo_pid = message_get_from(recv);
liberer_message(recv);
philos_pid[philo_id] = philo_pid;
}
ecrire("Waiter: I have everything I need, let's go !\n");
//starts the dinner
for (i = 0; i < num_philo; i++)
envoyer_entier(philos_pid[i], GO_FOR_IT, 10);
in = 0;
while (!end)
{
//the waiter loops until it receives the order to stop
recevoir_premier(&recv);
code = message_get_int_value(recv);
philo_pid = message_get_from(recv);
philo_id = get_philo_id(philo_pid, philos_pid, num_philo);
switch (code)
{
case WANT_LEFT_FORK:
if (!left_fork(philo_id, philo_pid, forks, &forks_taken, num_philo))
{
//fork taken or only one fork left. In the last case, it can only be taken by a philosopher who already has a fork. Since the left forks are requested first, this is not the case here. We put the request in the buffer
buffer[in] = recv;
in++;
}
else
liberer_message(recv);
break;
case WANT_RIGHT_FORK:
if (!right_fork
((philo_id + 1) % num_philo, philo_pid, forks, &forks_taken))
{
buffer[in] = recv;
in++;
}
else
liberer_message(recv);
break;
case PUT_FORKS_BACK:
liberer_message(recv);
forks[philo_id] = FORK_FREE;
forks[(philo_id + 1) % num_philo] = FORK_FREE;
forks_taken -= 2;
//look if some of the buffered requests can be satisfied now
for (i = 0; i < in; i++)
{
do_packing = 0;
temp = buffer[i];
code = message_get_int_value(temp);
philo_pid = message_get_from(temp);
philo_id = get_philo_id(philo_pid, philos_pid, num_philo);
if (code == WANT_LEFT_FORK)
{
if (left_fork(philo_id, philo_pid, forks, &forks_taken, num_philo))
//this request has been satisfied
do_packing = 1;
}
else
if (right_fork
((philo_id + 1) % num_philo, philo_pid, forks, &forks_taken))
do_packing = 1;
if (do_packing)
{
liberer_message(temp);
//the request number i has been satisfied, let's pack the array
for (j = i + 1; j < in; j++)
buffer[j - 1] = buffer[j];
in--;
i--;
}
}
break;
case END_OF_DINNER:
end = 1;
liberer_message(recv);
break;
}
}
}
/* An average philosopher: thinking, eating, thinking, eating and so on. What a livelocked mind ! */
void
philosopher(int waiter_pid, int philo_id, int num_cycles)
{
int m_w = 4000 - philo_id, m_z = philo_id + 2000; //initializers for random numbers generation
int count = 0; //each philosopher does num_cycles cycles before exiting
int my_pid = obtenir_pid();
char s[MAX_STRING], buf[4];
message_t mess;
itoa(my_pid, buf, 4);
//each philosopher gives its philo_id to the waiter. Those id represent the id of the forks
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " is sending its id to the waiter\n", MAX_STRING - strlen(s));
ecrire(s);
envoyer_entier(waiter_pid, philo_id, 10);
//wait until the waiter says the show can begin
if (recevoir_de_delai(waiter_pid, &mess, 1000) != SUCCESS)
{
ecrire("The waiter took too long to answer. Dinner canceled\n");
quitter(FAILURE);
}
liberer_message(mess);
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " starts the dinner\n", MAX_STRING - strlen(s));
ecrire(s);
while (count < num_cycles)
{
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " is thinking\n", MAX_STRING - strlen(s));
ecrire(s);
retarder(my_pid, random(&m_w, &m_z) % 5000);
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " is trying to get its left fork\n", MAX_STRING - strlen(s));
ecrire(s);
if (envoyer_entier(waiter_pid, WANT_LEFT_FORK, 10) != SUCCESS)
{
ecrire("Envoyer_entier failed\n");
quitter(FAILURE);
}
recevoir_de(waiter_pid, &mess);
liberer_message(mess); //the content of a message from the waiter is always GO_FOR_IT
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " is trying to get its right fork\n", MAX_STRING - strlen(s));
ecrire(s);
if (envoyer_entier(waiter_pid, WANT_RIGHT_FORK, 10) != SUCCESS)
{
ecrire("Envoyer_entier failed\n");
quitter(FAILURE);
}
recevoir_de(waiter_pid, &mess);
liberer_message(mess);
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " is eating\n", MAX_STRING - strlen(s));
ecrire(s);
retarder(my_pid, random(&m_w, &m_z) % 5000);
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, " puts its forks back\n", MAX_STRING - strlen(s));
ecrire(s);
envoyer_entier(waiter_pid, PUT_FORKS_BACK, 10);
count++;
}
strncpy(s, "Process ", MAX_STRING);
strncat(s, buf, MAX_STRING - strlen(s));
strncat(s, ", thanks for the food !\n", MAX_STRING - strlen(s));
ecrire(s);
}
void piege(emplacement)
{
FILE* fichier = NULL;
long int nbaleatoire = 0;
long int nbaleatoire2 = 0;
long int i,j, choix = 0;
long int evite, degat = 0;
char nom[50];
char path[50];
long int taille_max = 50;
long int pv = 1;
long int nombre = 0;
fichier = fopen("pieges/liste.ars", "r+");
fscanf(fichier, "%ld", &nombre);
fclose(fichier);
nbaleatoire = (rand() % (nombre - 1 + 1)) +1 ;
sprintf(path, "pieges/piege%ld.ars", nbaleatoire);
fichier = fopen(path, "r+");
fscanf(fichier, "%s\n%ld, %ld", nom, &evite, °at);
printf("Il s\'agit d\'un piège mortel nommé %s\n", nom);
fclose(fichier);
nbaleatoire2 = (rand() % (100 - 1 +1)) +1;
if (nbaleatoire2 <= evite)
{
printf("\nVous avez évité le piège\n");
}
else
{
printf("\nVous n'avez pas réussi à éviter le piège et vous subissez %ld dégats.\n", degat);
pv = appel_carac_joueur(emplacement,8);
pv = pv - degat;
if (pv <= 0)
{
mort(emplacement);
pv = 0;
}
sauvegarde_carac(emplacement,8,pv);
}
printf("\nVoulez-vous continuer à jouer (1), ou arrêter (2) ?\n");
scanf("%ld", &choix);
if(choix == 1)
game(emplacement);
else
{
quitter();
}
}
