Adding Clojure starter kit

Signed-off-by: Tom Marble <[email protected]>

Author: tmarble

starter_kits/Clojure/hlt/app/halite3/mybot.clj

@@ -0,0 +1,71 @@
+(ns halite3.mybot
+  (:require [hlt.log :refer [log]]
+            [hlt.random :refer [set-seed! rrand-int]]
+            [hlt.input :refer [as-int]]
+            [hlt.state :refer [constants]]
+            [hlt.ship :as ship]
+            [hlt.shipyard :as shipyard]
+            [hlt.direction :as direction]
+            [hlt.game-map :as game-map]
+            [hlt.game :as game])
+  (:gen-class))
+
+;; This Clojure API uses kebab-case instead of the snake_case as documented
+;; in the API docs. Otherwise the names of methods are analogous.
+
+(defn -main
+  "MyBot in Clojure"
+  [& args]
+  ;; Initialize repeatable random number generator
+  (set-seed! (if (seq args) (as-int (first args)) (System/nanoTime)))
+
+  (game/new-game) ;; get initial map data
+
+  ;; At this point the "game" atom is populated with the game state
+  ;; This is a good place to do computationally expensive start-up pre-processing.
+  ;; After calling ready below, the 2 second per turn timer will start.
+
+  (game/ready "my-clojure-bot")
+
+  ;; Now that your bot is initialized, save a message to yourself in
+  ;; the log file with some important information. Here, you log here
+  ;; your id, which you can always fetch from the game using my-id
+
+  (log "Successfully created bot! My Player ID is " (game/my-id) ".")
+
+  (while true
+    ;; This loop handles each turn of the game. The game state
+    ;; changes every turn, and you refresh that state by running update-frame
+    (game/update-frame)
+
+    ;; below is a naive example of handling a turn
+
+    ;; For each of your ships, move randomly if the ship is on a low halite
+    ;; location or the ship is full. Else, collect halite.
+    (let [me (game/me) ;; option 1: get player, destructure by hand
+          {:keys [shipyard halite ships dropoffs]} me]
+      (doseq [[_ ship] ships]
+        (let [{:keys [::ship/id position halite]} ship
+              cell (game-map/at ship)]
+          (log "Ship:" id  "has"  halite "halite.")
+          (if (or (< (:halite cell) (/ (constants :MAX_HALITE) 10))
+                (ship/is-full? ship))
+            (game/command
+              (ship/move ship
+                (get (direction/get-all-cardinals) (rrand-int 4))))
+            (game/command (ship/stay-still ship))))))
+
+    ;; If the game is in the first 200 turns and you have enough
+    ;; halite, spawn a ship. Don't spawn a ship if you currently have
+    ;; a ship at port, though - the ships will collide.
+    (when (and (< (game/turn-number) 200)
+            (>= (game/me :halite) ;; option 2 destructure inline
+              (constants :SHIP_COST))
+            (not (game-map/is-occupied? (game/me :shipyard))))
+      (log "Spawning a ship!")
+      (game/command (shipyard/spawn)))
+
+    ;; above is a naive example of handling a turn
+
+    ;; Send your moves back to the game environment, ending this turn.
+    (game/end-turn)))

starter_kits/Clojure/hlt/lib/hlt/commands.clj

@@ -0,0 +1,10 @@
+(ns hlt.commands)
+
+(def north "n")
+(def south "s")
+(def east "e")
+(def west "w")
+(def stay-still "o")
+(def generate "g")
+(def construct "c")
+(def move "m")

starter_kits/Clojure/hlt/lib/hlt/direction.clj

@@ -0,0 +1,37 @@
+(ns hlt.direction
+  (:require [hlt.commands :as commands]))
+
+(def north [0 -1])
+(def south [0 1])
+(def east [1 0])
+(def west [-1 0])
+
+(def still [0 0])
+
+(def all-cardinals [north south east west])
+
+(defn get-all-cardinals
+  []
+  all-cardinals)
+
+(defn convert
+  "Converts from this direction tuple notation to the engine's string notation"
+  [direction]
+  (cond
+    (= direction north) commands/north
+    (= direction south) commands/south
+    (= direction east) commands/east
+    (= direction west) commands/west
+    :else
+    commands/stay-still))
+
+(defn invert
+  "Returns the opposite cardinal direction given a direction"
+  [direction]
+  (cond
+    (= direction north) south
+    (= direction south) north
+    (= direction east) west
+    (= direction west) east
+    :else
+    still))

starter_kits/Clojure/hlt/lib/hlt/dropoff.clj

