View Full Version : [C] chiudere o no le pipes?
australopiteci
14-02-2007, 16:23
salve ho problema con le pipes
Dovrei fare un qualcosa del genere:
processo1 ---[pipe1] - - -> processo2 --- -[pipe2] - - - - ->processo1
in pratica una comunicazione bidirezionale tra questi processi
io ho fatto una cosa del genere:
dal main ho forkato 2 processi: processo1 e processo2
e poi:
close(pipeA[1]);
close(pipeB[0])
processo1(pipeA[0],pipeB[1]);
close(pipeA[0]);
close(pipeB[1])
processo2(pipeB[0],pipeA[1]);
processo1(int pipein,int pipeout)
{
read(pipein,blabla,blabla) //da pipeA
write(pipeout,blabla,blabla) //su pipeB)
}
processo2(int p_in,int p_out)
{
read(p_in,blabla,blabla) //da pipeB
write(p_out,blabla,blabla) //su pipeA
}
processo2(int p_in,int p_out)
{
read(da pipeA);
}
in questo modo praticamente si blocca tutto... come mai????
ilsensine
14-02-2007, 16:29
Non capisco che c'entra la domanda col titolo del thread :D
Comunque, la read blocca finché non ci sono dati sul pipe da leggere. Se entrambi i processi fanno una read come prima operazione, rimarranno entrambi bloccati e non ci sarà nessuna write che sbloccherà le read. Se ho capito bene cosa stai combinando.
australopiteci
14-02-2007, 17:11
ciao ilsensine :)
beh, in pratica stavo pensando se si potesse usare una sola pipes e non mettere i close.. ma poi ci ho ripensato.. cosi proprio non fa perchè non possono scrivere contemporaneamente..
comunque non ci può essere il dead state di cui tu parli perchè
nel processo b in pratica la read l ho commentata ma si blocca lo stesso..
spero che ci sia un modo per risolvere il problema e per far comunicare i processi bidirezionalmente :mbe:
Bahamut Zero
14-02-2007, 22:19
spero che ci sia un modo per risolvere il problema e per far comunicare i processi bidirezionalmente :mbe:
La PIPE se mi ricordo bene è unidirezionale e funziona solo tra processi imparentati.....altrimenti devi usare una FIFO o passi direttamente alle IPC......Memoria condivisa e Code di Messaggi
australopiteci
15-02-2007, 01:14
già sono monodirezionali.. so che le fifo e l'IPC di system V sono bidirezionali ma vorrei proprio usare le pipes :muro:
ilsensine
15-02-2007, 13:05
beh, in pratica stavo pensando se si potesse usare una sola pipes e non mettere i close..
Dopo la fork, alcuni fd sono ridondanti e puoi chiuderli.
comunque non ci può essere il dead state di cui tu parli perchè
nel processo b in pratica la read l ho commentata ma si blocca lo stesso..
Puoi postare un pò di codice completo, compilabile e testabile?
australopiteci
15-02-2007, 23:19
questo è il codice di quel che sto facendo:
// makefile
//guardieladri: guardieladri.c
// gcc -o guardieladri guardieladri.c -lncurses
//clean:
// rm guardieladri
#include <stdio.h>
#include <curses.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#define PASSO 10 /* entita dello spostamento del nemico*/
#define SU 65 /* Freccia su */
#define GIU 66 /* Freccia giu */
#define SINISTRA 68 /* Freccia sinsitra */
#define DESTRA 67 /* Freccia destra */
#define SPAZIO 32 /* Tasto Spazio */
#define MAXX 150 /* Numero di colonne dello schermo */
#define MAXY 50 /* Numero di righe dello schermo */
#define VITA_INIZIALE 5
#define NEMICI_PER_RIGA 5
#define MAXNEMICI 15
#define DISTANZANEMICI_X 10
#define DISTANZANEMICI_Y 4
#define POSIZIONE_INIZIALE_NEMICI_X 5
#define POSIZIONE_INIZIALE_NEMICI_Y 5
#define DIR_DESTRA 1
#define DIR_SINISTRA 2
#define DIR_GIU 3
#define DIR_SU 4
#define DIR_SU_DES 5
#define DIR_SU_SIN 6
#define SPOSTAMENTO_NEMICI 3
#define SPOSTAMENTO_MUNIZIONE_NAVE 1
#define SPOSTAMENTO_MUNIZIONE_NEMICI 2
#define SPOSTAMENTO_NAVE 1
#define NEMICO 1
#define NAVE 2
#define MUNIZIONE_NAVE 3
#define MUNIZIONE_NEMICI 4
#define NIENTE 5
#define POSIZIONE_NEMICI 6
#define FINE_LIVELLO 7
#define GAME_OVER 8
#define RESTART 9
#define ESCI 10
#define COLLISIONE_BOMBANAVE_NEMICI 11
#define MISSILE_SEMPLICE 1
#define MISSILE_MEDIO 2
#define MISSILE_POTENTE 3
#define MISSILE_VELOCE 4
#define MISSILE_DOPPIO 5
#define MISSILE_TRIPLO 6
#define MAX_MUNIZIONI_NAVE 60
#define PROBABILITA_BOMBA 6
#define VELOCITA_MUNIZIONI_NEMICI 70
#define VELOCITA_MUNIZIONI_NAVE 10
#define VELOCITA_NEMICI 3
#define INTERVALLO_NEMICI 650000
#define INTERVALLO_TEMPO 40000
#define INTERVALLO_MUNIZIONI 7000
#define INTERVALLO_MUNIZIONI_NEMICI 4
#define PAUSA_INTER_LIVELLO 100000
struct pos
{
char c; /* carattere visualizzato */
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*nemico numero n*/
int d; /*direzione*/
int vita; /*vita*/
};
struct muni
{
char c;
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*munizione numero n*/
};
void nemici(int pipz_in,int pipeout,int p_out);
void nave(int pipeout,int p_out);
void controllo (int pipein, int pg_out,int pipz_out);
void munizioni_nave(int p_in,int pk_out);
void controllo_tempo(int pg_in);
void controllo_munizioni( int pk_in, int pipeout);
int main()
{
int filedes[2];
int pipe_munizioni[2];
int pipe_z[2];
int pipe_g[2];
int pipe_k[2];
int pipe_l[2];
int pid_nemici;
int pid_nave;
int pid_boh;
int pid_munizioni;
int pid_dany;
int stato_gioco;
initscr(); /* inizializzazione dello schermo */
start_color();
noecho(); /* i caratteri corrispondenti ai tasti premuti non saranno
* visualizzati sullo schermo del terminale */
curs_set(0); /* nasconde il cursore */
if(pipe(filedes) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_munizioni) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_z) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_g) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_k) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_l) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
/*processo padre p1 crea due processi figli p1_1 e p1_2*/
switch(pid_nemici = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:/* processo figlio di p1, p1_1 : crea il processo per i nemici*/
close(filedes[0]);
close(pipe_z[1]);
close(pipe_munizioni[0]);
nemici(pipe_z[0], filedes[1],pipe_munizioni[1]);
default:/*processo padre p1*/
switch(pid_nave = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_2 che si occupa della funzione nave*/
close(filedes[0]);
close(pipe_k[1]);
controllo_munizioni(pipe_k[0],filedes[1]);
default:
switch(pid_dany = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
/* il padre p lancia la funzione di controllo per la nave*/
close(filedes[1]);
close(pipe_g[0]);
close(pipe_z[0]);
controllo(filedes[0],pipe_g[1],pipe_z[1]);
default:switch(pid_boh = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_1_1: crea la funzione per i nemici*/
close(filedes[0]);
close(pipe_munizioni[0]);
nave(filedes[1],pipe_munizioni[1]);
default:/* processo ora padre p1_1: crea la funzione per controllare i nemici*/
switch(pid_munizioni = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
close(pipe_munizioni[1]);
close(pipe_k[0]);
munizioni_nave(pipe_munizioni[0],pipe_k[1]);
default:/*forse provare a commentare per far funzionare*/
switch(pid_munizioni = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
close(pipe_g[1]);
controllo_tempo(pipe_g[0]);
default:/*forse provare a commentare per far funzionare*/
while(1) {};
}
}
}
}
}
}
// siamo usciti dal controllo e si terminano i 2 processi figli
// ripristina il normale modo oparativo dello schermo
kill(pid_nave,1);
kill(pid_nemici,1);
kill(pid_boh,1);
kill(pid_munizioni,1);
kill(pid_dany,1);
endwin();
return 0;
}
void controllo (int pipein, int pg_out,int pipz_out)
{
struct pos munizioni_nave[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],pos_nave,nemici[MAXNEMICI],valore_letto,temp;
int z,h;
do{
read(pipein,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == MUNIZIONE_NAVE) munizioni_nave[valore_letto.n] = valore_letto;
else if ( valore_letto.tipo == MUNIZIONE_NEMICI) munizioni_nemici[valore_letto.n] = valore_letto;
else if ( valore_letto.tipo == NEMICO) nemici[valore_letto.n] = valore_letto;
else write(pg_out,&valore_letto,sizeof(valore_letto));
for(h=0;h<MAXNEMICI;h++)
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
if( (munizioni_nave[z].x == nemici[h].x) && (munizioni_nave[z].y == nemici[h].y) )
{
temp.tipo = COLLISIONE_BOMBANAVE_NEMICI;
temp.vita = 1; //quanto toglie di vita al nemico
temp.n = nemici[h].n; //quale nemico ha colpito
write(pipz_out,&valore_letto,sizeof(valore_letto));
}
write(pg_out,&valore_letto,sizeof(valore_letto));
}while(1);
}
/*
processo 'figlio - nave'. Legge la tastiera e calcola la nuova posizione, in base
ai tasti letti. Comunica questa nuova posizione al 'padre'.
*/
void nave (int pipeout,int p_out)
{
struct pos pos_nave, pos_munizione,pos_niente;
char c;
int contatore;
int livello;
int arma;
bool continuare;
bool in_esecuzione;
in_esecuzione = true;
while (in_esecuzione)
{
continuare = true;
livello = 1;
arma = MISSILE_SEMPLICE;
arma = MISSILE_DOPPIO;
//contatore = 0;
timeout(1);
pos_nave.c = '#';
pos_nave.x = MAXX/2-2;
pos_nave.y = MAXY-10;
pos_nave.tipo = NAVE;
pos_nave.vita = VITA_INIZIALE;
pos_niente.x = -5;
pos_niente.y = -5;
pos_niente.c = ' ';
pos_niente.n = livello;
pos_niente.tipo = NIENTE;
write(pipeout,&pos_nave,sizeof(pos_nave));
do
{
usleep(50);
pos_niente.tipo = NIENTE;
pos_niente.n = livello;
/*e gli altri casi? il default ad es??*/
switch(c = getch())
{
case SINISTRA:
if(pos_nave.x > 0)
pos_nave.x -= SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
case DESTRA:
if(pos_nave.x < MAXX-1)
pos_nave.x += SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
case SPAZIO:
switch(arma)
{
case MISSILE_SEMPLICE:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'o';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_MEDIO:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '^';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_POTENTE:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'O';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_VELOCE:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '|';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_DOPPIO:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x -1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'S';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 3;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'S';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_TRIPLO:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '0';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
write(p_out,&pos_munizione,sizeof(struct pos));
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x -1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '0';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU_SIN;
write(p_out,&pos_munizione,sizeof(struct pos));
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 3;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '0';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU_DES;
write(p_out,&pos_munizione,sizeof(struct pos));
break;
}
break;
case 88:
pos_niente.n = livello = livello + 1;
pos_niente.tipo = FINE_LIVELLO;
//write(pipz_out,&pos_niente,sizeof(pos_niente));
write(p_out,&pos_niente,sizeof(pos_niente));
write(pipeout,&pos_niente,sizeof(pos_niente));
break;
case 66 :
{//da cancellare.. cmq.. se ti hanno ucciso
pos_niente.tipo = GAME_OVER;
livello = 0;
}
break;
}
write(p_out,&pos_nave,sizeof(struct pos));
if(pos_niente.tipo == FINE_LIVELLO)
{
usleep(PAUSA_INTER_LIVELLO);
write(pipeout,&pos_nave,sizeof(pos_nave)); /*altrimenti la nave all inizio del prossimo livello non viene visualizzata*/
pos_nave.c = '#';
pos_nave.x = MAXX/2-2;
pos_nave.y = MAXY-10;
}
if(pos_nave.vita <= 0) {
pos_niente.tipo = GAME_OVER;
livello = 0;
}
write(p_out,&pos_niente,sizeof(pos_niente)); /*contatore -= 1; if(contatore < 0) contatore= 0;*/
//write(pipz_out,&pos_niente,sizeof(pos_niente));
write(pipeout,&pos_niente,sizeof(pos_niente));
write(pipeout,&pos_nave,sizeof(pos_nave));
if( livello == 0 )
{
while(1)
{
pos_niente.tipo = GAME_OVER;
write(pipeout,&pos_niente,sizeof(pos_niente));
c=getch();
if(c == 's' || c == 'S')
{
pos_niente.tipo = FINE_LIVELLO;
pos_niente.d = 1;
write(pipeout,&pos_niente,sizeof(pos_niente));
pos_niente.tipo = GAME_OVER;
write(p_out,&pos_niente,sizeof(pos_niente));
//write(pipz_out,&pos_niente,sizeof(pos_niente));
continuare = false;
break;
}
if(c == 'n' || c == 'N')
{
continuare = false;
in_esecuzione = false;
break;
}
}
}
}while(continuare);
}
}
void nemici (int pipz_in, int pipeout, int p_out)
{
struct pos pos_nemico[MAXNEMICI],posizione_munizione[MAXNEMICI],valore_letto;
int z, pos_iniz_x,pos_iniz_y,temp,pausa, livello;
//bool avanza = false;
livello = 1;
//temp = -1;
while(1)
{
bool avanza = false;
temp = -1;
pausa = 0;
pos_iniz_x = POSIZIONE_INIZIALE_NEMICI_X;
pos_iniz_y = POSIZIONE_INIZIALE_NEMICI_Y;
//read(pipz_in,&valore_letto,sizeof(valore_letto));
//if( valore_letto.tipo == FINE_LIVELLO) break;
//read(pipz_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
/*
if( valore_letto.tipo == GAME_OVER )
{
do {
read(pipz_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == RESTART)
{
livello = 1;
break;
}
}while(1);
}
*/
for(z=0;z<MAXNEMICI;z++)
{
temp += 1;
pos_iniz_x = POSIZIONE_INIZIALE_NEMICI_X + (DISTANZANEMICI_X * (z % NEMICI_PER_RIGA) );
//pos_iniz_y = POSIZIONE_INIZIALE_NEMICI_Y;
if(temp == NEMICI_PER_RIGA)
{
pos_iniz_y += DISTANZANEMICI_Y;
//pos_iniz_x
temp = 0;
}
pos_nemico[z].c = '@';
pos_nemico[z].x = pos_iniz_x;
pos_nemico[z].y = pos_iniz_y;
pos_nemico[z].n = z;
pos_nemico[z].d = DIR_DESTRA;
pos_nemico[z].vita = livello;
pos_nemico[z].tipo = NEMICO;
posizione_munizione[z].c = 'v';
posizione_munizione[z].x = pos_iniz_x;
posizione_munizione[z].y = pos_iniz_y;
posizione_munizione[z].n = z;
posizione_munizione[z].d = DIR_GIU;
posizione_munizione[z].vita = livello;
posizione_munizione[z].tipo = POSIZIONE_NEMICI;
write(pipeout,&pos_nemico[z],sizeof(struct pos));
}
while (1)
{
//read(pipz_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO && valore_letto.n != livello) {livello = valore_letto.n;break;}
if( valore_letto.tipo == GAME_OVER) {livello = 1; break;}
//if( valore_letto.tipo == NIENTE ) pausa+=1;
//pausa+=1;
usleep(INTERVALLO_NEMICI);
//if(pausa >= VELOCITA_NEMICI )
{
for(z=0;z<MAXNEMICI;z++)
{
//if( (pos_nemico[z].x > 0) && (pos_nemico[z].d == DIR_DESTRA) && (pos_nemico[z].vita > 0) )
if( (pos_nemico[z].d == DIR_DESTRA) && (pos_nemico[z].vita > 0) )
{
pos_nemico[z].x += SPOSTAMENTO_NEMICI;
posizione_munizione[z].x += SPOSTAMENTO_NEMICI;
if(pos_nemico[z].x > (MAXX - 4) ) avanza = true;
}
//else if( (pos_nemico[z].x > 0) && (pos_nemico[z].d == DIR_SINISTRA) && (pos_nemico[z].vita > 0) )
else if( (pos_nemico[z].d == DIR_SINISTRA) && (pos_nemico[z].vita > 0) )
{
pos_nemico[z].x -= SPOSTAMENTO_NEMICI;
posizione_munizione[z].x -= SPOSTAMENTO_NEMICI;
if(pos_nemico[z].x < 4 ) avanza = true;
}
//if (pos_nemico[z].vita > 0) write(pipz_out,&pos_nemico[z],sizeof(pos_nemico[z]));
}
if(avanza == true )
{
for(z=0;z<MAXNEMICI;z++)
if(pos_nemico[z].vita > 0)
{
pos_nemico[z].y += SPOSTAMENTO_NEMICI; /*spostamento verticale dei nemici*/
posizione_munizione[z].y += SPOSTAMENTO_NEMICI;
}
/*inverti direzione se raggiungi la fine dello schermo*/
for(z=0;z<MAXNEMICI;z++)
if(pos_nemico[z].vita > 0)
if (pos_nemico[z].d == DIR_DESTRA) pos_nemico[z].d = DIR_SINISTRA;
else pos_nemico[z].d = DIR_DESTRA;
}
avanza = false;
write(pipeout,&pos_nemico,sizeof(pos_nemico));
for(z=0;z<MAXNEMICI;z++) write(p_out,&posizione_munizione[z],sizeof(struct pos));
pausa = 0;
}
}
/*azzera gli array*/
for(z=0;z<MAXNEMICI;z++)
{
pos_nemico[z].c = ' ';
pos_nemico[z].x = -1;
pos_nemico[z].y = -1;
pos_nemico[z].n = z;
pos_nemico[z].d = DIR_DESTRA;
pos_nemico[z].vita = 0;
pos_nemico[z].tipo = NEMICO;
posizione_munizione[z].c = ' ';
posizione_munizione[z].x = -1;
posizione_munizione[z].y = -1;
posizione_munizione[z].n = z;
posizione_munizione[z].d = DIR_GIU;
posizione_munizione[z].vita = 0;
posizione_munizione[z].tipo = POSIZIONE_NEMICI;
write(pipeout,&pos_nemico[z],sizeof(struct pos));
}
//usleep(PAUSA_INTER_LIVELLO);
}
}
void munizioni_nave(int p_in,int pk_out)
{
struct pos munizioni_nave[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],ultima_posizione_nemico[MAX_MUNIZIONI_NAVE],valore_letto,niente;
int z;
int munizione_corrente,munizione_nemico_corrente, frequenza_munizioni,velocita_munizioni_nave,velocita_munizioni_nemici, nemico_corrente;
munizione_corrente = munizione_nemico_corrente = frequenza_munizioni = velocita_munizioni_nemici = nemico_corrente = 0;
velocita_munizioni_nave = MISSILE_SEMPLICE;
while (1)
{
niente.c = ' ';
niente.x = -1;
niente.y = -1;
niente.n = 0;
niente.tipo = NIENTE;
niente.vita = 0;
niente.d = 0;
//questi due cicli servono??
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nave[z].c = ' ';
munizioni_nave[z].x = -1;
munizioni_nave[z].y = -1;
munizioni_nave[z].n = z;
munizioni_nave[z].d = DIR_SU;
munizioni_nave[z].vita = 0;
munizioni_nave[z].tipo = MUNIZIONE_NAVE;
write(pk_out,&munizioni_nave[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nemici[z].c = ' ';
munizioni_nemici[z].x = -1;
munizioni_nemici[z].y = -1;
munizioni_nemici[z].n = z;
munizioni_nemici[z].d = DIR_GIU;
munizioni_nemici[z].vita = 0;
munizioni_nemici[z].tipo = MUNIZIONE_NEMICI;
write(pk_out,&munizioni_nemici[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
ultima_posizione_nemico[z].c = '?';
ultima_posizione_nemico[z].x = -10;
ultima_posizione_nemico[z].y = -10;
ultima_posizione_nemico[z].n = z;
ultima_posizione_nemico[z].d = 0;
ultima_posizione_nemico[z].tipo = NIENTE;
ultima_posizione_nemico[z].vita = 0;
//write(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
//if (valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
while (1)
{
//usleep(INTERVALLO_MUNIZIONI);
read(p_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO || valore_letto.tipo == GAME_OVER) break;
if( valore_letto.tipo == MUNIZIONE_NAVE && valore_letto.vita > 0 )
{
munizioni_nave[munizione_corrente].y = valore_letto.y;
munizioni_nave[munizione_corrente].x = valore_letto.x;
munizioni_nave[munizione_corrente].vita = valore_letto.vita; /*ripetizione?*/
munizioni_nave[munizione_corrente].c = valore_letto.c;
munizioni_nave[munizione_corrente].n = munizione_corrente;
munizioni_nave[munizione_corrente].d = valore_letto.d;
munizioni_nave[munizione_corrente].tipo = valore_letto.tipo;
write(pk_out,&munizioni_nave[munizione_corrente],sizeof(struct pos));
munizione_corrente += 1;
if(munizione_corrente == MAX_MUNIZIONI_NAVE) munizione_corrente = 0;
}
if( valore_letto.tipo == POSIZIONE_NEMICI)
{
ultima_posizione_nemico[valore_letto.n] = valore_letto;
ultima_posizione_nemico[valore_letto.n].vita = 0;
if (rand() % PROBABILITA_BOMBA == 0)ultima_posizione_nemico[valore_letto.n].vita = 1;
write(pk_out,&niente,sizeof(struct pos));
}
if( valore_letto.tipo == NIENTE)
{
frequenza_munizioni += 1;
velocita_munizioni_nave+=1;
velocita_munizioni_nemici+=1;
write(pk_out,&niente,sizeof(struct pos));
}
/*spara una bomba dalla posizione del nemico corrente*/
if( frequenza_munizioni == 50)
{
munizioni_nemici[munizione_nemico_corrente].y = ultima_posizione_nemico[nemico_corrente].y + 3;
munizioni_nemici[munizione_nemico_corrente].x = ultima_posizione_nemico[nemico_corrente].x + 1;
munizioni_nemici[munizione_nemico_corrente].vita = ultima_posizione_nemico[nemico_corrente].vita;
munizioni_nemici[munizione_nemico_corrente].c = ultima_posizione_nemico[nemico_corrente].c;
munizioni_nemici[munizione_nemico_corrente].n = munizione_nemico_corrente;
munizioni_nemici[munizione_nemico_corrente].d = ultima_posizione_nemico[nemico_corrente].d;
munizioni_nemici[munizione_nemico_corrente].tipo = MUNIZIONE_NEMICI;
write(pk_out,&munizioni_nemici[munizione_nemico_corrente],sizeof(struct pos));
munizione_nemico_corrente += 1;
nemico_corrente += 1;
if(munizione_nemico_corrente == MAX_MUNIZIONI_NAVE) munizione_nemico_corrente = 0;
if(nemico_corrente == MAXNEMICI) nemico_corrente = 0;
frequenza_munizioni = 0;
}
}
}
}
void controllo_tempo(int pg_in)
{
struct pos nave, nemici[MAXNEMICI], munizioni[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],valore_letto;
int z,h;
int vita,livello,punti;
vita = VITA_INIZIALE;
livello = 1;
punti = 0;
nave.x = -1;
for(h=0;h<MAXNEMICI;h++) nemici[h].x = -1;
init_pair(1,COLOR_RED,COLOR_BLACK);
init_pair(2,COLOR_WHITE,COLOR_BLACK);
init_pair(3,COLOR_BLUE,COLOR_BLACK);
init_pair(4,COLOR_GREEN,COLOR_BLACK);
init_pair(5,COLOR_YELLOW,COLOR_BLACK);
init_pair(6,COLOR_MAGENTA,COLOR_BLACK);
init_pair(7,COLOR_CYAN,COLOR_BLACK);
do
{
attron(COLOR_PAIR(6));
mvprintw(MAXY-5,2,"VITA ASTRONAVE: %d",vita);
attron(COLOR_PAIR(5));
mvprintw(1,MAXX/2 -5,"LIVELLO %d",livello);
attron(COLOR_PAIR(5));
mvprintw(MAXY-3,2,"PUNTI %d",punti);
read(pg_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == GAME_OVER)
{
for(z=0;z<MAXX;z++)
for(h=0;h<MAXY;h++)
mvaddch(h,z,' ');
livello = 0;
attron(COLOR_PAIR(1));
mvprintw(MAXY/2,MAXX/2,"GAME OVER");
mvprintw(MAXY/3,MAXX/3,"VUOI FARE UNA NUOVA PARTITA? [S]I/ [N]O ");
}
else if(valore_letto.tipo == FINE_LIVELLO)
{
for(z=0;z<MAXX;z++)
for(h=0;h<MAXY;h++)
mvaddch(h,z,' ');
livello = valore_letto.n;
}
else if(valore_letto.tipo == NEMICO)
{
attron(COLOR_PAIR(3));
if (nemici[valore_letto.n].x >= 0)
{ /* cancello la 'vecchia' posizione del nemico*/
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x + 2,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x + 2,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x + 2,' ');
}
nemici[valore_letto.n] = valore_letto;
/*disegno i nemici*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x + 2,valore_letto.c);
}
else if(valore_letto.tipo == NAVE)
{
attron(COLOR_PAIR(7));
vita = valore_letto.vita;
if (nave.x >= 0)
{ /* cancello la 'vecchia' posizione della nave */
mvaddch(nave.y,nave.x,' ');
mvaddch(nave.y,nave.x + 1,' ');
mvaddch(nave.y,nave.x + 2,' ');
mvaddch(nave.y -1 ,nave.x + 1,' ');
}
nave = valore_letto;
/*disegno l'astronave*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y - 1,valore_letto.x + 1,valore_letto.c);
}
else if(valore_letto.tipo == MUNIZIONE_NEMICI)
{
attron(COLOR_PAIR(7));
for(z=0;z<MAXNEMICI;z++)
if (nemici[z].vita > 0)
if(
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) || (munizioni_nemici[valore_letto.n].y + 1 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 1== nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 1 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x)
);
else
{ /* cancello la 'vecchia' posizione della munizione dei nemici*/
mvaddch(munizioni_nemici[valore_letto.n].y,munizioni_nemici[valore_letto.n].x,' ');
munizioni_nemici[valore_letto.n] = valore_letto;
/* disegno la munizione dei nemici*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
}
}
else if(valore_letto.tipo == MUNIZIONE_NAVE)
{
attron(COLOR_PAIR(6));
{ /* cancello la 'vecchia' posizione della munizione */
mvaddch(munizioni[valore_letto.n].y,munizioni[valore_letto.n].x,' ');
}
munizioni[valore_letto.n] = valore_letto;
/* disegno la munizione */
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
}else if(valore_letto.tipo == NIENTE || valore_letto.tipo == POSIZIONE_NEMICI); /*non fare nulla*/
curs_set(0);
refresh();
}
while (1);
}
void controllo_munizioni( int pk_in, int pipeout)
{
struct pos munizioni_nave[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],ultima_posizione_nemico[MAX_MUNIZIONI_NAVE],valore_letto;
int z;
int munizione_corrente,munizione_nemico_corrente, frequenza_munizioni,velocita_munizioni_nave,velocita_munizioni_nemici, nemico_corrente;
munizione_corrente = munizione_nemico_corrente = frequenza_munizioni = velocita_munizioni_nemici = nemico_corrente = 0;
velocita_munizioni_nave = MISSILE_SEMPLICE;
while (1)
{
//questi due cicli servono??
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nave[z].c = ' ';
munizioni_nave[z].x = -1;
munizioni_nave[z].y = -1;
munizioni_nave[z].n = z;
munizioni_nave[z].d = DIR_SU;
munizioni_nave[z].vita = 0;
munizioni_nave[z].tipo = MUNIZIONE_NAVE;
write(pipeout,&munizioni_nave[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nemici[z].c = ' ';
munizioni_nemici[z].x = -1;
munizioni_nemici[z].y = -1;
munizioni_nemici[z].n = z;
munizioni_nemici[z].d = DIR_GIU;
munizioni_nemici[z].vita = 0;
munizioni_nemici[z].tipo = MUNIZIONE_NEMICI;
write(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
ultima_posizione_nemico[z].c = '?';
ultima_posizione_nemico[z].x = -10;
ultima_posizione_nemico[z].y = -10;
ultima_posizione_nemico[z].n = z;
ultima_posizione_nemico[z].d = 0;
ultima_posizione_nemico[z].tipo = NIENTE;
ultima_posizione_nemico[z].vita = 0;
//write(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
//if (valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
while(1)
{
velocita_munizioni_nave += 1;
velocita_munizioni_nemici += 1;
read(pk_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == MUNIZIONE_NAVE) munizioni_nave[valore_letto.n] = valore_letto;
else if(valore_letto.tipo == MUNIZIONE_NEMICI) munizioni_nemici[valore_letto.n] = valore_letto;
usleep(1);
/* ciclo che si occupa di far spostare le bombe (munizioni) della nave*/
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
if( munizioni_nave[z].vita > 0 )
{
if(velocita_munizioni_nave == VELOCITA_MUNIZIONI_NAVE)
{
if(munizioni_nave[z].d == DIR_SU) munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
else if(munizioni_nave[z].d == DIR_SU_SIN)
{
munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
munizioni_nave[z].x -= SPOSTAMENTO_MUNIZIONE_NAVE;
}
else if(munizioni_nave[z].d == DIR_SU_DES)
{
munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
munizioni_nave[z].x += SPOSTAMENTO_MUNIZIONE_NAVE;
}
}
write(pipeout,&munizioni_nave[z],sizeof(struct pos));
}
}
if(velocita_munizioni_nave == VELOCITA_MUNIZIONI_NAVE) velocita_munizioni_nave = 0;
/* ciclo che si occupa di far spostare le bombe (munizioni) delle navi nemiche */
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
if( munizioni_nemici[z].vita > 0 )
{
if(velocita_munizioni_nemici == VELOCITA_MUNIZIONI_NEMICI)
{
munizioni_nemici[z].y += SPOSTAMENTO_MUNIZIONE_NEMICI;
}
write(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
}
if(velocita_munizioni_nemici == VELOCITA_MUNIZIONI_NEMICI) velocita_munizioni_nemici = 0;
}
}
}
australopiteci
15-02-2007, 23:32
mi sono scordato di scrivere che il problema riguarda la funzione controllo e la funzione nemici. Controllo serve per vedere se vi siano collisioni tra la munizione della nave spaziale ed uno dei nemici. In caso vi sia una collisione, in controllo entra in funzione la write che invia informazioni al nemico (ancora non l'ho implementato bene.. in teoria dovrebbe decrementare la vita). Il fatto è che quando si ha una collisione si blocca tutto...
ho provato davvero tutto.. cercato su libri ecc ma nulla..
ah.. per compilare dare una -lncurses (es gcc -o nuovonome questofile.c -lncurses)
ilsensine
16-02-2007, 08:41
No ti prego, non posso studiarmi tutto il programma.
Intendevo se potevi realizzare un testcase, minimale, illustrando unicamente come usi le pipe.
australopiteci
16-02-2007, 10:34
ora sto partendo in paese purtroppo e non posso farlo perchè non c'è linux. Appena torno però lo faccio. Se per caso hai voglia di guardare il codice, non c'è nulla di complicato. Se lo esegui vedi che si blocca quando vi sono delle collisioni con un punto del nemico (ancora non ho implementato il codice per colpire tutte e 9 i caratteri che compongono il nemico ;P)
australopiteci
19-02-2007, 11:08
ho ridotto il codice all'osso. Ecco due listati con una sola riga di codice diversa:
// makefile
//guardieladri: guardieladri.c
// gcc -o guardieladri guardieladri.c -lncurses
//clean:
// rm guardieladri
#include <stdio.h>
#include <curses.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#define PASSO 10 /* entita dello spostamento del nemico*/
#define SU 65 /* Freccia su */
#define GIU 66 /* Freccia giu */
#define SINISTRA 68 /* Freccia sinsitra */
#define DESTRA 67 /* Freccia destra */
#define SPAZIO 32 /* Tasto Spazio */
#define MAXX 150 /* Numero di colonne dello schermo */
#define MAXY 50 /* Numero di righe dello schermo */
#define VITA_INIZIALE 5
#define NEMICI_PER_RIGA 5
#define MAXNEMICI 15
#define DISTANZANEMICI_X 10
#define DISTANZANEMICI_Y 4
#define POSIZIONE_INIZIALE_NEMICI_X 5
#define POSIZIONE_INIZIALE_NEMICI_Y 5
#define DIR_DESTRA 1
#define DIR_SINISTRA 2
#define DIR_GIU 3
#define DIR_SU 4
#define DIR_SU_DES 5
#define DIR_SU_SIN 6
#define SPOSTAMENTO_NEMICI 3
#define SPOSTAMENTO_MUNIZIONE_NAVE 1
#define SPOSTAMENTO_MUNIZIONE_NEMICI 2
#define SPOSTAMENTO_NAVE 1
#define NEMICO 1
#define NAVE 2
#define MUNIZIONE_NAVE 3
#define MUNIZIONE_NEMICI 4
#define NIENTE 5
#define POSIZIONE_NEMICI 6
#define FINE_LIVELLO 7
#define GAME_OVER 8
#define RESTART 9
#define ESCI 10
#define COLLISIONE_BOMBANAVE_NEMICI 11
#define MISSILE_SEMPLICE 1
#define MISSILE_MEDIO 2
#define MISSILE_POTENTE 3
#define MISSILE_VELOCE 4
#define MISSILE_DOPPIO 5
#define MISSILE_TRIPLO 6
#define MAX_MUNIZIONI_NAVE 60
#define PROBABILITA_BOMBA 6
#define VELOCITA_MUNIZIONI_NEMICI 70
#define VELOCITA_MUNIZIONI_NAVE 10
#define VELOCITA_NEMICI 3
#define INTERVALLO_NEMICI 650000
#define INTERVALLO_TEMPO 40000
#define INTERVALLO_MUNIZIONI 7000
#define INTERVALLO_MUNIZIONI_NEMICI 4
#define PAUSA_INTER_LIVELLO 100000
//#define NON_AVANZARE -1
//MUNIZIONI QUASI PERFETTE, ho messo il random ed il coso per lo spazio è solo commentato
//passaggio di livello in progress..
/* Struttura per la comunicazione tra figli e padre */
struct pos
{
char c; /* carattere visualizzato */
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*nemico numero n*/
int d; /*direzione*/
int vita; /*vita*/
};
struct muni
{
char c;
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*munizione numero n*/
};
void nave(int pipz_in,int pipeout);
void controllo (int pipein, int pg_out,int pipz_out);
void controllo_tempo(int pg_in);
int main()
{
int filedes[2];
int pipe_z[2];
int pipe_g[2];
int pid_nemici;
int pid_nave;
int stato_gioco;
initscr(); /* inizializzazione dello schermo */
start_color();
noecho(); /* i caratteri corrispondenti ai tasti premuti non saranno
* visualizzati sullo schermo del terminale */
curs_set(0); /* nasconde il cursore */
if(pipe(filedes) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_z) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_g) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
/*processo padre p1 crea due processi figli p1_1 e p1_2*/
switch(pid_nemici = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:/* processo figlio di p1, p1_1 : crea il processo per i nemici*/
close(filedes[0]);
close(pipe_z[1]);
nave(pipe_z[0],filedes[1]);
default:/*processo padre p1*/
switch(pid_nave = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_2 che si occupa della funzione nave*/
close(filedes[1]);
close(pipe_g[0]);
close(pipe_z[0]);
controllo(filedes[0],pipe_g[1],pipe_z[1]);
default:
close(pipe_g[1]);
controllo_tempo(pipe_g[0]);
}
}
// siamo usciti dal controllo e si terminano i 2 processi figli
// ripristina il normale modo oparativo dello schermo
kill(pid_nave,1);
kill(pid_nemici,1);
endwin();
return 0;
}
void controllo (int pipein, int pg_out,int pipz_out)
{
struct pos pos_nave,valore_letto,temp;
int z,h;
z=0;
do{
read(pipein,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == NAVE) z++;
if(z==40) write(pipz_out,&valore_letto,sizeof(valore_letto));
write(pipz_out,&valore_letto,sizeof(valore_letto));
write(pg_out,&valore_letto,sizeof(valore_letto));
}while(1);
}
/*
processo 'figlio - nave'. Legge la tastiera e calcola la nuova posizione, in base
ai tasti letti. Comunica questa nuova posizione al 'padre'.
*/
void nave (int pipz_in,int pipeout)
{
struct pos pos_nave, pos_munizione,pos_niente;
char c;
int contatore;
int livello;
int arma;
bool continuare;
bool in_esecuzione;
in_esecuzione = true;
while (in_esecuzione)
{
continuare = true;
livello = 1;
arma = MISSILE_SEMPLICE;
//contatore = 0;
timeout(1);
pos_nave.c = '#';
pos_nave.x = MAXX/2-2;
pos_nave.y = MAXY-10;
pos_nave.tipo = NAVE;
pos_nave.vita = VITA_INIZIALE;
write(pipeout,&pos_nave,sizeof(pos_nave));
do
{
usleep(50);
/*e gli altri casi? il default ad es??*/
switch(c = getch())
{
case SINISTRA:
if(pos_nave.x > 0)
pos_nave.x -= SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
case DESTRA:
if(pos_nave.x < MAXX-1)
pos_nave.x += SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
}
write(pipeout,&pos_nave,sizeof(pos_nave));
}while(continuare);
}
}
void controllo_tempo(int pg_in)
{
struct pos nave, nemici[MAXNEMICI], munizioni[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],valore_l
etto;
int z,h;
int vita,livello,punti;
vita = VITA_INIZIALE;
livello = 1;
punti = 0;
nave.x = -1;
for(h=0;h<MAXNEMICI;h++) nemici[h].x = -1;
init_pair(1,COLOR_RED,COLOR_BLACK);
init_pair(2,COLOR_WHITE,COLOR_BLACK);
init_pair(3,COLOR_BLUE,COLOR_BLACK);
init_pair(4,COLOR_GREEN,COLOR_BLACK);
init_pair(5,COLOR_YELLOW,COLOR_BLACK);
init_pair(6,COLOR_MAGENTA,COLOR_BLACK);
init_pair(7,COLOR_CYAN,COLOR_BLACK);
do
{
attron(COLOR_PAIR(6));
mvprintw(MAXY-5,2,"VITA ASTRONAVE: %d",vita);
attron(COLOR_PAIR(5));
mvprintw(1,MAXX/2 -5,"LIVELLO %d",livello);
attron(COLOR_PAIR(5));
mvprintw(MAXY-3,2,"PUNTI %d",punti);
read(pg_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == NAVE)
{
attron(COLOR_PAIR(7));
vita = valore_letto.vita;
if (nave.x >= 0)
{ /* cancello la 'vecchia' posizione della nave */
mvaddch(nave.y,nave.x,' ');
mvaddch(nave.y,nave.x + 1,' ');
mvaddch(nave.y,nave.x + 2,' ');
mvaddch(nave.y -1 ,nave.x + 1,' ');
}
nave = valore_letto;
/*disegno l'astronave*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y - 1,valore_letto.x + 1,valore_letto.c);
}
curs_set(0);
refresh();
}
while (1);
}
// makefile
//guardieladri: guardieladri.c
// gcc -o guardieladri guardieladri.c -lncurses
//clean:
// rm guardieladri
#include <stdio.h>
#include <curses.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#define PASSO 10 /* entita dello spostamento del nemico*/
#define SU 65 /* Freccia su */
#define GIU 66 /* Freccia giu */
#define SINISTRA 68 /* Freccia sinsitra */
#define DESTRA 67 /* Freccia destra */
#define SPAZIO 32 /* Tasto Spazio */
#define MAXX 150 /* Numero di colonne dello schermo */
#define MAXY 50 /* Numero di righe dello schermo */
#define VITA_INIZIALE 5
#define NEMICI_PER_RIGA 5
#define MAXNEMICI 15
#define DISTANZANEMICI_X 10
#define DISTANZANEMICI_Y 4
#define POSIZIONE_INIZIALE_NEMICI_X 5
#define POSIZIONE_INIZIALE_NEMICI_Y 5
#define DIR_DESTRA 1
#define DIR_SINISTRA 2
#define DIR_GIU 3
#define DIR_SU 4
#define DIR_SU_DES 5
#define DIR_SU_SIN 6
#define SPOSTAMENTO_NEMICI 3
#define SPOSTAMENTO_MUNIZIONE_NAVE 1
#define SPOSTAMENTO_MUNIZIONE_NEMICI 2
#define SPOSTAMENTO_NAVE 1
#define NEMICO 1
#define NAVE 2
#define MUNIZIONE_NAVE 3
#define MUNIZIONE_NEMICI 4
#define NIENTE 5
#define POSIZIONE_NEMICI 6
#define FINE_LIVELLO 7
#define GAME_OVER 8
#define RESTART 9
#define ESCI 10
#define COLLISIONE_BOMBANAVE_NEMICI 11
#define MISSILE_SEMPLICE 1
#define MISSILE_MEDIO 2
#define MISSILE_POTENTE 3
#define MISSILE_VELOCE 4
#define MISSILE_DOPPIO 5
#define MISSILE_TRIPLO 6
#define MAX_MUNIZIONI_NAVE 60
#define PROBABILITA_BOMBA 6
#define VELOCITA_MUNIZIONI_NEMICI 70
#define VELOCITA_MUNIZIONI_NAVE 10
#define VELOCITA_NEMICI 3
#define INTERVALLO_NEMICI 650000
#define INTERVALLO_TEMPO 40000
#define INTERVALLO_MUNIZIONI 7000
#define INTERVALLO_MUNIZIONI_NEMICI 4
#define PAUSA_INTER_LIVELLO 100000
//#define NON_AVANZARE -1
//MUNIZIONI QUASI PERFETTE, ho messo il random ed il coso per lo spazio è solo commentato
//passaggio di livello in progress..
/* Struttura per la comunicazione tra figli e padre */
struct pos
{
char c; /* carattere visualizzato */
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*nemico numero n*/
int d; /*direzione*/
int vita; /*vita*/
};
struct muni
{
char c;
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*munizione numero n*/
};
void nave(int pipz_in,int pipeout);
void controllo (int pipein, int pg_out,int pipz_out);
void controllo_tempo(int pg_in);
int main()
{
int filedes[2];
int pipe_z[2];
int pipe_g[2];
int pid_nemici;
int pid_nave;
int stato_gioco;
initscr(); /* inizializzazione dello schermo */
start_color();
noecho(); /* i caratteri corrispondenti ai tasti premuti non saranno
* visualizzati sullo schermo del terminale */
curs_set(0); /* nasconde il cursore */
if(pipe(filedes) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_z) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_g) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
/*processo padre p1 crea due processi figli p1_1 e p1_2*/
switch(pid_nemici = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:/* processo figlio di p1, p1_1 : crea il processo per i nemici*/
close(filedes[0]);
close(pipe_z[1]);
nave(pipe_z[0],filedes[1]);
default:/*processo padre p1*/
switch(pid_nave = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_2 che si occupa della funzione nave*/
close(filedes[1]);
close(pipe_g[0]);
close(pipe_z[0]);
controllo(filedes[0],pipe_g[1],pipe_z[1]);
default:
close(pipe_g[1]);
controllo_tempo(pipe_g[0]);
}
}
// siamo usciti dal controllo e si terminano i 2 processi figli
// ripristina il normale modo oparativo dello schermo
kill(pid_nave,1);
kill(pid_nemici,1);
endwin();
return 0;
}
void controllo (int pipein, int pg_out,int pipz_out)
{
struct pos pos_nave,valore_letto,temp;
int z,h;
z=0;
do{
read(pipein,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == NAVE) z++;
if(z==40) write(pipz_out,&valore_letto,sizeof(valore_letto));
write(pg_out,&valore_letto,sizeof(valore_letto));
}while(1);
}
/*
processo 'figlio - nave'. Legge la tastiera e calcola la nuova posizione, in base
ai tasti letti. Comunica questa nuova posizione al 'padre'.
*/
void nave (int pipz_in,int pipeout)
{
struct pos pos_nave, pos_munizione,pos_niente;
char c;
int contatore;
int livello;
int arma;
bool continuare;
bool in_esecuzione;
in_esecuzione = true;
while (in_esecuzione)
{
continuare = true;
livello = 1;
arma = MISSILE_SEMPLICE;
//contatore = 0;
timeout(1);
pos_nave.c = '#';
pos_nave.x = MAXX/2-2;
pos_nave.y = MAXY-10;
pos_nave.tipo = NAVE;
pos_nave.vita = VITA_INIZIALE;
write(pipeout,&pos_nave,sizeof(pos_nave));
do
{
usleep(50);
/*e gli altri casi? il default ad es??*/
switch(c = getch())
{
case SINISTRA:
if(pos_nave.x > 0)
pos_nave.x -= SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
case DESTRA:
if(pos_nave.x < MAXX-1)
pos_nave.x += SPOSTAMENTO_NAVE;
//contatore = 0;
write(pipeout,&pos_nave,sizeof(pos_nave));
break;
}
write(pipeout,&pos_nave,sizeof(pos_nave));
}while(continuare);
}
}
void controllo_tempo(int pg_in)
{
struct pos nave, nemici[MAXNEMICI], munizioni[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],valore_l
etto;
int z,h;
int vita,livello,punti;
vita = VITA_INIZIALE;
livello = 1;
punti = 0;
nave.x = -1;
for(h=0;h<MAXNEMICI;h++) nemici[h].x = -1;
init_pair(1,COLOR_RED,COLOR_BLACK);
init_pair(2,COLOR_WHITE,COLOR_BLACK);
init_pair(3,COLOR_BLUE,COLOR_BLACK);
init_pair(4,COLOR_GREEN,COLOR_BLACK);
init_pair(5,COLOR_YELLOW,COLOR_BLACK);
init_pair(6,COLOR_MAGENTA,COLOR_BLACK);
init_pair(7,COLOR_CYAN,COLOR_BLACK);
do
{
attron(COLOR_PAIR(6));
mvprintw(MAXY-5,2,"VITA ASTRONAVE: %d",vita);
attron(COLOR_PAIR(5));
mvprintw(1,MAXX/2 -5,"LIVELLO %d",livello);
attron(COLOR_PAIR(5));
mvprintw(MAXY-3,2,"PUNTI %d",punti);
read(pg_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == NAVE)
{
attron(COLOR_PAIR(7));
vita = valore_letto.vita;
if (nave.x >= 0)
{ /* cancello la 'vecchia' posizione della nave */
mvaddch(nave.y,nave.x,' ');
mvaddch(nave.y,nave.x + 1,' ');
mvaddch(nave.y,nave.x + 2,' ');
mvaddch(nave.y -1 ,nave.x + 1,' ');
}
nave = valore_letto;
/*disegno l'astronave*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y - 1,valore_letto.x + 1,valore_letto.c);
}
curs_set(0);
refresh();
}
while (1);
}
il primo si blocca mentre questo no..
la sola differenza tra i due è la write in più in controllo
che nel primo listato è presente anche dopo la if (la esegue sempre).
In entrambi il codice (la write) entra in funzione dopo che si preme per 40 volte SINISTRA o DESTRA.Il fatto è che se la write entra in funzione nel primo, il programma si blocca mentre nel secondo no. Sembra una cosa assurda dato che la write che blocca il gioco, alla fine è quella che viene usata ad ogni iterazione e non quella della if!
ilsensine
20-02-2007, 08:49
Non intendevo questo per "testcase"; intendevo un programma che esegue solo una sequenza di read e write che emula quello che fai nel programma, e che riproduce il blocco.
Comunque, se ti cabita un blocco sulla write, vuol dire che fai più write che read: tieni conto che un pipe ha uin buffer di 4 o 8 k, una volta riempito successive write bloccano.
Forse per il tuo caso sono più adatte funzioni non bloccanti (puoi bloccare in attesa di dati tramite poll, se ti serve), ma prima devi capire perché si blocca sulla write.
australopiteci
20-02-2007, 09:14
ho lasciato la struttura principale inalterata perchè altrimenti non si sarebbe potuto vedere bene quando si sarebbe bloccato.
IUhm.. ma le funzioni non bloccanti di cui parli, sonoper la write o per la read?
ilsensine
20-02-2007, 09:34
Puoi rendere un descrittore non bloccante, tramite fcntl:
fcntl(fd, F_SETFL, fcntl(fd,F_GETFL, 0) | O_NONBLOCK);
Se un fd è non bloccante e una funzione dovrebbe bloccare (read senza dati sull'fd, write con buffer di scrittura pieno) la funzione ritorna errore (-1) con errno che vale EAGAIN.
australopiteci
20-02-2007, 09:39
ok thx, ora proverò a usare questa funzione
ilsensine
20-02-2007, 16:07
Come non detto, ti ho consigliato di debuggare prima il programma -- non nascondere i bug :)
australopiteci
09-03-2007, 09:41
ciao
ho trovato il deadlock ma in pratica ora dopo un certo numero di iterazioni del programma si rallenta tutto e poi si blocca..
ho provato sia a rendere le read non bloccanti sia ad usare il codice su gapil per far si che le pipes leggano o scrivano esattamente count byte da un file descriptor ma niente da fare :((
A qualcuno è già successo??
allego l'ultimo codice
// makefile
//guardieladri: guardieladri.c
// gcc -o guardieladri guardieladri.c -lncurses
//clean:
// rm guardieladri
#include <stdio.h>
#include <curses.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <fcntl.h>
#include <errno.h>
#define PASSO 10 /* entita dello spostamento del nemico*/
#define SU 65 /* Freccia su */
#define GIU 66 /* Freccia giu */
#define SINISTRA 68 /* Freccia sinsitra */
#define DESTRA 67 /* Freccia destra */
#define SPAZIO 32 /* Tasto Spazio */
#define MAXX 150 /* Numero di colonne dello schermo */
#define MAXY 50 /* Numero di righe dello schermo */
#define VITA_INIZIALE 5
#define NEMICI_PER_RIGA 5
#define MAXNEMICI 15
#define DISTANZANEMICI_X 10
#define DISTANZANEMICI_Y 4
#define POSIZIONE_INIZIALE_NEMICI_X 5
#define POSIZIONE_INIZIALE_NEMICI_Y 5
#define DIR_DESTRA 1
#define DIR_SINISTRA 2
#define DIR_GIU 3
#define DIR_SU 4
#define DIR_SU_DES 5
#define DIR_SU_SIN 6
#define SPOSTAMENTO_NEMICI 3
#define SPOSTAMENTO_MUNIZIONE_NAVE 1
#define SPOSTAMENTO_MUNIZIONE_NEMICI 2
#define SPOSTAMENTO_NAVE 1
#define NEMICO 1
#define NAVE 2
#define MUNIZIONE_NAVE 3
#define MUNIZIONE_NEMICI 4
#define NIENTE 5
#define POSIZIONE_NEMICI 6
#define FINE_LIVELLO 7
#define GAME_OVER 8
#define RESTART 9
#define ESCI 10
#define COLLISIONE_BOMBANAVE_NEMICI 11
#define MISSILE_SEMPLICE 1
#define MISSILE_MEDIO 2
#define MISSILE_POTENTE 3
#define MISSILE_VELOCE 4
#define MISSILE_DOPPIO 5
#define MISSILE_TRIPLO 6
#define MAX_MUNIZIONI_NAVE 10
#define PROBABILITA_BOMBA 6
#define VELOCITA_MUNIZIONI_NEMICI 70
#define VELOCITA_MUNIZIONI_NAVE 10
#define VELOCITA_NEMICI 3
#define INTERVALLO_NEMICI 650000
#define INTERVALLO_TEMPO 40000
#define INTERVALLO_MUNIZIONI 7000
#define INTERVALLO_MUNIZIONI_NEMICI 4
#define PAUSA_INTER_LIVELLO 100000
//#define NON_AVANZARE -1
//MUNIZIONI QUASI PERFETTE, ho messo il random ed il coso per lo spazio è solo commentato
//passaggio di livello in progress..
/* Struttura per la comunicazione tra figli e padre */
struct pos
{
char c; /* carattere visualizzato */
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*nemico numero n*/
int d; /*direzione*/
int vita; /*vita*/
};
struct muni
{
char c;
int tipo; /* soggetto che invia il dato */
int x; /* coordinata x */
int y; /* coordinata y */
int n; /*munizione numero n*/
};
void nemici(int pipz_in,int pipeout,int p_out);
void nave(int pipz_in,int pipeout,int p_out);
void controllo (int pipein, int pg_out,int pipz_out);
void munizioni_nave(int p_in,int pk_out);
void controllo_tempo(int pg_in);
void controllo_munizioni( int pk_in, int pipeout);
ssize_t FullRead(int fd, void *buf, size_t count);
ssize_t FullWrite(int fd, const void *buf, size_t count);
int main()
{
int filedes[2];
int pipe_munizioni[2];
int pipe_z[2];
int pipe_g[2];
int pipe_k[2];
int pipe_l[2];
int pid_nemici;
int pid_nave;
int pid_boh;
int pid_munizioni;
int pid_dany;
int stato_gioco;
initscr(); /* inizializzazione dello schermo */
start_color();
noecho(); /* i caratteri corrispondenti ai tasti premuti non saranno
* visualizzati sullo schermo del terminale */
curs_set(0); /* nasconde il cursore */
if(pipe(filedes) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_munizioni) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_z) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_g) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_k) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
if(pipe(pipe_l) == -1)
{
perror("Errore nella creazione della pipe.");
exit(1);
}
//if (fcntl(pipe_k[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(pipe_k[0],F_SETFL,O_NONBLOCK)<0) exit(1);
//if (fcntl(pipe_z[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(pipe_z[0],F_SETFL,O_NONBLOCK)<0) exit(1);
//if (fcntl(filedes[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(filedes[0],F_SETFL,O_NONBLOCK)<0) exit(1);
//if (fcntl(pipe_munizioni[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(pipe_munizioni[0],F_SETFL,O_NONBLOCK)<0) exit(1);
//if (fcntl(pipe_g[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(pipe_g[0],F_SETFL,O_NONBLOCK)<0) exit(1);
//if (fcntl(pipe_k[0],F_SETFL,O_NDELAY)<0) exit(1);
//if(fcntl(pipe_k[0],F_SETFL,O_NONBLOCK)<0) exit(1);
/*processo padre p1 crea due processi figli p1_1 e p1_2*/
switch(pid_nemici = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:/* processo figlio di p1, p1_1 : crea il processo per i nemici*/
while(true);
default:/*processo padre p1*/
switch(pid_nave = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_2 che si occupa della funzione nave*/
close(pipe_k[1]);
close(filedes[0]);
controllo_munizioni(pipe_k[0], filedes[1]);
default:
switch(pid_dany = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
/* il padre p lancia la funzione di controllo per la nave*/
close(filedes[1]);
close(pipe_g[0]);
close(pipe_z[0]);
controllo(filedes[0],pipe_g[1],pipe_z[1]);
default:switch(pid_boh = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0: /*processo figlio p1_1_1: crea la funzione per i nemici*/
close(filedes[0]);
close(pipe_munizioni[0]);
close(pipe_z[1]);
nave(pipe_z[0],filedes[1],pipe_munizioni[1]);
default:/* processo ora padre p1_1: crea la funzione per controllare i nemici*/
switch(pid_munizioni = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
close(pipe_z[1]);
close(filedes[0]);
close(pipe_munizioni[0]);
nemici(pipe_z[0],filedes[1],pipe_munizioni[1]);
default:/*forse provare a commentare per far funzionare*/
switch(pid_munizioni = fork())
{
case -1:
perror("Errore nell'esecuzione della fork.");
exit(1);
case 0:
close(pipe_g[1]);
controllo_tempo(pipe_g[0]);
default:/*forse provare a commentare per far funzionare*/
close(pipe_munizioni[1]);
close(pipe_k[0]);
munizioni_nave(pipe_munizioni[0],pipe_k[1]);
}
}
}
}
}
}
// siamo usciti dal controllo e si terminano i 2 processi figli
// ripristina il normale modo oparativo dello schermo
kill(pid_nave,1);
kill(pid_nemici,1);
kill(pid_boh,1);
kill(pid_munizioni,1);
kill(pid_dany,1);
endwin();
return 0;
}
void controllo (int pipein, int pg_out,int pipz_out)
{
struct pos munizioni_nave[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],pos_nave,nemici[MAXNEMICI],valore_letto,temp;
int z,h;
do{
FullRead(pipein,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == MUNIZIONE_NAVE) munizioni_nave[valore_letto.n] = valore_letto;
else if ( valore_letto.tipo == MUNIZIONE_NEMICI) munizioni_nemici[valore_letto.n] = valore_letto;
else if ( valore_letto.tipo == NEMICO) nemici[valore_letto.n] = valore_letto;
for(h=0;h<MAXNEMICI;h++)
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
if( (munizioni_nave[z].x == nemici[h].x) && (munizioni_nave[z].y == nemici[h].y) )
{
temp.tipo = COLLISIONE_BOMBANAVE_NEMICI;
temp.vita = 1; //quanto toglie di vita al nemico
temp.n = nemici[h].n; //quale nemico ha colpito
//FullWrite(pipz_out,&valore_letto,sizeof(valore_letto));
}
temp.vita=555;
FullWrite(pg_out,&valore_letto,sizeof(valore_letto));
FullWrite(pipz_out,&temp,sizeof(temp));
}while(1);
}
/*
processo 'figlio - nave'. Legge la tastiera e calcola la nuova posizione, in base
ai tasti letti. Comunica questa nuova posizione al 'padre'.
*/
void nave (int pipz_in,int pipeout,int p_out)
{
struct pos pos_nave, pos_munizione,pos_niente,valore_letto;
char c;
int contatore;
int livello;
int arma;
bool continuare;
bool in_esecuzione;
in_esecuzione = true;
int tempora;
tempora = 0;
while (in_esecuzione)
{
continuare = true;
livello = 1;
arma = MISSILE_SEMPLICE;
//contatore = 0;
timeout(1);
pos_nave.c = '#';
pos_nave.x = MAXX/2-2;
pos_nave.y = MAXY-10;
pos_nave.tipo = NAVE;
pos_nave.vita = VITA_INIZIALE;
pos_niente.x = -5;
pos_niente.y = -5;
pos_niente.c = ' ';
pos_niente.n = livello;
pos_niente.tipo = NIENTE;
FullWrite(pipeout,&pos_nave,sizeof(pos_nave));
do
{
pos_niente.tipo = NIENTE;
pos_niente.n = livello;
//if(tempora< 50) {tempora++;pos_nave.x -= 1;}
//if(tempora>=50 ){tempora++;pos_nave.x +=1;}
//if(tempora >= 100) tempora=0;
//FullRead(pipz_in,&valore_letto,sizeof(valore_letto));
pos_nave.vita = valore_letto.vita;
switch(c = getch())
{
case SINISTRA:
if(pos_nave.x > 0)
pos_nave.x -= SPOSTAMENTO_NAVE;
//contatore = 0;
FullWrite(pipeout,&pos_nave,sizeof(pos_nave));
break;
case DESTRA:
if(pos_nave.x < MAXX-1) pos_nave.x += SPOSTAMENTO_NAVE;
FullWrite(pipeout,&pos_nave,sizeof(pos_nave));
break;
case SPAZIO:
switch(arma)
{
case MISSILE_SEMPLICE:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'o';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
FullWrite(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_MEDIO:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = '^';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
FullWrite(p_out,&pos_munizione,sizeof(struct pos));
break;
case MISSILE_POTENTE:
pos_munizione.tipo = MUNIZIONE_NAVE;
pos_munizione.x = pos_nave.x + 1;
pos_munizione.y = pos_nave.y - 2;
pos_munizione.c = 'O';
pos_munizione.vita = 1;
pos_munizione.d = DIR_SU;
FullWrite(p_out,&pos_munizione,sizeof(struct pos));
break;
}
break;
}
FullWrite(pipeout,&pos_nave,sizeof(pos_nave));
}while(continuare);
}
}
void nemici (int pipz_in, int pipeout, int p_out)
{
struct pos pos_nemico[MAXNEMICI],posizione_munizione[MAXNEMICI],valore_letto;
int z, pos_iniz_x,pos_iniz_y,temp,pausa, livello;
//bool avanza = false;
livello = 1;
//temp = -1;
while(1)
{
bool avanza = false;
temp = -1;
pausa = 0;
pos_iniz_x = POSIZIONE_INIZIALE_NEMICI_X;
pos_iniz_y = POSIZIONE_INIZIALE_NEMICI_Y;
//FullRead(pipz_in,&valore_letto,sizeof(valore_letto));
//if( valore_letto.tipo == FINE_LIVELLO) break;
//FullRead(pipz_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
/*
if( valore_letto.tipo == GAME_OVER )
{
do {
FullRead(pipz_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == RESTART)
{
livello = 1;
break;
}
}while(1);
}
*/
for(z=0;z<MAXNEMICI;z++)
{
temp += 1;
pos_iniz_x = POSIZIONE_INIZIALE_NEMICI_X + (DISTANZANEMICI_X * (z % NEMICI_PER_RIGA) );
//pos_iniz_y = POSIZIONE_INIZIALE_NEMICI_Y;
if(temp == NEMICI_PER_RIGA)
{
pos_iniz_y += DISTANZANEMICI_Y;
//pos_iniz_x
temp = 0;
}
pos_nemico[z].c = '@';
pos_nemico[z].x = pos_iniz_x;
pos_nemico[z].y = pos_iniz_y;
pos_nemico[z].n = z;
pos_nemico[z].d = DIR_DESTRA;
pos_nemico[z].vita = livello;
pos_nemico[z].tipo = NEMICO;
posizione_munizione[z].c = 'v';
posizione_munizione[z].x = pos_iniz_x;
posizione_munizione[z].y = pos_iniz_y;
posizione_munizione[z].n = z;
posizione_munizione[z].d = DIR_GIU;
posizione_munizione[z].vita = livello;
posizione_munizione[z].tipo = POSIZIONE_NEMICI;
FullWrite(pipeout,&pos_nemico[z],sizeof(struct pos));
}
while (1)
{
FullRead(pipz_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO && valore_letto.n != livello) {livello = valore_letto.n;break;}
if( valore_letto.tipo == GAME_OVER) {livello = 1; break;}
//if( valore_letto.tipo == NIENTE ) pausa+=1;
//pausa+=1;
usleep(INTERVALLO_NEMICI);
//if(pausa >= VELOCITA_NEMICI )
{
for(z=0;z<MAXNEMICI;z++)
{
//if( (pos_nemico[z].x > 0) && (pos_nemico[z].d == DIR_DESTRA) && (pos_nemico[z].vita > 0) )
if( (pos_nemico[z].d == DIR_DESTRA) && (pos_nemico[z].vita > 0) )
{
pos_nemico[z].x += SPOSTAMENTO_NEMICI;
posizione_munizione[z].x += SPOSTAMENTO_NEMICI;
if(pos_nemico[z].x > (MAXX - 4) ) avanza = true;
}
//else if( (pos_nemico[z].x > 0) && (pos_nemico[z].d == DIR_SINISTRA) && (pos_nemico[z].vita > 0) )
else if( (pos_nemico[z].d == DIR_SINISTRA) && (pos_nemico[z].vita > 0) )
{
pos_nemico[z].x -= SPOSTAMENTO_NEMICI;
posizione_munizione[z].x -= SPOSTAMENTO_NEMICI;
if(pos_nemico[z].x < 4 ) avanza = true;
}
//if (pos_nemico[z].vita > 0) FullWrite(pipz_out,&pos_nemico[z],sizeof(pos_nemico[z]));
}
if(avanza == true )
{
for(z=0;z<MAXNEMICI;z++)
if(pos_nemico[z].vita > 0)
{
pos_nemico[z].y += SPOSTAMENTO_NEMICI; /*spostamento verticale dei nemici*/
posizione_munizione[z].y += SPOSTAMENTO_NEMICI;
}
/*inverti direzione se raggiungi la fine dello schermo*/
for(z=0;z<MAXNEMICI;z++)
if(pos_nemico[z].vita > 0)
if (pos_nemico[z].d == DIR_DESTRA) pos_nemico[z].d = DIR_SINISTRA;
else pos_nemico[z].d = DIR_DESTRA;
}
avanza = false;
FullWrite(pipeout,&pos_nemico,sizeof(pos_nemico));
//for(z=0;z<MAXNEMICI;z++) FullWrite(p_out,&posizione_munizione[z],sizeof(struct pos));
pausa = 0;
}
}
/*azzera gli array*/
for(z=0;z<MAXNEMICI;z++)
{
pos_nemico[z].c = ' ';
pos_nemico[z].x = -1;
pos_nemico[z].y = -1;
pos_nemico[z].n = z;
pos_nemico[z].d = DIR_DESTRA;
pos_nemico[z].vita = 0;
pos_nemico[z].tipo = NEMICO;
posizione_munizione[z].c = ' ';
posizione_munizione[z].x = -1;
posizione_munizione[z].y = -1;
posizione_munizione[z].n = z;
posizione_munizione[z].d = DIR_GIU;
posizione_munizione[z].vita = 0;
posizione_munizione[z].tipo = POSIZIONE_NEMICI;
FullWrite(pipeout,&pos_nemico[z],sizeof(struct pos));
}
//usleep(PAUSA_INTER_LIVELLO);
}
}
void munizioni_nave(int p_in,int pk_out)
{
struct pos munizione_nave,munizioni_nemici[MAX_MUNIZIONI_NAVE],ultima_posizione_nemico[MAX_MUNIZIONI_NAVE],valore_letto,niente;
int z;
int munizione_corrente,munizione_nemico_corrente, frequenza_munizioni,velocita_munizioni_nave,velocita_munizioni_nemici, nemico_corrente;
munizione_corrente = munizione_nemico_corrente = frequenza_munizioni = velocita_munizioni_nemici = nemico_corrente = 0;
velocita_munizioni_nave = MISSILE_SEMPLICE;
while (1)
{
niente.c = ' ';
niente.x = -1;
niente.y = -1;
niente.n = 0;
niente.tipo = NIENTE;
niente.vita = 0;
niente.d = 0;
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nemici[z].c = ' ';
munizioni_nemici[z].x = -1;
munizioni_nemici[z].y = -1;
munizioni_nemici[z].n = z;
munizioni_nemici[z].d = DIR_GIU;
munizioni_nemici[z].vita = 0;
munizioni_nemici[z].tipo = MUNIZIONE_NEMICI;
//FullWrite(pk_out,&munizioni_nemici[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
ultima_posizione_nemico[z].c = '?';
ultima_posizione_nemico[z].x = -10;
ultima_posizione_nemico[z].y = -10;
ultima_posizione_nemico[z].n = z;
ultima_posizione_nemico[z].d = 0;
ultima_posizione_nemico[z].tipo = NIENTE;
ultima_posizione_nemico[z].vita = 0;
//FullWrite(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
//if (valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
while (1)
{
//usleep(INTERVALLO_MUNIZIONI);
FullRead(p_in,&valore_letto,sizeof(valore_letto));
if( valore_letto.tipo == FINE_LIVELLO || valore_letto.tipo == GAME_OVER) break;
if( valore_letto.tipo == MUNIZIONE_NAVE && valore_letto.vita > 0 )
{
munizione_nave.y = valore_letto.y;
munizione_nave.x = valore_letto.x;
munizione_nave.vita = valore_letto.vita; /*ripetizione?*/
munizione_nave.c = valore_letto.c;
munizione_nave.n = munizione_corrente;
munizione_nave.d = valore_letto.d;
munizione_nave.tipo = valore_letto.tipo;
FullWrite(pk_out,&munizione_nave,sizeof(struct pos));
munizione_corrente += 1;
if(munizione_corrente == MAX_MUNIZIONI_NAVE) munizione_corrente = 0;
}
}
}
}
void controllo_tempo(int pg_in)
{
struct pos nave, nemici[MAXNEMICI], munizioni[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],valore_letto;
int z,h;
int vita,livello,punti;
vita = VITA_INIZIALE;
livello = 1;
punti = 0;
nave.x = -1;
for(h=0;h<MAXNEMICI;h++) nemici[h].x = -1;
init_pair(1,COLOR_RED,COLOR_BLACK);
init_pair(2,COLOR_WHITE,COLOR_BLACK);
init_pair(3,COLOR_BLUE,COLOR_BLACK);
init_pair(4,COLOR_GREEN,COLOR_BLACK);
init_pair(5,COLOR_YELLOW,COLOR_BLACK);
init_pair(6,COLOR_MAGENTA,COLOR_BLACK);
init_pair(7,COLOR_CYAN,COLOR_BLACK);
int z1,z2,z3,z4,z5,z6,z7;
z1=z2=z3=z4=z5=z6=z7=0;
do
{
attron(COLOR_PAIR(6));
mvprintw(MAXY-5,2,"VITA ASTRONAVE: %d",vita);
attron(COLOR_PAIR(5));
mvprintw(1,MAXX/2 -5,"LIVELLO %d",livello);
attron(COLOR_PAIR(5));
mvprintw(MAXY-3,2,"PUNTI %d",punti);
FullRead(pg_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == GAME_OVER)
{
for(z=0;z<MAXX;z++)
for(h=0;h<MAXY;h++)
mvaddch(h,z,' ');
livello = 0;
attron(COLOR_PAIR(1));
mvprintw(MAXY/2,MAXX/2,"GAME OVER");
mvprintw(MAXY/3,MAXX/3,"VUOI FARE UNA NUOVA PARTITA? [S]I/ [N]O ");
z1++;
mvprintw(MAXY-3,15,"gameover %d",z1);
}
else if(valore_letto.tipo == FINE_LIVELLO)
{
for(z=0;z<MAXX;z++)
for(h=0;h<MAXY;h++)
mvaddch(h,z,' ');
livello = valore_letto.n;
z2++;
mvprintw(MAXY-5,15,"fineleivvello %d",z2);
}
else if(valore_letto.tipo == NEMICO)
{
attron(COLOR_PAIR(3));
if (nemici[valore_letto.n].x >= 0)
{ /* cancello la 'vecchia' posizione del nemico*/
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x,' ');
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x + 1,' ');
mvaddch(nemici[valore_letto.n].y,nemici[valore_letto.n].x + 2,' ');
mvaddch(nemici[valore_letto.n].y + 1,nemici[valore_letto.n].x + 2,' ');
mvaddch(nemici[valore_letto.n].y + 2,nemici[valore_letto.n].x + 2,' ');
}
nemici[valore_letto.n] = valore_letto;
/*disegno i nemici*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y + 1,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y + 2,valore_letto.x + 2,valore_letto.c);
z3++;
mvprintw(MAXY-7,15,"nemico %d",z3);
}
else if(valore_letto.tipo == NAVE)
{
attron(COLOR_PAIR(7));
vita = valore_letto.vita;
if (nave.x >= 0)
{ /* cancello la 'vecchia' posizione della nave */
mvaddch(nave.y,nave.x,' ');
mvaddch(nave.y,nave.x + 1,' ');
mvaddch(nave.y,nave.x + 2,' ');
mvaddch(nave.y -1 ,nave.x + 1,' ');
}
nave = valore_letto;
/*disegno l'astronave*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 1,valore_letto.c);
mvaddch(valore_letto.y,valore_letto.x + 2,valore_letto.c);
mvaddch(valore_letto.y - 1,valore_letto.x + 1,valore_letto.c);
z4++;
mvprintw(MAXY-9,15,"nave %d",z4);
}
else if(valore_letto.tipo == MUNIZIONE_NEMICI)
{
attron(COLOR_PAIR(7));
for(z=0;z<MAXNEMICI;z++)
if (nemici[z].vita > 0)
if(
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) || (munizioni_nemici[valore_letto.n].y + 1 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 1== nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 1 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 1 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x) ||
(munizioni_nemici[valore_letto.n].y + 2 == nemici[z].y) && (munizioni_nemici[valore_letto.n].x + 2 == nemici[z].x)
);
else
{ /* cancello la 'vecchia' posizione della munizione dei nemici*/
mvaddch(munizioni_nemici[valore_letto.n].y,munizioni_nemici[valore_letto.n].x,' ');
munizioni_nemici[valore_letto.n] = valore_letto;
/* disegno la munizione dei nemici*/
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
}
z5++;
mvprintw(MAXY-11,15,"gmunizioni nemici %d",z5);
}
else if(valore_letto.tipo == MUNIZIONE_NAVE)
{
attron(COLOR_PAIR(6));
{ /* cancello la 'vecchia' posizione della munizione */
mvaddch(munizioni[valore_letto.n].y,munizioni[valore_letto.n].x,' ');
}
munizioni[valore_letto.n] = valore_letto;
/* disegno la munizione */
mvaddch(valore_letto.y,valore_letto.x,valore_letto.c);
z6++;
mvprintw(MAXY-14,15,"muniz naver %d",z6);
}else if(valore_letto.tipo == NIENTE || valore_letto.tipo == POSIZIONE_NEMICI){z7++;
mvprintw(MAXY-16,15,"altro %d",z7);}; /*non fare nulla*/
curs_set(0);
refresh();
}
while (1);
}
void controllo_munizioni(int pk_in, int pipeout)
{
struct pos munizioni_nave[MAX_MUNIZIONI_NAVE],munizioni_nemici[MAX_MUNIZIONI_NAVE],ultima_posizione_nemico[MAX_MUNIZIONI_NAVE],valore_letto,temp;
int z;
int munizione_corrente,munizione_nemico_corrente, frequenza_munizioni,velocita_munizioni_nave,velocita_munizioni_nemici, nemico_corrente;
munizione_corrente = munizione_nemico_corrente = frequenza_munizioni = velocita_munizioni_nemici = nemico_corrente = 0;
velocita_munizioni_nave = MISSILE_SEMPLICE;
while (1)
{
//questi due cicli servono??
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nave[z].c = ' ';
munizioni_nave[z].x = -1;
munizioni_nave[z].y = -1;
munizioni_nave[z].n = z;
munizioni_nave[z].d = DIR_SU;
munizioni_nave[z].vita = 0;
munizioni_nave[z].tipo = MUNIZIONE_NAVE;
//FullWrite(pipeout,&munizioni_nave[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
munizioni_nemici[z].c = ' ';
munizioni_nemici[z].x = -1;
munizioni_nemici[z].y = -1;
munizioni_nemici[z].n = z;
munizioni_nemici[z].d = DIR_GIU;
munizioni_nemici[z].vita = 0;
munizioni_nemici[z].tipo = MUNIZIONE_NEMICI;
//FullWrite(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
ultima_posizione_nemico[z].c = '?';
ultima_posizione_nemico[z].x = -10;
ultima_posizione_nemico[z].y = -10;
ultima_posizione_nemico[z].n = z;
ultima_posizione_nemico[z].d = 0;
ultima_posizione_nemico[z].tipo = NIENTE;
ultima_posizione_nemico[z].vita = 0;
//FullWrite(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
//if (valore_letto.tipo == FINE_LIVELLO) usleep(PAUSA_INTER_LIVELLO);
while(1)
{
;
velocita_munizioni_nave += 1;
velocita_munizioni_nemici += 1;
usleep(1);
FullRead(pk_in,&valore_letto,sizeof(valore_letto));
if(valore_letto.tipo == MUNIZIONE_NAVE) munizioni_nave[valore_letto.n] = valore_letto;
else if(valore_letto.tipo == MUNIZIONE_NEMICI) munizioni_nemici[valore_letto.n] = valore_letto;
//usleep(1);
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
if( munizioni_nave[z].vita > 0 )
{
//if(velocita_munizioni_nave == VELOCITA_MUNIZIONI_NAVE)
{
if(munizioni_nave[z].d == DIR_SU) munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
else if(munizioni_nave[z].d == DIR_SU_SIN)
{
munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
munizioni_nave[z].x -= SPOSTAMENTO_MUNIZIONE_NAVE;
}
else if(munizioni_nave[z].d == DIR_SU_DES)
{
munizioni_nave[z].y -= SPOSTAMENTO_MUNIZIONE_NAVE;
munizioni_nave[z].x += SPOSTAMENTO_MUNIZIONE_NAVE;
}
}
FullWrite(pipeout,&munizioni_nave[z],sizeof(struct pos));
}
}
if(velocita_munizioni_nave == VELOCITA_MUNIZIONI_NAVE) velocita_munizioni_nave = 0;
/*
for(z=0;z<MAX_MUNIZIONI_NAVE;z++)
{
if( munizioni_nemici[z].vita > 0 )
{
if(velocita_munizioni_nemici == VELOCITA_MUNIZIONI_NEMICI)
{
munizioni_nemici[z].y += SPOSTAMENTO_MUNIZIONE_NEMICI;
}
FullWrite(pipeout,&munizioni_nemici[z],sizeof(struct pos));
}
}
if(velocita_munizioni_nemici == VELOCITA_MUNIZIONI_NEMICI) velocita_munizioni_nemici = 0;
*/
}
}
}
ssize_t FullRead(int fd, void *buf, size_t count)
{
size_t nleft;
ssize_t nread;
nleft = count;
while (nleft > 0)
{ /* repeat until no left */
if ( (nread = read(fd, buf, nleft)) < 0)
{
if (errno == EINTR)
{ /* if interrupted by system call */
continue; /* repeat the loop */
} else
{
return(nread); /* otherwise exit */
}
} else if (nread == 0) { /* EOF */
break; /* break loop here */
}
nleft -= nread; /* set left to read */
buf +=nread; /* set pointer */
}
return (nleft);
}
ssize_t FullWrite(int fd, const void *buf, size_t count)
{
size_t nleft;
ssize_t nwritten;
nleft = count;
while (nleft > 0) { /* repeat until no left */
if ( (nwritten = write(fd, buf, nleft)) < 0) {
if (errno == EINTR) { /* if interrupted by system call */
continue; /* repeat the loop */
} else {
return(nwritten); /* otherwise exit with error */
}
}
nleft -= nwritten; /* set left to write */
buf +=nwritten; /* set pointer */
}
return (nleft);
}
DanieleC88
11-03-2007, 08:29
Mamma mia, australopiteci, ma come fai a gestire il tuo codice? :eek:
Non ho letto tutto il codice, ma ho notato una decina di pipe() e altrettanti fork(), il che è più o meno suicida da scrivere tutto in una sola funzione, fattelo dire. :D
Dovresti cercare di scriverlo in modo che sia più leggibile, prima di tutto, per te stesso... :p
Assicurati che il codice faccia proprio quello che è descritto anche nella pagina del manuale (nel codice d'esempio): http://www.die.net/doc/linux/man/man2/pipe.2.html
In pratica, fatto il fork(), il processo padre scrive nella pipe e aspetta che il figlio termini l'esecuzione. Il figlio invece legge dalla pipe e poi termina la propria esecuzione.
if (pid > 0) {
write(filedes[1], ...); /* scrivi i dati */
wait(NULL); /* aspetta che il figlio finisca di leggerli */
exit(EXIT_SUCCESS);
}
else if (pid == 0) {
read(filedes[0], ...); /* leggi i dati */
exit(EXIT_SUCCESS);
}
Questo, ovviamente, ricordandoti di chiudere i descriptor che i processi non usano.
australopiteci
13-03-2007, 17:49
ciao..
il main si occupa esclusivamente di creare dei processi che devono essere eseguiti in parallelo.. su questo codice ho tagliato tantissime righe.. risulta complicato per quel motivo ;P
comunque è troppo strano quel che succede facendolo eseguire.
Le wait ecc sono cose che non c'entrano purtroppo con questo problema :(
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.