---
layout: ../Site.layout.js
---
# Devlog 0 Actual game lispgamejam using my [NicCLIM](https://lispy-gopher-show.itch.io/nicclim)! Making, composing and peeking at symbolic maps

Reuseable bits (an eev ToC):

```
;; make a map
# «.§»	(to "§")
;; take peek at a map
# «.†»	(to "†")
;; put map inside another map in a new map
# «.‡»	(to "‡")
```

## Intro

In the past, I have [focused on producing some kind of technical demonstration](/lispgames/LCKR-running-the-simulation/) when lispgamejams have rolled around. Contrarywise [this autumnal lispgames lispgamejam](https://itch.io/jam/autumn-lisp-game-jam-2025), My intent is to sub-jam one cogent and rich game in the first day, and then idle the next ten days picking at additional technological niceties.

**STILL WIP**: Furthermore, I will [toot code this entire gamejam](https://gamerplus.org/@screwlisp/115476828348071343) as an exploration for branching and multifaceted fediverse programming game authorship. Tootcoding (codetooting? I forgot) is my mastodon tag for threads of evaluable mastodon toots.

Hopefully the fediversal mix-and-match programming game creation might allow people to spin off additional lispgamejam submissions of their own.

[If you were following before](/tootcoding/nicclim-0/), my NicCLIM lets me instantaneously make s-expression files interpreted as GUI maps of graphical or textual tiles, including macro and lisp defined game source. Let us make a couple forthwith. NicCLIM has functionality for macroing doors which will let us walk off the edge of one map, and onto the edge of an adjacent map (I think; well it is Turing complete several ways).

## Initial setup toot

Of course I am using [embeddable common lisp](https://ecl.common-lisp.dev/), [McCLIM](https://mcclim.common-lisp.dev/) [common lisp interface manager 2 spec](http://bauhh.dyndns.org:8000/clim-spec/index.html) [implementation](https://codeberg.org/McCLIM/McCLIM) (via my own NicCLIM "map editor", [Eduardo's eev](https://anggtwu.net/#eev), [slime](https://common-lisp.net/project/slime/doc/html/) and [emacs](https://emacsconf.org/2025). I basically always do this. I am just copying from [whatever article with NicCLIM is easy to eww to recently](/eev/mastodonel-eev-repl-programming/).

```
• (setq inferior-lisp-program "ecl")
• (setq eepitch-buffer-name "*slime-repl ECL*")
• (slime)
(ql:Quickload :McCLIM)
(compile-file "~/Downloads/nicclim.lisp" :load t)
(in-package :nic)
```

oh, I see. I set up a `~/GAME/` directory and switch to it as well.

```
(string '~/game)
(ensure-directories-exist *)
(uiop:chdir (string '~/game/))
(uiop:chdir (string '~/game/)) ;; Twice, for some reason.
```


## Forest map

```
(rect-file 'tree.map 12 8 '(tree))
(enclose-map 'tree.map)
```

<img src="/lispgames/lispgamejam-00.png">

I chose the `map-layout` option from the layouts menu. 


# AT THIS POINT, SEVERAL DAYS OF INACTIVITY SUDDENLY PASS

But I was reinvigorated [by Kepeken on the Mastodon](https://mastodon.gamedev.place/@kepeken/115476298512304383).

# NicCLIM Almost Does Everything Already

Remembering that NicCLIM is basically just this bog standard common lisp interface manager 2 table example https://www.lispworks.com/documentation/lwu41/climuser/GUID_281.HTM#HEADING281-0 and some spreadsheet-like behaviours.

However I am commited to using general purpose NicCLIM snippets I hope other people will then fork from this jam for other, better conceived jam submissions that in some sense I contributed to.

I guess I want these behaviours which are trivial to implement:

1. Make a map, as above
1. Fill in subrectangles of a map with another map
1. Pop up some pictures and dialog using CLIM's `accepting-values`
1. Use a door in the map to enter another map

I am particularly going to use [the lisp REPL's * ** *** / // ///](https://www.lispworks.com/documentation/HyperSpec/Body/v__stst_.htm) to curry [] values into my expressions in order to reuse them. Well, that is the supposition.

## Making a map more generically
I will say `(to "§")` meaning to run this `apply` line here. (This is an eev thing). In eev you would press M-e to follow these between each other.

### «§»  (to ".§")

Mastodon toot: https://gamerplus.org/@screwlisp/115476875141207449

```
;; 1. 'name-for-map (file) should be a symbol ; consider 'tree.map which will be `~/GAME/TREE.MAP`
;; 2. '(width height) of this map
;; 3. '(cell contents)
(apply 'rect-file *** (append ** (list *)))
```

### Grass clearing

```
'grass-clearing.map
'(12 8)
'(grass)
;; (to "§")
```

#### Peek at that.

```
'grass-clearing.map
```

Let's say (to "†")

##### «†»  (to ".†")

Mastodon toot: https://gamerplus.org/@screwlisp/115476882368216801

```
(enclose-map *)
```

<img src="../actual-game-2.png">

### Rocky underground

just while we are here.

```
'solid-rock.map
'(12 8)
'(solid rock)
;; (to "§")
```

We can see the default contents can have multiple items; there might be some graphical convention for `SOLID` such that it can be attached to `rock` to denote impassable rock, in contrast to simply an interesting rock sitting on the ground one could stand on.

```
'solid-rock.map
;; (to "†")
```

<img src="../actual-game-3.png">


<img>

### Rock cavern

```
'rock-cavern.map
'(12 8)
'(rock cavern)
;; (to "§")
```

# Put map into other map

Argh, for some reason the signature for `clobber-rect` is `(outside-sym inside-sym new-sym y1 y2 x1 x2)` please expect this to be changed in the future.

The evolution of clobber-rect so far has been that its first three arguements are `(outside-file inside-file new-file)` in symbols (so it is not clobbering..) and its last four arguements are `(y-start y-stop x-start x-stop)` - and it *always* starts in the top left of the `inside-sym` file (symbol). There is a separate `extract-rect` function you would use to pull a subrectangle *out of* another map. This is just how it ended up working so far.

Let's say (to "‡")

## «‡»  (to ".‡")

Mastodon toot: https://gamerplus.org/@screwlisp/115476901608166443

```
(append ** *)
(apply 'clobber-rect *)
```


So for example

```
'(solid-rock.map rock-cavern.map mountain-cave.map)
'(1 3 2 4) ; argh y1 y2 x1 x2
```

```
(to "‡")
```


take a peek

```
'mountain-cave.map
```

```
;; (to "†")
```

<img src="../actualy-game-4.png">

Actually, I think we should stop here to maintain the article's purity of essence.

# Edit: Recapitulation

So for making these zones; forest, grass, rock, a mountain with a cave

The *game programming as such* continuously and in one place was:

```
;; Make map:
'grass-clearing.map
'(12 8)
'(grass)
;; (to "§")

;;peek:
'grass-clearing.map
;; (to «†»)

'solid-rock.map
'(12 8)
'(solid rock)
;; (to "§")

'solid-rock.map
;; (to "†")

'rock-cavern.map
'(12 8)
'(rock cavern)
;; (to "§")

'(solid-rock.map rock-cavern.map mountain-cave.map)
'(1 3 2 4) ; argh y1 y2 x1 x2
;; (to "‡")

'mountain-cave.map
;; (to "†")
```

done in the lisp repl. (after running the eev anchor lines, I continued in this code block).

# Conclusions

Basically I have achieved informally replacing functions with gotos. I guess Dijkstra is rolling in his grave (halloween themed...!).

I desired this because I want myself (and you) to see we are explicitly reusing a heading we can just flick back to (however you are browsing it - eww in emacs with eev works for me), rather than call-an-opaque-function. In my theory adding a named function for interactive code reuse seems to increase the programming burden. Maybe my memory is not as good as Dijkstra's.

Repeating my goals

1. Make a map, as above ✓
1. Fill in subrectangles of a map with another map ✓
1. Pop up some pictures and dialog using CLIM's `accepting-values`
1. Use a door in the map to enter another map
1. + picturize the map symbols

We knocked out the first two; it occurred to me we should see that map symbols having a `:bitmap` property will render images in a hopefully-transparent-background stack so I have appended that goal. If I make these images hexagons, hopefully I stop getting these helpful messages saying "hey, I don't think your columns are aligning properly".

We made a cave in a mountain. I guess we could put that grass in the forest for a forest clearing as well.

So we have multiple, complex (in that the contents are not homogeneous) zones.

Then dialog/game events and moving between zones, and all the rest of the jam will be attempting to write a game story.

Actually, all the rectangle functions which I am using here from-the-repl are *"available inside the map"* as well, but I guess that REPLs are warm and familiar and NicCLIM is a dangerously nouveau basically spreadsheeting program.

# Fin.

[Join me on the Mastodon thread for this article](https://gamerplus.org/@screwlisp/115476828348071343); I guess I will begin my tootcoding adventure there.