source of truth comes from inventory for which item is selected.

desktop/project.clj

@@ -26,7 +26,7 @@
   :profiles {
              :dev {
                    :source-paths ["src" "src-common" "src-dev"]
-                   :jvm-opts ["-Duse-repl=true" "-Dno-steam=true" "-Dclojure.compiler.direct-linking=true"]
+                   :jvm-opts ["-Duse-repl=true" "-Dno-steam=true" #_"-Dclojure.compiler.direct-linking=true"]
                    :dependencies [[com.badlogicgames.gdx/gdx-tools "1.5.3"]
                                   [org.clojure/tools.nrepl "0.2.7"]
                                   [play-clj-nrepl "0.1.0" :exclusions [play-clj]]
@@ -53,6 +53,6 @@
                          
                          :warn-on-reflection true}
              }
-  :aot [advent.core.desktop-launcher advent.tryitout]
+  :aot [advent.core.desktop-launcher]
   :main advent.core.desktop-launcher)
 

desktop/src-common/advent/actions.clj

@@ -472,10 +472,7 @@
       (run-action entities
                   (begin [this screen entities]
                          (screen! dialogue/choice-screen :on-present-choices :choices dialogue-choices :callback #(reset! selected-index %))
-                         (screen! @(resolve 'advent.screens.scene/scene) :on-deactivate)
+                         (assoc-in entities [:state :active?] false))
-                         (-> entities
-                             (assoc-in [:cursor :override] nil)
-                             (assoc-in [:cursor :current] :main)))
 
                   (continue [this screen entities] entities)
 
@@ -483,9 +480,7 @@
                          (not (nil? @selected-index)))
 
                   (terminate [this screen entities]
-                             (-> entities
+                             (assoc-in entities [:state :active?] true))
-                                 (assoc-in [:state :active?] true)
-                                 (assoc-in [:cursor :override] nil)))
                   (skip-type [this screen entities]
                             :none))
 
@@ -677,8 +672,7 @@
                            (assoc-in e [:tweens :fade-out] (tween/tween :fade-out screen [:fade :opacity] 0.0 1.0 time))
                            (if music-changed?
                              (assoc-in e [:tweens :fade-out-music] (tween/tween :fade-out-music screen [:volume :value] 1.0 0.0 time))
-                             e)
+                             e)))
-                           (assoc-in e [:cursor :current] :main)))
 
                 (continue [this screen entities]
                           entities)

desktop/src-common/advent/screens/inventory.clj

@@ -21,9 +21,10 @@
   (and (:shown? entities)  (= 1.0 (:opacity entities))))
 
 
