Newsgroup: it.hobby.scacchi
Titolo: (Avvenimento Storico:-) PRIMA Partita fra (programmi) ITALIANI

A parte il fatto che l'oggetto puo' sembrare (e lo e' ) un po scerzoso ...
ma questa e' effettivamente la prima partita che mi risulti tra Programmi
Italiani.
Se qualcuno ha notizia di una partita precedente e' vivamente pregato di
postarla subito o taccia per sempre:-).
All'inizio l'idea era di fare un minitorneo di programmi italiani per vedere
a che livello si era in italia e magari ... diciamo catalizzare un po di
sviluppo nel settore della Computer-Chess in italia.
Cosi' ho fatto una ricerca di tutti i programmatori italiani e di tutti i
programmi di scacchi ... il risultato di queste semi-sconfortanti ricerche
e' stato che di programmi finiti in grado di giocare ce ne sono solo 2.
(Anche riguardo a questo sarei lietissimo di essere smentito)
A dire la verita' ci sarebbe anche un programmino che ho fatto qualche anno
fa' per generare tutte le mosse possibili da una posizione data e che avevo
rudimentalmente messo in grado di giocare a vari livalli di profondita ...
ma era indubbiamnete inferiore a questi due e in ogni caso e' sepolto nei
miei vecchi dischetti e sarebbe stata una fatica titanica ritrovarlo.
Cosi Ho fatto giocare il grande Drago (scaricato dal sito di Stefano Gemma)
contro il prode LarsenVB (gentilmente inviatomi in beta version da Luca
Dormio)
Un problema pratico e' stato che per fare questa partita, ovviamente ci
volevano 2 computer ... possibilmente di veocita' non troppo diversa.
Fortunatamente mi e' venuto in aiuto mio fratello Gianluca che ha un
computer simile al mio (io ho un P133  e lui un P166). Fatti gli opportuni
test e' venuto fuori che 2 ore del P166 equivalevano a 2 ore e 10 mi sul
P133)
Cosi ho istallato Drago sul P166 e ho compensato Larsen a cui e' toccato il
P133 dandogli i sui bei 10 minuti in piu'.
Tuttavia devo dire che in realta' questa partita non dovrebbe essere
considerata ad armi veramente pari
Il problema e' che Drago non ha ancora la possibilita di settare un livello
di gioco del tipo
40 mosse in 2 ore ma solo il livello di profondita' desiderato.
Cosi' ho dovuto giocare un po' con drago per capire quale era il livello di
profondita piu' vicino
ed e' risultato che il livello 7 (su un pentium 166) era un po troppo basso
e il livello 8 abbastanza troppo lungo.
A occhio il 7 sebrava piu' vicino e cosi' ho iniziato la prima partita che
riporto qui sotto e che e' stata vinta abbastanza tranquillamente da
LarsenVB.
[Event "ITALIAN 1"]
[Site "PRATO"]
[Date "1999.10.16"]
[Round "1"]
[White "LarsenVB"]
[Black "Drago versione 0.21"]
[Result "1-0"]
[TimeControl "40/7200"]
1. d4 d5 2. e3 e5 3. dxe5 Nc6 4. Bb5 Bc5 5. Bxc6+ bxc6 6. Nf3 Bf5 7. Nc3
Bg4 8. O-O a5 9. Bd2 a4 10. h3 Bc8 11. b3 axb3 12. axb3 Bf5 13. Rxa8 Qxa8
14. g4 Bc8 15. Qa1 Ba6 16. Qa4 f5 17. Ra1 fxg4 18. hxg4 Ne7 19. Qxa6 Qxa6
20. Rxa6 O-O 21. Nd4 Bb4 22. Nxc6 Nxc6 23. Rxc6 g5 24. Rxc7 Rb8 25. Nxd5
Bxd2 26. Nf6+ Kf8 27. e6 Rb7 28. Rxb7 Bxe3 29. Rf7#
{White Mates} 1-0
durante lo svolgersi del gioco ho notato che quando la mossa era forzata
drago tendeva a
muovere piu' velocemente del previsto.
In questo modo e' andata a finire che larsen ha impegato 1ora e 15 minuti
per fare le sue 29 mosse mentre drago ha fatto tutto in circa 31 minuti.
Beh ... non poteva finire cosi: ho provato a  fare una partita
(chilometrica) con drago settato a liv. 8.
eccola qua'
[Event "ITALIAN 2"]
[Site "MYHOME"]
[Date "1999.11.13"]
[Round "2"]
[White "ric"]
[Black "LarsenVB"]
[Result "*"]
[TimeControl "40/7800"]
1. e4 g6 2. d4 Bg7 3. Bb5 c5 4. a4 a6 5. Bc4 cxd4 6. Bf4 e5 7. Bd2 Nf6 8.
Bg5 Qb6 9. Nd2 Qxb2 10. Rb1 Qa3 11. Qf3 Qxf3 12. Ngxf3 Nc6 13. Rb6 h6 14.
Bxf6 Bxf6 15. O-O O-O 16. Ra1 g5 17. h3 d6 18. Nf1 Bd8 19. Rb2 Ba5 20. Rd1
Bb4 21. Ng3 Bd7 22. Nf5 Bxf5 23. exf5 Rfc8 24. Bd5 a5 25. f6 b6 26. Kh2 Rc7
27. Kg3 Rac8 28. Kg4 Nb8 29. c4 dxc3 30. Rc2 Nd7 31. Kf5 Nc5 32. Rb1 Nxa4
33. h4 gxh4 34. Rh1 b5 35. Rxh4 Nb6 36. Rg4+ Kh8 37. Bb3 Rg8 38. Rxg8+ Kxg8
39. g4 a4 40. Ba2 Ba3 41. g5 hxg5 42. Bb1 b4 43. Re2 b3 44. Bc2 Nd5 45. Be4
c2 46. Re1 Nc3 47. Rg1 Nxe4 48. Kxe4 b2 49. Rxg5+ Kh8 50. Rh5+ Kg8 51. Rg5+
Kh8 52. Rh5+ Kg8 53. Rg5+ Kh8
SORPRESA: Larsen lascia pattare Drago ... quando ormai beh ... quando ormai
io non me lo aspettavo piu'
Programmatori ... date un'occiata alla partita ... illustra abbastanza bene
un errore che vien fuori che
non si controlla la patta per ripetizione di mosse ... larsenvb e' convinto
di poter vincere lo stesso anche andando con il Re in h8 ponsando ...
be in ambedue i casi ho diverso materiale in piu'. ma se questo puo essere
(parzialmente) vero alla mossa 49 .. Rh8 .. non e' piu' vero la volta
successiva alla
mossa 51 (tornando in h8 il nero offre la possibilita al bianco di forzare
la triplice ripetizione.
Nessuno dei 2 programmi si e' accorto che la partita era patta. Ho dovuto
smettere io perche' ambedue avrebbero continuato all'infinito a ripetere le
stesse mosse, vero Stefano e Luca
Per quello che riguarda il tempo ... larsen ha impiegato 2ore e 15 minuti
ma drago( purtroppo per me) ha impegato 6ore e 14 minuti (in pratica di
media 7 minuti a mossa!!)
Se qualche programmatore  vedendo le partite pensasse ... beh anch'io potrei
fare un programma e probabilmente non giocherebbe peggio di questi due ...
E VIVAMENTE RACCOMANDATO DI FARLO.
Tra l'altro questo e' proprio il motivo per il quale ho perso le mie ore a
far giocare questi bebe' software.
Un'ultima cosa: spero che gli autori dei sue programmi Luca e Stefano ci
dicano cosa ne pensano delle 2 partite che ho postato selando magari qualche
retroscena  :-)
ciao a tutti
Gianluigi "the chess-golem" Masciulli

