Skip to main content

Indie game storeFree gamesFun gamesHorror games
Game developmentAssetsComics
SalesBundles
Jobs
TagsGame Engines

screwtape

216
Posts
10
Topics
24
Followers
66
Following
A member registered May 26, 2023 · View creator page →

Creator of

Recent community posts

https://screwlisp.small-web.org/lispgames/nicclim.lisp I spot fixed the PATH thing, I didn’t figure out uiop:chdir not working yet though. Will try tomorrow.

How did you try getting mcclim? Did you use quicklisp ?

Thanks for trying! I only just tried with sbcl myself, and I found I had the same problem. I should have used UIOP compatibility layer, or tested with sbcl at least!

This fixes the path in the repl:

(merge-pathnames #p"Downloads/nicclim.lisp" (user-homedir-pathname))
(compile-file *)

but then sbcl has a conniption on

(load *)

Where it is angry I wrote this: (lambda (path &aux (path (string path)))) which I believe is conformant shorthand for (lambda (path) (let ((path (string path))))) which I think is obviously allowed. I will think if there is an optimize declamation that will fix this in sbcl or something since it is kind of late days to fix.

(1 edit)

Can you let me know if it works as expected in sbcl (+sly), I probably should have tried/shown it with sbcl myself. I like the idea of embedding it into random C++ programs with embeddable common lisp in the future though.

Article in which I make-my-own-map-as-a-player-of my unix-surrealism-jam. In particular I make a map that is too big to fit on the screen, change it to have a this-jam-movement-radio-choice to move from the edge of the left map onto the right map, put pictures in. I made a white writing graphic, so I put the penguin from https://analognowhere.com/ in the cell behind it so you can kind of see it since the gui is lightfield.

https://screwlisp.small-web.org/lispgames/my-common-lisp-game-jam-self-experience/

(1 edit)

I think it is correct to say interlisp medley as the language (and not refer to it as interlisp-d because it is quite different to the 80s d machines - I’m pretty sure I have seen the Medley crew give this correction before). Of course, interlisp is a complete programming system which includes its common lisp implementation.

Pixel Outlaw, I am so happy with your game and your promulgation of the incredible work by interlisp.org.

I was thinking that to emphasize the lisp of lispGameJam, it would be attractive for the jam submission to specifically be the lisp source code written purely in the jam. And we could magic(5) the variety of lisp from the extension of the code submission. Itch.io supports source upload type. And the ten day window means there will never be too much original source per game.

Oh, you are right. I had to try my-other-left-click (??). Beautiful game.

The rules are a little different to what I remember

Took me a while to press bug a second time so the bugs actually appeared.

There is no rule saying chickens can’t play basketball

I’m having trouble making it go. Beautiful in-retro-vm-graphic though.

Intense jellyfish energy

Now if you could get them to release the rights for spooky scary skeletons

Awesome that you created a multiplayer in-browser MUD in a jam (with lisp). We should coordinate a game of hide-and-seek or something.

(1 edit)

Looking forward to helping you debug running it. Just download, tar xkvf GAME.TAR and

(ql:quickload :McCLIM)
(compile-file "~/Downloads/nicclim.lisp")
(load "~/Downloads/nicclim.fas")
(in-package :nic)
(compile-file "~/Downloads/unix-surrealism-jam.lisp")
(load "~/Downloads/unix-surrealism-jam.fas")

(uiop:chdir "~/GAME")
(uiop:chdir "~/GAME") ; not a typo
(load "LEVELS/LEVEL-1-STRANDED.LISP")
(load "LEVELS/LEVEL-2-WALL-RADIO.LISP")
(enclose-map 'TECHNO-MAGE/STRANDED.MAP)

?

Done and dusted! https://itch.io/jam/autumn-lisp-game-jam-2025/rate/3822491

I am looking forward to debugging it running with you. Running it after downloading and extracting the assets is literally

(ql:quickload :McCLIM)
(compile-file "~/Downloads/nicclim.lisp")
(load "~/Downloads/nicclim.fas")
(in-package :nic)
(compile-file "~/Downloads/unix-surrealism-jam.lisp")
(load "~/Downloads/unix-surrealism-jam.fas")

(uiop:chdir "~/GAME")
(uiop:chdir "~/GAME") ; not a typo
(load "LEVELS/LEVEL-1-STRANDED.LISP")
(load "LEVELS/LEVEL-2-WALL-RADIO.LISP")
(enclose-map 'TECHNO-MAGE/STRANDED.MAP)

Whence (watch the animated gif video on my blog) / get from the itch submission

(1 edit)

My blog article is the same as the project page, except itchio did not have an opportunity to break my formatting. https://screwlisp.small-web.org/lispgames/instructions-for-game-jam/

unix-surrealism-jam.lisp and levels (GAME.TAR) and unix-surrealism-level-making were created wholly within this jam using my pre-existing map editor NicCLIM; please judge the unix-surrealism.lisp and levels experience, and making-your-own-unix-surrealism-levels experience as per the instructions. See the video. All of that was this jam.

The reuseable compatibly to the lisp-game-jam art is due with permission for this purpose to the excellent https://analognowhere.com/ , adapted by me. Primarily, https://analognowhere.com/techno-mage/stranded/ .

In which I actually make a level for my NicCLIM map editor game like I am asking other people to join my jam submission by doing for/with me this final weekend!

https://screwlisp.small-web.org/lispgames/making-one-nicclim-level/

i.e. me making

(SKY)	(SKY)	(SKY SUN)	(SKY)	(SKY)
(HORIZON)	(HORIZON TREE)	(HORIZON PUFFY)	(HORIZON)	(HORIZON)
(GROUND)	(GROUND OPENBLADE)	(GROUND MAGE)	(GROUND PENGUIN)	(GROUND)
(GROUND)	(GROUND SODA)	(GROUND BAG)	(GROUND)	(GROUND)
(GROUND)	(GROUND)	(GROUND)	(GROUND)	(GROUND)
Clobber SKY-GROUND? y/n  (Y or N) y

out of https://analognowhere.com/techno-mage/stranded/

with my extraction thereof being kindly licensed for lispgamejam compatible reuse by prahou.

My first ~ level map for the game I am making with my NicCLIM thing. Well, by the end of the GIF the map of the game reuseably derived from Prahou’s comic is done.

If anyone would like to join my submission by helping make more s-expression file levels / scenes, I am actively seeking you doing that.

Article detailing the gif: https://screwlisp.small-web.org/lispgames/making-one-nicclim-level/ Mastodon thread: https://gamerplus.org/@screwlisp/115511544523581843 (ask questions plz)

Another article relates the game mechanics side of the hextille grid we see one of build here.

(1 edit)

Okay! I jammed out the last piece of game mechanics

  • keyboard arrowkeys are movement
  • can’t walk through any symbol in impassable
  • if you walk over something with a :radio-choices, it pops up the radio selector with your text and pictures (and notes your choice in cursor cur2

Per the article, I am really hoping anyone who wants to, and either is or is not jamming themselves so far contributes an s-expression “map” to our dungeons of unix_surrealism lisp doom

https://screwlisp.small-web.org/lispgames/game-movement/

A map is an s-expression file like this:

(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	
(WALL)	NIL	NIL	NIL	NIL	NIL	(WALL)	
(WALL)	NIL	NIL	NIL	NIL	NIL	(WALL)	
(WALL)	NIL	NIL	(EXAMPLE)	NIL	NIL	(WALL)	
(WALL)	NIL	NIL	NIL	NIL	NIL	(WALL)	
(WALL)	NIL	NIL	NIL	NIL	NIL	(WALL)	
(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	(WALL)	

Radio choices are like you see in the article. Pictures are symbols with a :bitmap property image path. If you ask me here I will help you coauthor this with me.

https://analognowhere.com/ art theme/source for the jam game.

Aside, there was this conversation on the Mastodon about gamedev by various people with decades in the subject: https://gamerplus.org/@screwlisp/115501448005940820

Your article gopher://cyberhole.online/0/phlog/20251104_190646.txt cannot be missed or understated https://mdhughes.tech/2025/11/04/phlog-collection-2025-11-04/

(1 edit)

3th devlog:

Implementing radio selection windows popups. I really like having these at hand. It even seems to be a missing feature in modern OSes/DEs in my opinion.

https://screwlisp.small-web.org/lispgames/com-popup/

Radio selections for active interaction by the user.

2th devlog: Basically a retrospective on the first two devlogs and a deeper self experiential examination of tagbody-go centric programming today. Oddly many thousands of words.

https://screwlisp.small-web.org/fundamental/a-prog-feature/

No pressure but I am looking forward to multi-MUDdying mudhole and lambda on the Tuesday-night-in-the-Americas weekly Lispy Gopher show.

Topically to your devlog phloging, we will have someodd, who hosts my gopher and topically to gamedev also turned the entire gopher into an rpg -game (in haskell not lisp ;_;) gopher://gopher.someodd.zip/1/gateway/mksession/random/1/gateway/games/grpg/look/ .

(1 edit)

Continuing the spirit of my above extraction-of-the-code from my 1th https://screwlisp.small-web.org/lispgames/the-other-threeish-checkmarks/ jam devlog, here is what happened, I guess. Use your imagination and/or emacs for the eev-mode tooling.

All new repl lines:

;; «🎭» (to “.🎭”)
(setf (get ** :bitmap) *)

'SOLID
'IMGS/SOLID.PNG
;; (to "🎭")

'ROCK
'IMGS/ROCK.PNG
#.+++

'TREE
'IMGS/TREE.PNG
#.+++

'GRASS
'IMGS/GRASS.PNG
#.+++

'LAMBDA
'IMGS/LAMBDA.PNG
#.+++

IMGS/*.PNG were:

;; «🚪» (to “.🚪”)
`(lambda
     (&rest r)
   (execute-frame-command
    *application-frame*
    '(com-change-map ,*)))

'grass-clearing.map
;; (to "🚪")

#|Output:
(LAMBDA (&REST R)
  (EXECUTE-FRAME-COMMAND
   *APPLICATION-FRAME*
   '(COM-CHANGE-MAP GRASS-CLEARING.MAP)))
|#
(execute-frame-command
 *nic*
 `(com-set-cur1 ,*))
(execute-frame-command
 *nic*
 `(com-cur1-rotatef))

(This lambda was useable inside-the-map to go-through-the-door to another map in a messy looking way; but later it will just be the one game movement action)

Ah, yeah. If I had not-just-seven-days I wanted to particularly implement Pitman’s https://dspace.mit.edu/handle/1721.1/5619 which basically was a lisp machine system like that. This jam I will see how things as they are now evolve and get insights like yours.

I’m having trouble accessing gopher://cyberhole.online:70/0/phlog/20251031_051056.txt .

(6 edits)

Who else is using ANSI CL? If you will forgive my laziness to sift through everyone, could people chime in about their CL game and where they’re devloging?

I guess I am using my NicCLIM starting with my somewhat late initial devlog: Mastodon toot: https://gamerplus.org/@screwlisp/115476828348071343

Devlog 0: https://screwlisp.small-web.org/lispgames/actual-game-gamejam/

My NicCLIM is really just the clim 2 spec’s formatting-table macro and McCLIM as such. I am trying out writing reuseable #codeTooting toots as a style, so the four zones/maps of my game initially were the REPL commands:

;; 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 "†")

Anchored to the toots in that thread:

# «§»  (to ".§")

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

# «†»  (to ".†")

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

# «‡»  (to ".‡")

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

So you would enter three values one by one into the repl, and then the toot jump consumes those values. DM joked that I had independently rediscovered forth, which is a lisp tradition I think. The anchors are Edrx’s eev emacs style. https://anggtwu.net/#eev

What about educational, technical lisp demonstration, programming concept (I say as one of the people the dot matrix was referencing ;p). I have seen feedback like "I had no idea I could use that compiler like that"

Hey everyone, I walked through my own game source submission, showing it being evaluated / working in emacs with 12 screenshots. There were about 4 typos/omissions which meant it would not have naively worked. It also shows emacs eev, and how I am actually writing and running my new kitten markdown files bit by bit.

One screenshot attached.


I walked through re-creating my own game per the submission. https://gamerplus.org/@screwlisp/114554113125754945 There turn out to be about 4 typos/small-omissions/a-backslack-getting-eaten in the uploaded source.

It is shown in 12 annotated screenshots.


Well, whether I'm gonna do it within three hours though ;p. I will try and make the game I initially described to Ksaj out of it post-jam.

Lots of fun and fun to see made! See I think your crisp a-game-is-the-conjunction-of-these-logical-and-graphical-ideas-and-their-facilitation-and-outcomes is amenable to a knowledge rep approach

You are right I should post a video of the KRF and put timezones other than Zulu time somewhere. In terms of emacs eev in general, Eduardo has a lot, but I will record an example myself on a different machine later today. ("today").

Lots of fun.  And yeah, I never survived low orbit.

Mm, yeah. I must have typed it or something instead of pasting it since it's already at-that-path for me from (the couple of devlogs).

git clone https://codeberg.org/tfw/pawn-75.git

Would work I guess. Are you using eev as well?

It's this one: https://codeberg.org/tfw/pawn-75 which is my port/revivification of https://www.ida.liu.se/ext/leonardo/ (https://franz.com/success/customer_apps/knowledge_mgmt/leordo.lhtml) and related things.

(1 edit)

This has been quite interesting to read so far though I am only 1000 lines (half-way) in. I was debating how easy it would be to port to common lisp for me to really-look-at-it but your work is nontrivial.

(The tiles and things have ascii structure / inlined examples in the large linecount)

    (*

right

             0   1   2   3   4   5   6   7   8   9

    left 0   0   14  X   X   X   X   36  X   X   X

         1   1   80  X   X   X   X   70  X   X   X

         2   X   X   X   3   2   X   X   44  X   56

         3   X   X   34  X   X   26  X   X   42  X

         4   X   X   24  X   X   16  X   X   60  54

         5   X   X   X   22  12  X   X   54  X   66

         6   32  74  X   X   X   X   90  X   X   X

         7   X   X   40  X   X   50  X   X   100 X

         8   X   X   X   46  64  X   X   104 X   106

         9   X   X   52  X   X   62  X   X   102 X

                   tile, rot

    take the tile, and rotate it clockwise as indicated.

    *)