Newsgroup: it.comp.lang.c++
Titolo: Algoritmo per gli scacchi.

Ciao a tutti,
  non so se questa richiesta e` OT ma vorrei sapere dove posso trovare 
algoritmi "umani" per il gioco degli scacchi, io programmo in BUILDER 
C++
Grazie.
-- 
Posted from 217.57.247.125 by way of 
smtp2.libero.it
 [193.70.192.52] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 C++
Piu' semplice di quanto tu possa pensare:
#include <chess.h>
....
std::board myBoard;
myBoard.reset();        // inizializza la scacchiera
std::player myPlayer(WHITE, 2);         // Giocatore bianco e livello 2
myBoard.addPlayer(myPlayer);
......
Trovi tutto su qualsiasi libro che parli di GCC 2001 ( odissea nello
spazio ).
Questo newsgroup si occupa del linguaggio C++ in quanto
tale, e non di aspetti specifici di particolari implementazioni. Per
questo non e' il posto piu' adatto per porre domande specifiche come la
tua.
Potresti avere piu' fortuna su uno dei seguenti gruppi:
Per Win32 (95, 98, NT): it.comp.programmare.win32
Per Dos/Win 3.x: it.comp.os.dos
Per Linux:      it.comp.os.linux.development
Per C++Builder: i gruppi borland.public.cppbuilder.*, disponibili sul
                server 
newsgroups.borland.com
 (prevalentemente in
                inglese, ma si puo' postare anche in italiano)
Grazie,
Il solito.
-- 
Posted from [194.214.173.28] 


                 inglese, ma si puo' postare anche in italiano)
D'OH !! (Seconda volta che inizio un messaggi con D'OH :-) )
Ma e' lo stesso messaggio di Nicola... Io direi che una voce unica per 
queste segnalazioni OT sarebbe piu' utile.
Altrimenti ci ritroveremmo con 150 messaggi di segnalazioni OT postati per 
lo stesso messaggio, specialmente da chi consulta il NG offline, e non fa in 
tempo a vedere i messaggi gia' arrivati.
-- 
- Dado : Extreme Snowboarder
*-> I believe I can fly, I believe I can touch the sky <-*

queste segnalazioni OT sarebbe piu' utile.
Non sono d'accordo, anzi, piu' siamo meglio e'.
Nessuno poi, paga Nicola per fare da OT-Terminator.
--
Andrea Laforgia (mica uno qualunque...)

io programmo in BUILDER C++
Posta in questi termini la domanda e' decisamente off-topic.
Una cosa che mi ha sempre incuriosito e' come si potrebbe
realizzare un programma di scacchi in C++ (intendo il motore
di analisi, l'interfaccia utente e' ovviamente qualcosa di
fortemente system dependent).
Io ho scritto molti programmi di scacchi ma sempre in
assembler, pascal, C o al massimo "C con le classi".
Le mie implementazioni sono sempre state molto low-level...
e probabilmente sono orientato a pensare in quel modo
perche' sono affezionato alle mie soluzioni.
Mi piacerebbe capire come invece si potrebbe progettare
un programma per il gioco degli scacchi in C++ secondo
il parere di chi ha piu' esperienza reale di me con
questo linguaggio...
Io quando ci provo dopo un po' mi ritrovo sempre a pensare
a quanto e' comodo avere la scacchiera in un array di
120 interi :DDD
Non so quanto IT sia questa questione, pero'.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Non so quanto IT sia questa questione, pero'.
Credo lo sia. Si tratta di algoritmi. E soprattutto puo' portare a parlare di
come implementare in C++ un cero tipo di strutture e/o di algoritmi e/o di
problemi.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Magari anche dal punto di vista non OO che hai usato in passato.
C'e' una scacchiera di 8x8 caselle su cui si muovono
dei pezzi che appartengono a due schieramenti. I pezzi
sono di 16 per schieramento e di 6 tipi diversi (pedone,
torre, cavallo, alfiere, donna e re). I pezzi possono
spostarsi, catturare pezzi avversari che vengono
eliminati dal gioco e possono anche cambiare tipo
(promozione).
I giocatori muovono a turno e le mosse che si possono
fare dipendono dal pezzo (ogni pezzo ha delle proprie
regole), dalla posizione sulla scacchiera e dalla
storia della partita (ovvero dalle mosse precedenti:
ci sono mosse che si possono fare solo se in passato
non si sono fatte altre mosse... oppure mosse che se
non si fanno subito non si possono piu' fare in seguito).
Per realizzare un giocatore "intelligente" sono necessarie
sostanzialmente quattro cose di base
  1) La "scacchiera" ... ovvero un motore in grado
     di rappresentare lo stato della partita in
     un determinato momento e di giocare mosse.
  2) Le "regole" ... ovvero un sistema che data
     una scacchiera e' in grado di generare l'elenco
     di tutte le mosse legali nella posizione.
  3) La "guida" ... ovvero una funzione di
     valutazione di "basso livello" che permetta
     di associare ad una posizione un valore che
     ne indichi la "bonta'" per un giocatore.
     Un esempio molto primitivo e' contare il
     numero di pezzi che ogni giocatore ha a
     disposizione ed il loro relativo valore
     standard.
  4) Il "cervello" ... ovvero un algoritmo che
     sfruttando le tre parti precedenti ricerchi
     la mossa migliore da fare in una determinata
     posizione. In questo campo esistono molti
     algoritmi "standard" che prescindono dal
     gioco... uno dei piu' diffusi si chiama
     alpha-beta con varianti specifiche che si
     sono trovate funzionare molto bene con
     gli scacchi.
Con il C++ i miei dubbi sono:
 - ogni pezzo merita di essere una classe ?
 - come gestire la scacchiera ? le caselle meritano
   di essere classi ?
 - come avviene la generazione mosse (ci sono
   sia regole locali che globali da considerare...)
 - come gestire le eccezioni (es. e' illegale
   scoprire il re, oppure ripetere per tre volte
   una posizione sulla scacchiera e' partita patta,
   regola delle 50 mosse, regole per la validita'
   dell'arrocco)
 - come gestire la promozione (sparisce un pedone
   e compare al suo posto un altro pezzo) ?
Ora ti faccio solo un esempio di come ho affrontato
la cosa in passato. Io in C rappresento la scacchiera
come un due array di 120 elementi che virtualmente
immagino essere due matrici 12 x 10 :
  0-> x x x x x x x x x x
      x x x x x x x x x x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x . . . . . . . . x
      x x x x x x x x x x
      x x x x x x x x x x <- 119
Un array tiene il tipo pezzo (-1=out, 0=casella
vuota, 1=pedone,...,6=re) e l'altro array tiene
il colore del pezzo della casella (se il valore
indicato dal primo array e' > 0).
La rappresentazione ad array e' comoda perche'
una casella e' rappresentata da un solo intero
e anche uno spostamento relativo e' un intero.
Ad esempio per spostarsi nelle quattro diagonali
basta sommare -11, 11, 9 oppure -9 al numero
di una casella. Il motivo del "doppio bordo" di
caselle classificate out e' che la mossa di
cavallo salta una riga o una colonna (offset:
-12,12,-19,19,-21,21,-8,8).
Come vedi si tratta di strutture molto "fisiche".
Tu, senza questa zavorra di esperienze precedenti,
come vedresti la cosa ?


 come vedresti la cosa ?
Purtroppo non solo mi manca la zavorra (il che puo' essere un bene) ma non ho
mai avuto occasione di pensare agli algoritmi. E dato che stiamo "lavorando per
hobby" e a, sperabile, vantaggio di tutti, credo abbia piu' senso se, passo
passo, tu che gia' li conosci parli degli algoritmi e poi discutiamo
(pubblicamente, ed eventaulmente con partecipazione di altri) la parte OO e C++
del discorso. Se non altro perche' gia' scrivere messaggi come questo porta via
parecchio tempo. Pero' dato che non richiede un mega sforzo di concentrazione
posso farlo anche mentre lavoro (per esempio mentre aspetto il termine di una
acquisizione audio/video, di un multiplex del DVD o la scrittura su DLT/DVD-R di
una immagine. Praticamente con questo post ho "riempito" tutte le "attese" della
giornata).
Piccola nota. Il post e' lungo. Ma in realtà ho cercato di bilanciare la
prolissita' con il contenuto informativo. Il risultato e' un post che dovrebbe
essere leggibile e capibile da tutti i frequentatori abituali con esperienza
(anzi, per loro forse certe parti sono fin troppo ovvie), da tutti o quasi i
neofiti che hanno un minimo di background (che invece troveranno altre parti
legermente piu' oscure) e da molti superneofiti (per i quali alcuni concetti
sono veramente troppo avanzati). In un certo senso ho cercato di avere un
messaggio che possa essere non del tutto oscuro (sebbene non completamente
chiaro) ai superneofiti e nello stesso tempo non troppo banale per gli altri.
Comunque in questo stesso messaggio ci sono MOLTI PIU' CONCETTI di quelli che
possono trasparire in un primo tempo. E fra questi quello che io ritengo il piu'
importante: il metodo. Ovvero:
- separare i livelli di astrazione
- non sforzarsi di definire le cose troppo presto
- nello stesso tempo non dimenticarsi di definire qualche cosa (al giusto
livello di astrazione)
- se capita di avere "idee a basso livello" in ambiti a livello di astrazione
piu' alto non commettere il peccato di "overspecificazione" ma neppure quello di
"omessa documentazione dell'idea".


 perche' sono affezionato alle mie soluzioni.
In Assembly? E quanti milioni di righe hai scritto :)?
Per C mi dicesti una volta, che avevi usato un algoritmo già pronto che
forniva alcune utili funzioni... era alpha-beta?
Ciao
--
Luigi
http://web.tiscali.it/luigi_web
ICQ #46240443

marea di byte inutile....
scusa ma il limitarti a non rispondere ti è così difficile ?
-------
sito: 
www.dadev.it
ultime: Ocx per irc testi freeware
-------

 scusa ma il limitarti a non rispondere ti č cosě difficile ?
Con chi parli ? Ti e' cosi' difficile invece imparare a quotare ?
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 


> Con chi parli ? Ti e' cosi' difficile invece imparare a quotare ?
ti è così difficile seguire la posizione del del post sul thread??
cmq con te :))
--


 cmq con te :))
Si visto che alcuni usano dei reader in formato testo....
visto che parlavi di me, ti viene cosi' difficile ignorarmi ?
