C/C++ - Progetto Scacchiera gioco cani e gatti

Forum - C/C++ - Progetto Scacchiera gioco cani e gatti - Pagina 2

Pagine: [ 1 2 3 ]

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 18:43
Lunedì, 16/02/2015

pseudocodice non ne so scrivere (o meglio, non riusciresti a capirlo probabilmente) quindi te lo scrivo in qualcosa di molsto simile al C

Codice sorgente - presumibilmente C++

for (int i = 0; i < COLONNE_SCACCHIERA; i++)
    for (int j = 0; j < RIGHE_SCACCHIERA; j++)
        if (scacchiera[i][j] == CANE)
        {
            for (int a = 0;a < COLONNE_SCACCHIERA; a++)
            {
                int distanza_minore = MAX_INT;
                int colonna_gatto_piu_vicino = -1;
                int riga_gatto_piu_vicino = -1;
                if (scacchiera[a][b] == GATTO)
                {
                    int distanza_cane_attuale_da_gatto_attuale = .............;
                    if (............)
                    {
                     .......................
                    }
                }
            }
        }

Dovresti aver capito ora, no?

tonyleone (Normal User)
Newbie

Messaggi: 12
Iscritto: 15/02/2015

Postato alle 19:44
Lunedì, 16/02/2015

Ora mi è più chiaro , domani riprovo a mettere tutto insieme , ti ringrazio infinitamente , non sai quante difficoltà per sostenere questi esami .. hai un recapito sul quale posso disturbarti in caso di problemi ? Non so skype o qualcosa del genere visto che sei l'unico che mi sta aiutando , ti ringrazio ancora

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 20:47
Lunedì, 16/02/2015

Sono contro a queste cose: questo è un problema che potrebbero avere altre persone, se io ti rispondessi in privato le persone che in futuro avranno questo problema non avranno una risposta. Quanto ti darebbe fastidio trovare un thread di 3 anni fa con il tuo problema, leggere che è stato risolto privatamente e che l'unica cosa che hai è una email che probabilmente non viene più controllata?

tonyleone (Normal User)
Newbie

Messaggi: 12
Iscritto: 15/02/2015

Postato alle 17:31
Martedì, 17/02/2015

Ok perdonami allora , era per rendere il tutto più veloce , ovviamente alla fine avrei postato il risultato finale senza alcuni problemi , sto lavorando a ciò che mi hai spiegato tu , entro stasera spero di riuscire a postare i risultati

tonyleone (Normal User)
Newbie

Messaggi: 12
Iscritto: 15/02/2015

Postato alle 20:10
Martedì, 17/02/2015

Altra domanda : conviene usare le struct ?

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 21:19
Martedì, 17/02/2015

Dove e per cosa? Alla fine se usi una struct non risparmi spazio, aumenti la chiarezza. Se hai bisogno o vedi che ti conviene usare un nuovo tipo usi una struct.

Non è solo questione di risultato: la conversazione può includere risposte a domande esempio quella sulle struct. Se avessi postato solo il risultato finale la domanda sulle struct e la sua risponsta non sarebbero di dominio pubblico, e una persona con lo stesso problema che si sarebbe chiesta "conviene usare le struct ?" non avrebbe avuto una risposta. Comunque in privato non sono più veloce a rispondere, anzi......

tonyleone (Normal User)
Newbie

Messaggi: 12
Iscritto: 15/02/2015

Postato alle 1:54
Mercoledì, 18/02/2015

Seguendo un algoritmo simile al mio spiegato dal prof sono arrivato a questo punto , purtroppo non riesco nella stesura corretta del codice procedimento spiegato per il calcolo della distanza ..

Codice sorgente - presumibilmente C#

#include<stdio.h>//header file che consente le varie operazioni di input e output
#include<stdlib.h>//header file che consente l'uso di rand, srand e di RAND_MAX
#include<time.h>//fornisce un accesso standardizzato alle funzioni di acquisizione e manipolazione del tempo.
 
