       (-> state :world :player :pos :y)
       (-> state :world :player :sym)
       {:fg :green})
+    ;; maybe draw pick up menu
+    (render-pick-up state)
     ;; maybe draw inventory
-    (when (-> state :world :show-inventory?)
-        (dorun (map (fn [y] (s/put-string (state :screen) 40 y "                                        " {:bg :white})) (range 23)))
-        (s/put-string (state :screen) 40 0 "  Inventory                             " {:fg :black :bg :white :styles #{:underline}}))
+    (render-inventory state)
     ;; draw status bar
     (s/put-string (state :screen) 0  23
-      (format " %s $%d HP:%d(%d) Pw:%d Amr:%d XP:%d/%d T%d                             "
+      (format " %s $%d HP:%d(%d) Pw:%d(%d) Amr:%d XP:%d/%d T%d                         "
         "location-detail"
         (-> state :world :player :$)
         (-> state :world :player :hp)
         (-> state :world :player :max-hp)
-        0 0
+        0 0 10
         (-> state :world :player :xp)
         100
         (-> state :time))

                                              \j :down
                                              \k :up
                                              \l :right)))
    (case keyin
      \h (move-left state)
      \j (move-down state)
      \k (move-up state)
      \l (move-right state)
      \i (toggle-inventory state)
      \o (set-last-command state :open)
      \c (set-last-command state :close)
      state)))

(defn render [state]
  (do
    (println "render")
    (s/clear (state :screen))
    ;; draw map
    (println "map-with-xy")
    (map-with-xy
      (fn [cell x y]
        (println cell x y)
        (when (not (nil? cell))
          (let [cell-items (cell :items)
                out-char (if (not (nil? cell-items))

          (assoc-in state [:world :places place target-y target-x :type] :door-closed))
        state))))

(defn pick-up [state keyin]
  (let [place (current-place state)
        [player-cell x y] (player-cellxy state)
        items (player-cellxy :items)
        item-index (.indexOf (state :world :remaining-hotkeys) keyin)]
    (-> state
      ;; dup the item into inventory with hotkey
      (update-in [:world :player :inventory]
        (fn [prev-inventory]
          (conj prev-inventory (nth items item-index))))
      ;; remove the item from cell
      (update-in [:world :places place y x :items]
        (fn [prev-items] (vec (concat (subvec prev-items 0 (dec item-index))
                                      (subvec prev-items item-index (count prev-items))))))
      ;; hotkey is no longer available
      (update-in [:world :remaining-hotkeys]
        (fn [prev-keys] (vec (concat (subvec prev-keys 0 (dec item-index))
                                     (subvec prev-keys item-index (count prev-keys)))))))))

(defn toggle-inventory [state]
  (println "toggle-inventory" (not (-> state :world :show-inventory?)))
  (assoc-in state [:world :show-inventory?] (not (-> state :world :show-inventory?))))

(defn toggle-pick-up [state]
  (println "toggle-pick-up" (not (-> state :world :show-pick-up?)))
  (assoc-in state [:world :show-pick-up?] (not (-> state :world :show-pick-up?))))
  
  
(defn update-state [state keyin]