@@ -0,0 +1,33 @@
+(ns hlt.dropoff
+  (:require [hlt.input :refer [read-line-ints]]
+            [hlt.position :refer [new-position]]))
+
+(defn id
+  "Get id for a dropoff"
+  [dropoff]
+  (::id dropoff))
+
+(defn owner
+  "Get owner for a dropoff"
+  [dropoff]
+  (:hlt.player/id dropoff))
+
+(defn position
+  "Get position of a dropoff"
+  [dropoff]
+  (:position dropoff))
+
+(defn new-dropoff
+  "New dropoff"
+  [player-id dropoff-id position]
+  {::id dropoff-id
+   :hlt.player/id player-id
+   :position position})
+
+(defn read-dropoff
+  "Read dropoff"
+  [player-id]
+  (let [[dropoff-id x y] (read-line-ints)
+        position (new-position x y)
+        dropoff (new-dropoff player-id dropoff-id position)]
+    [dropoff-id dropoff]))

starter_kits/Clojure/hlt/lib/hlt/game.clj

@@ -0,0 +1,115 @@
+(ns hlt.game
+  (:require [clojure.string :as string]
+            [clojure.data.json :as json]
+            [hlt.state :refer [game]]
+            [hlt.log :refer [log]]
+            [hlt.input :refer [read-one-line read-line-ints exit]]
+            [hlt.position :refer [position?]]
+            [hlt.player :as player :refer [read-players update-players]]
+            [hlt.map-cell :as map-cell]
+            [hlt.game-map :refer [read-game-map update-game-map at]]))
+
+(defn my-id
+  "Return my player id"
+  []
+  (::player/id @game))
+
+(defn me
+  "Return my player information"
+  [& ks]
+  (let [{:keys [::player/id players]} @game
+        player (get players id)]
+    (if (seq ks)
+      (get-in player ks)
+      player)))
+
+(defn game-map
+  "Return the game map"
+  []
+  (:game-map @game))
+
+(defn has-structure?
+  "Is cell empty?"
+  [position-or-entity]
+  (let [cell (at position-or-entity)]
+    (map-cell/has-structure? cell)))
+
+(defn structure-type
+  "Get structure-type for a map cell"
+  [position-or-entity]
+  (let [cell (at position-or-entity)]
+    (map-cell/structure-type cell)))
+
+(defn turn-number
+  "Return the turn-number"
+  []
+  (:turn-number @game))
+
+(defn new-game
+  "Initialize the game"
+  []
+  (let [constants (json/read-json (read-one-line) true)
+        [num-players id] (read-line-ints)
+        log-file (str "bot-" id ".log")
+        players (read-players num-players)
+        game-map (read-game-map)]
+    (swap! game assoc
+      ::player/id id
+      :num-players num-players
+      :log-file log-file
+      :constants constants
+      :players players
+      :game-map game-map
+      :turn-number 0
+      :commands [])))
+
+(defn ready
+  "Game initialization"
+  [bot-name]
+  (println bot-name))
+
+(defn update-frame
+  "Update game state"
+  []
+  (let [{:keys [num-players players game-map]} @game
+        [turn-number] (read-line-ints)
+        players (update-players num-players players)
+        game-map (update-game-map game-map)]
+    (log "=============== TURN" turn-number "================")
+    (swap! game assoc
+      :players players
+      :game-map game-map
+      :turn-number turn-number
+      :commands [])
+    (doseq [[_ player] (seq players)]
+      (let [{:keys [::player/id shipyard ships dropoffs]} player]
+        (swap! game update-in
+          [:game-map :map-cells (:position shipyard)]
+          assoc :structure shipyard)
+        (doseq [[_ ship] (seq ships)]
+          (swap! game update-in
+            [:game-map :map-cells (:position ship)]
+            (partial map-cell/mark-unsafe ship)))
+        (doseq [[_ dropoff] (seq dropoffs)]
+          (swap! game update-in
+            [:game-map :map-cells (:position dropoff)]
+            assoc :structure dropoff))))
+    nil))
+
+(defn command
+  "queue an engine command"
+  [cmd]
+  (swap! game update-in [:commands] conj cmd))
+
+(defn end-turn
+  "End turn"
+  []
+  (let [commands (:commands @game)]
+    (if (seq commands)
+      (println (string/join " " commands))
+      (exit 1 "no commands queued.. exiting"))))
+
+(defn log-game
+  "Debugging function to log the game data (without the game-map)"
+  []
+  (log (with-out-str (clojure.pprint/pprint (dissoc @game :game-map)))))