E' un programmino didattico: sarebbe una emulazione del gioco di space invaders (ma molto grezzo!),con grafica scarna.
Il programma è quasi analogo al classico problema dei "produttori-consumatori": creo dei processi, che accedono ad un buffer condiviso (protetto da semafori), basandomi sulle librerie lpthread e lncurses, utilizzando il sistema comunicazione interprocesso delle System V di linux.
Ho creato un sistema iniziale ma non capisco come mai quando sparo le bombe della navetta con il tasto "spazio" i processi della nave vengono duplicati e non funziona la funzione (scusate la ripetizione!) di collisione delle bombe nave con gli alieni..
Potete darmi una mano per favore? Ecco il codice, Grazie
- Codice: Seleziona tutto
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <sys/wait.h>
#include <sys/signal.h>
#include <setjmp.h>
#include <stdlib.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <curses.h>
#include <time.h>
#define RMODE 0644
#define WMODE 0666
#define NUM_MAX_RIGHE 5
#define SINISTRA 68
#define DESTRA 67
#define N_INIZIALE_ALIENI 10
#define SPAZIO 3
#define SPAZIO_RIGHE 1
#define PASSO_X 2
#define PASSO_Y 1
#define BUFFER_DIM 10
#define MAX_BOMBE_NAVE 5
#define MAX_BOMBE_ALIENO N_INIZIALE_ALIENI * 2
struct pos {
char *c;
int x;
int y;
int index;
int xPrec;
int yPrec;
int pid;
};
int empty, full, mutex, buffer_id, mutexBombeNave, mutexBombeAlieni, livello;
key_t empty_t, full_t, mutex_t, mutex_nave, mutex_alieni; // le zone di memoria dei due semafori e del semaforo-mutex
void scrittore(struct pos *, struct pos );
void lettore(struct pos *);
void crea_proc(int, int);
void bomba(struct pos, struct pos *, int *);
void creaBomba(struct pos);
void sparaBomba(struct pos);
bool collisione_alieni(int);
bool collisione_nave(int);
// buffer che poi verrà condiviso //
struct BUF {
struct pos *info_elementi[BUFFER_DIM];
struct pos info_alieno[N_INIZIALE_ALIENI];
struct pos info_nave;
struct pos bombe_nave[MAX_BOMBE_NAVE];
struct pos bombe_alieno[MAX_BOMBE_ALIENO];
int vitaAlieni[N_INIZIALE_ALIENI];
int vitaNave;
int vitaBombeNave[MAX_BOMBE_NAVE];
int vitaBombeAlieno[MAX_BOMBE_ALIENO];
int in;
int out;
bool esci;
int posDisponibileAlieno;
int posDisponibileNave;
int nBombeNaveResidue;
int nBombeAlienoResidue;
} * bufferpointer;
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;};
/* Function MutexCreate : create a mutex / semaphore */
int MutexCreate ( key_t ipc_key )
{
const union semun semunion={1}; /* semaphore union structure: mutex must be initialized with 1*/
int sem_id , ret;
sem_id = semget ( ipc_key , 1 , IPC_CREAT | WMODE); /* get semaphore ID */
if ( sem_id == -1) { /* if error return code */
return sem_id ;
}
ret = semctl (sem_id , 0 , SETVAL , semunion ); /* init semaphore */
if ( ret == -1) {
return ret;
}
return sem_id ;
}
/* Define sembuf structures to lock and unlock the mutex or to create wait and signal for semaphores */
struct sembuf sem_lock_or_wait ={ /* to lock mutex or wait for semaphore */
0, /* semaphore number ( only one so 0) */
-1, /* operation ( -1 to use resource ) */
SEM_UNDO }; /* flag ( set for undo at exit ) */
struct sembuf sem_ulock_or_signal ={ /* to unlock mutex or post a signal for semaphore */
0, /* semaphore number ( only one so 0) */
1, /* operation (1 to release resource ) */
SEM_UNDO }; /* flag ( in this case 0) */
/* Function Lock_Wait : to lock a mutex or wait for semaphore */
int Lock_Wait (int sem_id )
{
return semop (sem_id , & sem_lock_or_wait , 1);
}
/* Function Unlock_Signal : to unlock a mutex or signal for semaphore */
int Unlock_Signal (int sem_id )
{
return semop (sem_id , & sem_ulock_or_signal , 1);
}
/* Function SemRemove : remove a mutex / semaphore */
int SemRemove (int sem_id )
{
return semctl (sem_id , 0 , IPC_RMID );
}
void alieni(int index, int xIniz, int yIniz)
{
int i;
bufferpointer=(struct BUF *) shmat ( buffer_id , NULL , 0) ; // Attachment al buffer condiviso
struct pos pos_alieno, pos_bomba;
int dx, dy;
pos_alieno.x = xIniz * (SPAZIO + 1);
pos_alieno.y = yIniz * (SPAZIO_RIGHE + 1);
pos_alieno.c = "#";
pos_alieno.index = index;
pos_alieno.pid = getpid();
srand(pos_alieno.pid); //inizializziamo il generatore random
int dir = 1;
while(!bufferpointer->esci && bufferpointer->vitaAlieni[index])
{
pos_alieno.pid = getpid();
pos_alieno.yPrec = pos_alieno.y;
pos_alieno.xPrec = pos_alieno.x;
dx = PASSO_X * dir;
dy = 0;
if (pos_alieno.x + dx >= COLS -1 || pos_alieno.x + dx <= 0)
{
if(dir > 0)
pos_alieno.x = COLS - 1;
else
pos_alieno.x = 0;
dir = -dir;
dx = PASSO_X * dir;
dy = PASSO_Y;
}
pos_alieno.x += dx;
pos_alieno.y += dy;
scrittore(&bufferpointer->info_alieno[pos_alieno.index], pos_alieno);
double t = clock();
if((rand() % 100) >= 99 - 1) // 1 qui equivale al livello....da aggiornare!
{
Lock_Wait(mutexBombeAlieni);
if(bufferpointer->nBombeAlienoResidue > 0)
{
bufferpointer->nBombeAlienoResidue--;
bufferpointer->posDisponibileAlieno = (bufferpointer->posDisponibileAlieno + 1) % MAX_BOMBE_ALIENO;
pos_bomba.index = bufferpointer->posDisponibileAlieno;
pos_bomba.x = pos_bomba.xPrec = pos_alieno.x;
pos_bomba.y = pos_alieno.y + 1;
pos_bomba.c = "!";
creaBomba(pos_bomba);
}
Unlock_Signal(mutexBombeAlieni);
}
t = 1000000 - (clock() - t);
usleep(t);
}
shmdt (bufferpointer); //Detachment del buffer condiviso
shmctl (buffer_id, IPC_RMID , NULL); //Deallocazione del buffer condiviso
}
void nave()
{
bufferpointer=(struct BUF *) shmat (buffer_id , NULL , 0) ; // Attachment al buffer condiviso
struct pos pos_nave;
struct pos pos_bomba;
pos_nave.c = "^";
pos_nave.x = COLS / 2;
pos_nave.yPrec = pos_nave.y = LINES - 1;
pos_nave.index = 1; //per ora è inutile...
scrittore(&bufferpointer->info_nave, pos_nave);
while(!bufferpointer->esci && bufferpointer->vitaNave)
{
char c;
pos_nave.xPrec = pos_nave.x;
switch(c = getch())
{
case SINISTRA: if(pos_nave.x > 1) pos_nave.x -= 1;
break;
case DESTRA: if(pos_nave.x < COLS - 1) pos_nave.x += 1;
break;
case 'q': bufferpointer->esci = true;
break;
case ' ':
Lock_Wait(mutexBombeNave);
if(bufferpointer->nBombeNaveResidue > 0)
{
bufferpointer->nBombeNaveResidue--;
bufferpointer->posDisponibileNave = (bufferpointer->posDisponibileNave + 1) % MAX_BOMBE_NAVE;
pos_bomba.index = bufferpointer->posDisponibileNave;
pos_bomba.x = pos_bomba.xPrec = pos_nave.x;
pos_bomba.y = LINES - 2;
pos_bomba.c = "o";
creaBomba(pos_bomba);
}
Unlock_Signal(mutexBombeNave);
}
if (c == DESTRA || c == SINISTRA)
{
scrittore(&bufferpointer->info_nave, pos_nave);
}
}
shmdt(bufferpointer); //Detachment
shmctl(buffer_id, IPC_RMID , NULL);//Deallocazione
}
void creaBomba(struct pos pos_bomba)
{
switch(fork()) {
case -1: printf("Errore fork!");
break;
case 0:sparaBomba(pos_bomba);
break;
default: return;
}
}
void sparaBomba(struct pos pos_bomba)
{
pos_bomba.pid = getpid();
struct pos *posizione;
int *posizioneVita;
if(pos_bomba.c == "!") // è un alieno?
{
Lock_Wait(mutexBombeAlieni);
posizione = &bufferpointer->bombe_alieno[bufferpointer->posDisponibileAlieno];
posizioneVita = &bufferpointer->vitaBombeAlieno[bufferpointer->posDisponibileAlieno];
*posizioneVita = 1;
Unlock_Signal(mutexBombeAlieni);
bomba(pos_bomba, posizione, posizioneVita);
Lock_Wait(mutexBombeAlieni);
bufferpointer->nBombeAlienoResidue++;
Unlock_Signal(mutexBombeAlieni);
}
else
if(pos_bomba.c == "o") //è una nave?
{
Lock_Wait(mutexBombeNave);
posizione = &bufferpointer->bombe_nave[bufferpointer->posDisponibileNave];
posizioneVita = &bufferpointer->vitaBombeAlieno[bufferpointer->posDisponibileAlieno];
*posizioneVita = 1;
Unlock_Signal(mutexBombeNave);
bomba(pos_bomba, posizione, posizioneVita);
Lock_Wait(mutexBombeNave);
bufferpointer->nBombeNaveResidue++;
Unlock_Signal(mutexBombeNave);
}
}
void bomba(struct pos pos_bomba, struct pos *posizione, int *posVita)
{
int limite = (pos_bomba.c == "!") ? LINES - 1 : 0;
int dir = (pos_bomba.c == "!") ? 1 : -1;
scrittore(posizione, pos_bomba);
while(pos_bomba.y != limite && *posVita)
{
usleep(100000);
pos_bomba.yPrec = pos_bomba.y;
pos_bomba.y += dir;
scrittore(posizione,pos_bomba);
}
pos_bomba.c = " ";
scrittore(posizione, pos_bomba);
}
void controllo()
{
struct pos valore_letto;
int nAlieni = N_INIZIALE_ALIENI;
int statoGioco = 0;
int punteggio = 0;
int puntiKiller = 10;
int dimAlieni = 1;
int nAlieniRiga = COLS / (dimAlieni + SPAZIO);
bufferpointer=(struct BUF *) shmat ( buffer_id , NULL , 0) ; // Attachment al buffer condiviso
livello = 1;
do {
statoGioco = 1;
do {
lettore(&valore_letto);
if(valore_letto.c == "#")
{
if(valore_letto.y == bufferpointer->info_nave.y - SPAZIO_RIGHE)
{
bufferpointer->vitaNave--;
bufferpointer->info_nave.xPrec = bufferpointer->info_nave.x;
bufferpointer->info_nave.x = LINES / 2;
statoGioco = -1;
}
}
else
if(valore_letto.c == "o")
{
if (collisione_alieni(valore_letto.index))
{
punteggio += puntiKiller;
nAlieni--;
if(nAlieni == 0) statoGioco = 0;
valore_letto.c = " ";
}
}
else
if(valore_letto.c == " ")
{
if(collisione_nave(valore_letto.index))
{
bufferpointer->vitaNave--;
bufferpointer->info_nave.xPrec = bufferpointer->info_nave.x;
bufferpointer->info_nave.x = LINES / 2;
statoGioco = -1;
valore_letto.c = "^";
}
}
move(valore_letto.yPrec, valore_letto.xPrec);
printw(" ");
move(valore_letto.y, valore_letto.x);
printw("%s",valore_letto.c);
move(0,0); // colloca nelle coordinate 0,0 il punteggio
printw("Punteggio %d",punteggio);
move(0,15);
printw("\tlivello %d",livello);
move(0,27);
printw("\tvite %d",bufferpointer->vitaNave);
move(1,0);
printw("nAlieni %d",nAlieni);
refresh();
}
while (statoGioco > 0 && !bufferpointer->esci);
if(statoGioco == -1) //vita persa
{
move(COLS - 10, 0);
printw("Vita Persa!!!!");
refresh();
usleep(1000000);
move(COLS - 10, 0);
deleteln(); //cancella vita persa
insertln();
move(bufferpointer->info_nave.y, bufferpointer->info_nave.x);
printw(" ");
refresh();
}
else if(statoGioco == 0)
{
livello++;
nAlieni = N_INIZIALE_ALIENI;
crea_proc(0, nAlieniRiga);
}
}
while(bufferpointer->vitaNave > 0 && !bufferpointer->esci);
shmdt (bufferpointer);
shmctl (buffer_id, IPC_RMID , NULL );
}
bool collisione_alieni(int index)
{
int i;
int status;
for(i=0; i< N_INIZIALE_ALIENI; i++)
{
Lock_Wait(mutex);
if(bufferpointer->bombe_nave[index].x == bufferpointer->info_alieno[i].x && bufferpointer->bombe_nave[index].y == bufferpointer->info_alieno[i].y && bufferpointer->vitaAlieni[i] && bufferpointer->vitaBombeNave[index])
{
bufferpointer->vitaAlieni[i] -= 1;
bufferpointer->vitaBombeNave[index] -= 1;
if (bufferpointer->vitaAlieni[i] == 0)
{
kill(bufferpointer->info_alieno[i].pid, 1);
}
if (bufferpointer->vitaBombeNave[index] == 0)
{
kill(bufferpointer->bombe_nave[index].pid, 1);
}
return true;
}
Unlock_Signal(mutex);
}
return false;
}
bool collisione_nave(int index)
{
return(bufferpointer->bombe_alieno[index].x == bufferpointer->info_nave.x && bufferpointer->bombe_alieno[index].y == LINES - 1);
}
void crea_proc(int n, int nAlieniRiga)
{
int i,j;
i = n % nAlieniRiga;
j = (n / nAlieniRiga) + 1;
switch(fork())
{
case -1: printf("Errore nell'esecuzione della fork");
case 0: alieni(n, i, j);
break;
default:if (n < N_INIZIALE_ALIENI - 1)
crea_proc(n + 1, nAlieniRiga);
}
}
void scrittore(struct pos *posizione, struct pos item)
{
Lock_Wait(empty);
Lock_Wait(mutex);
bufferpointer->info_elementi[bufferpointer->in] = posizione;
*posizione = item;
bufferpointer->in = (bufferpointer->in + 1) % BUFFER_DIM;
Unlock_Signal(mutex);
Unlock_Signal(full);
}
void lettore(struct pos *item)
{
Lock_Wait(full); //Segnala che è stata letta una posizione dal buffer
Lock_Wait(mutex);
*item = *bufferpointer->info_elementi[bufferpointer->out];
bufferpointer->out = (bufferpointer->out + 1) % BUFFER_DIM;
Unlock_Signal(mutex);
Unlock_Signal(empty);
}
int dimAlieni = 1;
int main()
{
union semun arg1, arg2; // argomento per semctl per indicare il valore del semaforo
int i;
initscr();
noecho();
curs_set(0);
// creazione semaforo empty //
if ((empty = semget(empty_t, 1, IPC_CREAT | IPC_EXCL | WMODE)) == (-1))
printf("Errore semaforo empty\n");
// inizializzazione del semaforo empty con la dimensione del buffer //
arg1.val = BUFFER_DIM;
semctl (empty, 0, SETVAL, arg1);
// creazione semaforo full //
if ((full = semget(full_t, 1, IPC_CREAT | IPC_EXCL | WMODE)) == (-1))
printf("Errore semaforo full\n");
// inizializzazione del semaforo full a zero //
arg2.val = 0;
semctl (full, 0, SETVAL, arg2);
// creazione del mutex //
mutex=MutexCreate(mutex_t);
mutexBombeNave = MutexCreate(mutex_nave);
mutexBombeAlieni = MutexCreate(mutex_alieni);
// creazione della memoria condivisa per il buffer //
buffer_id = shmget ( IPC_PRIVATE , sizeof(struct BUF) , IPC_CREAT | IPC_EXCL | WMODE ); /* Ottiene l'ID della Shared memory */
bufferpointer=(struct BUF *) shmat ( buffer_id , NULL , 0) ; // Attachment al buffer condiviso
Lock_Wait(mutex);
bufferpointer->in = 0;
bufferpointer->out = 0;
bufferpointer->vitaNave = 3;
for(i = 0;i < N_INIZIALE_ALIENI; i++)
bufferpointer->vitaAlieni[i] = 1;
bufferpointer->posDisponibileAlieno = 0;
bufferpointer->posDisponibileNave = 0;
bufferpointer->nBombeNaveResidue = MAX_BOMBE_NAVE;
bufferpointer->nBombeAlienoResidue = MAX_BOMBE_ALIENO;
Unlock_Signal(mutex);
shmdt(bufferpointer);
int nAlieniRiga = COLS / (dimAlieni + SPAZIO);
pid_t pid;
int status; // conterra' lo stato
crea_proc(0, nAlieniRiga);
switch(fork()){
case 0:nave();
break;
default:controllo();
break;
}
SemRemove(empty);
SemRemove(full);
SemRemove(mutex);
SemRemove(mutexBombeNave);
SemRemove(mutexBombeAlieni);
clear();
endwin();
wait(&status);
exit(0);
}