E VIVAMENTE RACCOMANDATO DI FARLO.
ASSOLUTAMENTE!! se ci sono riuscito con Visual Basic e con le scarse conoscenze
di C che mi ritrovo... e poi non vorrete che Gianluigi si annoi con solo due
programmi da provare ;)
Se poi quei simpaticoni di Tin si decidesero a sistemare la procedura di
attivazione dello spazio Web sarei ben felice di rendere disponibili programma e
sorgenti, grrrr!!
Magari provo a mettere tutto su it.binari.visual-basic...
Ciao
--
   o   o
o / \ / \ o  Luca Dormio
  \ - - /    
ldo...@tin.it
 (real email address)
   =====
Chess.net ID: Luca_b3
FICS ID: LarsenB
IECG ID: 17105

 
Mi chiedo chi ti da' la pazienza :-))
Ciao,
Carmelo
----------------
 ciccio su FICS
----------------

 Magari provo a mettere tutto su it.binari.visual-basic...
    Se vuoi, ti offro (gratuitamente) tutto lo spazio che ti serve per
pubblicare i sorgenti sul mio sito 
www.linformatica.com
. Anzi, lo spazio è a
disposizione di chiunque voglia rendere pubblico il proprio lavoro, purchè
sia originale (non mi interessano i vari cloni di Crafty o di GnuChess).
    Sarebbe interessante organizzare un secondo match, ad armi pari... col
buon Gianluigi come arbitro imparziale :-))))
    Ciao!!!


Sent: Monday, November 22, 1999 11:23 PM
Subject: (Avvenimento Storico:-) PRIMA Partita fra (programmi) ITALIANI
[censura]
    Se dovessi commentare le partite come scacchista, dovrei dire che fanno
veramente pena :-))) LarsenVB si dimostra decisamente superiore a Drago, ma
la differenza credo che debba essere ricercata in un "dettaglio tecnico",
sebbene di non poca importanza. Non conosco LarsenVB, ma conosco bene Drago
e ancora mi stupisco per come riesca a giocare, nonostante le pochissime
informazioni di carattere scacchistico di cui l'ho dotato. Drago conosce
solo queste cose:
- il valore dei pezzi
- il valore delle case (crescente dalla "periferia" al centro)
- un valore di "mobilità" per i pezzi
    Una cosa che si nota subito, soprattutto nella prima partita, è
