(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-message actor message
- #:val (slot-ref actor slot))))
+ (<-reply message (slot-ref actor slot))))
-(define (gameobj-replace-step-occupants actor replace-reply)
- (define occupants
- (message-ref replace-reply 'occupants #f))
+(define (gameobj-replace-step-occupants actor occupants)
;; Snarf all the occupants!
(display "replacing occupant\n")
(when occupants
(for-each
(lambda (occupant)
- (<-wait actor occupant 'set-loc!
+ (<-wait occupant 'set-loc!
#:loc (actor-id actor)))
occupants)))
(define gameobj-replace-steps*
(list gameobj-replace-step-occupants))
-(define (run-replacement actor message replace-steps)
- (define replaces (message-ref message 'replace #f))
+(define (run-replacement actor replaces replace-steps)
(when replaces
- (let ((replace-reply
- (<-wait actor replaces 'assist-replace)))
+ (mbody-receive (_ #:key occupants)
+ (<-wait replaces 'assist-replace)
(for-each
(lambda (replace-step)
- (replace-step actor replace-reply))
+ (replace-step actor occupants))
replace-steps))))
;; @@: This could be kind of a messy way of doing gameobj-act-init
;; stuff. If only we had generic methods :(
-(define-mhandler (gameobj-act-init actor message)
+(define* (gameobj-act-init actor message #:key replace)
"Your most basic game object init procedure.
Assists in its replacement of occupants if necessary and nothing else."
- (run-replacement actor message gameobj-replace-steps*))
+ (run-replacement actor replace gameobj-replace-steps*))
(define (gameobj-goes-by gameobj)
"Find the name we go by. Defaults to #:name if nothing else provided."
(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"
verb))
commands))
-(define-mhandler (gameobj-get-commands actor message verb)
+(define* (gameobj-get-commands actor message #:key verb)
"Get commands a co-occupant of the room might execute for VERB"
(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-mhandler (gameobj-get-container-commands actor message verb)
+(define* (gameobj-get-container-commands actor message #:key verb)
"Get commands as the container / room of message's sender"
(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-mhandler (gameobj-get-contained-commands actor message verb)
+(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-mhandler (gameobj-add-occupant! actor message who)
+(define* (gameobj-add-occupant! actor message #:key who)
"Add an actor to our list of present occupants"
(hash-set! (slot-ref actor 'occupants)
who #t))
-(define-mhandler (gameobj-remove-occupant! actor message who)
+(define* (gameobj-remove-occupant! actor message #:key who)
"Remove an occupant from the room."
(hash-remove! (slot-ref actor 'occupants) who))
;; A list of addresses... since our address object is (annoyingly)
;; currently a simple cons cell...
((exclude-1 ... exclude-rest)
- (pk 'failboat (member occupant (pk 'exclude-lst exclude))))
+ (member occupant exclude))
;; Must be an individual address!
(_ (equal? occupant exclude))))
(if exclude-it?
'()
(slot-ref gameobj 'occupants)))
-(define-mhandler (gameobj-get-occupants actor message)
+(define* (gameobj-get-occupants actor message #:key exclude)
"Get all present occupants of the room."
- (define exclude (message-ref message 'exclude #f))
(define occupants
(gameobj-occupants actor #:exclude exclude))
- (<-reply actor message
- #:occupants occupants))
+ (<-reply message #:occupants occupants))
-(define-mhandler (gameobj-act-get-loc actor message)
- (<-reply actor message
- #:val (slot-ref actor 'loc)))
+(define (gameobj-act-get-loc actor message)
+ (<-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-mhandler (gameobj-act-set-loc! actor message loc)
+(define* (gameobj-act-set-loc! actor message #:key loc)
"Action routine to set the location."
(gameobj-set-loc! actor loc))
(define gameobj-get-name (simple-slot-getter 'name))
-(define-mhandler (gameobj-act-set-name! actor message val)
+(define* (gameobj-act-set-name! actor message val)
(slot-set! actor 'name val))
-(define-mhandler (gameobj-get-desc actor message whos-looking)
+(define* (gameobj-get-desc actor message #:key whos-looking)
(define desc-text
(match (slot-ref actor 'desc)
((? procedure? desc-proc)
(desc-proc actor whos-looking))
(desc desc)))
- (<-reply actor message #:val 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.
By default, this is whether or not the generally-visible flag is set."
(slot-ref gameobj 'generally-visible))
-(define-mhandler (gameobj-visible-name actor message whos-looking)
+(define* (gameobj-visible-name actor message #:key whos-looking)
;; Are we visible?
(define we-are-visible
((slot-ref actor 'visible-to-player?) actor whos-looking))
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"
;; Boom!
(self-destruct gameobj))
-(define-mhandler (gameobj-act-self-destruct gameobj message)
+(define* (gameobj-act-self-destruct gameobj message #:key why)
"Action routine for self destruction"
(gameobj-self-destruct gameobj))
;; 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? _)
- (message-ref
- (<-wait gameobj (slot-ref gameobj 'gm) 'lookup-special
- #:symbol special-symbol)
- 'val))
+ (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
projects / mudsync.git / blobdiff