#define MAX_SIZE  16//dimensione massima delle righe e delle colonne dell'array2D
 
/*Algoritmo per la simulazione del movimento di un robot in una stanza
La legge con cui il robot si muove è la seguente: nel 30% dei casi il robot si muove
a caso in una delle quattro caselle vicine possibili(parete permettendo); nel 70% dei casi
il robot prima "vede" e individua la direzione(avanti,indietro,sinistra,destra) del movimento
e poi si muove in quella  direzione
*/
 
typedef struct animali {
   int nx;
   int ny;
}robot;
animali r;
 
 
 
 
 
//prototipo di funzioni
void inserisci_cane(char stanza[][MAX_SIZE]);
 
void visualizza_stanza(char stanza[][MAX_SIZE]);
void movimento_casuale(char stanza[][MAX_SIZE]);
void movimento_intelligente(char stanza[][MAX_SIZE]);
int max_array(int arr[]);
 
int main()
{
   int nc;
   char stanza[MAX_SIZE][MAX_SIZE]={' ','',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                              ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                            ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
                           }   ;
   inserisci_cane(stanza);
      
   srand((unsigned int)time(0));
   
   while((r.nx>=0 && r.nx<MAX_SIZE) && (r.ny>=0 && r.ny<MAX_SIZE))//ciclo ripetuto finchè il robot resta all'interno alla stanza
   {
         visualizza_stanza(stanza);
         printf("RIGA=%d\t COLONNA=%d\n",r.nx,r.ny);
         nc=rand()%10;
      if(nc>=0 && nc<3)
         movimento_casuale(stanza);
      else
         movimento_intelligente(stanza);
           system("PAUSE");      
   }
   printf("\nIl robot e' uscito dalla stanza\n");
   visualizza_stanza(stanza);
}
 
/*inserisci_robot: procedura per inserire il robot all'interno della stanza tramite coordinate
input: stanza[][] (array 2D che rappresenta la stanza;servirà per inserire il robot,
sempre se in una certa posizione è possibile)
*/
void inserisci_cane(char stanza[][MAX_SIZE])
{
        srand((unsigned int)time(0));
     
     int i;
       /* Il contatore viene nuovamente azzerato in modo da poterlo riutilizzare.*/
i=0;
    while (i<2)
    {
        r.nx = rand()%16;
        r.ny = rand()%16;
 
 
          stanza[r.nx][r.ny]='G';
         printf("ROBOT inserito nella posizione %d,%d,%d\n",r.nx,r.ny);   
         i++;
}
 
       
       i=0;
       while (i<2)
    {
        r.nx = rand()%16;
        r.ny = rand()%16;
 
 
          stanza[r.nx][r.ny]='C';
         printf("ROBOT inserito nella posizione %d,%d\n",r.nx,r.ny);   
         i++;
        }
 
       
 
}
 
 
/*visualizza_stanza: procedura che visualizza sullo schermo l'intera stanza
input: stanza[][] (array 2D che rappresenta la stanza)
*/
void visualizza_stanza(char stanza[][MAX_SIZE])
{
   int i,j;
      for(i=0;i<MAX_SIZE;++i)
         {   
            for(j=0;j<MAX_SIZE;++j)
               printf("%c",stanza[i][j]);
            printf("\n");
         }
}
 
/*movimento_casuale: procedura che consente al robot di muoversi in maniera casuale
in una delle quattro caselle vicine
input: stanza[][] (array 2D che rappresenta la stanza)
*/
void movimento_casuale(char stanza[][MAX_SIZE])
{
   int nc;
   stanza[r.nx][r.ny]=' ';
   nc=rand()%4;
 
   switch(nc)
   {
      case 0:   r.ny--;   if(stanza[r.nx][r.ny]=='-' && r.ny>=0)r.ny++;        break;//robot verso ovest
      case 1:   r.ny++; if(stanza[r.nx][r.ny]=='-' && r.ny<MAX_SIZE)r.ny--;  break;//robot verso est
      case 2: r.nx--; if(stanza[r.nx][r.ny]=='-')r.nx++;                 break;//robot verso nord
      case 3:   r.nx++;   if(stanza[r.nx][r.ny]=='-')r.nx--;                        //robot verso sud
   }
   if((r.nx>=0 && r.nx<MAX_SIZE) && (r.ny>=0 && r.ny<MAX_SIZE))
      stanza[r.nx][r.ny]='C';   
}
 
