Newsgroup: it.comp.os.linux.development
Titolo: battaglia navale

ciao a tutti, ho un problema, non riesco a risolvere questo problema
su questo gioco fatto da me in c con l'utilizzo di memoria condivisa e
semafori per la sincronizzazione.
Vi espongo il problema:
il gioco e' la battaglia navale, due processi si inviano le mosse
tramite shared memory, se invio la mossa sbagliata il programma mi da
in output "non colpito" e passa il controllo all'altro processo; nel
momento in cui inserisco la mossa esatta mi stampa "colpito" e vanno
in blocco i due processi.mi date una mano a risolvere il problema?sono
disperato devo consegnare questo lavoro lunedi' e solo voi mi potete
aiutare.grazie mille alessandro.
vi allego il codice cosi' potete compilarlo e eseguirlo.
dovete avviare lo stesso eseguibile in due shell diverse:
#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>
char *p, a, b, c, d, e, f;
  int des_shm, s1, s2,set1,set2,rimuovi,ops1,ops2,n;
  char *barche[6];
  short numproc;
void installaStrutture(){
 des_shm = shmget(50, 10000, IPC_CREAT|0666);
   if (des_shm==-1)puts("errore nella chiamata nella creazione della
memoria condivisa");
 s1 = semget(60, 1,IPC_CREAT|0666);
   if(s1==-1)puts("errore nella crezione del semaforo s1");
 s2 = semget(70, 1,IPC_CREAT|0666);
   if(s2==-1)puts("errore nella creazione del semaforo s2");
   p = shmat(des_shm, NULL, SHM_R|SHM_W);
   if(p==(char*)-1)puts("errore nel collegamento alla memoria
condivisa");
}
void riempiArray(){
  barche[0]=&a;
  barche[1]=&b;
  barche[2]=&c;
  barche[3]=&d;
  barche[4]=&e;
  barche[5]=&f;
   printf("digitare la coordinata della barca:\n");
   scanf("%s",barche[1]);
   printf("digitare la coordinata della barca:\n");
   scanf("%s",barche[2]);
   printf("digitare la coordinata della barca:\n");
   scanf("%s",barche[3]);
   printf("digitare la coordinata della barca:\n");
   scanf("%s",barche[4]);
   printf("digitare la coordinata della barca:\n");
   scanf("%s",barche[5]);
}
void algoritmoPartita1(){
struct sembuf wait;
wait.sem_num = 0;
wait.sem_op = -1;
wait.sem_flg = 0;
struct sembuf signal;
signal.sem_num = 0;
signal.sem_op = 1;
signal.sem_flg = 0;
  char vittoria;
  char contenuto1;
  int colpiti1;
  colpiti1=0;
  puts("sei il primo giocatore");
  set1 = semctl(s1, 0, SETVAL, 0);
  if(set1==-1)puts("errore nel settaggio del valore del semaforo s1");
  set2 = semctl(s2, 0, SETVAL, 0);
  if(set2==-1)puts("errore nel settaggio del valore del semaforo s2");
  while((strcmp(&vittoria,"partitafinita")!=0)){
   strcpy(&contenuto1,p);
      if(strcmp(&contenuto1,"partitafinita")==0){
      puts("hai perso");
      rimuovi=semctl(s1,0,IPC_RMID);
      exit(0);
      }
    puts("digita la mossa(2 lettere):");
    scanf("%s",&contenuto1);
    strcpy(p,&contenuto1);
    ops2 = semop(s2,&signal,1);
    ops1 = semop(s1,&wait,1);
    strcpy(&contenuto1,p);
    if(strcmp(&contenuto1,"colpito")==0){
      puts("colpito");
      colpiti1++;
      if(colpiti1==5){
	strcpy(&vittoria,"partitafinita");
	strcpy(p,"partitafinita");
	puts("hai vinto");
	ops2 = semop(s2,&signal,1);
        rimuovi=semctl(s1,0,IPC_RMID);
	exit(0);
      }
    }
     else puts("non colpito");
    ops2 = semop(s2,&signal,1);
    ops1 = semop(s1,&wait,1);
    strcpy(&contenuto1,p);
    int j;
    for(j=0; j<6; j++){
      if(strcmp(&contenuto1,barche[j])==0){
	strcpy(p,"colpito");
	barche[j]=NULL;
      }
    }
      ops2 = semop(s2,&signal,1);
      ops1 = semop(s1,&wait,1);
    }
  }
void algoritmoPartita2(){
struct sembuf wait;
wait.sem_num = 0;
wait.sem_op = -1;
wait.sem_flg = 0;
struct sembuf signal;
signal.sem_num = 0;
signal.sem_op = 1;
signal.sem_flg = 0;
  char vittoria;
  char contenuto2;
  int colpiti2;
  colpiti2=0;
  puts("sei il secondo giocatore");
  while((strcmp(&vittoria,"partitafinita")!=0)){
    ops2 = semop(s2,&wait,1);
    strcpy(&contenuto2,p);
    int j;
    for(j=0; j<6; j++){
      if(strcmp(&contenuto2,barche[j])==0){
	strcpy(p,"colpito");
	barche[j]=NULL;
      }
    }
    ops1 = semop(s1,&signal,1);
    ops2 = semop(s2,&wait,1);
    strcpy(&contenuto2,p);
    if(strcmp(&contenuto2,"partitafinita")==0){
      puts("hai perso");
      rimuovi=semctl(s2,0,IPC_RMID);
      exit(0);
    }
    puts("digita la mossa (2 lettere):");
    scanf("%s",&contenuto2);
    strcpy(p,&contenuto2);
    ops1 = semop(s1,&signal,1);
    ops2 = semop(s2,&wait,1);
    strcpy(&contenuto2,p);
    if(strcmp(&contenuto2,"colpito")==0){
      puts("colpito");
      colpiti2++;
       if(colpiti2==5){
	strcpy(p,"partitafinita");
	puts("hai vinto");
        ops1 = semop(s1,&signal,1);
        rimuovi=semctl(s2,0,IPC_RMID);
	exit(0);
       }
       else puts("ciao");
       }
    else puts("non colpito");
     ops1 = semop(s1,&signal,1);
  }
}
int main(){
 
struct shmid_ds mem;
 
installaStrutture();
 
 riempiArray();
int k;
  for(k=1;k<6;k++){
    printf("%s\n",barche[k]);
  }
  n = shmctl(des_shm, IPC_STAT,&mem);
  if(n==-1)puts("errore nella chiamata shmctl");
  numproc = mem.shm_nattch;
 
if(numproc==1){
    algoritmoPartita1();
    }
 else if(numproc==2){
    algoritmoPartita2();
    }
 else{
   puts("partita gia iniziata");
   exit(3);
 }
  exit(0);
}



 semafori per la sincronizzazione.
ma sono compiti o una tesina?
A me ne hanno fatta fare una cosě :)

si sarebbe la tesina per un esame di sistemi operativi I, e' un esame
di ingegneria...ti incollo la specifica cosi' male che va mi passi la
tua cosi' risolvo...ciao e grazie
Battaglia Navale (versione peer-to-peer) 
 
Realizzazione di una versione elettronica del famoso gioco "Battaglia 
Navale". In questa versione due processi (ognuno dei quali funge da 
interfaccia con uno dei due giocatori) cooperano tra loro. Per prima 
cosa decidono la posizione delle navi e quale dei due processi deve 
iniziare (i meccanismi di decisione su quale sia il prio processo ad
effettuare
una mossa sono lasciati alla discrezione 
dello studente), poi il processo iniziale accetta come input una
mossa,
la trasmette al secondo processo, aspetta che il secondo processo
comunichi
l'esito della mossa, e si pone in attesa di una mossa da parte del
secondo
processo. Entrambi i processi ogni volta che ricevono una mossa o
l'esito
di una mossa dal processo avversario, valutano se l'avversario ha
colpito,
valutano se qualcuno ha vinto e lo riferiscono al loro giocatore. Il
canale
di comunicazione tra i due processi deve essere implementato tramite
l'uso
di memoria condivisa.

 
[CUT]
scusa se mi permetto ma non si capisce niente...
magari commentare un po' o perlomeno spiegare all'utente che sta 
succendendo.... nemmeno lanciandolo si capisce ce sta succedendo...
l'ingegneria del sw avrebbe dovuto insegnarti a scrivere buon codice nel 
senso di leggibile...
magari commenta che riesco a dargli un'occhiata come si deve...
-- 
eminux
Linux Registered User #380522
--------------------------------------------------
Coltiva linux, che tanto win si pianta da solo....