;; 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)))
;; 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?
(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