@@ -10,6 +10,8 @@

   [day8.re-frame/tracing "0.6.2"]

   [garden "1.3.10"]

   [net.dhleong/spade "1.1.0"]

+  [org.babashka/sci "0.5.34"]

+  [org.clojure/core.match "1.0.0"]

   [day8/shadow-git-inject "0.0.5"]

   [binaryage/devtools "1.0.3"]

@@ -1,8 +1,11 @@

 (ns dmr.events

   (:require

-   [cljs.reader :refer [read-string]]

-   [clojure.string :refer [lower-case split join starts-with?]]

+   [clojure.edn :as edn]

+   [clojure.core.match :refer-macros [match]]

+   [clojure.walk :refer [postwalk]]

+   [clojure.string :refer [lower-case split join starts-with? replace]]

    [re-frame.core :as re-frame]

+   [sci.core :as sci]

    [dmr.db :as db]

    [day8.re-frame.tracing :refer-macros [fn-traced]]))

@@ -50,21 +53,46 @@

 (defn get-using [f coll]

   (->> coll (filter f) first))

+(defn roll-die [nsides] (-> nsides (+ 1) rand-int (+ 1)))

-(defn parse-dice-roll [roll]

-  (let [dice-regex #"([1-9][0-9]*)*d([1-9][0-9]*)"

-        match (re-matches dice-regex roll)]

-    (when match

-      (let [[_ ndice nsides] match]

-        {:ndice (-> ndice (or "1") read-string)

-         :nsides (-> nsides read-string)}))))

-

-

-(defn roll-die [n-sides] (-> n-sides (+ 1) rand-int (+ 1)))

-

-(defn roll-dice [{:keys [ndice nsides]}]

+(defn roll-dice [ndice nsides]

   (vec (repeatedly ndice (partial roll-die nsides))))

+(def dice-regex #"\b([1-9][0-9]*)*d([1-9][0-9]*)\b")

+

+(defn contains-dice-roll? [s]

+  (identity (re-find dice-regex s)))

+

+(defn evaluate-rolls [s]

+  (let [evaluated-roll (fn [[_ ndice nsides]]

+                         (if (nil? ndice)

+                           (roll-dice 1 (edn/read-string nsides))

+                           (roll-dice (edn/read-string ndice) (edn/read-string nsides))))]

+    (replace s dice-regex evaluated-roll)))

+

+(defn infixify [expr]

+  (match [expr]

+    [([x] :seq)] (infixify x)

+    [([x op & rest] :seq)] (list op (infixify x) (infixify rest))

+    [x :guard number?] x

+    :else (throw (js/Error. (str "Expected number, but got '" (pr-str expr) "'")))))

+

+

+(defn evaluate-roll-expression [s]

+  (let [string-expr (evaluate-rolls s)

+        result (as-> string-expr x

+                 (str "(" x ")")  ;So that 'read-string' reads everything

+                 (edn/read-string x)

+                 (postwalk #(if (vector? %) (reduce + %) %) x)

+                 (infixify x)

+                 (pr-str x)

+                 (sci/eval-string x))]

+     {:roll-expression string-expr :result result}))

+

+(defn safely-evaluate-roll-expression [s]

+  (try

+    (evaluate-roll-expression s)

+    (catch js/Error e {:err (.-message e)})))

 (defn execute [db cmdline]

  (let [append-history #(update-in db [:cmdline :history] conj {:input cmdline :output %})

@@ -78,7 +106,7 @@

    (= "Open Game License" cmdline) (append-history (db :license))

    (= "spells" cmdline) (-> entities :spells append-history)

    (= "items" cmdline)  (-> entities :equipment append-history)

-   (parse-dice-roll cmdline) (->> cmdline parse-dice-roll roll-dice (hash-map :rolls) append-history)

+   (contains-dice-roll? cmdline) (->> cmdline safely-evaluate-roll-expression append-history)

    ; TODO: refactor this to avoid 2 lookups (cond -> or)

    (-> entities concatv (get-using-name)) (-> entities concatv get-using-name append-history)

    :else (append-history {:err (str "Unknown command '" cmdline "'")}))))

@@ -359,10 +359,10 @@

        #(weight % :unit "lb" :no-quantity true)]

    [listing-license-notice items]])

-(defn dice-roll [{:keys [rolls]}]

+(defn dice-roll [{:keys [roll-expression result]}]

   [:article {:class (styles/dice-roll)}

-   [:span (str rolls)]

-   [:span (reduce + rolls)]])

+   [:span roll-expression]

+   [:span (str result)]])

 (defn error-message

     [{e :err}]

@@ -371,7 +371,7 @@

 (defn input [x]

     [:div.input x])

-(def is-dice-roll? :rolls)

+(def is-dice-roll? :roll-expression)

 (def is-license? :license-name)

 (def is-spell? #(some-> % :url (string/starts-with? "/api/spells")))

 (def is-spell-list? #(some-> % first is-spell?))

@@ -390,7 +390,8 @@

       (is-spell-list? x) [spell-list-panel x]

       (is-spell? x) (spell-panel x)

       (is-equipment? x) [equipment-panel x]

-      (is-error? x) [error-message x])])

+      (is-error? x) [error-message x]

+      :else [error-message {:err (str "cannot display result: " x)}])])

 (defn history []

   (let [history (re-frame/subscribe [::subs/cmd-history])]