Question

Could you provide an example of how one would represent a “player” class with mutable properties such as HP and position (3d vector), functions such as init, setters and getters?

Answer 1

I agree with mikera, that you should try to do it immutably, but you ask specifically for mutable properties, so the way I might suggest is very similar to mikera’s answer, but to use atoms inside the map where you will have mutable properties you may want to change.

(def player1
  {:type       :player
   :team       :red
   :hit-points (atom 10)
   :location   (atom [17 9 6])})

Notice that only the things you may want to change are wrapped in atoms. In order to access the mutable data you would have to dereference it, like so:

@(player1 :hit-points)
10

In order to set the value you could use swap! or reset!, like so:

(swap! (player1 :hit-points) dec)
9
@(player1 :hit-points)
9
(reset! (player1 :hit-points) 2)
2
@(player1 :hit-points)
2

This would be an example for you making one player, although you asked for something like an init, a getter, and a setter. I should say at this point that I have almost no programming experience outside of Clojure, so I may not have a complete grasp of what those would be, but here’s how I would set it up.

(defn new-player
  [hit-points location]
  {:type       :player
   :team       :red
   :hit-points (atom hit-points)
   :location   (atom location)})

Then when I wanted to make a new player, I would do:

(def my-player
  (new-player 20 [0 0 0]))
{:type       :player
 :team       :red
 :hit-points #<Atom@1959415: 20>
 :location   #<Atom@12d0e49: [0 0 0]>}

I think it would unnecessary to make explicit “getters” and/or “setters”, because you could simply get any mutable data by dereferencing it, and set any mutable data with swap! or reset! in exactly the same way I showed above. Having said that, if you wanted to, you could do something like this:

(defn get-hp
  [player]
  @(player :hit-points))
(defn get-loc
  [player]
  @(player :location))
(defn set-hp
  [player new-hp]
  (reset! (player :hit-points) new-hp))
(defn set-loc
  [player new-loc]
  (reset! (player :location) new-loc))

Now with these you could do:

(get-hp my-player)
20
(get-loc my-player)
[0 0 0]
(set-hp my-player 17)
17
(get-hp my-player)
17
(set-loc my-player [0 1 1])
[0 1 1]
(get-loc my-player)
[0 1 1]

Since this answer isn’t already long enough, I think it might be nice to include default values when making new players. I can think of an easy, but not necessarily elegant way to do this:

(defn new-player
  ([]
   (new-player 20 [0 0 0]))
  ([hp-or-loc]
    (cond
      (integer? hp-or-loc) (new-player hp-or-loc [0 0 0])
      (vector? hp-or-loc)  (new-player 20 hp-or-loc)
      :else                (throw (Exception. "Value must be either integer for hp or vector for location."))))
  ([hp loc]
   {:type       :player
    :team       :red
    :hit-points (atom hp)
    :location   (atom loc)}))

Now by default, new players will have 20 hp and be at location [0 0 0]. If passed either an integer or a vector, it will assume that should be the value for hp or location (respectively), or else it will throw an exception.

Again, I think that mutable data would probably be unnecessary in most cases, and the simplest solution may be to conceive of the problem not as “how can a make this mutable data structure” but rather “how can I create new, updated versions of immutable data, then pass these data back to the beginning of a loop, wherein afterwards I may update and recur again”.

Hopefully some of this is helpful.