displays and engines now always have a single object associated with

them

diff --git a/chess-common.el b/chess-common.el
index 7161e73c26db854588e41e13477412f4461acbc3..9e05c96eb5e6e5b458ba27babd69f8c0620ee217 100644 (file)
--- a/chess-common.el
+++ b/chess-common.el
@@ -37,8 +37,7 @@
       proc))
 
    ((eq event 'ready)
-    (and (chess-engine-game nil)
-        (chess-game-set-data (chess-engine-game nil) 'active t)))
+    (chess-game-set-data chess-engine-game 'active t))
 
    ((eq event 'shutdown)
     (chess-engine-send nil "quit\n")
@@ -58,16 +57,14 @@
 
    ((memq event '(resign abort))
     (chess-engine-send nil "new\n")
-    (and (chess-engine-game nil)
-        (chess-engine-set-start-position nil)))
+    (chess-engine-set-position nil))
 
    ((eq event 'undo)
-    (when (chess-engine-game nil)
-      (dotimes (i (car args))
-       (chess-engine-send nil "undo\n"))
-      (if (= 1 (mod (car args) 2))
-         (chess-engine-send nil "go\n"))
-      (chess-game-undo (chess-engine-game nil) (car args))))
+    (dotimes (i (car args))
+      (chess-engine-send nil "undo\n"))
+    (if (= 1 (mod (car args) 2))
+       (chess-engine-send nil "go\n"))
+    (chess-game-undo chess-engine-game (car args)))
 
    ((eq event 'move)
     (chess-engine-send nil (concat (chess-ply-to-algebraic (car args))

diff --git a/chess-display.el b/chess-display.el
index 931acbb11ced1b3846c534c7368750d4fc75e1f3..5fd3fc4d04bf9799b49bdb8f8e68ed4429063732 100644 (file)
--- a/chess-display.el
+++ b/chess-display.el
@@ -138,10 +138,8 @@ makes moves, or any other changes to the underlying game."
 
 (defun chess-display-set-ply (display ply)
   (chess-with-current-buffer display
-    (setq chess-game-index 1)
-    (chess-game-set-plies chess-display-game
-                         (list ply (chess-ply-create
-                                    (chess-ply-next-pos ply))))))
+    ;; jww (2002-04-13): NYI
+    ))
 
 (defun chess-display-ply (display)
   (chess-with-current-buffer display
@@ -154,8 +152,8 @@ the user able to scroll back and forth through the moves in the
 variation.  Any moves made on the board will extend/change the
 variation that was passed in."
   (chess-with-current-buffer display
-    (setq chess-game-index (or index (chess-var-index variation)))
-    (chess-game-set-plies chess-display-game variation)))
+    ;; jww (2002-04-13): NYI
+    ))
 
 (defun chess-display-variation (display)
   (chess-with-current-buffer display

diff --git a/chess-engine.el b/chess-engine.el
index f90c50475914af49d676b118f6aa860ca3bfce1e..a207c34ca87f433ecd5909a8982e42c3ca9c4b21 100644 (file)
--- a/chess-engine.el
+++ b/chess-engine.el
@@ -18,7 +18,6 @@
 (defvar chess-engine-event-handler nil)
 (defvar chess-engine-response-handler nil)
 (defvar chess-engine-current-marker nil)
-(defvar chess-engine-position nil)
 (defvar chess-engine-game nil)
 (defvar chess-engine-pending-offer nil)
 (defvar chess-engine-pending-arg nil)
@@ -27,7 +26,6 @@
 (make-variable-buffer-local 'chess-engine-event-handler)
 (make-variable-buffer-local 'chess-engine-response-handler)
 (make-variable-buffer-local 'chess-engine-current-marker)
-(make-variable-buffer-local 'chess-engine-position)
 (make-variable-buffer-local 'chess-engine-game)
 (make-variable-buffer-local 'chess-engine-pending-offer)
 (make-variable-buffer-local 'chess-engine-pending-arg)
@@ -57,13 +55,6 @@
           ,@body)
        ,@body)))
 
-(defun chess-engine-do-move (ply)
-  (cond
-   (chess-engine-game
-    (chess-game-move chess-engine-game ply))
-   (chess-engine-position
-    (setq chess-engine-position (chess-ply-next-pos ply)))))
-
 (defsubst chess-engine-convert-algebraic (move &optional trust-check)
   (or (chess-algebraic-to-ply (chess-engine-position nil) move trust-check)
       (ignore
@@ -80,201 +71,183 @@
        (message "Received invalid PGN text"))))
 
 (defun chess-engine-default-handler (event &rest args)
-  (let ((game (chess-engine-game nil)))
-    (cond
-     ((eq event 'move)
-      (if (null game)
+  (cond
+   ((eq event 'move)
+    (if (chess-game-data chess-engine-game 'active)
+       ;; we don't want the `move' event coming back to us
+       (let ((chess-engine-handling-event t))
          (when (car args)
-           (setq chess-engine-position (chess-ply-next-pos (car args)))
-           t)
-       (if (chess-game-data game 'active)
-           ;; we don't want the `move' event coming back to us
+           ;; if the game index is still 0, then our opponent
+           ;; is white, and we need to pass over the move
+           (when (and (not chess-engine-inhibit-auto-pass)
+                      (chess-game-data chess-engine-game 'my-color)
+                      (= (chess-game-index chess-engine-game) 0))
+             (message "Your opponent played the first move, you are now black")
+             (chess-game-run-hooks chess-engine-game 'pass)
+             ;; if no one else flipped my-color, we'll do it
+             (if (chess-game-data chess-engine-game 'my-color)
+                 (chess-game-set-data chess-engine-game 'my-color nil)))
+           (chess-game-move chess-engine-game (car args))
+           t))))
+
+   ((eq event 'pass)
+    (when (chess-game-data chess-engine-game 'active)
+      (message "Your opponent has passed the move to you")
+      t))
+
+   ((eq event 'match)
+    (if (chess-game-data chess-engine-game 'active)
+       (chess-engine-command nil 'busy)
+      (if (y-or-n-p
+          (if (and (car args) (> (length (car args)) 0))
+              (format "Do you wish to play a chess game against %s? "
+                      (car args))
+            (format "Do you wish to play a chess game against an anonymous opponent? ")))
+         (progn
            (let ((chess-engine-handling-event t))
-             (when (car args)
-               ;; if the game index is still 0, then our opponent
-               ;; is white, and we need to pass over the move
-               (when (and game
-                          (not chess-engine-inhibit-auto-pass)
-                          (chess-game-data game 'my-color)
-                          (= (chess-game-index game) 0))
-                 (message "Your opponent played the first move, you are now black")
-                 (chess-game-run-hooks game 'pass)
-                 ;; if no one else flipped my-color, we'll do it
-                 (if (chess-game-data game 'my-color)
-                     (chess-game-set-data game 'my-color nil)))
-               (chess-engine-do-move (car args))
-               t)))))
-
-     ((eq event 'pass)
-      (when (and game (chess-game-data game 'active))
-       (message "Your opponent has passed the move to you")
-       t))
-
-     ((eq event 'match)
-      (if (and game (chess-game-data game 'active))
-         (chess-engine-command nil 'busy)
-       (if (y-or-n-p
-            (if (and (car args) (> (length (car args)) 0))
-                (format "Do you wish to play a chess game against %s? "
-                        (car args))
-              (format "Do you wish to play a chess game against an anonymous opponent? ")))
-           (progn
-             (let ((chess-engine-handling-event t))
-               (unless game
-                 (setq game (chess-engine-set-game nil (chess-game-create))))
-               (chess-engine-set-start-position nil))
-             (chess-engine-command nil 'accept))
-         (chess-engine-command nil 'decline)))
-      t)
-
-     ((eq event 'setup-pos)
-      (when (car args)
-       ;; we don't want the `setup-game' event coming back to us
-       (let ((chess-engine-handling-event t))
-         (chess-engine-set-start-position nil (car args) t))
-       t))
-
-     ((eq event 'setup-game)
-      (when (car args)
-       ;; we don't want the `setup-game' event coming back to us
-       (let ((chess-engine-handling-event t))
-         (if (null game)
-             (chess-engine-set-game nil (car args))
-           (let ((chess-game-inhibit-events t))
-             (chess-engine-copy-game nil (car args))
-             (chess-game-set-data game 'active t)
-             (if (string= chess-full-name (chess-game-tag game "White"))
-                 (chess-game-set-data game 'my-color t)
-               (chess-game-set-data game 'my-color nil)))
-           (chess-game-run-hooks game 'orient)))
-       t))
-
-     ((eq event 'quit)
-      (message "Your opponent has quit playing")
-      (if game
+             (chess-engine-set-position nil))
+           (chess-engine-command nil 'accept))
+       (chess-engine-command nil 'decline)))
+    t)
+
+   ((eq event 'setup-pos)
+    (when (car args)
+      ;; we don't want the `setup-game' event coming back to us
+      (let ((chess-engine-handling-event t))
+       (chess-engine-set-position nil (car args) t))
+      t))
+
+   ((eq event 'setup-game)
+    (when (car args)
+      ;; we don't want the `setup-game' event coming back to us
+      (let ((chess-engine-handling-event t))
+       (let ((chess-game-inhibit-events t))
+         (chess-engine-set-game nil (car args))
+         (chess-game-set-data chess-engine-game 'active t)
+         (if (string= chess-full-name
+                      (chess-game-tag chess-engine-game "White"))
+             (chess-game-set-data chess-engine-game 'my-color t)
+           (chess-game-set-data chess-engine-game 'my-color nil))))
+      t))
+
+   ((eq event 'quit)
+    (message "Your opponent has quit playing")
+    (let ((chess-engine-handling-event t))
+      (chess-game-set-data chess-engine-game 'active nil))
+    t)
+
+   ((eq event 'resign)
+    (let ((chess-engine-handling-event t))
+      (message "Your opponent has resigned")
+      (chess-game-end chess-engine-game :resign)
+      (chess-game-set-data chess-engine-game 'active nil)
+      t))
+
+   ((eq event 'draw)
+    (if (y-or-n-p "Your opponent offers a draw, accept? ")
+       (progn
          (let ((chess-engine-handling-event t))
-           (chess-game-set-data game 'active nil)))
-      t)
-
-     ((eq event 'resign)
-      (when game
-       (let ((chess-engine-handling-event t))
-         (message "Your opponent has resigned")
-         (chess-game-end game :resign)
-         (chess-game-set-data game 'active nil))
-       t))
-
-     ((eq event 'draw)
-      (when game
-       (if (y-or-n-p "Your opponent offers a draw, accept? ")
-           (progn
-             (let ((chess-engine-handling-event t))
-               (chess-game-end game :draw)
-               (chess-game-set-data game 'active nil))
-             (chess-engine-command nil 'accept))
-         (chess-engine-command nil 'decline))
-       t))
-
-     ((eq event 'abort)
-      (when game
-       (if (y-or-n-p "Your opponent wants to abort this game, accept? ")
-           (progn
-             (let ((chess-engine-handling-event t))
-               (chess-game-set-data game 'active nil))
-             (chess-engine-command nil 'accept))
-         (chess-engine-command nil 'decline))
-       t))
-
-     ((eq event 'undo)
-      (when game
-       (if (y-or-n-p
-            (format "Your opponent wants to take back %d moves, accept? "
-                    (car args)))
-           (progn
-             (let ((chess-engine-handling-event t))
-               (chess-game-undo game (car args)))
-             (chess-engine-command nil 'accept))
-         (chess-engine-command nil 'decline))
-       t))
-
-     ((eq event 'accept)
-      (when chess-engine-pending-offer
-       (if (eq chess-engine-pending-offer 'match)
-           (unless (and game (chess-game-data game 'active))
-             (if (and (car args) (> (length (car args)) 0))
-                 (message "Your opponent, %s, is now ready to play"
-                          (car args))
-               (message "Your opponent is now ready to play"))
-             (let ((chess-engine-handling-event t))
-               ;; NOTE: There will be no display for this game object!  This
-               ;; is really only useful if you are using a computer on the
-               ;; accepting side
-               (unless game
-                 (setq game (chess-engine-set-game nil (chess-game-create))))
-               (chess-engine-set-start-position nil)))
+           (chess-game-end chess-engine-game :draw)
+           (chess-game-set-data chess-engine-game 'active nil))
+         (chess-engine-command nil 'accept))
+      (chess-engine-command nil 'decline))
+    t)
+
+   ((eq event 'abort)
+    (if (y-or-n-p "Your opponent wants to abort this game, accept? ")
+       (progn
          (let ((chess-engine-handling-event t))
-           (cond
-            ((eq chess-engine-pending-offer 'draw)
-             (message "Your draw offer was accepted")
-             (chess-game-end game :draw)
-             (chess-game-set-data game 'active nil))
-
-            ((eq chess-engine-pending-offer 'abort)
-             (message "Your offer to abort was accepted")
-             (chess-game-set-data game 'active nil))
-
-            ((eq chess-engine-pending-offer 'undo)
-             (message "Request to undo %d moves was accepted"
-                      chess-engine-pending-arg)
-             (chess-game-undo game (car args))))))
-       (setq chess-engine-pending-offer nil
-             chess-engine-pending-arg nil)
-       t))
-
-     ((eq event 'decline)
-      (when (and game chess-engine-pending-offer)
-       (cond
-        ((eq chess-engine-pending-offer 'draw)
-         (message "Your draw offer was declined"))
-
-        ((eq chess-engine-pending-offer 'abort)
-         (message "Your offer to abort was declined"))
-
-        ((eq chess-engine-pending-offer 'undo)
-         (message "Your request to undo %d moves was decline"
-                  chess-engine-pending-arg)))
-
-       (setq chess-engine-pending-offer nil
-             chess-engine-pending-arg nil)
-       t))
-
-     ((eq event 'retract)
-      (when (and game chess-engine-pending-offer)
-       (cond
-        ((eq chess-engine-pending-offer 'draw)
-         (message "Your opponent has retracted their draw offer"))
-
-        ((eq chess-engine-pending-offer 'abort)
-         (message "Your opponent has retracted their offer to abort"))
-
-        ((eq chess-engine-pending-offer 'undo)
-         (message "Your opponent has retracted their request to undo %d moves"
-                  chess-engine-pending-arg)))
-
-       (setq chess-engine-pending-offer nil
-             chess-engine-pending-arg nil)
-       t)))))
-
-(defun chess-engine-create (module &optional response-handler &rest args)
+           (chess-game-set-data chess-engine-game 'active nil))
+         (chess-engine-command nil 'accept))
+      (chess-engine-command nil 'decline))
+    t)
+
+   ((eq event 'undo)
+    (if (y-or-n-p
+        (format "Your opponent wants to take back %d moves, accept? "
+                (car args)))
+       (progn
+         (let ((chess-engine-handling-event t))
+           (chess-game-undo chess-engine-game (car args)))
+         (chess-engine-command nil 'accept))
+      (chess-engine-command nil 'decline))
+    t)
+
+   ((eq event 'accept)
+    (when chess-engine-pending-offer
+      (if (eq chess-engine-pending-offer 'match)
+         (unless (chess-game-data chess-engine-game 'active)
+           (if (and (car args) (> (length (car args)) 0))
+               (message "Your opponent, %s, is now ready to play"
+                        (car args))
+             (message "Your opponent is now ready to play"))
+           (let ((chess-engine-handling-event t))
+             (chess-engine-set-position nil)))
+       (let ((chess-engine-handling-event t))
+         (cond
+          ((eq chess-engine-pending-offer 'draw)
+           (message "Your draw offer was accepted")
+           (chess-game-end chess-engine-game :draw)
+           (chess-game-set-data chess-engine-game 'active nil))
+
+          ((eq chess-engine-pending-offer 'abort)
+           (message "Your offer to abort was accepted")
+           (chess-game-set-data chess-engine-game 'active nil))
+
+          ((eq chess-engine-pending-offer 'undo)
+           (message "Request to undo %d moves was accepted"
+                    chess-engine-pending-arg)
+           (chess-game-undo chess-engine-game (car args))))))
+      (setq chess-engine-pending-offer nil
+           chess-engine-pending-arg nil)
+      t))
+
+   ((eq event 'decline)
+    (when chess-engine-pending-offer
+      (cond
+       ((eq chess-engine-pending-offer 'draw)
+       (message "Your draw offer was declined"))
+
+       ((eq chess-engine-pending-offer 'abort)
+       (message "Your offer to abort was declined"))
+
+       ((eq chess-engine-pending-offer 'undo)
+       (message "Your request to undo %d moves was decline"
+                chess-engine-pending-arg)))
+
+      (setq chess-engine-pending-offer nil
+           chess-engine-pending-arg nil)
+      t))
+
+   ((eq event 'retract)
+    (when chess-engine-pending-offer
+      (cond
+       ((eq chess-engine-pending-offer 'draw)
+       (message "Your opponent has retracted their draw offer"))
+
+       ((eq chess-engine-pending-offer 'abort)
+       (message "Your opponent has retracted their offer to abort"))
+
+       ((eq chess-engine-pending-offer 'undo)
+       (message "Your opponent has retracted their request to undo %d moves"
+                chess-engine-pending-arg)))
+
+      (setq chess-engine-pending-offer nil
+           chess-engine-pending-arg nil)
+      t))))
+
+(defun chess-engine-create (game module &optional response-handler
+                                &rest handler-ctor-args)
   (let ((regexp-alist (intern-soft (concat (symbol-name module)
                                           "-regexp-alist")))
        (handler (intern-soft (concat (symbol-name module) "-handler"))))
     (with-current-buffer (generate-new-buffer " *chess-engine*")
-      (let ((proc (apply handler 'initialize args)))
+      (let ((proc (apply handler 'initialize handler-ctor-args)))
        (setq chess-engine-regexp-alist (symbol-value regexp-alist)
              chess-engine-event-handler handler
              chess-engine-response-handler
              (or response-handler 'chess-engine-default-handler))
+       (chess-engine-set-game* nil game t)
        (when (processp proc)
          (unless (memq (process-status proc) '(run open))
            (error "Failed to start chess engine process"))
@@ -299,8 +272,8 @@
 
 (defun chess-engine-command (engine event &rest args)
   (chess-with-current-buffer engine
-    (apply 'chess-engine-event-handler
-          (chess-engine-game nil) engine event args)))
+    (apply 'chess-engine-event-handler chess-engine-game
+          engine event args)))
 
 ;; 'ponder
 ;; 'search-depth
@@ -323,75 +296,44 @@
   (chess-with-current-buffer engine
     chess-engine-response-handler))
 
-(defun chess-engine-set-position (engine position)
+(defun chess-engine-set-position (engine &optional position my-color)
   (chess-with-current-buffer engine
-    (if chess-engine-game
-       (chess-engine-detach-game nil))
-    (setq chess-engine-game nil
-         chess-engine-position position)
-    (chess-engine-command nil 'setup-pos position)))
+    (let ((chess-game-inhibit-events t))
+      (if position
+         (progn
+           (chess-game-set-start-position chess-engine-game position)
+           (chess-game-set-data chess-engine-game 'my-color my-color))
+       (chess-game-set-start-position chess-engine-game
+                                      chess-starting-position)
+       (chess-game-set-data chess-engine-game 'my-color t))
+      (chess-game-set-data chess-engine-game 'active t))))
 
 (defun chess-engine-position (engine)
   (chess-with-current-buffer engine
-    (or (and chess-engine-game
-            (chess-game-pos chess-engine-game))
-       chess-engine-position)))
+    (chess-game-pos chess-engine-game)))
 
-(defun chess-engine-set-start-position (engine &optional position my-color)
+(defun chess-engine-set-game (engine game &optional no-setup)
   (chess-with-current-buffer engine
-    (let ((game (chess-engine-game nil)))
-      (if (null game)
-         (chess-engine-set-position nil (or position
-                                            chess-starting-position))
-       (let ((chess-game-inhibit-events t))
-         (if position
-             (progn
-               (chess-game-set-start-position game position)
-               (chess-game-set-data game 'my-color my-color))
-           (chess-game-set-start-position game chess-starting-position)
-           (chess-game-set-data game 'my-color t))
-         (chess-game-set-data game 'active t))
-       (chess-game-run-hooks game 'orient)))))
+    (chess-game-set-tags chess-engine-game (chess-game-tags game))
+    ;; this call triggers `setup-game' for us
+    (let ((chess-game-inhibit-events no-setup))
+      (chess-game-set-plies chess-engine-game (chess-game-plies game)))))
 
-(defun chess-engine-set-game (engine game &optional no-setup)
+(defun chess-engine-set-game* (engine game &optional no-setup)
   (chess-with-current-buffer engine
     (if chess-engine-game
        (chess-engine-detach-game nil))
-    (setq chess-engine-game game
-         chess-engine-position nil)
-    (when game
-      (chess-game-add-hook game 'chess-engine-event-handler engine)
-      (unless no-setup
-       (chess-engine-command nil 'setup-game game)))))
-
-(defsubst chess-engine-set-game* (engine game)
-  "This function is a special variant of `chess-engine-set-game'.
-It should be used only if:
-  ENGINE is an engine which is newly created, and has not been used.
-  GAME is a new game at the starting position, which has not been used.
-
-This function exists because all engines start out assuming the
-starting position, which in effect means that `setup-game's work has
-already been done, and therefore does not need to be duplicated.
-
-There is no harm in calling `chess-engine-set-game' instead of this
-function in all cases; this is merely a bandwidth-saver."
-  (chess-engine-set-game engine game t))
-
-(defun chess-engine-copy-game (engine game)
-  (chess-with-current-buffer engine
-    (if (null chess-engine-game)
-       (chess-engine-set-game nil game)
-      (chess-game-set-tags chess-engine-game game)
-      ;; this call triggers `setup-game' for us
-      (chess-game-set-plies chess-engine-game game))))
+    (setq chess-engine-game game)
+    (chess-game-add-hook game 'chess-engine-event-handler
+                        (or engine (current-buffer)))
+    (unless no-setup
+      (chess-engine-command nil 'setup-game game))))
 
 (defun chess-engine-detach-game (engine)
   (chess-with-current-buffer engine
-    (if chess-engine-game
-       (chess-game-remove-hook chess-engine-game
-                               'chess-engine-event-handler
-                               (or engine (current-buffer))))))
+    (chess-game-remove-hook chess-engine-game
+                           'chess-engine-event-handler
+                           (or engine (current-buffer)))))
 
 (defun chess-engine-game (engine)
   (chess-with-current-buffer engine
@@ -399,12 +341,11 @@ function in all cases; this is merely a bandwidth-saver."
 
 (defun chess-engine-index (engine)
   (chess-with-current-buffer engine
-    (if chess-engine-game
-       (chess-game-index chess-engine-game))))
+    (chess-game-index chess-engine-game)))
 
 (defun chess-engine-move (engine ply)
   (chess-with-current-buffer engine
-    (chess-engine-do-move ply)
+    (chess-game-move chess-engine-game ply)
     (chess-engine-command engine 'move ply)))
 
 (defun chess-engine-send (engine string)
@@ -437,7 +378,6 @@ function in all cases; this is merely a bandwidth-saver."
   "Handle any commands being sent to this instance of this module."
   (unless chess-engine-handling-event
     (chess-with-current-buffer engine
-      (assert (eq game (chess-engine-game nil)))
       (apply chess-engine-event-handler event args))
 
     (cond

diff --git a/chess-ics.el b/chess-ics.el
index 5bd9639e73962e56fe1c1e4749e6aa7d659712f4..96a410d63aa5b8378bb76daea97e2991788fbd88 100644 (file)
--- a/chess-ics.el
+++ b/chess-ics.el
@@ -126,25 +126,25 @@ who is black."
   (let ((chess-engine-handling-event t)
        (begin (match-beginning 1))
        (end (match-end 1))
-       (info (chess-ics12-parse (match-string 3)))
-       (game (chess-engine-game nil)))
-    (assert game)
-    (if (and (chess-game-data game 'active)
-            (> (chess-game-index game) 0))
+       (info (chess-ics12-parse (match-string 3))))
+    (if (and (chess-game-data chess-engine-game 'active)
+            (> (chess-game-index chess-engine-game) 0))
        (when (and (cadr info)
                   (eq (chess-pos-side-to-move (car info))
-                      (chess-game-data game 'my-color)))
-         (chess-engine-do-move
-          (chess-algebraic-to-ply
-           (chess-ply-pos (car (last (chess-game-plies game))))
-           (cadr info) t))
+                      (chess-game-data chess-engine-game 'my-color)))
+         (chess-game-move chess-engine-game
+                          (chess-algebraic-to-ply
+                           (chess-ply-pos
+                            (car (last (chess-game-plies chess-engine-game))))
+                           (cadr info) t))
          (assert (equal (car info) (chess-engine-position nil))))
       (let ((chess-game-inhibit-events t) plies)
-       (chess-game-set-data game 'my-color (string= (nth 2 info)
-                                                    chess-ics-handle))
-       (chess-game-set-data game 'active t)
-       (chess-game-set-start-position game (car info)))
-      (chess-game-run-hooks game 'orient))
+       (chess-game-set-data chess-engine-game
+                            'my-color (string= (nth 2 info)
+                                               chess-ics-handle))
+       (chess-game-set-data chess-engine-game 'active t)
+       (chess-game-set-start-position chess-engine-game (car info)))
+      (chess-game-run-hooks chess-engine-game 'orient))
     (delete-region begin end)
     t))
 

diff --git a/chess-link.el b/chess-link.el
index a6dea4e0cfa473838f23c19c67f18d13c11e3d12..9552a0f02b085050b62f8cb8a7665091b9a33913 100644 (file)
--- a/chess-link.el
+++ b/chess-link.el
@@ -12,10 +12,11 @@
 
 (defun chess-link-response-handler (event &rest args)
   "This function handles responses from the bot's computing engine."
-  (let* ((game (chess-engine-game nil))
-        (first-engine (chess-game-data game 'first-engine))
-        (second-engine (chess-game-data game 'second-engine))
-        return-value)
+  (let ((first-engine
+        (chess-game-data chess-engine-game 'first-engine))
+       (second-engine
+        (chess-game-data chess-engine-game 'second-engine))
+       return-value)
     (cond
      ((eq event 'match)
       (chess-engine-command nil 'accept)
@@ -51,23 +52,23 @@ engine, and the computer the second engine."
        second-engine-type (intern (concat "chess-" second-engine-type)))
   (require chess-default-display)
   (let* ((my-color t)                  ; we start out as white always
-        (display (chess-display-create chess-default-display my-color))
-        (game (chess-game-create)))
+        (game (chess-game-create))
+        (display (chess-display-create game chess-default-display
+                                       my-color)))
     (chess-game-set-data game 'my-color my-color)
-    (chess-display-set-game display game)
     (chess-display-set-main display)
     (chess-display-disable-popup display)
     (condition-case err
        (when (and (require first-engine-type)
                   (require second-engine-type))
-         (let ((first-engine (chess-engine-create first-engine-type))
-               (second-engine (chess-engine-create second-engine-type)))
+         (let ((first-engine
+                (chess-engine-create game first-engine-type))
+               (second-engine
+                (chess-engine-create game second-engine-type)))
 
-           (chess-engine-set-game* first-engine game)
            (chess-game-set-data game 'first-engine first-engine)
            (chess-engine-command first-engine 'ready)
 
-           (chess-engine-set-game* second-engine game)
            (chess-game-set-data game 'second-engine second-engine)
            (chess-link-connect first-engine second-engine)
            (chess-engine-command second-engine 'ready)

diff --git a/chess-network.el b/chess-network.el
index c80487e65e03a2cabe2bb3db9f2622e559020fe6..c5e92c926c7663720811d2a4fc8b3f6adb7f59ab 100644 (file)
--- a/chess-network.el
+++ b/chess-network.el
@@ -112,8 +112,7 @@
 
    ((eq event 'resign)
     (chess-engine-send nil "resign\n")
-    (and (chess-engine-game nil)
-        (chess-game-set-data (chess-engine-game nil) 'active nil)))
+    (chess-game-set-data chess-engine-game 'active nil))
 
    ((eq event 'draw)
     (if chess-engine-pending-offer
@@ -144,10 +143,9 @@
     (chess-engine-send nil "retract\n"))
 
    ((eq event 'move)
-    (chess-engine-send nil (concat (chess-ply-to-algebraic (car args))
-                                  "\n"))
-    (if (chess-game-over-p (chess-engine-game nil))
-       (chess-game-set-data (chess-engine-game nil) 'active nil)))))
+    (chess-engine-send nil (concat (chess-ply-to-algebraic (car args)) "\n"))
+    (if (chess-game-over-p chess-engine-game)
+       (chess-game-set-data chess-engine-game 'active nil)))))
 
 (provide 'chess-network)
 

diff --git a/chess-none.el b/chess-none.el
index db628bf7ee59a1df7807520bedbcf3c35bcc9caf..edd2a293caf8f55c6ffd571e4487068cb9426205 100644 (file)
--- a/chess-none.el
+++ b/chess-none.el
@@ -7,17 +7,16 @@
 (require 'chess-engine)
 
 (defun chess-none-handler (event &rest args)
-  "Initialize the network chess engine."
+  "An empty chess engine, used for fielding key events.
+This is only useful when two humans are playing each other, in which
+case this engine will do the job of accepting undos, handling
+resignations, etc."
   (cond
-   ((eq event 'send))
-
    ((memq event '(resign abort))
-    (and (chess-engine-game nil)
-        (chess-engine-set-start-position nil)))
+    (chess-engine-set-position nil))
 
    ((eq event 'undo)
-    (if (chess-engine-game nil)
-       (chess-game-undo (chess-engine-game nil) (car args))))))
+    (chess-game-undo chess-engine-game (car args)))))
 
 (provide 'chess-none)
 

diff --git a/chess.el b/chess.el
index 0048b6bb5bc8f9386307d2ab2a89b0883f537c05..26ec0769ff0fa3c4ad5667579eba5e07ce75856c 100644 (file)
--- a/chess.el
+++ b/chess.el
@@ -128,8 +128,9 @@ minibuffer, which works well for Emacspeak users."
 
   (require chess-default-display)
   (let* ((my-color t)                  ; we start out as white always
-        (display (chess-display-create chess-default-display my-color))
-        (game (chess-game-create)))
+        (game (chess-game-create))
+        (display (chess-display-create game chess-default-display
+                                       my-color)))
 
     (when (and (eq chess-default-display 'chess-images)
               (with-current-buffer display
@@ -137,19 +138,17 @@ minibuffer, which works well for Emacspeak users."
       (message "Could not find suitable chess images; using ics1 display")
       (chess-display-destroy display)
       (require 'chess-ics1)
-      (setq display (chess-display-create 'chess-ics1 my-color)))
+      (setq display (chess-display-create game 'chess-ics1 my-color)))
 
     (chess-game-set-data game 'my-color my-color)
     (if disable-popup
        (chess-display-disable-popup display))
-    (chess-display-set-game display game)
     (chess-display-set-main display)
 
     (let ((engine-module (or engine chess-default-engine)))
       (when (and engine-module (require engine-module nil t))
-       (let ((engine (apply 'chess-engine-create engine-module nil
+       (let ((engine (apply 'chess-engine-create game engine-module nil
                             engine-ctor-args)))
-         (chess-engine-set-game* engine game)
          ;; for the sake of engines which are ready to play now, and
          ;; which don't need connect/accept negotiation (most
          ;; computerized engines fall into this category), we need to
@@ -187,9 +186,8 @@ minibuffer, which works well for Emacspeak users."
   (let ((game (chess-pgn-to-game)))
     (when game
       (require chess-default-display)
-      (chess-display-set-game
-       (chess-display-create chess-default-display
-                            (chess-game-side-to-move game)) game))))
+      (chess-display-create game chess-default-display
+                           (chess-game-side-to-move game)))))
 
 (defvar chess-puzzle-locations nil)
 
@@ -220,23 +218,23 @@ making it easy to go on to the next puzzle once you've solved one."
       (let ((game (chess-pgn-to-game)))
        (when game
          (require chess-default-display)
-         (let ((puzzle-display
-                (or (and (buffer-live-p (aref chess-puzzle-locations 2))
-                         (aref chess-puzzle-locations 2))
-                    (chess-display-create chess-default-display
-                                          (chess-game-side-to-move game)))))
-           (chess-display-set-game puzzle-display game)
+         (let (puzzle-display)
+           (if (buffer-live-p (aref chess-puzzle-locations 2))
+               (progn
+                 (setq puzzle-display (aref chess-puzzle-locations 2))
+                 (chess-display-set-game puzzle-display game))
+             (setq puzzle-display
+                   (chess-display-create game chess-default-display
+                                         (chess-game-side-to-move game))))
            (aset chess-puzzle-locations 2 puzzle-display)
            ;; setup spacebar as a convenient way to jump to the next puzzle
            (with-current-buffer puzzle-display
              (define-key (current-local-map) [? ] 'chess-puzzle-next)))
          (require chess-default-engine)
-         (let ((puzzle-engine
-                (or (and (buffer-live-p (aref chess-puzzle-locations 3))
-                         (aref chess-puzzle-locations 3))
-                    (chess-engine-create chess-default-engine))))
-           (chess-engine-set-game puzzle-engine game)
-           (aset chess-puzzle-locations 3 puzzle-engine)))))))
+         (aset chess-puzzle-locations 3
+               (or (and (buffer-live-p (aref chess-puzzle-locations 3))
+                        (aref chess-puzzle-locations 3))
+                   (chess-engine-create game chess-default-engine))))))))
 
 (provide 'chess)