Newsgroup: it.hobby.scacchi
Titolo: Per tutti i programmatori scacchisti!!

Ciao!
volevo chiedervi, visto che un po' di tempo fa si parlava di creare il primo
programma di scacchi tutto italiano, se qualche programmatore sa come
leggere l'output di una finestra dos tramite VB, eventualmente con tutte le
API del caso.
Il mio problema, è che vorrei creare una interfaccia personale per crafty.
Ho provato a dare un'occhiata alle API che sono presenti sul Win32
Programmer's Reference relative all'input ed output da console ma
sinceramente sono troppo complicate per me per poterci capire qualcosa.
Sareste in grado di darmi un aiuto con qualche spezzone di codice, scambio
di informazioni, indirizzi internet o quant'altro che riguardino il mio
problema?
Vi ringrazio in qualsiasi caso
Un saluto
Daniele Cazzaro
PS. Ho trovato due controlli che rappresentano due scacchiere molto ben
fatte, un activeX ed una serie di file in C++, se li volete per il programma
di scacchi italiano che state realizzando ve li posso mandare, o lo volete
realizzare completamente voi, quindi TUTTO italiano?
Inoltre, che voi sappiate dato il listato in c++ sarebbe possibile
realizzare un controllo activeX (pura curiosita)?

 realizzare un controllo activeX (pura curiosita)?
    vediamo se il mio potentissimo collega ti puo' dire di piu'... chi vivra'
vedra'...!! (forse ho esagerato un po'!)
byezzz,
Julian//

Daniele Cazzaro
Il tuo approccio credo sia da contemplare solo quando la
documentazione non esiste, ma qui c'e' e credo che in un sacco di
posti sia possibile ottenere aiuto e delucidazioni, quindi...
Scusa se dico un'ovvieta', ma la cosa piu' naturale da fare a mio
parere e' leggere la documentazione scritta da Tim Mann su come
interfacciare gli engines con Winboard, in cui viene descritto il
protocollo di comunicazione da e verso Winboard.
Se non l'hai gia' fatto, l'indirizzo e' questo:
http://www.research.digital.com/SRC/personal/Tim_Mann/xboard/engine-intf.html

...


