Spring Lisp Game Jam 2023

Hosted by technomancy, David Thompson · #lispgamejam

Entries

393

Ratings

Overview Submissions Results

Community14

Screenshots Submission feed

Spring Lisp Game Jam 2023 community

Feedback for future devlog posts for my jam?

A topic by screwtape created May 27, 2023 Views: 620 Replies: 31

Viewing posts 1 to 12

screwtapeSubmitted348 days ago(+1)

My boilerplate is functioning as intended but messy. I annotated and shared it here.

https://lispy-gopher-show.itch.io/jam-no-theme/devlog/537069/annotated-ecl-sdl2-...

who else is writing here? How am I meant to be finding that, by this forum? I would like to read everyone's devlogs. With this boilerplate out of the way, I can write on more introductory and game-focused topics in the remaining days. Is there any computer stuff anyone would like me to wrap in throughout the jam? What improvements should I work on for my devloging? Do you have an example for me?

Looks like I should be line wrapping at 60 characters on here, not 69.

Jiggling line gif:

jaredkrinkeSubmitted348 days ago

Thanks for sharing the detailed post! Out of curiosity, why did you choose ECL+C instead of using existing SDL bindings? Portability? Ease of deployment? Apologies if you discussed this already and I missed it. I’m fairly new to CL and packaging/distributing CL apps looks pretty tricky!

As far as following progress, in other game jams I’ve seen dedicated threads for progress updates (or links to dev logs). I do wonder if there’s a better way.

screwtapeSubmitted348 days ago(+1)

I use the ECL compiler for portability. Especially, sbcl has difficulty being ported to openbsd whereas ECL does not. ECL also works reliably in every context I'm aware of, except compiling to WASM (which isn't real libc), such as linux and apple phones. The c2ffi based cffi package also isn't ported to openbsd.

That combined with how easy it is to mix C and lisp to use a game library like SDL2 is my reason ! So yes ease of deployment as well (ecl is just libecl.so after all). You know, this response is just me agreeing with your two paragraphs ;p

It's not visible yet, but an executably linked object is also pretty much just (asdf:make-build "package-name" :executable t) ; I have to check I got that right.

Vito VanSubmitted342 days ago(+1)

Preliminary support for the emscripten target

https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/277

technomancyHostSubmitted348 days ago(+1)

I’ve thought it’d be fun to post a devlog as you go, but I felt like it is too time-consuming to do during the jam, so I usually post retrospectives afterwards once I’ve had more time to reflect:

I do enjoy reading them tho, so thanks for sharing.

screwtapeSubmitted348 days ago

Thanks for your links! I like your retrospective titles In Which A Game Is Jammed, In Which Rays Are Cast... By habit from my aNONradio show, I can more or less just talk for an hour about what I'm doing so affording the hour to paper it is quite easy for me to jam my notes. Which is probably good considering I don't always write docstrings in passing !

screwtapeSubmitted347 days ago

I'm also gonna go for the cute-maths angle for my game for this jam (I'm calling your raycasting cute maths).

technomancyHostSubmitted347 days ago

Oh yeah, and there’s one more: https://technomancy.us/197

This one doesn’t seem to be about a game, but the game I’m doing for this jam uses the code in the post as its engine!

I think my problem is I am a bit of a perfectionist when it comes to writing; I spend way too much time editing and tweaking my posts. Maybe I just need to go more stream-of-consciousness during the jam!

screwtapeSubmitted347 days ago

+1 for broadcasting your stream of consciousness! Especially if it juxtaposes your very polished retrospectives.

One thing I have found I can't do to save my life is program while talking and recording my screen. Maybe I just need to leave my screen being secretly recorded, and then I can find out whatever it was that I was doing that resulted in my programs afterwards ;p

I will read this link while I spend this morning in a waiting room!

screwtapeSubmitted347 days ago (2 edits)

Day 2 devlog wost: Squeaky clean day. Functional programming, disappointingly hygeinic, less interesting garbage everywhere. Basically I decided I didn't need dark magic on C variables, and got functional in preparation for a more dynamic REPL experience.

Draw a (half-open) grid. Fallback game will be an emacs gomoku clone :D

https://lispy-gopher-show.itch.io/jam-no-theme/devlog/537538/lisp-game-jam-2-squ...

What do you think! Cleaner? Has anyone run it yet? Should I prioritize adding a Makefile?

jaredkrinkeSubmitted347 days ago (1 edit)

I’m actually curious how you’re building your game for ECL. A Makefile might be overkill, but any tips on how ECL finds an entry point are welcome.

In my case, I have :ENTRY-POINT set for my system, but when I ASDF:MAKE, ECL seems to ignore it and the produced executable just launches into a REPL (vs. SBCL which runs my entry point and exits afterward). Of course, you don’t even have the entry point set in your .asd file, so now I’m curious…

