Creating a 4*4 table CommonLISP Game - lisp

Question

I'm trying to create a program in CommonLISP that creates a 4*4 table in which the player has a total of 16 pieces he can play and the goal is to reach 4 common traits between the pieces placed on the board, each piece has 4 traits, a color(white or black), a shape (square or round), a height(low or high) and a depth(empty or full) whether it be horizontal, vertigal or obliqual in order to win. After this, i wanted to apply searching algorithms such as BFS and DFS in order to examine the solution outcomes.
To do this, i've devided the program into 3 separate lisp files, one for the loading/GUI, one for the game puzzle and one where i will later incorporate the algorithms.
I have the Loading/GUI file done, but i'm uncertain as to how i should implement the game logic via code and would wish to get help in what would be the most efficient way of implementing this.
This is a test board that i've made, the first part of it being towards the board, and the second are the pieces of the board that are in reserve.
(defun test-board ()
"Return an test board"
'(
(
((white round high empty) 0 0 0)
(0 (black round high empty) 0 0)
(0 0 (white round low empty) 0)
(0 0 0 0)
)
(
( white round high full)
( white round low full)
( white square high empty)
( white square low empty)
( white square high full)
( white round low full)
( black round high full)
( black round low full)
( black round low empty)
( black square high full)
( black square high empty)
( black square low full)
( black square low empty)
)
)
)
How would i go about coding a function that allows me to make a play and identify if the game is over or not based on the traits being shared?

Answer 1

I was thinking of how to differently express you data, but then I remembered section "5.4 Defining Structure Types" of htdp2 book and thought that your starting point may actually work fine. In summary, defining a structure means defining three types of functions:
A constructor. This function takes as arguments the fields and creates an instance of the structure.
A selector per field that extracts the value of a field from an instance.
A structure predicate, which tells you whether an instance is of your structure type.
You've so far done step 1. Your function will return an instance. The first remark is, your function is returning a static list, and to my knowledge will return the same object each time you call it, i.e. lisp will create the object in memory statically (like a literal) when the function is defined and calling the function from anywhere anytime will return that same memory. That means you will only have one instance of that object everywhere. If you'd like a structure that can be instantiated each time you call the function, you would start with a (list ...) call instead of '((((white round...) in your function, but that's a bit more involved, and also your method may just be fine for your purpose. Let me show you what I mean with some code:
(defparameter tb1 (test-board))
(defparameter tb2 (test-board))
(eq tb1 tb2)
> T
(eq tb1 (test-board))
> T
(eq) call shows that they are exactly the same items in memory. That means changing an element through one variable / function call will change the same object. Here:
tb1
> ((((WHITE ROUND HIGH EMPTY) 0 0 0) (0 (BLACK ROUND HIGH EMPTY) 0 0)
(0 0 (WHITE ROUND LOW EMPTY) 0) (0 0 0 0))
...
(setf (caaaar tb1) 'black)
tb1
> ((((BLACK ROUND HIGH EMPTY) 0 0 0) (0 (BLACK ROUND HIGH EMPTY) 0 0)
(0 0 (WHITE ROUND LOW EMPTY) 0) (0 0 0 0))
...
(test-board)
> ((((BLACK ROUND HIGH EMPTY) 0 0 0) (0 (BLACK ROUND HIGH EMPTY) 0 0)
(0 0 (WHITE ROUND LOW EMPTY) 0) (0 0 0 0))
...
OK, now that we know some details of our structure, let's continue with the items 2 and 3 from the book. Given you're interested in 4 traits, you'd like selector functions for them given a piece. But we also need a selector for a piece given a test-board. So you should first write a function called (get-piece). You'll get a piece either from the board or the reserve, so maybe have two different get-piece functions, get-piece-from-board and get-piece-from-reserve.
(defun get-piece-from-board (position)
"Return a piece object from the position
e.g. Given a position '(0 1 0 0), would return '(black round high empty)
from the initial board."
...)
(defun get-first-from-reserve ()
"Return the first item in reserve."
...)
Since (test-board) always returns the same instance, we may skip item 3 / predicate for structure as we won't be comparing different test-boards.
Then you want selectors for traits:
(defun get-color (piece)
(first piece))
(defun get-shape (piece)
(second piece))
and so forth.
I won't get into details of writing the above functions, and let you practice. But here are some pointers to help you.
To get the board section, use (car tb1), or this is the same: (car (test-board)). And it's a good idea to put this down as a function:
(defun get-board ()
(car (test-board)))
And to get the reserve:
(defun get-reserve ()
(cadr (test-board)))
you may want to remove items from reserve or add them:
(defun remove-piece-from-reserve (piece)
"Remove piece from reserve."
(setf (get-reserve) (remove piece (get-reserve) :test #'equal))) ;; (remove ...) call will remove the item that's #'equal to "piece" and return a list without that item, then you (setf) that result back to the (get-reserve) position to save it.
You can add a piece with (push) function. I suggest a separate add-piece-to-reserve definition.
I'm hoping now you would be closer to write the functions to "make a play" and "identify if game is over".