l'assoluta mancanza dei concetti "sviluppo" e "struttura dei pedoni". Questi
concetti mancano semplicemente perchè non li ho mai "insegnati" a Drago. Ma
in realtà mancano a Drago praticamente tutte le basi teoriche più
elementari. Oserei dire che "Drago non sa giocare a scacchi" :-)))) Eppure
le partite che hai riportato potrebbero essere scambiate per partite giocate
tra due dilettanti, di cui uno un po' più forte dell'altro (LarsenVB). Posso
solo supporre che LarsenVB sia dotato di maggiore "intelligenza
scacchistica", mentre Drago lo è di una maggiore velocità. Paradossalmente,
il mio obiettivo iniziale non era quello di puntare sulla velocità, quando
ho scritto Drago, ma proprio quello opposto: dotarlo di quanta più
"intelligenza scacchistica" fosse possibile. Purtroppo, da quando ho
terminato il motore in modo "decente", non ho più avuto il tempo per
dedicarmi alla fase successiva, Drago perciò è rimasto al suo stadio
embrionale e credo che tale resterà ancora per parecchio tempo.
    Vorrei far notare una cosa: due anni fa Drago giocava molto male, ma ora
si è avvantaggiato dell'uscita di CPU sempre più veloci. Lavorando solo di
forza bruta, tra qualche anno potrebbe giocare al livello 10 (5 mosse),
senza alcuna modifica al programma e in un tempo inferiore a quello attuale.
Sarebbe interessante misurare come varia il rapporto di forza esistente tra
i due programmi (ora a favore di LarsenVB) al solo variare della velocità
della CPU. L'esperienza DeepBlue insegna che la sola forza bruta può essere
vicente. Non mi sono certo ispirato a DeepBlue per scrivere Drago (visto che
ancora non esisteva), ma il principio di base è lo stesso: velocità. Ma un
programma veloce è perdente, al di sotto di certi livelli. Per rendere
vincente un programma veloce gli si deve aggiungere intelligenza... ma
questo lo rallenta. Credo che esista un limite per entrambi gli aspetti,
superato il quale si ottengono programmi "imbattibili". Ma il limite minimo
di velocità richiede probabilmente soluzioni alla DeepBlue, ovvero sistemi
multiprocessore dedicati, al di fuori della nostra portata. Il limite minimo
di intelligenza è invece anche alla nostra portata e questo permette di
realizzare buoni programmi, certo non senza una discreta dose di fatica e...
pazienza!!!
    Ritengo che Drago sia imbattibile, in quanto a velocità di calcolo (non
in quanto a qualità di gioco), grazie al fatto di essere scritto interamente
in assembly. Nessun programma scritto in C (o altri linguaggi ad alto
livello) può competere con un programma assembly ottimizzato istruzione per
istruzione. Ma a scacchi non vince chi analizza il maggior numero di mosse.
Sul mio P200, Drago genera e valuta 60 milioni di posizioni in 40 secondi...
ma a me piace dire che analizza 1,5 milioni di mosse SBAGLIATE al secondo
:-)))))))
    Dal punto di vista strettamente tecnico, non c'è molto di nuovo da dire.
Entrambi i programmi peccano di fantasia e risentono degli errori tipici dei
loro "fratelli". Per Drago, il problema principale è l'"effetto orizzonte",
cioè l'incapacità di vedere oltre il livello massimo impostato (sebbene
mitigata da alcuni trucchi). Questo porta a mosse che neppure un giocatore
ubriaco giocherebbe. La mancanza di fantasia, nel caso di Drago, è
scusabile... non avendo inserito nel programma nessuna informazione di
carattere strategico. Il poco di fantasia che scaturisce dai tre elementi
noti a Drago è un interessante comportamento emergente, ma ben poca cosa,
rispetto a quello che vorrei ottenere. Un'ultima curiosità: nella prima
partita Drago impiega meno della metà del tempo di LarsenVB. Questo mi
ricorda alcuni dei miei tornei, in cui ero sempre il primo... a perdere!!!
:-)))))) Tale il padre...
    Ciao!!!
PS: una chicca per i programmatori: anche l'interfaccia di Drago è in
assembly... compresa la gestione del mouse e il disegno dei "bitmap" e dei
"pulsanti "alla Windows... il tutto in pochi Kb di programma.

 E VIVAMENTE RACCOMANDATO DI FARLO.
Mi piacerebbe. Davvero. Il problema che mi ha sempre bloccato e'
che non ho proprio voglia di programmarmi l'interfaccia.
Compreso pezzi e scacchiera. L'esperimento che mi piacerebbe fare
e' creare un programma che sa gli scacchi quanto me (cioe' niente)
e vedere come se la cava (praticamente sarebbe un 'ottima simulazione di
cosa succederebbe se avessi la possibilita' di pensare per 
circa dieci anni sulla mossa da fare, ma senza aver studiato 
niente di piu' di adesso)
Sentiamo se mi potete aiutare:
1) So il Fortran ed il Basic ma potrei mettermi a lavorare pure su Visual C++
2) Non voglio programmare l'interfaccia (possibile soluzione: Winboard?)
3) Non voglio usare algoritmi di altri (non so niente di prog. di scacchi
e non voglio sapere niente)
4) Ho poco tempo...ma tanto mica mi pagano :-)

 ordinare le mosse... vabbhè... altri tempi.
Come ti capisco! :-)
Quando ho scritto io il mio programma (nel '95) Internet esisteva ma
non era diffuso come oggi... Non avevo un account per accedervi e
sebbene un po' di materiale fossi riuscito a trovarlo, in rete o in
libreria, mi son comunque dovuto "inventare" quasi tutto...
Nonche' implementare direttamente in assembler la gestione del mouse,
e disegnare "a mano" finestre e pulsantini... Altri tempi, hai ragione;
proprio altri tempi! :-))
Ciao,
Carmelo
----------------
 ciccio su Fics
