[C/C++] Battaglia Navale in C

[P8257 WebMaster]

Infatti (Y)...

ora manca solo il problema dei tasti funzione..

forza dai, che si risolve con 1 riga di codice...

Bye

[Alhazred]

Devo lasciarli così oppure anche questi sono da cambiare?
Sto considerando solo i tasti che introdurrebbero un carattere valido per l'input

case(0+65): break;
case(0+66): break;
case(0+67): break;
case(0+68): break;
case(0+69): break;
case(0+70): break;
case(0+71): break;
case(0+72): break;
case(0+73): break;
case(0+74): break;

[P8257 WebMaster]

Alh, una sola riga di codice basta e avanza...

Dunque: abbiamo detto che la getch ritorna 2 cose durante la pressione del tasto funzione... la prima cosa è zero... la seconda è un carattere...

Quindi, se incontriamo zero vuol dire che l'utente ha premuto un tasto funzione, in quel caso eseguiamo una getch() supplementare per "buttare via" il valore che non ci interessa e il gioco è fatto...

case 0: getch();

(senza il break)

Inoltre un appunto:
ci sono troppi 'break' dopo il default.. ne basta uno solo in quanto il codice sotto la chiusura dell'else viene comunque eseguito ...

Bye

[Alhazred]

E io che continuavo a pensare a come fa accorgere al getch() che gli venivano restituiti 2 valori , ero totalmente fuori srtada, stavo diventando pazzo.
Questa parte di codice va bene oppure c'è qualcosa da cambiare? L'ho scritto così però ho qualche dubbio, è quello che converte l'input in maiuscolo all'interno di UserInput()

