implemented working externAgent wrapper

[progcomp10.git] / src / link / pexpect / examples / chess2.py

diff --git a/src/link/pexpect/examples/chess2.py b/src/link/pexpect/examples/chess2.py
new file mode 100755 (executable)
index 0000000..c62d5ce
--- /dev/null
+++ b/src/link/pexpect/examples/chess2.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+
+'''This demonstrates controlling a screen oriented application (curses).
+It starts two instances of gnuchess and then pits them against each other.
+'''
+
+import pexpect
+import string
+import ANSI
+import sys, os, time
+
+class Chess:
+
+        def __init__(self, engine = "/usr/local/bin/gnuchess -a -h 1"):
+                self.child = pexpect.spawn (engine)
+                self.term = ANSI.ANSI ()
+             
+                #self.child.expect ('Chess')
+                #if self.child.after != 'Chess':
+                #        raise IOError, 'incompatible chess program'
+                #self.term.process_list (self.child.before)
+                #self.term.process_list (self.child.after)
+
+                self.last_computer_move = ''
+
+        def read_until_cursor (self, r,c, e=0):
+            '''Eventually something like this should move into the screen class or
+            a subclass. Maybe a combination of pexpect and screen...
+            '''
+            fout = open ('log','a')
+            while self.term.cur_r != r or self.term.cur_c != c:
+                try:
+                    k = self.child.read(1, 10)
+                except Exception, e:
+                    print 'EXCEPTION, (r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c)
+                    sys.stdout.flush()
+                self.term.process (k)
+                fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c))
+                fout.flush()
+                if e:
+                    sys.stdout.write (k)
+                    sys.stdout.flush()
+                if self.term.cur_r == r and self.term.cur_c == c:
+                    fout.close()
+                    return 1
+            print 'DIDNT EVEN HIT.'
+            fout.close()
+            return 1
+
+        def expect_region (self):
+            '''This is another method that would be moved into the
+            screen class.
+            '''
+            pass
+        def do_scan (self):
+            fout = open ('log','a')
+            while 1:
+                c = self.child.read(1,10)
+                self.term.process (c)
+                fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c))
+                fout.flush()
+                sys.stdout.write (c)
+                sys.stdout.flush()
+
+        def do_move (self, move, e = 0):
+                time.sleep(1)
+                self.read_until_cursor (19,60, e)
+                self.child.sendline (move)
+
+        def wait (self, color):
+            while 1:
+                r = self.term.get_region (14,50,14,60)[0]
+                r = r.strip()
+                if r == color:
+                    return
+                time.sleep (1)
+
+        def parse_computer_move (self, s):
+                i = s.find ('is: ')
+                cm = s[i+3:i+9]        
+                return cm
+        def get_computer_move (self, e = 0):
+                time.sleep(1)
+                self.read_until_cursor (19,60, e)
+                time.sleep(1)
+                r = self.term.get_region (17,50,17,62)[0]
+                cm = self.parse_computer_move (r)
+                return cm
+
+        def switch (self):
+                print 'switching'
+                self.child.sendline ('switch')
+
+        def set_depth (self, depth):
+                self.child.sendline ('depth')
+                self.child.expect ('depth=')
+                self.child.sendline ('%d' % depth)
+
+        def quit(self):
+                self.child.sendline ('quit')
+
+def LOG (s):
+    print s
+    sys.stdout.flush ()
+    fout = open ('moves.log', 'a')
+    fout.write (s + '\n')
+    fout.close()
+
+print 'Starting...'
+
+black = Chess()
+white = Chess()
+white.read_until_cursor (19,60,1)
+white.switch()
+
+done = 0
+while not done:
+    white.wait ('Black')
+    move_white = white.get_computer_move(1)
+    LOG ( 'move white:'+ move_white )
+
+    black.do_move (move_white)
+    black.wait ('White')
+    move_black = black.get_computer_move()
+    LOG ( 'move black:'+ move_black )
+   
+    white.do_move (move_black, 1)
+
+g.quit()
+
+