----------------

  e ciao Luca e Stefano
trovo questo primo incontro fantastico! vorrei avere anch'io qualcosa da
buttar dentro il pentolone---ma i doveri mi tengono lontano>>>per adesso!
In gamba.
;)
Julian//
ps.
...e! belli i tempi dell'int 33,,, per restare in termini moderni...
"overri-dato"...!

 proprio altri tempi! :-))
    Evvai!!!!! Ne ho trovato un altro, di programmatori pazzi come me
:-)))))))))))
    Ciao!!!!

sia originale (non mi interessano i vari cloni di Crafty o di GnuChess).
Se non riesco a risolvere i problemi entro breve sarei molto felice di accettare
la tua offerta, tra sorgenti ed eseguibili attualmente sono ~170 KB... anche se
mi sento un po' "clone" anch'io.


 che non ho proprio voglia di programmarmi l'interfaccia.
beh allora fai come luca ... non la programmare e usa ad esempio
l'interfaccia standard winboard.
hope this help
gianluca

istruzione.
Sono convinto anch'io che l'ago della bilancia penderebbe sicuramente a favore
di Drago, visto che, a parita' di "conoscenza", un programma scritto in Visual
Basic non puo' assolutamente tener testa ad uno scritto in assembly (o in C) in
termini di nodi al secondo; se non ho sbagliato nel calcolare i nodi ;) LarsenVB
dovrebbe assestarsi su un modestissimo 5000 nodi/sec. (PII 233) e circa 8500
nodi/sec. (PII 400), gia' sul PII 233 Drago mi sembra arrivi a 1.950.000
nodi/sec. a livello 7!


4) Ho poco tempo...ma tanto mica mi pagano :-)
Non so quello che ho dato a Gianluigi ma l'ultimo eseguibile che ho qui di
LarsenVB e' stato compilato all' 1.07 di notte!


 LarsenVB e' stato compilato all' 1.07 di notte!
Il prob. e' che io gia' ci vado a letto a quell'ora...:-)))

La risposta sembra semplice, però...
[SNIP]
Un'altra questione di questo tipo molto interessante e': quando un programma ha
un buon vantaggio, come e' possibile fargli giocare la mossa non oggettivamente
migliore (=con lo score migliore) ma quella che offre minori chance di
controgioco all'avversario?
Questo e' un procedimento tipicamente umano (a molti di voi, in vantaggio di un
pezzo in posizione incasinata, sara' sicuramente successo di restituirlo per
entrare in un finale di soli pedoni stravinto) ed e' difficilmente inculcabile
quando il programma non riesce a "vedere" una contropartita tangibile a breve
termine.


 (Anche riguardo a questo sarei lietissimo di essere smentito)
Infatti ti smentisco: sono 3! :-)
Sono riuscito a recuperare il mio programma, di cui parlavo nell'altro
post; sono poco meno di 250 Kb zippati compresa la documentazione.
Se vuoi posso inviartelo via mail; naturalmente chiunque possa
essere interessato non ha che da chiedermelo.
Il programma in se' e' completo; gira sotto DOS o in una finestra
DOS a tutto schermo, e permette di salvare/caricare partite (ma in
un formato specifico, non PGN), settare la profondita' di ricerca
(non, ahime', il tempo di risposta), editare la posizione, rivedere
una partita ecc.
Non e' un granche' come forza di gioco, per via soprattutto della
mancanza di una libreria di aperture e perche' non implementa
l'iterative deepening; comunque gli ho fatto giocare una partita di
prova contro Drago (purtroppo una lampo, per mancanza di tempo :-()
ed ha vinto! :-))
C'e' da dire che avevo settato Drago a liv. 4 (per cui rispondeva
quasi istantaneamente) e PcChess a liv. 2 (in media 0.7 secondi a
mossa su Pentium 166 con NT 4.0); probabilmente per far scontrare
i due programmi "ad armi pari" bisognava settare Drago a liv. 5.
Comunque il risultato e' il seguente:
[Event "ITALIAN CHESS PROGRAMS"]
[Site "Warsaw"]
[Date "1999.11.24"]
[Round "1"]
[White "Drago lev. 4"]
[Black "PcChess lev. 2"]
[Result "0-1"]
[ECO "B01"]
1.e4 d5 2.Nc3 dxe4 3.Nxe4 Qd4 4.Qe2 Qd5 5.Qb5+ Qd7 6.Nc5 Qxb5 
7.Bxb5+ c6 8.Bc4 e5 9.Nd3 Bd6 10.b4 e4 11.Nb2 Bxb4 12.a3 Bd6 
13.d4 exd3 14.Nxd3 Bf5 15.Nb2 Nd7 16.Nf3 b5 17.Bb3 Be4 
18.Be3 Bxf3 19.gxf3 Ne5 20.Ke2 Nc4 21.Nxc4 bxc4 22.Bxc4 Be5 
23.Rad1 h6 24.h3 Nf6 25.Bc5 g6 26.Rhg1 g5 27.Ke3 Rb8 28.a4 Rb2 
29.Bxa7 Bf4+ 30.Kd3 0-0 31.Bd4 Rd8 32.Kc3 Rdb8 33.Bxf6 Bh2 
34.Rge1 R2b7 35.Rh1 Bc7 36.Rhg1 Ba5+ 37.Kd3 Rd7+ 38.Ke2 Re8+ 
39.Be6 Rxe6+ 40.Kf1 Rxd1+ 41.Kg2 Rxg1+ 42.Kxg1 Rxf6 43.Kg2 Rf4 
44.Kg3 Rxa4 45.Kg2 Rc4 46.f4 Rxc2 47.f5 Be1 48.Kf1 Bxf2 
49.Kg2 Bd4+ 50.Kf3 Kg7 51.Ke4 Rd2 52.Kf3 c5 53.Ke4 Rh2 
54.Kd3 Kf6 55.Ke4 Rxh3 56.Kd5 Kxf5 57.Kc4 Ke4 58.Kb5 h5 
59.Ka5 Ra3+ 60.Kb5 Kd5 61.Kb6 Be5 62.Kb7 f5 63.Kb6 Ra1 
64.Kb7 Rf1 65.Kb6 h4 66.Ka5 h3 67.Kb5 h2 68.Kb6 c4 69.Ka6 h1Q 
70.Kb5 Ra1 71.Kb4 Qb1# 0-1



