A bit cleaner logic, and removed unnecessary case in RPS check

gib-gab-gob/actors.scm

@@ -4,14 +4,13 @@
   #:use-module (goblins actor-lib methods)
   #:use-module (goblins actor-lib sealers)
   #:use-module (oop goops)
-  #:export (^rps ^client-picker))
+  #:export (^game-lobby ^client-picker))
 
-(define* (^rps bcom)
+(define* (^game-lobby bcom)
   (define pick (pick-rps))
   (methods
    ((register-opponent name client sealed-pick)
     (format #t "Hey there, ~a! You sent me your pick of rock-paper-scissors; now I will send mine.\n" name)
-    ;; server always picks scissors, it's the best strat
     (on (<- (<- client 'exchange-pick-for-unsealer pick) sealed-pick)
         (lambda (peer-pick)
           (format #t "The peer has picked ~a (do I win? ~s)\n" peer-pick (rps-winner pick peer-pick)))))))
@@ -21,8 +20,7 @@
     (spawn-sealer-triplet))
   (define pick (pick-rps))
   (methods
-   ;; client always picks rock, it's the real good strat
    ((get-sealed-pick) ($ seal-pick pick))
    ((exchange-pick-for-unsealer peer-pick)
-    (format #t "Peer picked ~a... (do I win? ~s), i will send my unsealer\n" peer-pick (rps-winner pick peer-pick))
+    (format #t "Peer picked ~a... a bold choice (do I win? ~s), i will send my unsealer\n" peer-pick (rps-winner pick peer-pick))
     unseal-pick)))

gib-gab-gob/rps.scm

@@ -9,22 +9,18 @@
   #:export (do-rps join-rps pick-rps rps-winner rock-paper-scissors))
 
 (define-class <rps-host> ()
-  (vat #:accessor vat)
-  (rps #:accessor rps)
-  (user-name #:accessor user-name #:init-keyword #:user-name)
-  (ocapn-vat #:getter ocapn-vat #:init-thunk spawn-vat))
+  (vat #:accessor vat #:init-thunk spawn-vat)
+  (lobby #:accessor lobby)
+  (user-name #:accessor user-name #:init-keyword #:user-name))
 
-(define-method (init (host <rps-host>))
-  (set! (vat host) (spawn-vat))
+(define-method (initialize (host <rps-host>) initargs)
+  (next-method)
   (with-vat (vat host)
-            (set! (rps host)
-                  (spawn ^rps)))
-  (with-vat (ocapn-vat host)
+            (set! (lobby host) (spawn ^game-lobby))
             (define uds-netlayer (new-testuds-netlayer))
             (define mycapn (spawn-mycapn uds-netlayer))
-            (let ((rps-sref ($ mycapn 'register (rps host) 'testuds)))
-              (format #t "Connect to: ~a\n" (ocapn-id->string rps-sref)))))
-
+            (define lobby-sref ($ mycapn 'register (lobby host) 'testuds))
+            (format #t "Connect to: ~a\n" (ocapn-id->string lobby-sref))))
 
 (define (new-testuds-netlayer)
   (define tmp "/tmp/netlayers")
@@ -32,31 +28,32 @@
   (spawn ^testuds-netlayer tmp))
 
 (define (do-rps user-name)
-  (init (make <rps-host> #:user-name user-name)))
+  (make <rps-host> #:user-name user-name))
 
 (define-class <rps-client> ()
   (vat #:accessor vat #:init-keyword #:vat #:init-thunk spawn-vat)
-  (rps #:accessor rps)
-  (rps-addr #:accessor rps-addr #:init-keyword #:rps-addr)
+  (lobby #:accessor lobby)
+  (addr #:accessor addr #:init-keyword #:addr)
   (user-name #:accessor user-name #:init-keyword #:user-name))
 
-(define-method (init (client <rps-client>))
-  (define rps-sref (string->ocapn-id (rps-addr client)))
-  (define uds-netlayer (new-testuds-netlayer))
-  (define mycapn (spawn-mycapn uds-netlayer))
-  (set! (rps client)
-        (<- mycapn 'enliven rps-sref)))
-
-(define (join-rps user-name rps-addr)
-  (define client (make <rps-client> #:user-name user-name #:rps-addr rps-addr))
+(define-method (initialize (client <rps-client>) initargs)
+  (next-method)
   (with-vat (vat client)
-            (init client)
-             (let ((client-picker (spawn ^client-picker))
-                   (rps (rps client)))
-               (on (<- rps 'register-opponent user-name client-picker ($ client-picker 'get-sealed-pick))
-                   (lambda (_)
-                     (format #t "Ok! we are registered.\n"))))))
+            (define lobby-sref (string->ocapn-id (addr client)))
+            (define uds-netlayer (new-testuds-netlayer))
+            (define mycapn (spawn-mycapn uds-netlayer))
+            (set! (lobby client)
+                  (<- mycapn 'enliven lobby-sref))))
 
+(define (join-rps user-name addr)
+  (define client (make <rps-client> #:user-name user-name #:addr addr))
+  (with-vat (vat client)
+            (define client-picker (spawn ^client-picker))
+              (on (<- (lobby client) 'register-opponent user-name client-picker ($ client-picker 'get-sealed-pick))
+                  (lambda (_)
+                    (format #t "Ok! we are registered.\n")))))
+
+;; Standard rock paper scissors logic follows!
 
 (define rock-paper-scissors (list 'rock 'paper 'scissors))
 
@@ -70,6 +67,5 @@
       (('rock 'scissors) #t)
       (('rock 'paper) #f)
       (('scissors 'paper) #t)
-      (('paper 'scissors) #f)
       ((x y) (not (rps-winner y x))))
     (error "Unexpected item in the shooting area" a b)))