Gioco C++

[ltmlmotig]

un tic-tac-toe è facilmente realizzabile anche se lungo, la parte più difficile è quella relativa alla intelligenza artificiale del programma ( capire che mettendo il cerchio o la croce in un determinato punto vince / blocca il tuo )

[trallallero]

Originariamente inviato da ltmlmotig

un tic-tac-toe è facilmente realizzabile anche se lungo, la parte più difficile è quella relativa alla intelligenza artificiale del programma ( capire che mettendo il cerchio o la croce in un determinato punto vince / blocca il tuo )

è stato il primo programma che ho fatto da solo in C col mitico Borland Turbo C++ e non mi è stato difficile implementare la logica. Secondo me non c'è bisogno di intelligenza artificiale (non ne sarei stato e non ne sarei capace) perchè son talmente poche le mosse che le puoi mettere benissimo in una serie di if

[HipT]

Ci stavo propio pensando ieri di fare una specie di Tris con allegro
Il problema era appunto far "capire" al computer dove mettere la croce con un po' di senso non mettendole a caso .
Pero' trallalero adesso che mi ci fai pensare hai ragione,le mosse sono poche,anche se le mette sensa senso...
Grazie

[ltmlmotig]

Originariamente inviato da trallallero

è stato il primo programma che ho fatto da solo in C col mitico Borland Turbo C++ e non mi è stato difficile implementare la logica. Secondo me non c'è bisogno di intelligenza artificiale (non ne sarei stato e non ne sarei capace) perchè son talmente poche le mosse che le puoi mettere benissimo in una serie di if

in effetti, lavorando su una matrice, basta (semplificando):

per ogni croce del giocatore umano
- controllare le caselle adiacenti (uno o due controlli) sulle diagonali - ascisse - ordinate
- SE è presente un'altra croce, e il pc NON ha la possibilità di vincere subito,
blocca la mossa ( metti il cerchio )
..

e una parte di codice simile relativa alle mosse non di difesa ma di "attacco"

[HipT]

E' quello il problema,bloccare la mossa.Oggi in corriera mentre tornavo da suola ci pensavo.Ditemi se mi sono complicato troppo le cose Pensavo ad una cosa del tipo:
-data la distanza tra il centro di una casella e l'altra se la distanza tra una croce del giocatore e l'altra è minore di questa (praticamente è attaccata) allora deve bloccare la mossa,ma come?Allora pensavo di fare tipo:
-Se deve bloccare le caselle adiacenti agli assi non c'è problema perchè basta che posizioni un cerchio del computer alla somma delle coordinate x O y.
-Se sta' in diagonale pensavo alla cosa un po' + complessa.
Praticamente calcola la diagonale (dove mettere il cerchio) usando ilteorema di pitagora così:
trova la diagonale del primo triangolo e del secondo,somma le diagonali e trovando la coordinata di dove mettere il cerchio.
Ho messo in allegato un'immagine (fatta con paint ) di come calcolerebbe dove mettere il cerchio nella diagonale.

E' una soluzione?
Grazie.
Ciao!

[cionci]

Guarda ci sono tanti tipi di soluzioni...ottimali e non ottimali.

Se ne vuoi una ottimale:

- il gioco si esplora tutte le possibili mosse successive che potrebbero essere generate dal posizionamento del segno in una cella e si sceglie la mossa corrente come quella genera meno possibilità di vincere al concorrente. In questo modo è impossibile perdere
- definisci dei pattern (possono essere derivati anche dal calcolo sopra): con i segni in delle date posizioni lui ha già preimpostato dove mettere il segno. I pattern non sono tanti anche considerando le simmetrie (infatti si riducono ad un quarto del totale ruotando il campo di gioco). Non occorre confrontare cella per cella con il pattern, ma basta farsi un calcolo abbastanza semplice (da studiare) per riepilogare le posizioni attuali tramite un numero (ad esempio potrebbe essere un numero a 9 cifre in base 3 - vuoto, X o O). Poi converti il campo di gioco in questa cifra (una conversione ruotando ogni volta il campo di gioco di 90°) e poi ti vai a vedere nella lista dei pattern se ce n'è uno corrispondente a questa posizione (anche i pattern saranno identificati con il numero che li rappresenta). Nota che se i pattern sono esaustivi allora anche qui è impossibile perdere.

Non ottimale:

- se ci sono due segni avversari su una colonna o su una riga più una cella libera, posiziona il segno nella cella libera, altrimenti posizioni il segno in una cella a caso. Qui il computer può perdere.

[HipT]

Hem meglio la prima o la terza,sia perchè il computer può perde Sia perchè non ho capito la seconda soluzione
Probabilmente non sono abbastanza preparato per quella
Una domanda,nella prima soluzione,per fare il controllo di ogni mossa devo inserire degli if annidati?
Grazie.
Ciao!