stefano sei troppo generoso nel togliere il mezzo punto della seconda
partita al tuo drago e regalarlo a larsenvb.
Come "arbitro imparziale devo dire che la seconda partita e' stata una patta
secondo le regole degli scacchi. Se poi e' stato il Drago a guadagnarlo o il
LarsenVB a perderlo ... e' una questione di lana caprina.
Una patta e' una patta.
ciao
gianluigi

 buttar dentro il pentolone---ma i doveri mi tengono lontano>>>per adesso!
lo so' ... e non sei neanche il solo su IHS!
Infatti ci sono diversi ihscacchisti che hanno fatto e non finito programmi
di scacchi ... Paolo B. ad esempio.
beh comunque ... non e' mai troppo tardi (per finire il programma:-)
ciao
a tutti
gianluigi

 mi sento un po' "clone" anch'io.
    In effetti... ma potrei chiudere un occhio, se non altro perchè un
programma di scacchi interamente in VB lo ritengo quasi un paradosso
:-))))))))). A proposito, i sorgenti saranno anche 170 Kb, ma il setup sarà
sicuramente di qualche Mega. Sul mio sito non ho comunque problemi di
spazio.
    Ciao!!!

 :-)))))))
buona questa :-)

 essere interessato non ha che da chiedermelo.
ok richiesta ufficale ... mandamelo !
non vedo l'ora ;-)
ciao e grazie in anticipo
gianluigi

 "pulsanti "alla Windows... il tutto in pochi Kb di programma.
scusa stefano un'informazione ci pui dire cosa indicano i misteriosi
numerini sulla destra sotto il logo di Drago. Uno dovrebbe essere il numero
di mosse esaminate , poi c'e' l'ultima mossa effetuata. Ce n'e' uno di
questi da cui si puo ricavare la valutazione della posizione secondo drago?
ciao e grazie in anticioi

 nodi/sec. a livello 7!
    Prima di generare un thread di incredulità :-), preferisco precisare la
cosa, riportando i dati dell'elaborazione di una mossa, ottenuti dalla
versione Windows di Drago (ebbene sì... esiste pure quella... solo che non
permette ancora di muovere i pezzi).
Pentium 200:
Milliseconds: 38035
Generated moves: 82034456
Played moves: 2258099
Number of Nodes: 2258100
Generated/nodes: 36
Generated/second: 2156815
Played/Generated: 28/1000
Nodes/second: 59369
    Tradotti: in 38 secondi circa, sono state generate 82034456 di mosse
legali. Le mosse effettivamente giocate sono state 2258099. Considero "nodi"
solo queste ultime. Ad ogni nodo sono state generate in media 36 mosse.
Effettivamente vengono generate 2156815 di mosse legali al secondo, ma il
numero di nodi scende a 59369 al secondo. Qualunque programmatore parli di
un nuomero di nodi/secondo più elevato, probabilmente sta barando o non ha
chiaro il concetto di nodo. Correggetemi se sbaglio:
- un Pentium a 200 MHz può eseguire 200.000.000 di cicli al secondo, ovvero
circa 70.000.000 istruzioni assembly/s
- 60.000 nodi/s significano 2.160.000 mosse/s (a 36 mosse per nodo)
- 70.000.000/2.160.000=32 istruzioni assembly/mossa
    Cioè, si dovrebbero usare mediamente solo 32 istruzioni assembly per
generare ogni mossa legale (o pseudo legale). Considerato che parte del
tempo viene speso nell'algoritmo alfa-beta (o comunque in valutazioni
effettuate ad ogni nodo), ritengo difficile scendere al di sotto di questi
valori (a parità di CPU e clock, si intende).
    Comunque ho notato un peggioramento delle prestazioni del programma, nel
passaggio a Windows, pur avendo mantenuto gli stessi sorgenti assembly, a
causa di alcune modifiche necessarie ma penalizzanti.
    Quasi quasi passo a Linux :-)))))
    Ciao!!!

 valori (a parità di CPU e clock, si intende).
davvero strano...!
l'ottimizzazione di un codice asm richiede una buona conoscenza
dell'interfacciamento tra i componenti hw. Il codice piu' veloce e' anche quello
piu' sporco e di difficile lettura.
ciao,
Julian//