/*movimento_intelligente:procedura che conta il numero di caselle libere
in ogni direzione a partire dalla posizione in cui si trova il robot
e sposta il robot scegliendo il percorso possibile più lungo
input:stanza[][] (array 2D che rappresenta la stanza)
*/
void movimento_intelligente(char stanza[][MAX_SIZE])
{
            
   int pos[4]={0},i,j,ind_max;
   /*pos[]   = array di 4 elementi che contiene il numero di caselle libere per ogni direzione
         pos[0]=numero di caselle libere verso ovest
         pos[1]=numero di caselle libere verso est
         pos[2]=numero di caselle libere verso nord
         pos[3]=numero di caselle libere verso sud
     ind_max = indice del massimo. Serve per stabilire (tramite switch) in quale locazione dell'array pos vi è il massimo
   */
      j=r.ny;
        while(stanza[r.nx][j-1]!='-' && j>0)
            {
               --j;
               ++pos[0];//caselle libere ovest
            }
      j=r.ny;
        while(stanza[r.nx][j+1]!='-' && j<MAX_SIZE)
            {
               ++j;
               ++pos[1];//caselle libere est
            }
      i=r.nx;
      while(stanza[i-1][r.ny]!='-' && i>0)
            {
               --i;
               ++pos[2];//caselle libere nord
            }
      i=r.nx;
      while(stanza[i+1][r.ny]!='-' && i<MAX_SIZE)
            {
               ++i;
               ++pos[3];//caselle libere sud
            }
            ind_max=max_array(pos);
            stanza[r.nx][r.ny]=' ';
         switch(ind_max)
         {
            case 0:--r.ny; if(stanza[r.nx][r.ny]=='-') ++r.ny;break;//ovest
            case 1:++r.ny; if(stanza[r.nx][r.ny]=='-') --r.ny;break;//est
            case 2:--r.nx; if(stanza[r.nx][r.ny]=='-') ++r.nx;break;//nord
            case 3:++r.nx; if(stanza[r.nx][r.ny]=='-') --r.nx;      //sud
         }
               stanza[r.nx][r.ny]='C';
}
 
/*max_array:function che restituisce l'indice dell'elemento massimo dell'array che riceve in input
input:arr[] = rappresenta l'array pos, il quale contiene il numero di caselle libere per ogni direzione
*/
int max_array(int arr[])
{
   int i,max=-1,num_max,ind[4];
   /*ind[]    = array che conterrà gli indici di 1 o più massimi
     num_max  = indica quanti massimi ci sono all'interno dell'array arr[]   
   */
      for(i=0;i<4;++i)
         if(arr[i]>max)
            {
               max=arr[i];
               ind[0]=i;//salva l'indice del massimo nella locazione ind[0]
               num_max=1;
            }
         else
            if(arr[i]==max)
            {
               ind[num_max]=i;
               ++num_max;
            }
 
      if(num_max>1)//se num_max>1 ci sono più massimi, quindi viene restituito un indice a caso tra questi
            {
               max=rand()%num_max;
               return ind[max];
            }
      else
            return  ind[0];//se num_max non risulta maggiore di 1 viene restituito l'indice dell'unico max dell'array                        
}

ovviamente le funzioni del movimento casuale e intelligente sono da modificare , sto letteralmente impazzendo :/

tonyleone (Normal User)
Newbie

Messaggi: 12
Iscritto: 15/02/2015

Postato alle 2:09
Mercoledì, 18/02/2015

Visto che viene stampata la posizione (int) non è possibile fare un confronto in base a questa posizione iniziale per stabilire qual'è il più vicino ?

Pagine: [ 1 2 3 ]