-(defn close [screen entities script-started? dragged-out?]
+(defn close [screen {:keys [selected-item] :as entities} script-started? dragged-out?]
   (log/info "closing inventory")
-  (screen! @(resolve 'advent.screens.scene/scene) :on-reactivate :script-started? script-started? :came-from-inventory? dragged-out?)
+  (screen! @(resolve 'advent.screens.scene/scene) :on-reactivate :came-from-inventory? dragged-out?)
+  (screen! @(resolve 'advent.screens.scene/hud) :on-reactivate :script-started? script-started? :item selected-item)
   (-> entities
       (assoc-in [:tweens :fade-out] (tween/tween :fade-out screen [:opacity] 1.0 0.0 0.2 :ease tween/ease-out-cubic
                                                  :finish #(assoc % :shown? false)))))
@@ -45,8 +46,7 @@
           hovered-entity (first (filter #((:box %) x y) (vals (:items entities))))]
       (cond 
        (and selected-item (mouse-outside-inventory? [x y]))
-       (do (screen! @(resolve 'advent.screens.scene/scene) :on-chose-item :item selected-item)
+       (close screen entities false true)
-           (close screen entities false true))
 
        selected-item
        (-> entities 
@@ -67,8 +67,7 @@
   (let [room-entities (-> @(resolve 'advent.screens.scene/scene)
                           :entities
                           deref
-                          first)
+                          first)]
-        current-cursor (get-in room-entities [:cursor :current])]
 
     (log/info "chose inventory item" selected-item)
     (println selected-item hovered-item dragged?)
@@ -94,9 +93,8 @@
                           :entities
                           deref
                           first)
-        current-cursor (get-in room-entities [:cursor :current])
         ego (get-in room-entities [:room :entities :ego])]
-    (when (and selected-item (= :main current-cursor))
+    (when selected-item
       (((:get-script ego) selected-item [0 0]) room-entities) 
       (close screen entities true false))))
 

desktop/src-common/advent/screens/scene.clj

@@ -172,6 +172,9 @@ void main ()
 ")
 ;
 
+(defn get-script-selector [entities]
+  (or (get-selected-inventory-item) :main))
+
 (def default-interaction
   {:get-script (fn [cursor [x y]] (if (= :main cursor)
                                    (actions/get-script entities
@@ -206,14 +209,8 @@ void main ()
     (assoc-in entities [:state :active?] false)))
 
 (defn open-inventory [screen entities]
-  (when (not (get-in entities [:fg-actions :script-running?]))
+  (screen! inventory-screen :show-screen :items (map (entities :all-items) (get-in entities [:state :inventory])))
-    (if (= (get-in entities [:cursor :current] ) :main) 
+  (assoc-in entities [:state :active?] false))
-      (do
-        (screen! inventory-screen :show-screen :items (map (entities :all-items) (get-in entities [:state :inventory])))
-        (-> entities
-            (assoc-in [:state :active?] false)
-            (assoc-in [:cursor :override] nil)))
-      (assoc-in entities [:cursor :current] :main))))
 
 
 
@@ -240,9 +237,7 @@ void main ()
         current-action (get-in entities [:fg-actions :current])
         ;; TODO - hacky way of resetting queue
         
-        entities (if (and current-action
+        entities (if current-action
-                          (= (get-in entities [:cursor :down-target])
-                             (or (:id interacting-entity) (:id interaction) nil)))
                    (skip-action screen entities)
                    entities)]
     
@@ -253,15 +248,14 @@ void main ()
                    (get-in entities [:cursor :came-from-inventory?])))
       ((or (when (and interacting-entity (not (:cursor interaction)))
              (do (screen! hud :on-start-script)
-                 ((:get-script interacting-entity) (doto (or (get-selected-inventory-item) (get-in entities [:cursor :current])) println) [x y])))
+                 ((:get-script interacting-entity) (get-script-selector entities)  [x y])))
            (when interaction
              (do (screen! hud :on-start-script)
                ((:get-script interaction) (or (when (:cursor interaction) :main)
-                                              (get-selected-inventory-item)
+                                              (get-script-selector entities))
-                                              (get-in entities [:cursor :current]))
                 [x y])))
            
-           ((:get-script default-interaction) (or (get-selected-inventory-item) (get-in entities [:cursor :current])) [x y])) entities))
+           ((:get-script default-interaction) (get-script-selector entities) [x y])) entities))
     (assoc-in entities [:cursor :down-target] nil))) 
 
 
@@ -882,9 +876,9 @@ void main ()
       entities)
     entities))
 
-(defn update-cursor [screen {{:keys [current override last active was-active]} :cursor :as entities}]
+(defn update-cursor [screen {{:keys [override last active was-active]} :cursor :as entities}]
   (if (= 0.0  (get-in entities [:fade :opacity]))
-    (let [new-current (or override (get-selected-inventory-item) current)]
+    (let [new-current (or override (get-selected-inventory-item) :main)]
       (when-not (and (= new-current
                         last)
                      (= active was-active))
@@ -1185,7 +1179,6 @@ void main ()
                         :music-override {:object nil
                                          :value nil}
                         :cursor {:id "cursor"
-                                 :current :main
                                  :last nil
                                  :override :hourglass
                                  :last-pos [0 0]
@@ -1213,7 +1206,7 @@ void main ()
             entities)))))
 
   :on-resume (fn [screen [{{:keys [current override last active was-active]} :cursor :as entities}]]
-               (let [current (or override current)
+               (let [current (or override (get-selected-inventory-item) :main)
                      image-path (if active "cursor_light.png" "cursor.png")]
                  (graphics! :set-cursor (utils/cursor image-path (or (:cursor current) current))))
                (doseq [[k [start time fn]] (get-in entities [:room :timers])]
@@ -1326,10 +1319,10 @@ void main ()
                               (filter identity))]
                (utils/stop-music snd)))
 
-  #_#_:on-mouse-moved
+  :on-mouse-moved
   mouse-moved
   
-  #_#_:on-touch-dragged
+  :on-touch-dragged
   mouse-moved
   
   :on-touch-down
@@ -1365,11 +1358,9 @@ void main ()
   :on-deactivate (fn [screen [entities]]
                    (assoc-in entities [:state :active?] false))
 
-  :on-reactivate (fn [{:keys [script-started? came-from-inventory?] :as screen} [entities]]
+  :on-reactivate (fn [{:keys [came-from-inventory?] :as screen} [entities]]
-                   (screen! hud :on-reactivate :cursor (get-in entities [:cursor :current]) :script-started? script-started?)
                    (-> entities
                        (assoc-in [:state :active?] true)
-                       (assoc-in [:cursor :current] :main)
                        (assoc-in [:cursor :came-from-inventory?] came-from-inventory?)))
 
   :on-end-safe (fn [screen [entities]]
@@ -1379,10 +1370,6 @@ void main ()
                        (assoc-in [:state :active?] true)
                        (assoc-in [:cursor :override] nil)))
 
-  :on-chose-item (fn [{:keys [item]} [entities]]
-                   (screen! hud :on-chose-item :item item)
-                   (assoc-in entities [:cursor :current] item))
-
   :on-open-inventory (fn [screen [entities]]
                        (open-inventory screen entities))
 
@@ -1441,10 +1428,9 @@ void main ()
       entities)))
 
 (defn get-selected-inventory-item []
-  (doto
+  (let [[{{:keys [state state-data]} :inv-fsm}] (-> hud :entities deref)]
-      (let [[{{:keys [state state-data]} :inv-fsm}] (-> hud :entities deref)]
+    (and (= state :selected)
-        (and (= state :selected)
+         state-data)))
-             state-data))))
 
 (defscreen demo
   :on-show
@@ -1849,11 +1835,11 @@ void main ()
 
 
   :on-reactivate
-  (fn [{:keys [cursor script-started?] :as screen} [entities]]
+  (fn [{:keys [script-started? item] :as screen} [entities]]
-    (let [selected-item? (and (:value cursor)
+    (let [selected-item? (and (:value item)
-                              (:cursor cursor))]
+                              (:cursor item))]
       (if (and (not script-started?) selected-item?)
-        (transition-hud screen entities :selected cursor)
+        (transition-hud screen entities :selected item)
         (transition-hud screen entities :none nil))))
 
   :on-touch-down

desktop/src-common/advent/utils.clj

@@ -361,7 +361,7 @@
   (let [current-action (get-in entities [:fg-actions :current])
         is-script-running (get-in entities [:fg-actions :script-running?])]
     (and is-script-running
-         (not= :end (get-in entities [:fg-actions :last-skip-type])))))
+         (not ( #{nil :end :none-but-arrow} (get-in entities [:fg-actions :last-skip-type]))))))
 
 (defn update-override [{:keys [^FitViewport viewport] :as screen} entities]
   (let [raw-pos (get-in entities [:cursor :last-pos])
@@ -393,7 +393,7 @@
          (assoc-in [:cursor :override] nil)
          (assoc-in [:cursor :active] false))
 
-    (and hovering-ego (not= :main current))
+     (and hovering-ego (not @(resolve 'advent.screens.scene/get-selected-inventory-item)))
     (-> entities
          (assoc-in [:cursor :override] (or (:cursor mouse-override) (when (#{:main :active-main} (get-in entities [:cursor :last])) :active-main)))
          (assoc-in [:cursor :active] true))