X-Git-Url: https://jxself.org/git/?p=mudsync.git;a=blobdiff_plain;f=mudsync%2Fplayer.scm;h=e3ae2ba8ffcee53cea6cef848d72216e5a74fbc4;hp=3d1ec7288baf6c83387046b4612436546e1105c3;hb=701425bc611abaa8b4140942d995d5f32d24e2d7;hpb=a07b01054f0c8bd8dc2bc4e278ed6a00e339bc79 diff --git a/mudsync/player.scm b/mudsync/player.scm index 3d1ec72..e3ae2ba 100644 --- a/mudsync/player.scm +++ b/mudsync/player.scm @@ -21,7 +21,7 @@ #:use-module (mudsync gameobj) #:use-module (mudsync game-master) #:use-module (mudsync parser) - #:use-module (8sync systems actors) + #:use-module (8sync actors) #:use-module (8sync agenda) #:use-module (ice-9 control) #:use-module (ice-9 format) @@ -35,41 +35,38 @@ ;;; Players ;;; ======= -(define player-actions - (build-actions - (init (wrap-apply player-init)) - (handle-input (wrap-apply player-handle-input)) - (tell (wrap-apply player-tell)))) - -(define player-actions* - (append player-actions - gameobj-actions)) - -(define player-dispatcher - (simple-dispatcher player-actions*)) +(define player-self-commands + (list + (empty-command "inventory" 'cmd-inventory) + ;; aliases... + ;; @@: Should use an "alias" system for common aliases? + (empty-command "inv" 'cmd-inventory) + (empty-command "i" 'cmd-inventory))) (define-class () (username #:init-keyword #:username #:getter player-username) - (self-commands - #:init-value '() - #:getter player-self-commands) + (self-commands #:init-value player-self-commands) - (message-handler - #:init-value - ;; @@: We're gonna need action inheritance real awful soon, huh? - (wrap-apply player-dispatcher))) + (actions #:allocation #:each-subclass + #:init-value + (build-actions + (init player-init) + (handle-input player-handle-input) + (tell player-tell) + (disconnect-self-destruct player-disconnect-self-destruct) + (cmd-inventory player-cmd-inventory)))) ;;; player message handlers -(define-mhandler (player-init player message) +(define (player-init player message) ;; Look around the room we're in (<- player (gameobj-loc player) 'look-room)) -(define-mhandler (player-handle-input player message input) +(define* (player-handle-input player message #:key input) (define split-input (split-verb-and-rest input)) (define input-verb (car split-input)) (define input-rest (cdr split-input)) @@ -82,15 +79,42 @@ (match winner ((cmd-action winner-id message-args) - (apply send-message player winner-id cmd-action message-args)) + (apply <- player winner-id cmd-action message-args)) (#f (<- player (gameobj-gm player) 'write-home #:text "Huh?\n")))) -(define-mhandler (player-tell player message text) +(define* (player-tell player message #:key text) (<- player (gameobj-gm player) 'write-home #:text text)) +(define (player-disconnect-self-destruct player message) + "Action routine for being told to disconnect and self destruct." + (define loc (gameobj-loc player)) + (when loc + (<- player loc 'tell-room + #:exclude (actor-id player) + #:text (format #f "~a disappears in a puff of entropy!\n" + (slot-ref player 'name)))) + (gameobj-self-destruct player)) + +(define (player-cmd-inventory player message) + "Display the inventory for the player" + (define inv-names + (map + (lambda (inv-item) + (msg-val (<-wait player inv-item 'get-name))) + (gameobj-occupants player))) + (define text-to-show + (if (eq? inv-names '()) + "You aren't carrying anything.\n" + (apply string-append + "You are carrying:\n" + (map (lambda (item-name) + (string-append " * " item-name "\n")) + inv-names)))) + (<- player (actor-id player) 'tell #:text text-to-show)) + ;;; Command handling ;;; ================ @@ -109,19 +133,19 @@ ;; Ask the room for its commands (define room-commands ;; TODO: Map room id and sort - (message-ref - (<-wait player player-loc + (msg-receive (_ #:key commands) + (<-wait player player-loc 'get-container-commands #:verb verb) - 'commands)) + commands)) ;; All the co-occupants of the room (not including ourself) (define co-occupants (remove (lambda (x) (equal? x (actor-id player))) - (message-ref - (<-wait player player-loc 'get-occupants) - 'occupants))) + (msg-receive (_ #:key occupants) + (<-wait player player-loc 'get-occupants) + occupants))) ;; @@: There's a race condition here if someone leaves the room ;; during this, heh... @@ -130,14 +154,11 @@ ;; Get all the co-occupants' commands (define co-occupant-commands - ;; TODO: Switch this to a fold. Ignore a result if it - ;; returns false for in the command response (fold (lambda (co-occupant prev) - (let* ((result (<-wait player co-occupant 'get-commands - #:verb verb)) - (commands (message-ref result 'commands)) - (goes-by (message-ref result 'goes-by))) + (msg-receive (_ #:key commands goes-by) + (<-wait player co-occupant 'get-commands + #:verb verb) (append (map (lambda (command) (list command goes-by co-occupant)) @@ -148,9 +169,29 @@ ;; Append our own command handlers (define our-commands - (player-self-commands player)) - - ;; TODO: Append our inventory's relevant command handlers + (filter + (lambda (cmd) + (equal? (command-verbs cmd) verb)) + (val-or-run + (slot-ref player 'self-commands)))) + + ;; Append our inventory's relevant command handlers + (define inv-items + (gameobj-occupants player)) + (define inv-item-commands + (fold + (lambda (inv-item prev) + (msg-receive (_ #:key commands goes-by) + (<-wait player inv-item + 'get-contained-commands + #:verb verb) + (append + (map (lambda (command) + (list command goes-by inv-item)) + commands) + prev))) + '() + inv-items)) ;; Now return a big ol sorted list of ((actor-id . command)) (append @@ -158,7 +199,8 @@ player-loc '()) ; room doesn't go by anything (sort-commands-multi-actors co-occupant-commands) (sort-commands-append-actor our-commands - (actor-id player) '()))) ; nor does player + (actor-id player) '()) ; nor does player + (sort-commands-multi-actors inv-item-commands))) (define (sort-commands-append-actor commands actor-id goes-by) (sort-commands-multi-actors @@ -175,7 +217,7 @@ (define (find-command-winner sorted-candidates line) "Find a command winner from a sorted list of candidates" ;; A cache of results from matchers we've already seen - ;; TODO: fill this in + ;; TODO: fill in this cache. This is a *critical* optimization! (define matcher-cache '()) (call/ec (lambda (return)