Edit: this assumes you’re building an executable and not just distributing the game as source only.

screwtapeSubmitted347 days ago(+1)

It's easier than you think! But remember that ECL generates C code, and passes that (and your user compiler flags) to your CC.

In particular to accomodate ECL, asdf has a specific function for doing-what-ecl-wants which is asdf:make-build . It works reliably as documented in the ECL manual's examples, and the asdf manual. It's also possible to build by directly using ECL's extensions (that asdf:make-build uses behind the scenes - basically compile-file has the &allow-other-keys :system-p t which spits out an .o object rather than a .fas fasl.).

Consider this Makefile ("Makefile") :

https://gopher.floodgap.com/gopher/gw.lite?=tilde.institute+70+302f7e73637265777...

for this project (web proxies of source) :

https://gopher.floodgap.com/gopher/gw.lite?=tilde.institute+70+312f7e73637265777...

screwtapeSubmitted347 days ago

*It's also fairly simple to jiggle it into working with the Android NDK gcc. There's an example of that, and for apple iirc in the ECL source. I haven't used a phone in a decade though, so it might have changed.

jaredkrinkeSubmitted347 days ago (2 edits)

Thanks! After looking at your post and going through the ECL manual again, I now see the example you mentioned: https://ecl.common-lisp.dev/static/manual/System-building.html#Build-it-as-an-si...