...
   char *Buff;
   char Current = ' ';
   char provvisorio[2];
   char *definitivo;

   Buff = (char *) malloc((max + 1));
   definitivo = (char *) malloc((max + 1));
   Buff[0] = '\0';
   definitivo[0] = '\0';

   while(EndInput)
   {
       provvisorio[Count3] = getch();
       strcpy(definitivo, strupr(provvisorio));
       definitivo[Count3 + 1] = '\0';
       Current = definitivo[Count3];
...

[P8257 WebMaster]

Potresti inserire in Allowedch anche i caratteri minuscoli, di modo che l'utente possa digitarli alla fine bastano queste 2 linee nel default nel caso in cui max sia uguale a 1

printf("%c", toupper(Current));
Buff[Count2] = toupper(Current);

Pensa sempre alla cosa più semplice ..

Bye

[LoryOne]

Analizziamo il programma che ho postato e leggermente modificato dal Web:

char c;

    printf("Premi un tasto. Escape termina il programma\n");
    while(c!=27){
		c=getch();
    ....
    .....
    {

Con questa porzione di codice impongo al compilatore di eseguire le istruzioni racchiuse nelle parentesi graffe fino a che il codice ASCII del tasto premuto non sia uguale a 27 (ovvero il tasto Escape).

Nel momento in cui io premo un tasto, il suo codice ASCII viene immesso nel buffer della tastiera che altro non è che un contenitore preposto alla memorizzazione di sequenze di tasti.
Il buffer della tastiera è in parole povere una memoria temporanea atta a contenere un certo numero di pressioni di tasti per non perdere la sequenza digitata, qualora le prorità di processo non consentano momentaneamente la visualizzazione del testo immesso.
Vi è mai capitato di non riuscire a vedere in tempo reale sul monitor la corretta sequenza digitata mentre il PC è impegnato a fare qualcos'altro per poi magicamente veder apparire la sequenza corretta ?
In questo caso dovete dire grazie al buffer.
Esso però non è così capiente e come tutte le momorie riutilizzabili deve essere svuotato prima di venir riempito nuovamente.

Non tutti i tasti presenti sulla tastiera si comportano nello stesso modo.
Alcuni agiscono sul buffer riempiendolo con un solo codice, altri vengono definiti con un valore+un codice ASCII scelto tra quelli stampabili, operazione questa che consente di renderli speciali e quindi riconoscibili dai comuni (che per intenderci sono numeri, punteggiatura e lettere).

Nel programmino che ho postato sono riconoscibili ben 2 tipologie di tasti:
I tasti funzione da F1 a F10 ed altri tasti aggiuntivi F11,F12,PgUp,PgDwn,Canc,Ins,Fine,ecc che nel corso degli anni sono stati aggiunti per facilitare alcune operazioni con la loro semplice pressione.
Risulta ovvio, quindi, che un programmatore debba essere in grado di riconoscere la tipologia del tasto premuto e comportarsi di conseguenza.

Eseguendo il programma e premendo diversi tasti, il programma stesso mostra con quali codici venga riempito il buffer durante la digitazione.
Se i tasti sono quelli comuni, non v'è bisogno di un codice aggiuntivo che specifichi a quale tipologia appartenga quel tasto ma le cose cambiano quando ci si trova a dover gestire i tasti funzione.
La pressione di F1, genera una sequenza pari a 0+59.
Questo significa che nel buffer vi sono 2 caratteri, non uno.
La stessa cosa dicasi per PgUp, anche se il primo valore non è 0 ma -32.

Se tentassimo ora di immaginare il buffer come una serie di celle una di seguito all'altra, avremmo bisogno di due celle per identificare il tasto funzione f1, ossia:

Cella1|Cella2
  0      59

mentre per un qualsiasi tasto comune ne basterebbe una sola.

Se si provasse ora ad eseguire questo piccolo programmino

#include <stdio.h>
#include <conio.h>

main(void){
    char c;

    printf("Premi un tasto. Escape termina il programma\n");
    while(c!=27){//Escape termina il programma
        c=getch();
        printf("%i",kbhit());
    }    
}

si avrebbe come risultato 0 se il tasto premuto fosse un tasto comune, mentre 10 se non lo fosse.
Attenzione perchè 10 non vale 10 (dieci) ma sta a significare che la prima cella è un carattere speciale e la seconda no.

[P8257 WebMaster]

Esattamente.. (Y)

ed aggiungo che se la lettura dal buffer avviene tramite una funzione che, come 'getch()' ne prelevi il contenuto carattere per carattere, essa, in presenza della pressione di un tasto che riempia più di una "cella" nel buffer, restituirà in primis il codice della prima cella e poi via via tutti i successivi ...

Questo vuol dire che le chiamate a getch nel programma saranno ricorsive ed immediate finché il buffer non è vuoto .. il che si traduce nell'impossibilità dell'utente ad inserire ulteriori caratteri nel buffer finché la funzione non li abbia estratti... è per questo motivo che nella battaglia navale c'é una chiamata a 'getch()' il cui risultato (valore superluo derivante da pressione di tasti 'speciali') viene scartato...

Bye

[LoryOne]

Una visione del codice che esplica il concetto:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>

char *UserInput(int);

char *UserInput(int max){
    char c,*Buff;
    short int i=0,vmin,vmax;
    
    switch(max){
        case 1:vmin='A';vmax='J';break;
        case 2:vmin='0';vmax='9';
    }    
    Buff=(char*)malloc(max+1);
    while(c!=13){
        c=toupper(getch());
        if(c==0||c==-32) getch();
            switch(c){
                case 8:
                    if(i>0){
                        i--;
                        printf("\b%c\b",32);
                    }break;
                default:
                    if(c>=vmin&&c<=vmax&&i<max){
                        printf("%c",c);
                        Buff[i]=c;
                        i++;
                    }    
            }    
    }Buff[i]='\0';    
    return Buff;
}   
 
main(void){
    char *c;
    
    printf("\n%s",UserInput(2));
    getch();
}

Ehi Web questa sera anche tu casalingo ?

Edito: Mi sono dimenticato le due graffe nella gestione del tasto backspace.
Devo ricordarmi di non scrivere codice alle 21:30 e dintorni. Ho già sonno

[P8257 WebMaster]

LoryOne ha scritto:

Ehi Web questa sera anche tu casalingo ?

Eh si .. .. tutti in vacanza .. ma tra poco anch'io ...

Bye

[Alhazred]

L'ho modificato così:

char * UserInput(int max) {
   BOOL EndInput = TRUE;
   unsigned int Count;
   int Count2 = 0, Count3 = 0, cursore = 0;
   char AllowedCh[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', '\0'};
   char AllowedNum[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '\0'};
   char *Buff;
   char Current = ' ', provvisorio = ' ';

   Buff = (char *) malloc((max + 1));
   Buff[0] = '\0';

   while(EndInput)
   {
       provvisorio = getch();
       Current = toupper(provvisorio);
       switch(Current)
...

[LoryOne]

Un metodo spiccio per verificare la presenza di un valore in un range senza ricorrere a for e break

#include <stdlib.h>
#include <memory.h>
#include <conio.h>

main(void){
    char d,c[]={'A','C','E'};
    
    printf("Premi un tasto.\n");
    d=getch();
    printf((memchr(c,d,sizeof(c)/sizeof(char))?"Incluso":"Non incluso"));
}

[P8257 WebMaster]

Beh, se è per questo allora c'é anche la 'strchr'...

@Alh: la variabile d'appoggio 'provvisorio' è inutile.. usa toupper(getch()) direttamente su 'Current' prima dello switch....

Bye

[Alhazred]

Già fatto

[Alhazred]

Ecco la nuova versione di UserInput()

char * UserInput(int max) {
   BOOL EndInput = TRUE;
   int Count2 = 0, Count3 = 0, cursore = 0;
   char AllowedCh[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', '\0'};
   char AllowedNum[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '\0'};
   char *Buff;
   char Current = ' ';

   Buff = (char *) malloc((max + 1));
   Buff[0] = '\0';

   while(EndInput)
   {
       Current = toupper(getch());
       switch(Current)
       {
          case 13: if(Count2 == 0);
                   else
                   {
                        EndInput = FALSE;
                        Buff[Count2] = '\0';
                        break;
                   }

          case 8: Buff[Count2] = '\0';
                  if(cursore > 0)
                  {
                    printf("\b \b");
                    Count2--;
                    Buff[Count2] = '\0';
                    cursore--;
                  }
                  break;

          /*esclusione tasti funzione*/
          case(0): getch();

          default: if(max == 1)
                   {
                       if(strchr(AllowedCh,Current) != NULL && (Count2 < max))
                       {
                            printf("%c", Current);
                            Buff[Count2] = Current;
                            Count2++;
                            cursore++;
                       }
                   }
                   else
                   {
                       if(strchr(AllowedNum,Current) != NULL && (Count2 < max))
                       {
                            printf("%c", Current);
                            Buff[Count2] = Current;
                            Count2++;
                            cursore++;
                       }
                   }
       }
   }
   return Buff;
} //End UserInput

il codice aggiunto a case 13: mi serve per fare in modo che premendo invio come primo tasto non succeda nulla invece di passare ad esempio da colonna_ a riga_ senza inserire niente in input e dovermi far chiedere di nuovo le coordinate per la stessa nave o lo stesso colpo.

[P8257 WebMaster]

Bene (Y)...

Ma gira la condizione del case 13 dai .. .. ti risparmi una linea di codice.

Bye