float *compute_seq(unsigned iterations){
if(!is_end){
return DYNAMIC_COLORING;
}
is_end = 0;
for (unsigned i = 0; i < iterations; i++){
for (int x = 1; x < DIM-1; x=x+2){
for (int y = 1; y < DIM-1; y++){
if(ocean[y][x][table] >= MAX_HEIGHT)
{
traitement(x,y);
}
}
}
for (int x = 2; x < DIM-1; x=x+2){
for (int y = DIM-2; y > 0; y--){
if(ocean[y][x][table] >= MAX_HEIGHT)
{
traitement(x,y);
}
}
}
#pragma omp barrier
table = 1 - table;
if(is_end){
copy(table);
}
}
return DYNAMIC_COLORING;
}
char *get_next_line(const int fd)
{
static t_get *g;
static int k = 0;
if (k == 0)
{
CHECK_RETURN(g = malloc(sizeof(t_get)), NULL, NULL);
g->j = 0;
g->len = 0;
}
k = 1;
g->count = 0;
g->i = 0;
if (++(g->j) >= g->len)
{
CHECK_RETURN(g->len = read(fd, g->buff, READ), 0, NULL);
g->j = 0;
}
if (g->len <= 0 || READ <= 0)
return (NULL);
CHECK_RETURN(g->str = malloc(sizeof(char) * READ + 1), NULL, NULL);
g->str[0] = '\0';
g->buff[g->len] = '\0';
CHECK_RETURN(traitement(g, fd), NULL, NULL);
tronque(g->buff, 1, g->len - (g->i - 2));
return (g->str);
}
/**
Représente un tour de boucle, ici ce trouve
toutes la gestion du jeu
@return true si pas de collision
*/
bool Game::gameLoop(sf::Clock & clock)
{
affichage();
sf::Event event;
recuperationEntree(event);
//valeur qui sera retrournée a la fin de la GameLoop
bool etat = m_map.collisionBloc(m_vaisseauJoueur, m_tirs, m_distanceParcouru);
actualisationInfoJoueur();
//actualisation du temps
m_tempsPasse = clock.getElapsedTime().asMicroseconds() / 20000.;
clock.restart().asMicroseconds();
m_tempsPasse /= m_coefRalentissement;
//calcul de la trajectoire puis la vitesse sera calculé a part
traitement(event, m_tempsPasse);
gestionScrolling(m_tempsPasse);
//deplacement des tirs
gererTirs(m_tempsPasse);
rechargeDesVaisseaux(m_tempsPasse);
actualiserAnimation(m_tempsPasse);
//comp 1
float tempsMaxComp = m_vaisseauJoueur.getCompetence(2)->getTempsDeRechargeMax();
float tempsActuelComp = m_vaisseauJoueur.getCompetence(2)->getTempsDeRechargeActuel();
float rapportComp1 = 1;
if (tempsActuelComp != tempsMaxComp)
rapportComp1 = ((tempsMaxComp - tempsActuelComp) / tempsMaxComp);
//comp 2
tempsMaxComp = m_vaisseauJoueur.getCompetence(3)->getTempsDeRechargeMax();
tempsActuelComp = m_vaisseauJoueur.getCompetence(3)->getTempsDeRechargeActuel();
float rapportComp2 = tempsActuelComp / tempsMaxComp;
//comp 3
tempsMaxComp = m_vaisseauJoueur.getCompetence(1)->getTempsDeRechargeMax();
tempsActuelComp = m_vaisseauJoueur.getCompetence(1)->getTempsDeRechargeActuel();
float rapportComp3 = 1;
if (m_vaisseauJoueur.getCompetence(1)->estActive())
{
rapportComp3 = tempsActuelComp / tempsMaxComp;
}
else if (tempsActuelComp != tempsMaxComp)
{
rapportComp3 = (tempsMaxComp - tempsActuelComp) / tempsMaxComp;
}
tableauDeBord.actualiserAnimationAvecCompetence(rapportComp1, rapportComp2, rapportComp3, m_vaisseauJoueur.getCompetence(1)->estActive());
return etat;
}
void func() {
// array we want to permute
int array[SIZE];
int alreadyPlaces[SIZED * SIZED]; // array n * n to see if a value as already been in a specific place. aka: alreadyPlaces[index + SIZE * position] = 1 if the value at the index index as already been permuted to the position position
for(i = 0 ; i<SIZED * SIZED ; ++i) {
alreadyPlaces[i] = 0;
}
// temporary array for operations
int temp[SIZE];
int i = 0;
int nbPermutation = factoriel(SIZE);
// For an array of a size SIZE there is SIZE! permutation
for(i=0 ; i<nbPermutation ; ++i) {
// We want to edit the temporary array
for(int j = 0 ; j< SIZE ; ++j) {
// what index do we take ?
int index;
for(int k = 0 ; k < SIZE ; ++k) {
// We choose an index that hasn't already been placed at the specific position
if(alreadyPlaces[k + j * SIZE] == 0) {
// We verify that the value isn't already in temp
int alreadyIntTemp = 0;
for(int m = 0 ; m < j ; ++m) {
if(temp[m] == array[k])
alreadyInTemp = 1;
}
if(alreadyInTemp == 0) {
index = k;
break;
}
}
}
temp[j] = array[index];
alreadyPlaces[index + j * SIZE] = 1;
}
// On fait le traitement avec temp
traitement(temp);
}
}
int main(int argc, char **argv) {
struct myshm* p_shm;
struct message* request;
signal(SIGINT, handler);
if (argc != 2) {
printf("error syntaxe ex: %s /server_shm:0\n", argv[0]);
exit(EXIT_FAILURE);
}
shmsrv_nom = argv[1];
nb_users = 0;
if ((shm_id = shm_open(shmsrv_nom, O_CREAT | O_EXCL | O_RDWR, 0600))
== -1) {
perror("shm_open");
exit(-1);
}
if (ftruncate(shm_id, LENGTH_SHM) == -1) {
perror("ftruncate");
exit(-1);
}
if ((p_shm = (struct myshm*) mmap(NULL, LENGTH_SHM, PROT_READ | PROT_WRITE,
MAP_SHARED, shm_id, 0)) == MAP_FAILED) {
perror("mmap");
exit(-1);
}
printf(" shm_id %d \n", shm_id);
sem_init(&p_shm->sem, 1, 1);
sem_init(&p_shm->sem_message, 1, 0);
p_shm->nb = 0;
printf("serveur %s demarré \n", argv[1]);
while (1) {
request = NULL;
sem_wait(&p_shm->sem_message);
sem_wait(&p_shm->sem);
if (p_shm->nb) {
p_shm->nb--;
request = &(p_shm->messages[p_shm->nb]);
}
sem_post(&p_shm->sem);
if (request) {
traitement(request);
}
}
return EXIT_SUCCESS;
}
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);
}
//gerer les fuites
int main()
{
t_home fourmilliere;
//t_lst_chemins *paths;
if (acquisition(&fourmilliere) == -1)
{
printf("erreur lors de l'aquisition");
return (0);
}
if (traitement(&fourmilliere) == -1)
{
printf("erreur lors du traitement");
return (0);
}
/* if (impression(paths) == -1)
{
printf("erreur lors de l'impression");
return (0);
}*/
return(0);
}
void *run_com(void *arg) {
char response[512];
char **tab = NULL;
int size;
memset(response, 0, 1024);
fprintf(stderr, "thread com demarre :\n");
/*--------------Blocquer les signaux------------------*/
sigset_t mask;
sigfillset(&mask);
pthread_sigmask(SIG_SETMASK, &mask, NULL);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
while (TRUE) {
read_response(sc, response);
fprintf(stderr, "com: recu reponse len %zu : %s\n", strlen(response),
response);
if (0 == strlen(response)) {
fprintf(stderr, "ERROR : Connection Socket");
erreur("ERROR : Connection Socket", TRUE);
break;
}
tab = string_to_arraystring(response, &size, '/');
traitement(tab, size);
/*free resources*/
free_table(tab, size);
memset(response, 0, sizeof(response));
}
pthread_cancel(thread_chat); //TODO
return NULL;
}
int main(){
init();
msg msgR;
fd_set fd;
struct timeval timeout;
timeout.tv_sec=3;
timeout.tv_usec=0;
int s;
printf("\nAttendre...\n");
while(1) {
FD_ZERO(&fd);
FD_SET(sock,&fd);
s = select(sock+1, &fd, NULL, NULL, &timeout);
if (s>0) {
msgR.type=-1;strcpy(msgR.data,"");
recvfrom(sock,&msgR,sizeof(msgR),0,(struct sockaddr *)&recu,&len);
printf("Recu 1 msg ");
traitement(msgR);
printf("\nAttendre...\n");}
else {}
}
return EXIT_SUCCESS;
}