I'm still surprised that specifying a system entry point doesn't work for ECL, but at least there appears to be a bug tracking that behavior (although it's unclear to me whether it's an issue with ECL, ASDF/UIOP, or actually just expected behavior that I don't understand): https://gitlab.com/embeddable-common-lisp/ecl/-/issues/686

screwtapeSubmitted346 days ago

You mean like how the ecl idiom seems to be to use :epilogue-code ? I remember being confused by that until I got used to it ! I think the manual example also uses :epilogue-code like that. It will be cool to see some deployed ECL games !

screwtapeSubmitted345 days ago (1 edit)

I had another evening eventually, and my game jamming made it to LISP and not HACKNEYED C !

https://lispy-gopher-show.itch.io/jam-no-theme/devlog/538625/day-5-actual-lisp-g...

There's a link to a mastodon toot with a video of actual lisp interaction finally.

For me, a working lisp game editor means I'm pretty much done. I will interactive editor in my robots and puzzles. I guess I need to deploy it as well ;p. 90% done, now for the second and much harder 90% ;p

If you like this wost more than a different wost, please use this Like button that seems to exist on here.

(The video is only on the mastodon (since we can't upload video here, everything else appears first on the tilde.institute gopher)

screwtapeSubmitted343 days ago

Short video of the game as I'll submit it. I have enough for a retrospective phost, and maybe a deployment phost. I'll build it for openbsd amd64 aarch64, linux amd64, maybe I can borrow something else. It's pretty addictive. It's meant to be a maze in that you can indirectly control berry growth (which you eat for energy to prevent resets), towards the sparkling treasures which make your berries better. Secretly you can control what the blue dots do via

q -> stops the game for now

(in-package :ja)
(defparameter *programming* (lambda (bot) (funcall bot :move 'n))
(ja::play-game) ; restarts the game where we were

would program new bots to always move north, but this was kind of a complicated topic (I wanted to have them home in on berries and treasures, which is technically already possible...)

screwtapeSubmitted341 days ago (8 edits)

Thank you to Ksaj for sighting the game in the repl, and extensive build debugging with me! https://ksaj.inlisp.org/

Can anyone take a squiz before I submit it? I added an amd64 linux binary, but it would be better to play from an ecl repl. The undocumented robot control feature depends on a repl.

https://lispy-gopher-show.itch.io/jam-no-theme

revision 1 - I added (require :asdf) where needed (it was in my ~/.eclrc and I forgot about it)

sha256sum of linux binary

f8ecc4edf9b26080e76a4a31038e26fba922f1c75fc2be43d68dbf6ade1b0b83  jam-no-theme-linux-amd64

Notes!

- I was able to reproduce not having (require :asdf) and have fixed that in the Makefile and README.txt

You could consider putting that in your rcfiles.

- Downloading the project goes through a default begging screen. Javascript must be enabled to follow the link to the downloads.

- Google Chrome blocks the download of an executable, and the domain ( itch.io ) must be explicitly allowed

- Once downloaded, the executable does not have the executable bit set so we must

chmod +x ./jam-no-theme-linux-amd64

to mark it as an executable again.

the tarball extracts and loads as per the readme (for me with my cache and .eclrc deleted at least)

Edit 2:

Remove unused "alexandria" dependency from system definition

Edit 3:

Can anyone confirm asdf's build status on the Rpi pico w/ ecl?

screwtapeSubmitted340 days ago (1 edit)

I'm calling this a release ! Thank you #lispgames #lispGameJam lisp aliens!

https://lispy-gopher-show.itch.io/jam-no-theme/devlog/540935/done-and-done-post-...

Please share screenshots of the backgrounds you find with your berries / treasure-meter!

(We'll be able to tell if you were start scumming for backgrounds...)

Thank you to use-links2 for making backgrounds for this game and everyone for support and advice!

EDIT: Connected mastodon toot: https://sdf.org/l/vu

oofoeSubmitted339 days ago(+1)

For what it's worth, I tried to take my own advice and devlog every day. Usually at the end of the day, just before I fell over, which might explain why some of them are less than completely coherent. Like @technomancy, I do try to wrap up with some in-depth posts about choices I made or things I did. https://oofoe.itch.io/sparxline

screwtapeSubmitted339 days ago

oh awesome, I didn't get to taking a peek at your game yet so maybe I can follow along.

jaredkrinkeSubmitted339 days ago(+1)

By the way, I asked on the Itch community forum if there's a way to link devlogs to a game jam and, currently, there is not. They are aware that this would be a convenient feature, so hopefully some day!

Rather than spin up a new thread, I'll just link my write-up here for maximum thread-hijacking: https://jaredkrinke.itch.io/13l/devlog/541420/spring-lisp-game-jam-entry

screwtapeSubmitted339 days ago(+1)

Hmm I have a reference to something in the yawl module I feel like might just be a file of all the words (words.lisp)

screwtapeSubmitted339 days ago(+1)

Anyway I changed *valid-word* (I guess just wanting an asdf system is the previous version) to

(defvar *valid-words*
 (let ((ht (make-hash-table :test 'equal)))
  (loop for word in (apply 'append *bucketed-words*)
   do (setf (gethash word ht) t))))

(Yes I know, but there aren't that many words.).

Then I was able to

$ rlwrap ecl
> (require "thirteen-words")
> (13l:menu)

Also I missed that the game is that every wrong guess reveals a character. I thought you were asking me to just unscramble thirteen letters cold. So I

(defun delete-1st (ch list)
 (let ((idx (search `(,ch) list))
  (cond ((null idx) list)
   (= idx (1- (length list)) (butlast list))
   (t (append (subseq list 0 idx) (subseq list (1+ idx))))))
(defun word-has (word letters)
 (loop for lord = (coerce word 'list) then (delete-1st ch lord)
  for ch across letters
  when (not (member ch lord)) do (return-from word-has nil))
 (list word))
(defun cheat (letters)
 (loop for word in (apply 'append *bucketed-words*) nconc (word-has word letters)))

;p my score is very good...

jaredkrinkeSubmitted338 days ago(+1)

Ah, I broke the console version while making the web one. Sorry about that!

I think it would work if you synced the Git sub module (something I should add to the instructions). But fortunately for you *valid-words* is only used on the web server, so even just making it nil should make the console game run 🙂

Thanks for giving it a spin!

screwtapeSubmitted338 days ago

Aha, I simply saw it was being used elsewhere in my glance over the codes and tried to hackily fulfill its spirit.

jaredkrinkeSubmitted338 days ago

You are far more patient with broken code than I am 🙂

screwtapeSubmitted338 days ago(+1)

I feel like there's gotta be a suitable data structure that does 'member that looks like 'member and not 'gethash as well. I'll ask people on my show, they're smart ;p

jaredkrinkeSubmitted337 days ago(+1)

I didn't see anything built-in, although it looks like there is at least one library: https://github.com/samebchase/hash-set/

screwtapeSubmitted337 days ago

I guess the idiom is most of the time to just use 'member. 'member will be O(b . n) for very small b, whereas using a hashtable with no collisions will be O(c . 1) for very large c. And maybe there are collisions, so <hash table collision complexity>

screwtapeSubmitted338 days ago

ECL build tests !

Hi everyone, I know I linked an old sharedobject, so everyone had to build jam-no-theme themselves, but some people had different build failures !

So I wrote three minimal idiomatic ecl command line utility build tests

1) Hello world

2) Use #include <math.h> and -lm to use powf

3) Use #include <SDL2/SDL.h> and -lSDL2 to use SDL_atan2

See this mastodon toot please:

https://mastodon.sdf.org/@screwtape/110494065796345224

screwtapeSubmitted331 days ago

I made a gameplay video (10 days late) for everyone who didn't get to see my game, or didn't have me on hand personally explaining how to play it :D

I also talk about my reading of the archtypicalisation of games, and why technomancy's TIC-40 fennel game approach is so desirable (before exploring it)

I was procrastinating this video, and wasn't reading everyone's retrospectives until after I made it, so please (re)link me your game jam retrospectiveses on the mastodon if you would like me to read and inescapably talk about them. https://mastodon.sdf.org/@screwtape/110534523906302467