(define-module (mudsync gameobj)
#:use-module (mudsync command)
- #:use-module (8sync systems actors)
+ #:use-module (8sync actors)
#:use-module (8sync agenda)
#:use-module (srfi srfi-1)
#:use-module (ice-9 format)
gameobj-act-init
gameobj-set-loc!
gameobj-occupants
- gameobj-actions
gameobj-self-destruct
slot-ref-maybe-runcheck
;;; =======
-;;; Actions supported by all gameobj
-(define gameobj-actions
- (build-actions
- (init (wrap-apply gameobj-act-init))
- ;; Commands for co-occupants
- (get-commands (wrap-apply gameobj-get-commands))
- ;; Commands for participants in a room
- (get-container-commands (wrap-apply gameobj-get-container-commands))
- ;; Commands for inventory items, etc (occupants of the gameobj commanding)
- (get-contained-commands (wrap-apply gameobj-get-contained-commands))
- (get-occupants (wrap-apply gameobj-get-occupants))
- (add-occupant! (wrap-apply gameobj-add-occupant!))
- (remove-occupant! (wrap-apply gameobj-remove-occupant!))
- (get-loc (wrap-apply gameobj-act-get-loc))
- (set-loc! (wrap-apply gameobj-act-set-loc!))
- (get-name (wrap-apply gameobj-get-name))
- (set-name! (wrap-apply gameobj-act-set-name!))
- (get-desc (wrap-apply gameobj-get-desc))
- (goes-by (wrap-apply gameobj-act-goes-by))
- (visible-name (wrap-apply gameobj-visible-name))
- (self-destruct (wrap-apply gameobj-act-self-destruct))
- (tell (wrap-apply gameobj-tell-no-op))
- (assist-replace (wrap-apply gameobj-act-assist-replace))))
-
;;; *all* game components that talk to players should somehow
;;; derive from this class.
;;; And all of them need a GM!
;; Commands we can handle by being contained by something else
(contained-commands #:init-value '())
- (message-handler
- #:init-value
- (simple-dispatcher gameobj-actions))
-
;; Most objects are generally visible by default
(generally-visible #:init-value #t
#:init-keyword #:generally-visible)
;; Set this on self-destruct
;; (checked by some "long running" game routines)
- (destructed #:init-value #f))
+ (destructed #:init-value #f)
+
+ (actions #:allocation #:each-subclass
+ ;;; Actions supported by all gameobj
+ #:init-value
+ (build-actions
+ (init gameobj-act-init)
+ ;; Commands for co-occupants
+ (get-commands gameobj-get-commands)
+ ;; Commands for participants in a room
+ (get-container-commands gameobj-get-container-commands)
+ ;; Commands for inventory items, etc (occupants of the gameobj commanding)
+ (get-contained-commands gameobj-get-contained-commands)
+ (get-occupants gameobj-get-occupants)
+ (add-occupant! gameobj-add-occupant!)
+ (remove-occupant! gameobj-remove-occupant!)
+ (get-loc gameobj-act-get-loc)
+ (set-loc! gameobj-act-set-loc!)
+ (get-name gameobj-get-name)
+ (set-name! gameobj-act-set-name!)
+ (get-desc gameobj-get-desc)
+ (goes-by gameobj-act-goes-by)
+ (visible-name gameobj-visible-name)
+ (self-destruct gameobj-act-self-destruct)
+ (tell gameobj-tell-no-op)
+ (assist-replace gameobj-act-assist-replace))))
;;; gameobj message handlers
;; Kind of a useful utility, maybe?
(define (simple-slot-getter slot)
(lambda (actor message)
- (<-reply actor message (slot-ref actor slot))))
+ (<-reply message (slot-ref actor slot))))
(define (gameobj-replace-step-occupants actor occupants)
;; Snarf all the occupants!
(when occupants
(for-each
(lambda (occupant)
- (<-wait actor occupant 'set-loc!
+ (<-wait occupant 'set-loc!
#:loc (actor-id actor)))
occupants)))
(define (run-replacement actor replaces replace-steps)
(when replaces
- (msg-receive (_ #:key occupants)
- (<-wait actor replaces 'assist-replace)
+ (mbody-receive (_ #:key occupants)
+ (<-wait replaces 'assist-replace)
(for-each
(lambda (replace-step)
(replace-step actor occupants))
(define (gameobj-act-goes-by actor message)
"Reply to a message requesting what we go by."
- (<-reply actor message
- #:goes-by (gameobj-goes-by actor)))
+ (<-reply message #:goes-by (gameobj-goes-by actor)))
(define (val-or-run val-or-proc)
"Evaluate if a procedure, or just return otherwise"
(define filtered-commands
(filter-commands (val-or-run (slot-ref actor 'commands))
verb))
- (<-reply actor message
+ (<-reply message
#:commands filtered-commands
#:goes-by (gameobj-goes-by actor)))
(define filtered-commands
(filter-commands (val-or-run (slot-ref actor 'container-commands))
verb))
- (<-reply actor message #:commands filtered-commands))
+ (<-reply message #:commands filtered-commands))
(define* (gameobj-get-contained-commands actor message #:key verb)
"Get commands as being contained (eg inventory) of commanding gameobj"
(define filtered-commands
(filter-commands (val-or-run (slot-ref actor 'contained-commands))
verb))
- (<-reply actor message
+ (<-reply message
#:commands filtered-commands
#:goes-by (gameobj-goes-by actor)))
(define occupants
(gameobj-occupants actor #:exclude exclude))
- (<-reply actor message
- #:occupants occupants))
+ (<-reply message #:occupants occupants))
(define (gameobj-act-get-loc actor message)
- (<-reply actor message (slot-ref actor 'loc)))
+ (<-reply message (slot-ref actor 'loc)))
(define (gameobj-set-loc! gameobj loc)
"Set the location of this object."
(slot-set! gameobj 'loc loc)
;; Change registation of where we currently are
(if old-loc
- (<-wait gameobj old-loc 'remove-occupant! #:who (actor-id gameobj)))
+ (<-wait old-loc 'remove-occupant! #:who (actor-id gameobj)))
(if loc
- (<-wait gameobj loc 'add-occupant! #:who (actor-id gameobj)))))
+ (<-wait loc 'add-occupant! #:who (actor-id gameobj)))))
;; @@: Should it really be #:id ? Maybe #:loc-id or #:loc?
(define* (gameobj-act-set-loc! actor message #:key loc)
((? procedure? desc-proc)
(desc-proc actor whos-looking))
(desc desc)))
- (<-reply actor message desc-text))
+ (<-reply message desc-text))
(define (gameobj-visible-to-player? gameobj whos-looking)
"Check to see whether we're visible to the player or not.
name)
(#f #f))
#f))
- (<-reply actor message #:text name-to-return))
+ (<-reply message #:text name-to-return))
(define (gameobj-self-destruct gameobj)
"General gameobj self destruction routine"
;; But that's life in a live hacked game!
(define (gameobj-act-assist-replace actor message)
"Vanilla method for assisting in self-replacement for live hacking"
- (apply <-reply actor message
+ (apply <-reply message
(gameobj-replace-data* actor)))
\f
(match special-symbol
;; if it's a symbol, look it up dynamically
((? symbol? _)
- (msg-val (<-wait gameobj (slot-ref gameobj 'gm) 'lookup-special
- #:symbol special-symbol)))
+ (mbody-val (<-wait (slot-ref gameobj 'gm) 'lookup-special
+ #:symbol special-symbol)))
;; if it's false, return nothing
(#f #f)
;; otherwise it's probably an address, return it as-is