[cionci]

No dovresti fare una ricorsione fino ad arrivare alla conclusione della partita esplorando tutte le possibili posizioni...probabilmente è un po' lunghetto...

Ad esempio in pseudo codice:

vittoria(caselle)
{
  se ci sono tre segni uguali nella stessa riga o colonna
    ritorno vero
  altrimenti 
    ritorno falso
}

esplora_soluzioni(caselle)
{
   vittorie_avversario = 0
   per ogni casella libera in caselle
   {
     posiziono il segno dell'avversario nella casella libera
     se vittoria(caselle) = vero
        vittorie_avversario++
     altrimenti
      {
          per ogni casella libera in caselle
          {
              posiziono il mio segno nella casella libera
              se vittoria(caselle) = falso
                  vittorie_avversario += esplora_soluzioni(caselle)
          }
      }
   }
   return vittorie_avversario
}

Per sapere dove posizionare il mio segno:

 
   vittorie_min = INT_MAX
   prossima_casella
   per ogni casella libera in caselle
   {
       posiziono il mio segno nella casella libera
       vittorie = esplora_soluzioni(caselle);
       elimino il mio segno dalla casella libera
       se vittoria < vittoria_min
       {
           prossima_casella = casella libera
           vittoria_min = vittoria
       }
   }

    posiziono il mio segno nella prossima_casella

[ltmlmotig]

esatto.

[HipT]

Ho un problema,è da circa 2 ore che cerco di fare la presentazione iniziale.
Praticamente dato che con allegro non posso caricare le gif mettevo in successione una serie di BMP (lo so' son pesantissime! ).
Avevo deciso di inserirci un "timer" (al raggiungimento ti TOT cicli fai...) ma o restava sermpre caricato il primo fotogramma oppure continuavano a cambiare ad una velocità assurda
I fotogrammi sono 9.Ma per fare la prova ho iniziato con 2.
Posto il codice

#include "allegro.h"
#include "stdio.h"
BITMAP *buf,*intro_1,*intro_2;
int timer,go,gos;
PALETTE colori;
void doppiobuffering()
{
     vsync();
     blit(buf,screen,0,0,0,0,1280,1024);
     clear(buf);
}
void presentazione()
{
     if (go==1)
     {
               while(!key[KEY_SPACE])
               {
                                     if (gos==0)
                                     {
                                               blit(intro_1,screen,0,0,0,0,1280,1024);
                                               gos=1;
                                               if (gos==1)
                                               {            
                                                   timer++; 
                                                   if (timer>100)
                                                         {
                                                                 blit (intro_2,screen,0,0,0,0,1280,1024);
                                                                 gos=2;
                                                         }
                                                   
                                               }
                                     }
              }
     }
}
int main()
{
    allegro_init();
    install_keyboard();
    set_palette(colori);
    set_gfx_mode(GFX_AUTODETECT,1280,1024,0,0);
    buf=create_bitmap(1280,1024);
    intro_1=load_bmp("img/intro/intro_1.bmp",colori);
    intro_2=load_bmp("img/intro/intro_2.bmp",colori);
    timer=0;
    go=1;
    clear (buf);
    while(!key[KEY_ESC])
          {
                           doppiobuffering();
                           presentazione();
                      
          }
          
    destroy_bitmap(buf);
    destroy_bitmap(intro_1);
    destroy_bitmap(intro_2);
}
END_OF_MAIN();

GOS serve per non far ripetere un'immagine.
Timer per aspettare prima della prossima visualizzazione.
Il problema è che se metto "if (timer>100)" si vede solo il primo.Se metto "if (timer=100)" invece visualizza subito il secondo (appena premo compila,senza darmi il tempo di vedere il 1°).Ma questo vuol dire che per 100 c'è passato,perchè allora non
non lo visualizza nel primo modo?
Come faccio a fare un timer che praticamente dopo 2 secondi visualizzi il fotogramma successivo?

Ps:Sulla guida che ho usato per fare il primo,c'è usato questo tipo di "timer",incrementava timer finchè non arrivava a 100 per tener visualizzata un'immagine.
P-Ps: lo so' che le BMP sono pesanti pero' non posso visualizzare gif con allegro,almeno credo.
Grazie per tutto.
Ciao!

[HipT]

mmm.Ho cercato e ho trovato questa libreria da agigungere ad allegro per caricare le gif (comprese le animazioni .gif) al posto delle BMP.
Il problema è che non riesco a installarle
Su questo sito nella sezione HOW TO USE dicono comne installarle.
Voi capite cosa bisogna fare?
dove devo aggiungere le due stringhe per compilare il progetto?
Se io compilo un file con #include <algif.h>
mi dice che non trova la libreria.
Grazie