Trimmed down version of the dice probability solver.

core.clj

(ns dicer.core
  (:use seesaw.core
      [clojure.string :only [join trim split]]
  	  ))
(require ['clojure.algo.monads :as 'm])

; blue black green purple yellow red force 
(def the-dice {:blue    [[] [] [:a :a] [:a] [:a :s] [:s]]
	       :black   [[] [] [:t] [:t] [:f] [:f]]
	       :green   [[] [:s] [:s] [:s :s] [:a] [:a] [:a :s] [:a :a]]
	       :purple  [[] [:f] [:f :f] [:t] [:t] [:t] [:t :t] [:t :f]]
	       :yellow  [[] [:s] [:s] [:s :s] [:s :s] [:a] [:a :a] [:a :a] [:a :s] [:a :s] [:a :s] [:YEAH]]
	       :red     [[] [:f] [:f] [:f :f] [:f :f] [:t] [:t] [:f :t] [:f :t] [:t :t] [:t :t] [:NO]]
	       :force   [[:dark] [:dark] [:dark] [:dark] [:dark] [:dark] [:dark :dark]
	                 [:light] [:light] [:light :light] [:light :light] [:light :light]]
	       })



(defn analyze-prob [blue black green purple yellow red force]
	(let [
              all-res
	      	      (m/with-monad m/sequence-m (m/m-seq (concat
				(repeat blue   (:blue   the-dice))
				(repeat black  (:black  the-dice))
				(repeat green  (:green  the-dice))
				(repeat purple (:purple the-dice))
				(repeat yellow (:yellow the-dice))
				(repeat red    (:red    the-dice))
				(repeat force  (:force  the-dice))				
				)))
	      freqs (frequencies all-res)
	      kf (keys freqs)
	      num-rolls (count all-res)
	      success   (reduce + (map #(* (count (filter (fn [c] (= :s c)) (flatten %)))     (/ (get freqs %) num-rolls )) kf))
	      failure   (reduce + (map #(* (count (filter (fn [c] (= :f c)) (flatten %)))     (/ (get freqs %) num-rolls )) kf))
	      advantage (reduce + (map #(* (count (filter (fn [c] (= :a c)) (flatten %)))     (/ (get freqs %) num-rolls )) kf))
	      threat    (reduce + (map #(* (count (filter (fn [c] (= :t c)) (flatten %)))     (/ (get freqs %) num-rolls )) kf))
	      triumph   (reduce + (map #(* (count (filter (fn [c] (= :YEAH c))  (flatten %))) (/ (get freqs %) num-rolls )) kf))
	      despair   (reduce + (map #(* (count (filter (fn [c] (= :NO   c))  (flatten %))) (/ (get freqs %) num-rolls )) kf))
	      light     (reduce + (map #(* (count (filter (fn [c] (= :light c)) (flatten %))) (/ (get freqs %) num-rolls )) kf))
	      dark      (reduce + (map #(* (count (filter (fn [c] (= :dark c))  (flatten %))) (/ (get freqs %) num-rolls )) kf))
	      winner    (reduce + (map #(* (if (>= (- (+
	      							      (count (filter (fn [c] (= :YEAH c))  (flatten %)))
	      							      (count (filter (fn [c] (= :s    c)) (flatten %)))
	      							      )
	      						      (count (filter (fn [c] (= :NO c)) (flatten %)))
	      						      (count (filter (fn [c] (= :f  c)) (flatten %)))
	      						      ) 1) 1 0)
	      			      (/ (get freqs %) num-rolls )) kf))                                      
	      total-success   (reduce + (map #(* (- (+
	      							      (count (filter (fn [c] (= :YEAH c))  (flatten %)))
	      							      (count (filter (fn [c] (= :s    c)) (flatten %)))
	      							      )
	      						      (count (filter (fn [c] (= :NO c)) (flatten %)))
	      						      (count (filter (fn [c] (= :f  c)) (flatten %)))
	      						      )
	      			      (/ (get freqs %) num-rolls )) kf))
	      					      
	      total-advantage (reduce + (map #(* (- (+
	      							      (count (filter (fn [c] (= :YEAH c))  (flatten %)))
	      							      (count (filter (fn [c] (= :a    c)) (flatten %)))
	      							      )
	      						      (count (filter (fn [c] (= :NO c)) (flatten %)))
	      						      (count (filter (fn [c] (= :t  c)) (flatten %)))
	      						      )
	      			      (/ (get freqs %) num-rolls )) kf))
	     ]                         
	     
          (prn success   )
          (prn failure   )                              
          (prn advantage )
          (prn threat    )
          (prn triumph   )
          (prn despair   )                                  
          (prn light     )
          (prn dark      )
          
		{:success   success   
                 :failure   failure  
                 :advantage advantage 
                 :threat    threat    
                 :triumph   triumph   
                 :despair   despair   
                 :light     light     
                 :dark      dark   
                 :winner    winner      
                 :total-success   total-success
                 :total-advantage total-advantage
	}))
(let [res
    (analyze-prob 
       0 ;blue
       1 ;black
       2 ;green
       2 ;purple
       2 ;yellow
       1 ;red
       0 ;force
    )]
    (with-precision 5 (println (str 
    	       "\nSuccess/Failure: "  (:total-success res)  ;(- (:success res) (:failure res))
    	       "\nAdvantage/Threat: " (:total-advantage res);(- (:advantage res) (:threat res))
    	       "\nTriumph! " (:triumph res)
    	       "\nDESPAIR! " (:despair res)
    	       "\nLight Force: " (:light res)
    	       "\nDark Force: " (:dark res)
    	       "\nWin percentage: " (* 100M (bigdec (:winner res))) "%"))))