Question

我正在尝试使用Clojure创建一个类似俄罗斯方块的游戏，我在决定游戏领域的数据结构时遇到了一些麻烦。我想将比赛场定义为可变网格。各个块也是网格，但不需要是可变的。

我的第一次尝试是将网格定义为向量的向量。例如，S块看起来像这样：

:s-block {
    :grids [
      [ [ 0 1 1 ]
        [ 1 1 0 ] ]

      [ [ 1 0 ]
        [ 1 1 ]
        [ 0 1 ] ] ]
}

但对于像迭代和绘画这样的简单事情来说，这似乎相当棘手（参见下面的代码）。

为了使网格可变，我最初的想法是将每一行作为参考。但后来我无法弄清楚如何连续更改特定单元格的值。一种选择是创建每个单独的单元格而不是每行。但那感觉就像是一种不洁净的做法。

我正在考虑使用Java数组。 Clojure的aget和aset函数可能会变得更简单。

然而，在深入研究自己之前，我想提出想法/见解。你会如何推荐实现一个可变的2d网格？随意分享替代方法。

源代码当前状态：Tetris.clj (rev452)

更新的
在你的建议的帮助下，经过一些修修补补，我想出了以下内容：

(defstruct grid :width :height)

(defn create-grid [w h initial-value]
  (struct-map grid
    :width  w
    :height h
    :data   (ref (vec (repeat (* w h) initial-value)))))

(defn create-grid-with-data [w h gdata]
  (struct-map grid
    :width w
    :height h
    :data (ref gdata)))

(defn get-grid [g x y]
  (let [gdata (g :data)
        idx   (+ x (* (g :width) y)) ]
    (gdata idx)))

(defn set-grid [g x y value]
  (let [data  (deref (g :data))
        idx   (+ x (* (g :width) y)) ]
    (dosync (alter (g :data) (fn [_] (assoc data idx value))))))

(defn get-grid-rows [g]
  (partition (g :width) (deref (g :data))))

我喜欢它，因为它是一种更通用的解决方案。如果它完全错了，或者可以改进，请随意说出来。

Answer 1

对每个单元格使用ref不一定是个坏主意。将所有网格突变扔到dosync中，并且Clojure应该注意每个多单元更新都是以原子方式完成的。（我不知道你是否计划在你的网格上同时敲打多个线程，但这样做是安全的。）

下面我使用hash-maps作为网格中每个单元格的值，因为你可能希望它不仅仅是一个布尔占用/未占用;也许你想存储颜色信息或其他东西。我保留了你用来定义块的符号。

（此版本的indexed目前适用于前沿的Clojure。在旧版本中，您可以在clojure.contrib中找到indexed。）

(def indexed (partial map-indexed vector))

(defn make-grid [x y]
  (let [f #(vec (repeatedly %1 %2))
        r #(ref {:occupied? false})]
    (f y #(f x r))))

(defn draw-block [grid x y block]
  (dosync
   (doseq [[i row] (indexed block)
           [j square] (indexed row)]
     (alter (get-in grid [(+ y i) (+ x j)])
            assoc :occupied? (= 1 square)))))

(defn print-grid [grid]
  (doseq [row grid]
    (doseq [cell row]
      (print (if (cell :occupied?) "X" ".")))
    (println)))

(def *grid* (make-grid 5 5))

user> (draw-block *grid* 2 1 [[1 1 0] 
                              [0 1 1]])
nil
user> (print-grid *grid*)
.....
..XX.
...XX
.....
.....
nil

Java Arrays可能看起来更简单，但它们不是线程安全的，并且大多数在seqs上运行的优秀Clojure函数都会取消对数组的排列。改变一堆数组和对象肯定不是惯用的Clojure。 Java Arrays通常用于与Java库互操作。

Answer 2

如何将矢量矢量（如在原始方法中）存储在单个Atom中（或者如果你需要协调的并发更新到游戏场和其他东西......可能不太可能用于俄罗斯方块游戏），与update-in一起使用？（如果您使用的是Clojure的最新快照（1.1之后），您可以考虑使用vector-of来构建向量。有关详细信息，请参阅(doc vector-of)。

示例代码：

(def field (atom (vec (doall (for [_ (range 10)] (vec (repeat 10 false)))))))

(defn set-occupied! [x y]
  (swap! field #(update-in % [x y] (constantly true))))

(defn set-unoccupied! [x y]
  (swap! field #(update-in % [x y] (constantly false))))

(defn toggle-occupied! [x y]
  (swap! field #(update-in % [x y] not)))

实际上，上述内容只是为了说明如何操纵电路板。然而，这种方法的真正好处是您不需要核心逻辑中的那些破坏性（副作用）功能。相反，你可以把它写成一堆纯粹的函数来获取竞技场的当前状态，也许还有一些代表玩家输入（或缺乏）的东西。

最终，您只需将其包装在一些Java互操作代码中，以将其插入您的GUI，但这将完全与您的核心逻辑分离。总而言之，它应该能够在没有显着性能成本的情况下获得更愉快的整体体验（我的意思是，您的比赛场地可能有多大，以及更新有多复杂......？）。

Answer 3

我认为使用矢量矢量完全没问题。由于你可能每秒只会进行少量的更新，所以我认为整个比赛场地不会有任何不利因素。

您当然需要构建一些辅助函数来管理这个数据结构，但这里有一些基本的函数可以帮助您入门：

(defn make-row [w]
  (vec (for [x (range w)] 0)))

(defn make-grid [w h]
  (vec (for [y (range h)] (make-row w))))

(defn gget [grid x y]
  ((grid y) x))

(defn gset [grid x y v]
  (assoc grid y (assoc (grid y) x v)))

您可以使用这些或类似的东西实现您需要的所有其他内容。

俄罗斯方块的矢量或Java数组？

3 个答案: