Managing game list in lobby using ajax calls

Should probably use ws and push the updated game list when necessary.
Oh well

project.clj

@@ -8,11 +8,13 @@
                 [jarohen/chord "0.4.2" :exclusions [org.clojure/clojure]]
                 [javax.servlet/servlet-api "2.5"]                
                 [org.clojure/clojure "1.6.0"]                 
                 [org.clojure/clojurescript "0.0-2496"]               
                 [org.clojure/clojurescript "0.0-2496"]
                 [cljs-ajax "0.3.9"]
                 [org.clojure/core.async "0.1.346.0-17112a-alpha"]
                 [reagent "0.5.0-alpha"]
                 [ring/ring-core "1.3.2"]
                 [ring/ring-devel "1.3.2"]]
                 [ring/ring-devel "1.3.2"]
                 [ring-middleware-format "0.4.0"]]
  :plugins [[lein-cljsbuild "1.0.4"]]
  :hooks [leiningen.cljsbuild]
  :cljsbuild {:builds

src/clj/battlesnake/server.clj

@@ -1,13 +1,19 @@
(ns battlesnake.server
  (:gen-class)
  (:require [clojure.java.io :as io]
            [compojure.core :refer [defroutes GET]]
  (:require [chord.http-kit :refer [wrap-websocket-handler]]
            [clojure.core.async :refer [<! >! put! close! go-loop]]
            [clojure.java.io :as io]
            [compojure.core :refer [defroutes GET POST]]
            [compojure.handler :refer [site]]
            [compojure.route :refer [resources]]
            [org.httpkit.server :refer [run-server]]
            [ring.middleware.reload :as reload]
            [chord.http-kit :refer [wrap-websocket-handler]]
            [clojure.core.async :refer [<! >! put! close! go-loop]]))
            [ring.middleware.format :refer [wrap-restful-format]]
            [ring.middleware.reload :as reload]))

(def idseq (java.util.concurrent.atomic.AtomicInteger.))
(defn next-id [] (.getAndIncrement idseq))

(def games (atom {}))

(defn ws-handler [{:keys [ws-channel] :as req}]
  (println "Connection from " (:remote-addr req))
@@ -19,15 +25,31 @@
                       {:received (format "You passed: '%s' at %s." (pr-str message) (java.util.Date.))}))
      (recur))))

(defn active-games []
  (filter #(= :active (:status %))(vals @games)))

(defn game-info [id]
  (get @games id))

(defn create-game [name]
  (let [id (next-id)]
    (println "creating " name)
    (swap! games assoc id {:id id :name name :status :active})))

(defroutes app
  (GET "/" [] (io/resource "public/index.html"))
  (GET "/ws" [] (-> ws-handler wrap-websocket-handler))
  (GET "/games" [] (active-games))
  (GET "/games/:id" [id] (game-info id))
  (POST "/games" {{name :game-name} :body-params} (create-game name))
  (resources "/"))

(defn start-server []
  (let [handler (reload/wrap-reload (site #'app))]
    (run-server handler {:port 3000})
    (println "Server running!")))
  (-> (site #'app)
      (reload/wrap-reload)
      (wrap-restful-format)      
      (run-server {:port 3000}))
  (println "Server running!"))

(defn -main [& args]
  (start-server))

src/cljs/battlesnake/lobby.cljs

@@ -1,26 +1,49 @@
(ns battlesnake.lobby
  (:require [chord.client :refer [ws-ch]]
            [cljs.core.async :refer [chan <! >! put! close! timeout]]
            [reagent.core :as reagent :refer [atom]])
            [reagent.core :as reagent :refer [atom]]
            [ajax.core :refer [GET POST]])
  (:require-macros [cljs.core.async.macros :refer [go go-loop]]))

(def game-name (atom ""))
(def all-games (atom [{:name "Awesome game"} {:name "Less awesome game"}]))
(def all-games (atom []))

(defn handler [response]
  (.log js/console (str response)))

(defn error-handler [{:keys [status status-text]}]
  (.log js/console (str "something bad happened: " status " " status-text)))

(defn- on-create-game [name]
  (js/console.log (str "name: " name))
  (reset! game-name "")
  (POST "/games"
        {:params {:game-name name
                  :created-by "Bob"}
         :format :edn
         :handler handler
         :error-handler error-handler}))

(defn- update-game-list [fetched-games]
  (reset! all-games fetched-games))

(defn fetch-games []
  (GET "/games" {:handler update-game-list :response-format :edn}))

(defn create-game []
  [:div
   [:h3 "Create a game"]
   [:input {:type "text" :value @game-name :placeholder "Name the game!"
            :on-change #(reset! game-name (-> % .-target .-value))}]
   [:input {:type "button" :value "Start" :on-click #(reset! game-name "")}]])
   [:input {:type "button" :value "Start" :on-click #(on-create-game @game-name)}]])

(defn game-list []
  [:ul
   (for [game @all-games]
     [:li (game :name)])])

(defn lobby []
  [:div
  [:div   
   [create-game]
   [game-list]])

@@ -30,8 +53,15 @@
      (js/console.log (str "msg: " message))
      (recur))))

(defn update-games []
  (go-loop []    
    (fetch-games)
    (<! (timeout 5000))
    (recur)))

(defn ^:export init [parent]
  (go (let [{:keys [ws-channel]} (<! (ws-ch "ws://localhost:3000/ws"))]
        (listen ws-channel)
        (>! ws-channel "Hoist")))
  (update-games)
  (reagent/render-component [lobby] parent))

src/cljs/battlesnake/snake.cljs

@@ -77,16 +77,17 @@
  (reset! snake (create-snake))
  (let [body (aget js/document "body")]
    (.addEventListener body "keydown" handle-input))
  (js/setInterval move-snake 60)
  (js/setInterval (fn []
                    (when (< 2 (count @edibles))
                      (swap! edibles butlast))
                    (swap! edibles conj (create-edible)) ; TODO ensure no duplicates
                    (js/console.log (str "edibles: " @edibles))) 5000)
  (let [ctx (.getContext canvas "2d")]
    (letfn [(render []
              (.clearRect ctx 0 0 500 500)
              (render-snake ctx @snake)
              (render-edibles ctx @edibles)
              (.requestAnimationFrame js/window render))]
      (.requestAnimationFrame js/window render))))
  (comment
    (js/setInterval move-snake 60)
    (js/setInterval (fn []
                      (when (< 2 (count @edibles))
                        (swap! edibles butlast))
                      (swap! edibles conj (create-edible)) ; TODO ensure no duplicates
                      (js/console.log (str "edibles: " @edibles))) 5000)
    (let [ctx (.getContext canvas "2d")]
      (letfn [(render []
                (.clearRect ctx 0 0 500 500)
                (render-snake ctx @snake)
                (render-edibles ctx @edibles)
                (.requestAnimationFrame js/window render))]
        (.requestAnimationFrame js/window render)))))