causa di alcune modifiche necessarie ma penalizzanti.
Premetto la mia assoluta ignoranza di assembly pero' se la versione Windows
fosse solo un programma console (e rinunciassi quindi all'interfaccia) magari
riusciresti a ridurre l'overhead e automaticamente potresti diventare
Winboard-compatibile; i classici 2 piccioni...


spazio.
Un mega e mezzo circa; pero' non amo molto il setup di Visual Basic e pensavo di
distribuire i runtime VB6 a parte (in giro ci sono degli autoscompattanti gia'
pronti) e il resto in un semplice zip, piu' pratico...


:-)))
Assolutamente si!
come ho accennato in un altro messaggio a Stefano ho qualche problema ad
attivare lo spazio Web del mio abbonamento, appena e' pronto metto tutto in
linea...
Comunque per quanto riguarda la comunicazione a Winboard ecco qua:
=== INIZIO DI IO.BAS ===
Option Explicit
'==================================================
' MODULO DI COMUNICAZIONE WINBOARD <---> VISUAL BASIC
' by Luca Dormio
'==================================================
'---------------------------------------------------------------------------
'Dichiarazione API e variabili globali
'---------------------------------------------------------------------------
Declare Function GetStdHandle Lib "kernel32" _
    (ByVal nStdHandle As Long) As Long
Declare Function CloseHandle Lib "kernel32" _
    (ByVal hObject As Long) As Long
Declare Function PeekNamedPipe Lib "kernel32" _
    (ByVal hNamedPipe As Long, lpBuffer As Any, _
    ByVal nBufferSize As Long, lpBytesRead As Long, _
    lpTotalBytesAvail As Long, lpBytesLeftThisMessage As Long) As Long
Declare Function ReadFile Lib "kernel32" _
    (ByVal hFile As Long, _
    lpBuffer As Any, _
    ByVal nNumberOfBytesToRead As Long, _
    lpNumberOfBytesRead As Long, _
    lpOverlapped As Any) As Long
Declare Function WriteFile Lib "kernel32" _
    (ByVal hFile As Long, _
    ByVal lpBuffer As String, _
    ByVal nNumberOfBytesToWrite As Long, _
    lpNumberOfBytesWritten As Long, _
    lpOverlapped As Any) As Long
Public hStdIn         As Long   ' handle dello Standard Input
Public hStdOut        As Long   ' handle dello Standard Output
'---------------------------------------------------------------------------
'PollCommand() - Verifica la presenza di dati nel buffer dello standard input
'
'restituisce TRUE se sono disponibili nuovi dati
'---------------------------------------------------------------------------
Function PollCommand() As Boolean
Dim sBuff       As String
Dim lBytesRead  As Long
Dim lTotalBytes As Long
Dim lAvailBytes As Long
Dim rc          As Long
sBuff = String(256, Chr$(0))
rc = PeekNamedPipe(hStdIn, ByVal sBuff, 256, lBytesRead, lTotalBytes,
lAvailBytes)
PollCommand = CBool(rc And lBytesRead > 0)
End Function
'---------------------------------------------------------------------------
'ReadCommand() - Legge una stringa dallo standard input
'---------------------------------------------------------------------------
Function ReadCommand() As String
Dim sBuff      As String
Dim lBytesRead As Long
Dim rc         As Long
sBuff = String(256, Chr$(0))
rc = ReadFile(hStdIn, ByVal sBuff, 256, lBytesRead, ByVal 0&)
'ToDo: error handling if rc=0
ReadCommand = Left$(sBuff, lBytesRead)
End Function
'---------------------------------------------------------------------------
'SendCommand() - Invia una stringa sullo standard output
'
'restituisce la stringa effettivamente inviata (compresi i LineFeed)
'---------------------------------------------------------------------------
Function SendCommand(ByVal sCommand As String) As String
Dim lBytesWritten   As Long
Dim lBytes          As Long
Dim rc              As Long
'secondo la documentazione di WinBoard il LineFeed PRIMA del comando
'non dovrebbe essere inviato, pero' senza quello WinBoard legge solo
'la prima stringa che mandiamo e poi cessa di rispondere.
'Probabilmente c'e' qualcosa che mi sfugge nella documentazione oppure c'e'
'qualche "inghippo" con WriteFile e la gestione delle stringhe in VB;
'comunque questa "patch" fa funzionare il tutto e sembra non infastidire
WinBoard.
sCommand = vbLf & sCommand & vbLf
lBytes = LenB(sCommand)
rc = WriteFile(hStdOut, ByVal sCommand, lBytes, lBytesWritten, ByVal 0&)
'ToDo: error handling if rc=0
SendCommand = sCommand
End Function
=== FINE DI IO.BAS ===
Per usarlo in pratica e' sufficiente fare da qualche parte:
Dim sInput As String
Do
    If PollCommand Then
        sInput = ReadCommand
        ParseCommand sInput
    End If
    DoEvents
Loop
dove ParseCommand e' la funzione che interpreta i comandi di Winboard; qualcosa
come:
Public Sub ParseCommand(ByVal sCommand As String)
Select Case sCommand
Case "new"
    <nuova partita>
Case "white"
    <il motore gioca con il Bianco>
Case "draw"
    <una richiesta di patta, a cui magari rispondiamo con:>
    SendCommand "say sorry, this computer does not accept draws yet."
Case <e' una mossa, in formato algebrico ad es: e2e4>
    <Avviamo il motore di analisi e alla fine restituiamo la risposta con:>
    SendCommand "move " & EngineMove
