|
|||||||
|
|
|
 |
|
|
Strumenti |
14-02-2007, 17:23
|
#1 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
[C] chiudere o no le pipes?
salve ho problema con le pipes
Dovrei fare un qualcosa del genere: Codice:
processo1 ---[pipe1] - - -> processo2 --- -[pipe2] - - - - ->processo1 io ho fatto una cosa del genere: dal main ho forkato 2 processi: processo1 e processo2 e poi: Codice:
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????
__________________
the AUSTRALOPITECI |
|
|
|
14-02-2007, 17:29
|
#2 |
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
Non capisco che c'entra la domanda col titolo del thread
 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.
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
|
|
|
|
14-02-2007, 18:11
|
#3 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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 
__________________
the AUSTRALOPITECI |
|
|
|
|
14-02-2007, 23:19
|
#4 | |
|
Senior Member
Iscritto dal: Apr 2000
Città: Naples
Messaggi: 3907
|
Quote:
__________________
Cancellato stare lucido dal mio vocabolario -Speaker Cenzou- |
|
|
|
|
15-02-2007, 02:14
|
#5 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
già sono monodirezionali.. so che le fifo e l'IPC di system V sono bidirezionali ma vorrei proprio usare le pipes
__________________
the AUSTRALOPITECI |
|
|
|
|
15-02-2007, 14:05
|
#6 | ||
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
Quote:
Quote:
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
||
|
|
|
|
16-02-2007, 00:19
|
#7 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
questo è il codice di quel che sto facendo:
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>
#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;
}
}
}
__________________
the AUSTRALOPITECI |
|
|
|
|
16-02-2007, 00:32
|
#8 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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)
__________________
the AUSTRALOPITECI |
|
|
|
|
16-02-2007, 09:41
|
#9 |
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
No ti prego, non posso studiarmi tutto il programma.
Intendevo se potevi realizzare un testcase, minimale, illustrando unicamente come usi le pipe.
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
|
|
|
|
16-02-2007, 11:34
|
#10 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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)
__________________
the AUSTRALOPITECI |
|
|
|
|
19-02-2007, 12:08
|
#11 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
ho ridotto il codice all'osso. Ecco due listati con una sola riga di codice diversa:
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>
#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);
}
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>
#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!
__________________
the AUSTRALOPITECI |
|
|
|
|
20-02-2007, 09:49
|
#12 |
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
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.
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
|
|
|
|
20-02-2007, 10:14
|
#13 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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?
__________________
the AUSTRALOPITECI |
|
|
|
|
20-02-2007, 10:34
|
#14 |
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
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.
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
|
|
|
|
20-02-2007, 10:39
|
#15 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
ok thx, ora proverò a usare questa funzione
__________________
the AUSTRALOPITECI |
|
|
|
|
20-02-2007, 17:07
|
#16 |
|
Senior Member
Iscritto dal: Apr 2000
Città: Roma
Messaggi: 15625
|
Come non detto, ti ho consigliato di debuggare prima il programma -- non nascondere i bug
__________________
0: or %edi, %ecx; adc %eax, (%edx); popf; je 0b-22; pop %ebx; fadds 0x56(%ecx); lds 0x56(%ebx), %esp; mov %al, %al andeqs pc, r1, #147456; blpl 0xff8dd280; ldrgtb r4, [r6, #-472]; addgt r5, r8, r3, ror #12 |
|
|
|
|
09-03-2007, 10:41
|
#17 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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 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);
}
__________________
the AUSTRALOPITECI |
|
|
|
|
11-03-2007, 09:29
|
#18 |
|
Senior Member
Iscritto dal: Jun 2002
Città: Dublin
Messaggi: 5989
|
Mamma mia, australopiteci, ma come fai a gestire il tuo codice?
 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. Dovresti cercare di scriverlo in modo che sia più leggibile, prima di tutto, per te stesso...  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. Codice:
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);
}
__________________
C'ho certi cazzi Mafa' che manco tu che sei pratica li hai visti mai! |
|
|
|
|
13-03-2007, 18:49
|
#19 |
|
Member
Iscritto dal: Feb 2005
Messaggi: 127
|
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
__________________
the AUSTRALOPITECI |
|
|
|
|
|
| Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 11:37.
