(ns mtg.continuation)

 ;; convention: cps function names end in &

 

 (def not-nil? (comp not nil?))

 (defn cpt "Continuation-passing transform. Makes f take a continuation as an additional argument."[f]

   (fn[& args]

     ((last args) (apply f (butlast args)))))

 

 

 

 ;; Card operations

 

 

 ;; Open predicates

 					;(defmacro literal-to-keyword[x] `(keyword (quote ~x)))

 (defrecord Oracle [])

 (def *oracle* (atom (Oracle.)))

 

 (defn ask* [m k](get @m k (cpt(constantly nil))))

 (defn tell!* [m k v] (swap! m assoc k v))

 

 (def ask(partial ask* *oracle*))

 ;(def ? (fn [k & args] (apply (ask k) args)))

      

 (def tell! (partial tell!* *oracle*))

 (defn extend[k f] ((ask k) f))

 

 ;; PRELIMINARY DEFINITIONS

 (defmacro defq "Defines a query." [name params & body]

   `(tell! (keyword ~name) (fn ~params ~@body)))

 (defmacro ? "Asks a query." [name & args]

   `((ask (keyword name)) ~@args))  

 

 (defn true-preds "Returns a sequence of the preds for which (pred obj) returns true."

   [obj & preds]

   (map (comp (partial apply str) rest butlast str)

        (filter #(? % obj) preds)))

 

 (tell! :the-players #{})

 (tell! :player? (fn[obj & _] (not-nil? (? the-players obj)))) 

 

 

 

 

 

 

 

 (defq object? [obj & _] ;; 109.1

   ((comp not empty?)(true-preds obj :card? :copied-card? :token? :spell? :permanent? :emblem?)))

 

 (defq has-controller? [obj & _]

   (if (and (not (? in-zone 'battlefield obj))

 	   (not (? on-stack obj))) false))

 

 (defq take-turn [player & _] nil)

 

 

 (tell! :characteristics (fn[obj & _]

 			  (list :name :mana-cost :color :card-type :subtype :supertype :expansion-symbol :rules-text :abilities :power :toughness :loyalty :hand-modifier :life-modifier)))

 

 

 	      

 

 (tell! :colors

        (fn[obj & _]

 	 (true-preds obj :red? :blue? :green? :white? :black?)))

 

 

 

 

 

 

 ;; GAME / TURN MECHANICS

 (defn new-game "Start a new two-player game."[]

   (tell! :the-players #{'PLAYERONE 'PLAYERTWO})

   (tell! :life-total (reduce #(assoc %1 (keyword %2) 20) {} (ask :the-players) ))

 )

 

 

 

 ;;(ask :blue) blue? = (fn[& args](fn[k] (k  ...) ))

 ;;            (cpt (constantly nil))

 ;;(ask k) = (get self k (cpt(constantly nil))) 

 

 

 

 

 

 

 (defn reverse&[coll k]

   (if (empty? coll) (k '())

       (recur (rest coll) (fn[x](k (conj x (first coll))))

 

       )))

 					    

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 (defn choose "Asks player to choose a member of the universe which matches all the given predicate; returns the chosen member." [player & preds]

   

   )

 

 

 (defn get* "Returns the value of key for the object, default or nil if key is not present." 

   ([obj key])

   ([obj key default]))

 

 

 

 

 

 

 

 

 

 

 

 

 

 ;; shuffle decks

 ;; anyone may cut anyone else's deck

 ;; deck => library

 ;; decide who goes first

 ;; players decide whether to mulligan in APNAP

 ;; players mulligan simultaneously

 ;; ... finish mulligans

 ;; opening hand abilities

 ;; beginning game abilities

 ;; 2P game: first player skips draw phase of first turn

 

 ;; pooled mana: produced-by, spendable-on

 

 

 

 

 ;; VALUES WITH MODIFICATION HISTORY

 ;(deftype trace[subject ])

 

 ;(defn trace [x]{:subject x :modifiers '()})

 ;(defn modifiers[tr] (get :modifiers tr '()))

 ;(defn subject[tr] (:subject tr)) 

 

 ;(defn modify[tr f](assoc tr :modifiers (conj (modifiers tr) f)))

 ;(defn compute[tr]  (:modifiers tr))

 

 ;; players