vediamo se c'ho capito qualcosa.
ho guardato il sito che spiega come interfacciare winboard o altre scacchiere con
i programmi, e non e' per niente difficile. In effetti tutta la sfilza di
spiegazioni che da' Timman si basano sullo stesso concetto, ovvero : "Il mio
programma manda delle stringhe -comandi- alla scacchiera" ed il bello che c'e' un
canale (uno solo) per input ed uno per l'output. Quindi avendo l'handle, piu'
chiaramente avendo un riferimento valido, al canale di input del winboard dal
nostro programma basta inviare la stringa di comando. Il protocollo del winboard
che fa cio' si chiama xboard.
L'unico punto che non ho capito -- ma xche' non sono ferrato in api windows -- e'
come ottengo l'handle di i/o del winboard // diciamo meglio, come faccio in
qualsiasi linguaggio ad ottenere un handle dal winboard. Se ho l'handle e'
semplice poi, e' come l'I/O in un file oppure a video (un solo canale) o leggere
da tastiera (l'altro canale)
Mio Programma, canale Output--->canale Input Winboard (mando i cmd al winboard)
Mio Programma, canale Input<---canale Ouput Winboard (ricevo le risposte dal
winboard)
Questo e' il punto di vista dal nostro applicativo, ovvero quello da sviluppare e
che si interfaccera' col W.Board.


sono le API per farlo.
-2. Connection
-
-An xboard chess engine runs as a separate process from xboard itself,
-connected to xboard through a pair of anonymous pipes. The
-engine does not have to do anything special to set up these pipes.
-xboard sets up the pipes itself and starts the engine with one pipe
-as
-its standard input and the other as its standard output. The engine
-then reads commands from its standard input and writes responses to
-its standard output. This is, unfortunately, a little more
-complicated to do right than it sounds; see section 6 below. 
Si parla di anonymous pipes.
-6. Hints on input/output
-The most direct way to fix this problem is to use unbuffered
-operating system calls to read (and poll) the underlying file
-descriptor
-directly. On Unix, use read(0, ...) to read from standard input, and
-use select() to poll it. See the man pages read(2) and
-select(2). (Don't follow the example of GNU Chess and use the
-FIONREAD ioctl to poll for input. It is not very portable; that is,
-it does not exist on all versions of Unix, and is broken on some that
-do have it.) On Win32, you can use either the Unix-like _read(0,
-...) or the native Win32 ReadFile() to read. Unfortunately, under
-Win32, the function to use for polling is different depending on
-whether the input device is a pipe, a console, or something else.
-(More Microsoft brain damage here -- did they never hear of device
-independence?) For pipes, you can use PeekNamedPipe to poll (even
-when the pipe is unnamed). For consoles, you can use
-GetNumberOfConsoleInputEvents. For sockets only, you can use
-select(). It might be possible to use WaitForSingleObject
-more generally, but I have not tried it. Some code to do these things
-can be found in Crafty's utility.c, but I don't guarantee that it's
-all correct or optimal. 
Qui un certo numero di indicazioni le da'.

 realizzare un controllo activeX (pura curiosita)?
E' possibile, pero' se non si ha molta dimestichezza con Visual C++ non e' un
lavoro banale. Per scrivere un controllo ActiveX in C++ esistono due
alternative: usare MFC oppure la Active Template Library (ATL). La prima
soluzione e' quella che offre maggiori funzionalita', la seconda e' piu'
"leggera" e flessibile. Da Visual C++ mediante un Wizard e' possibile creare lo
"scheletro" di un componente ActiveX che non fa nulla. A questo punto si
possono  inserire le funzionalita', cioe' cio' che e' presente nei listati C++.
Il programmatore deve in effetti solo conoscere e risolvere il suo problema (nel
tuo caso si parla di scacchi), tutto il codice per far generare il controllo
ActiveX sara' generato dal Wizard.
Per chi e' interessato posso consigliare gli articoli su IoProgrammo (Ed.Master)
di Aprile, Maggio e Giugno riguardanti controlli ActiveX e ATL.
joe (Amico di Julian)

...

un momento ...il programma di cui ho bisogno dell'handle è crafty per
inviare e recuperare i caratteri, perche io voglio creare una interfaccia
like winboard, o no?


Da quello che ho capito, c'č un motore che pensa e genera le mosse e riduce
il risultato delle sue ricerche ad una stringa che passa ad un altro programma
che emette a video con la grafica e le opzioni di visualizzazione preferite
il risultato delle elaborazioni.


1) programma che pensa la mossa

2) programma che riceve la mossa e che la emette a video.


Ora come si fa a collegare il programma 1 al programma 2?

esiste uno standard input output per cui ad esempio il programma che
pensa la messa restituisce

1) un singolo parametro ovvero la mossa (in formato standard)

2) una serie di parametri che possono essere una serie di informazioni
su tante cose relate alla posizione


domada: per collegare i due programmi basta usare un'apposita funzione
interna ai due programmi? esempio programma A pensa le mosse B emette a
video i risultati.


Ritengo che sia logica che B lanci A e gli passi dei parametri e che
A terminata la sua esecuzione restituisca a B i dati che gli servono in
un formato che era gia' previsto quando B lancia A che possono essre la
scrittura di un file oppure un modo piů dinamico dato che spesso i linguaggi
di programmazione diversi generano procedure in grado di dialogare tra
loro.


Se qualcuno di voi volesse fare una tabella chiara, su quali sono questi
programmi che pensano e quali fanno da interfaccia, e come si attiva il
collegamento.

Sono sicuro che tra voi c'e' chi e' in grado 
di
fare una cosa di questo tipo o magari di indicare dove gia' esiste. credo
che una discussione tecnica sull'argomento necessiti di uno strumento diverso,
tipo una pagina web su cui si danno le informazioni, leggere tutte le lettere
fare una sintesi e' un po' complicato per un principiante come me.