[...]
Case "quit"
    <Winboard sta per terminare, chiudiamo il nostro programma>
End Select
End Sub
In attesa dei source completi spero che questo sia di aiuto...


 questi da cui si puo ricavare la valutazione della posizione secondo
drago?
    Dovrebbe essere scritto nel file leggimi... comunque la valutazione di
Drago è il numero di fianco a "r0.21" (release 0.21). La valutazione dopo
che hai fatto la tua mossa è semplicemente quella che Drago dà dopo
un'analisi di due livelli (serve solo a verificare la legalità della mossa).
Quella riportata dopo che ha mosso Drago è invece la valutazione dopo gli
enne livelli di analisi di Drago. Se non ricordo male (!), un pedone
dovrebbe valere circa 256 punti.
    Ciao!!!

 Una patta e' una patta.
    Al prossimo match allora... ma ti farò avere un Drago con controllo sul
tempo.
    Ciao!!!

 altri?
    Mi sa che sarà un match a 3 o 4 o 5... non mi va di escludere nessuno...
a proposito, questo chess-golem cos'è?
    Io avrei un suggerimento: diamo ai nostri programmi dei nomi italiani (o
al limite in latino) per sottolinearne l'origine.
    Ciao!!!

 pezzo in posizione incasinata, sara' sicuramente successo di restituirlo
per
[...]
    Oltretutto, anche in posizioni di parità, quante volte ci è capitato di
giocare fino alla morte, per questioni di classifica? Magari qualcuno avrà
offerto la patta, in posizione vinta, solo perchè gli bastava per vincere un
torneo... e portarsi a casa il solito prosciutto e due Kg di formaggio
:-))))))
    Ciao!!!

 tempo.
ci conto :-)
tra l'altro il club dei programmi italiani ha acquisito un'altro , devo
dire, ottimo membro.
Infatti mi e' arrivato il programma di "ciccio" PCCHESS che devo dire si
presenta molto bene.
diciamo che appena il progetto golem sara' un po' piu' avanzato ... metto su
un bello scontro a 4
e se qualcuno mi da' una mano potrebbe essere anche un po' piu' lungo del
minimo di 3 partite.
mi piacerebbe provare PCCHESS contro Larsen e Drago ma non ho piu' il
secondo computer.
A questo punto e' d'obbligo una domanda per tutti e tre (ciccio, luca e
stefano):
i vostri programmi sfruttano il tempo dell'avversario? se non lo fanno e se
non occupano le risorse quando non sta' a loro una partita giocata su un
solo computer con 2 task attivi potrebbe essere abbastanza indicativa.
e inoltre ho una domanda extra per ciccio ... fino a che PCCHESS non gestira
il tempo in proprio pensi che metterlo a livello massimo e forzare la mossa
dopo 3 minuti possa danneggiare il suo gioco?
ciao a tutti
gianluigi

 al limite in latino) per sottolinearne l'origine.
beh .. golem in italiano si dice golem!
ciao

 dopo 3 minuti possa danneggiare il suo gioco?
PcChess non sfrutta il tempo dell'avversario, per cui puoi farlo
tranquillamente giocare contro un altro programma sullo stesso computer;
inoltre come ti ho scritto in mail il controllo e' sulla profondita' e
non sul tempo, per cui se un altro programma gli "succhia" le risorse
mentre sta pensando lui semplicemente impiega piu' tempo per muovere,
ma i calcoli se li fa comunque tutti! :-)
In questo caso pero', per il problema che gia' ti ho accennato, non
puoi piu' fidarti degli "orologi" di PcChess, che cominciano a correre
come dannati per recuperare il tempo perduto! :-)
Per quanto riguarda la seconda domanda, la risposta ahime' e' si'....
forzare la mossa in PcChess danneggia pesantemente il gioco, in quanto
non implementa iterative deepening ed esplora i rami dell' albero uno
alla volta, scendendo per ognuno fino alla profondita' fissata prima di
passare agli altri. Questo e' uno dei principali limiti del programma,
insieme alla mancanza di una biblioteca di aperture e di un algoritmo di
quiescence search (la profondita' dell' albero e' rigidamente stabilita
ed e' uguale per tutti i rami).
Ad ogni modo, se vuoi fare un esperimento credo che settando il livello
4 dovresti ottenere un tempo di risposta medio di circa un minuto a
mossa, anche se dipende fortemente dal numero di pezzi in gioco. Il
livello 5 non te lo consiglio perche' mi pare che il programma tenda
a giocare peggio impostando una profondita' di ricerca dispari! :-)
Ciao,
C.




 piu' sporco e di difficile lettura.
    Nel caso di un programma in assembly, finchè si riesce a lavorare solo
in RAM, non c'è bisogno di conoscere nulla dell'hardware. Se non si è in un
sistema operativo multitasking, che assegna solo una parte del tempo di CPU
al nostro programma, si può addirittura prevedere esattamente il tempo che
impiegherà l'esecuzione di una certa routine, contando i cicli macchina
richiesti (tenendo conto degli accoppiamenti delle istruzioni nelle pipe).
Per ottimizzare Drago, ho usato un programma (PentOpt) che mi forniva gli
accoppiamenti ed i cicli reali delle istruzioni, ottenendo guadagni
incredibili semplicemente invertendo l'ordine di esecuzione di un paio di
istruzioni, in punti critici.
    Comunque concordo con te: il discorso è molto grossolano, ma il numero
di 32 istruzioni per mossa non si discosta molto dalla realtà... potrei
anche contarle... ma non ho tempo :-)))). Non significa che per generare una
singola mossa legale devo usare 32 istruzioni. La generazione potrebbe
richiederne anche solo 20, le altre derivano dall'incidenza
dell'elaborazione "fissa" effettuata ad ogni nodo.
    Ma forse stiamo andano un po' "fuori di topo" :-))))
    Ciao!!!

 pronti) e il resto in un semplice zip, piu' pratico...
    Non parlarmi dei setup di VB... ti prego!!!! Mi hanno fatto
