Beginning of an action resolver for FUDGE

resolve.lisp

(defparameter *outcomes* '(terrible poor mediocre fair good great superb))


(defun build-outcome-alist ()
  (loop for n from 0 for o in *outcomes* collect (cons n o)))

(defparameter *outcome-table* (build-outcome-alist))

(defparameter *superb-value* (car (rassoc 'superb *outcome-table*)))
(defparameter *terrible-value* (car (rassoc 'terrible *outcome-table*)))

(let ((random-state (make-random-state t)))
  (defun df (&optional (times 1) (random-state random-state))
    (flet ((1df () (1- (random 3 random-state))))
      (loop repeat times sum (1df)))))

(defmacro trait-value (trait)
  `(car (rassoc (quote ,trait) *outcome-table*)))

(defun trait-description (value)
  (cdr (assoc value *outcome-table*)))

(defun describe-resolution (value)
  (cond
    ((< value *terrible-value*) 'worse-than-terrible)
    ((> value *superb-value*) 'better-than-superb)
    (t (cdr (assoc value *outcome-table*)))))

(defun resolve-fn (base)
  (+ base (df 4)))

(defmacro resolve (trait-adjective)
  `(resolve-fn (trait-value ,trait-adjective)))

(defmacro resolve-opposed (trait opposing-trait)
  `(- (resolve ,trait) (resolve ,opposing-trait)))