ciao


Ciao


 

 

 


D&G ha scritto:


un momento ...il programma di cui ho bisogno dell'handle č crafty per



>Ritengo che sia logica che B lanci A e gli passi dei parametri e che A
terminata la sua >esecuzione restituisca a B i dati che gli servono in un
formato che era gia' previsto quando B >lancia A che possono essre la
scrittura di un file oppure un modo più dinamico dato che >spesso i
linguaggi di programmazione diversi generano procedure in grado di dialogare
tra >loro.
In effetti si potrebbe lanciare ogni volta crafty settando la nuova
posizione ma rimarrebbe il problema di recuperare la mossa giocata da lui
stesso!!
Sono tra l'altro convinto che non sarebbe molto efficiente in termini di
velocita sebbene piu semplice, in fondo si tratta pur sempre di aprire il
programma e chiuderlo, aprire, chiudere, aprire, chiudere, e cosi via...non
? proprio il massimo!!
Daniele Cazzaro


--
Posted from 
mta02-acc.tin.it
 [212.216.176.33]
via Mailgate.ORG Server - 
http://www.mailgate.org

Altolà!!
Il programma lo devo fare in VB, ecco perche ho bisogno delle API!!
Comunque la cosa era interessante, anzi se continui...in VB naturalmente
mifaresti un favore!!
Bye
Daniele Cazzaro
Blade Spammer ha scritto nel messaggio ...



--
Posted from 
ro...@ascu.unian.it
 [193.205.128.30]


qualche forte programma di scacchi i cui sorgenti siano in VB?).
Beh in effetti mi suona strano visto che dovendo creare solo l'interfaccia
per crafty l'uso di qualche API dovrebbe risolvere il problema!!O no?!
Info in merito??
Bye
Daniele Cazzaro

...

E' tanto che provo a cimentarmi anch'io nell'impresa, ma per mancanza di tempo
(e come te di informazioni) fino adesso ho sempre cincischiato. Per ora posso
dirti che, prendendo spunto da un sorgente per applicazioni CGI, per trattare lo
standard input e lo standard output puoi usare queste funzioni:
Declare Function GetStdHandle Lib "kernel32"
    (ByVal nStdHandle As Long) As Long
per ottenere i due handle che ti interessano le costanti da usare sono:
Public Const STD_INPUT_HANDLE = -10&
Public Const STD_OUTPUT_HANDLE = -11&
la chiamata quindi e':
Public hStdIn         As Long   ' handle of Standard Input
Public hStdOut        As Long   ' handle of Standard Output
hStdIn = GetStdHandle(STD_INPUT_HANDLE)
hStdOut = GetStdHandle(STD_OUTPUT_HANDLE)
a questo punto e' possibile usare questi 2 handle con le seguenti funzioni (come
parametro hFile)
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
che, tra l'altro sono proprio quelle di cui parla Tim Mann riguardo alle
"unbuffered operating system calls".
in lettura, quindi, ReadFile(hStdIn,...); in scrittura servono queste altre due
funzioni:
Declare Function SetFilePointer Lib "kernel32" _
   (ByVal hFile As Long, _
   ByVal lDistanceToMove As Long, _
   lpDistanceToMoveHigh As Long, _
   ByVal dwMoveMethod As Long) As Long
Declare Function SetEndOfFile Lib "kernel32" _
   (ByVal hFile As Long) As Long
e quindi:
SetFilePointer hStdOut, 0&, 0&, 0& 'questo dovrebbe muovere il puntatore
all'inizio del file
WriteFile hStdOut, .....
SetEndOfFile hStdOut
Scusami, lo so che non e' molto chiaro ma non ho ancora avuto modo di provare io
stesso e non credo affatto che sia sufficiente solo questo; se riesco a
combinare qualcosa di piu' ti faccio sapere...
Ciao
--
   o   o
o / \ / \ o  Luca Dormio
  \ - - /    
ldo...@tin.it
 (real email address)
   =====
Chess.net ID: Luca_b3
FICS ID: LarsenB
IECG ID: 17105