impazzire!!!! :-((((
    Comunque, se mi fai avere l'eseguibile ed il file .vbp del progetto (non
i sorgenti, solo il vbp e l'exe) posso preparare il setup con VB6.0 e
metterlo sul sito. Magari allegami anche una paginetta di descrizione html
(con sfondo nero e scritte giallo/verdi, che si intonino con il mio sito
www.linformatica.com
). Snnò facci avere il link dlela tua pagina (se è già
pronta), che sono proprio curioso di provare LarsenVB.
    Ciao!!!

solo computer con 2 task attivi potrebbe essere abbastanza indicativa.
Per quanto mi riguarda non c'e' problema, LarsenVB non pensa sul tempo
dell'avversario e non ha nemmeno hash tables che potrebbero occupare troppa RAM;
ho gia fatto qualche partita con programmi analoghi sullo stesso PC e non c'e'
nessuna perdita di velocita' percettibile.


haha! "fuori di topo",,,!!!
:))
sono daccordo con te in linea di massima; pero' la conoscenza (1)del processore
(2)del hw di supporto e' la chiave per la massima velocita'--->trattasi spesso e
volentieri solo di riorganizzare il codice.
es. i jmp entro +/- 127 byte sono piu' veloci, i blocchi di dati allineati sugli
offset multipli di 16 danno generalmente maggiore velocita';;; l'intel hw ha
molte magagne di questo tipo che si possono sfruttare a proprio piacere.
In gamba.
Ciao,
Julian//

 a giocare peggio impostando una profondita' di ricerca dispari! :-)
    Confermo, anche senza aver visto il programma... se si implementa una
ricerca considerando un numero fisso di livelli si ottiene proprio l'effetto
indicato, per livelli dispari. Il problema č che un livello dispari
significa che l'ultima mossa analizzata č quella del programma, che potrebbe
benissimo essere una presa, senza tenere conto della replica dell'avversario
(che il piů delle volte č proprio una presa). Ad un livello pari, al
contrario, l'ultima mossa analizzata č quella dell'avversario e questo mette
al riparo dal''inconveniente. Con un livello pari, si rischia tuttavia di
non riuscire a vedere le sequenze di tre prese, con guadagno di un pezzo (o
pedone) per il programma, almeno dopo enne livelli, quando l'ultima presa
esce dall' "orizzonte". Drago implementa una semplice estensione della
ricerca, almeno per quanto riguarda le prese.
    Ciao!!!

 i vostri programmi sfruttano il tempo dell'avversario? se non lo fanno e
se
    Drago non sfrutta il tempo dell'avversario e se ne sta buono buono a
riposarsi dalle fatiche dell'analisi dell'ultima posizione, dopo aver
giocato l'ennesima mossa perdente :-))))) A parte gli scherzi, puoi usare
tranquillamente un unico PC, cosě da avere anche un confronto ancora piů
equo. La memoria utilizzata č veramente misera... gira tranquillamente anche
su un PC con 640 Kb di RAM... e ce ne avanza!!! :-)))
    Ciao!!!

 es. i jmp entro +/- 127 byte sono piu' veloci, i blocchi di dati allineati
sugli
    Se per hardware intendi la CPU, sono pienamente d'accordo. Avevo capito
male io, credevo che ti riferissi a tutto l'hardware del PC. Riguardo alle
"magagne" delle CPU Intel, cerco sempre di sfruttarle, come dici tu
(allineando i dati alla pagina ed evitando jmp relativi oltre i 127 bytes,
quando possibile).
    Ciao!!!

pronta), che sono proprio curioso di provare LarsenVB.
Ti ringrazio di nuovo per la disponibilita'... per il setup ho deciso di
affidarmi a Wise, che funziona assai meglio: faro' un setup completo e poi gli
aggiornamenti con solo gli exe... per quanto riguarda la pagina sono un po'
cocciuto e vorrei riuscire ad attivare quel cacchio di abbonamento, anche
perche' l'unico motivo per cui l'ho fatto e' proprio quello di creare un sito
per LarsenVB :(
Se vuoi curiosare un po' posso comunque mandarti la versione 0.2 all'indirizzo
che preferisci; cosi' magari mi dai anche qualche tirata d'orecchi ;)


     Ciao!!!
!!dicevo tutto l'harware!! :) anche se poi il centro di tutto e' sempre la CPU e
la MMU.
byezzz,
Julian//
ps. il discorso e' decisamente OT! :)

 che preferisci; cosi' magari mi dai anche qualche tirata d'orecchi ;)
    Ok, manda manda (
steg...@tin.it
)... nel frattempo mi sto organizzando
per la versione Windows di Drago (tempo permettendo).
    Ciao!!!