[C] Gioco basato su comunicazione tramite "pipe"

[thesalien]

Salve a tutti,
sto creando un videogioco di astronavi con dei processi che comunicano tra di loro via pipes.
In pratica vi sono delle astronavi nemiche in alto che vanno verso sinistra ed una navicella controllata con le frecce direzionali.
Il problema è che quando tocco le frecce s'incasina tutto senza motivo. i caratteri dell'astronave inspiegabilmente vengono catapultati nella posizione delle navicelle nemiche.. ho riletto il codice svariate volte, fatto prove ecc. ma il codice sembra giusto..

E' possibile che sia colpa del modo in cui vengono gestite le pipes da linux?

si deve compilare con l'opzione -lncurses

ad es. gcc -o nomefile nomefile.c -lncurses

// 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>

#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 MAXX 80 /* Numero di colonne dello schermo */
#define MAXY 24 /* Numero di righe dello schermo */
#define MAXNEMICI 5
#define DISTANZANEMICI 8
/* Struttura per la comunicazione tra figli e padre */
struct pos
{
	char c; /* soggetto che invia il dato */
	int x; /* coordinata x */
	int y; /* coordinata y */
};

void nemici(int pipeout);
void nave(int pipeout);
void controllo(int pipein);
void controllo_nemici(int pipein);

int main()
{

 	//fare i menu ecc prima di usare le curses

	int filedes[2];
	int pipe_nemici[2];
	int pid_nemici;
	int pid_nave;
	int pid_boh;
	
	int stato_gioco;
	initscr(); /* inizializzazione dello schermo */
	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_nemici) == -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*/
			
			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(pipe_nemici[0]);
							nemici(pipe_nemici[1]);
						default:// processo ora padre p1_1: crea la funzione per controllare i nemici
							close(pipe_nemici[1]);
							controllo_nemici(pipe_nemici[0]);
					}
			
		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]);
					nave(filedes[1]);
				default:
					
					/* il padre p lancia la funzione di controllo per la nave*/
					close(filedes[1]);
					controllo(filedes[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);
	kill(pid_boh,1);
	endwin();
	return 0;
}




void controllo (int pipein)
{
	struct pos nave,valore_letto;
	
	nave.x = -1;
	do
	{
		read(pipein,&valore_letto,sizeof(valore_letto));
		
		
		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);
}



void controllo_nemici (int pipein)
{	
	struct pos nemici[MAXNEMICI],valore_letto[MAXNEMICI];
	int h;
	/*nemici.x = -1;*/

	do
	{		
		for(h=0;h<MAXNEMICI;h++)
		read(pipein,&valore_letto[h],sizeof(struct pos));
		
		for(h=0;h<MAXNEMICI;h++)
		if (nemici[h].x >= 0)
		{ /* cancello la 'vecchia' posizione del nemico*/
			mvaddch(nemici[h].y,nemici[h].x,' ');
		}
		
		for(h=0;h<MAXNEMICI;h++)
		nemici[h] = valore_letto[h];

		/*disegno i nemici*/
		for(h=0;h<MAXNEMICI;h++)
		mvaddch(valore_letto[h].y,valore_letto[h].x,valore_letto[h].c);
		
		
		curs_set(0);
		refresh();
		sleep(1);
	}
   	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)
{

	struct pos pos_nave;
	pos_nave.c = '#';
	pos_nave.x = MAXX -5;
	pos_nave.y = MAXY ;
	write(pipeout,&pos_nave,sizeof(pos_nave));

	while(1)
	{
		char c;
		/*e gli altri casi? il default ad es??*/
		switch(c = getch())
   		{
			
			case SINISTRA:
				if(pos_nave.x > 0)
					pos_nave.x -=1;
         			break;
			case DESTRA:
				if(pos_nave.x < MAXX-1)
					pos_nave.x +=1;
				break;
		}
		write(pipeout,&pos_nave,sizeof(pos_nave));
	}
}

void nemici (int pipeout)
{	
	

	struct pos pos_nemico[MAXNEMICI];
	int z;

	for(z=0;z<MAXNEMICI;z++)
	{
		pos_nemico[z].c = '@';
		pos_nemico[z].x = 5+(DISTANZANEMICI*z);
		pos_nemico[z].y = 5;
		write(pipeout,&pos_nemico[z],sizeof(struct pos));
	}
	
	
	while (1)
	{	
		sleep(1);
		for(z=0;z<MAXNEMICI;z++)
		if(pos_nemico[z].x > 0)
			pos_nemico[z].x +=1;
				
		write(pipeout,&pos_nemico,sizeof(pos_nemico));	
		
	}
	
}

[thesalien]

ho fatto 1000 modifiche ma funziona sempre male