| #!/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 |
| import os |
| import 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 as 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 True: |
| 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 True: |
| 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() |