itch.io

https://codeberg.org/tfw/nud

git as always. Probably use slime from emacs. Er, I had some videos at some point if it helps. https://toobnix.org/w/p/4bRcULzg6bBAyELkRqU6EQ

Itch.io can't deal with https git urls in code blocks.

https://codeberg.org/tfw/nud !

mkdir -p ~/common-lisp/
cd ~/common-lisp/
git clone https :// codeberg.org/tfw/nud.git
sbcl
(require :nud)
(in-package :nud/user)

It occurs to me there's no link to the git.

https://codeberg.org/tfw/nud

mkdir -p ~/common-lisp/
cd ~/common-lisp/
git clone https://codeberg.org/tfw/nud.git
cd;
sbcl
> (require :nud)
> (in-package :nud/user) ;as above.

Well, it's not perfect and for some reason my :export both didn't work but happy 2025 everyone. Chatter at me on the 'stodon plz. Remember the live show is every Wednesday  0UTC (Tuesday night in Americas various). We're mostly doing interviews when we can now. Check the pinned Mastodon toots for recent interviews or the peertube https://communitymedia.video/c/screwtape_channel/videos:

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

So so far it seems the Mastodon thread https://mastodon.sdf.org/@screwtape/113518658526470901 to get on the honorary jam roll has a little momentum.

(Well, we went from

to

so far, and hopefully you too will get involved soon.

Once our township forms, I think I will ask repeatedly-eval-qt to highlight actions that are happening on the graph, and then we basically have a top-down universe simulator in video, but where people in that universe can gain function via lisp/moo much more literally than in the offline world.

To be clear: Egbert's first contribution is now here in the git:

https://codeberg.org/tfw/lispmoo2/src/branch/main/games/egberts.limo

and Egbert's second contribution, connecting to Screwtape's MOUNTAIN-TRAIL is here:

https://codeberg.org/tfw/lispmoo2/src/branch/main/games/egberts-2.limo

So while I've been using the :lispmoo2/user package to absorb code, it is eminently possible to use other packages. We should verbs for making and manipulating lisp packages.

LISPMOO2/USER> (uiop:define-package :ofo)
 #<package "ofo"=""> 
LISPMOO2/USER> (intern "abr" :ofo)
 OFO::|abr|
 NIL 
LISPMOO2/USER> { @create $thing :named OFO::|abr| } x
  YOU @creates $THING :named abr. ($THING) 
LISPMOO2/USER> { @push ofo::|abr| :to (ocean :contents) } x 
(OFO::|abr| TROUT) 
LISPMOO2/USER> { look-around } x
  You are in OCEAN.
 Objects here are:
 abr TROUT
 Players here are:
 YOU
  Exits here are:

* Not that you were about to say so, but I used counting up instead of just 

(time (list (mod 1555432 3) (mod 1555432 5) 1555432))

in the spirit of fizzbuzz.

Oh I got it. My { reader stops at EOF. So if you are in the terminal rather than in slime, you probably have to issue C-d <return> for the read to ever finish. It seems like no-one could possibly be happy about how that { thing works ;p

Also I think in my other post I accidentally listend setqing *player* after (define-game), when it really needs to be before. What does (symbol-value 'start-locn) return?

Did you close the curly brace? You're not meant to. It will be considered a normal symbol. Here, let me try. When the sdf mastodon went down, I spent some time furiously navel-gazing about this instead, so it works on my machine at least!

I had to zoom out to 25% to see it

Deeply traumatic / 10

Now when you say "build" and "game"

alright I accept that I submitted this game to a game jam so we better do it

It's common lisp. 

1. 1. apt install sbcl or w/e
2. download and verify (sha256 or w/e) https://www.quicklisp.org/beta/ 's https://beta.quicklisp.org/quicklisp.lisp
   1. It says beta but it's not thaat beta
3. sbcl --load quicklisp.lisp and follow the prompt
4. git clone (or download/extract) int ~/quicklisp/local-projects/ :
   1. https://codeberg.org/tfw/moonclimb
   2. https://codeberg.org/tfw/lispmoo2
5. Good work so far
6. $ sbcl
7. > (ql:quickload :lispmoo2/main)
8. > (in-package :lispmoo2/main)
   1. I forgot, need to do > (define-game) ; here
   2. You could (setq *player* 'my-name-instead) ; first if you wanted to
9. > { north
10. > x
11. > { west
12. > x
13. > { @take gold-ring
14. x
15. { east
16. x
17. { @give gold-ring :to distressed-princess
18. x

And that's pretty much it. The thing is, the moo substrate for the game works really well so you can ignore the above "game" and do something better

1. { @create $room :named my-way-better-room
2. x
3. (push *player* (get 'my-way-better-room :inhabitants))
4. @create $thing :named incredible-sword

and just make your own better game / or improve my game ;p

Chat during the show is in lambda

(

telnet lambda.moo.mud.org 8888

co guest

@join screwtape

)

Okay, I will pay at least a little attention to everyone else's games on the show tomorrow ( 000UTC Wednesday https://anonradio.net ) but indulge me indulging me for just one second here. Is this crazy or not.

https://lispy-gopher-show.itch.io/lispmoo2/devlog/828749/my-very-own-computing-r...

What's the funniest way to pronounce cavez ? To rhyme with chez?

I suppressed all the warnings in my last commit. (Well, they are placed in *last-warnings*). So now you just see the meaningful returns and standard output I was showing above and in general, and changed the instructions to reflect quicklisp's default useage.

https://itch.io/jam/autumn-lisp-game-jam-2024/rate/3062506 oops linky

Okie dokes, I submitted it. devlog retrospective will be forthcoming, but here is where I ended up though with quite a few downsides:

Admittedly, it is quite a short and linear game with deficient narration. Sorry for spoilers.

> { north
> x
You navigate north to FOREST.
(:OWNER SCREWTAPE :PARENTS ($ROOM $OBJECT) 
:CONTENTS NIL 
:INHABITANTS  (DISTRESSED-PRINCESS SCREWTAPE) 
:EXITS  ((SOUTH . START-LOCN) (WEST . CLEARING)))
> { west
> x
You wander west to CLEARING. 
(:OWNER SCREWTAPE 
:PARENTS ($ROOM $OBJECT) 
:CONTENTS (GOLD-RING) 
:INHABITANTS  (SCREWTAPE) 
:EXITS ((EAST . FOREST)))
> { @take gold-ring
> x
"You take " GOLD-RING GOLD-RING
> { east
> x
You exit east to FOREST. 
(:OWNER SCREWTAPE 
:PARENTS ($ROOM $OBJECT) 
:CONTENTS NIL 
:INHABITANTS  (DISTRESSED-PRINCESS SCREWTAPE) 
:EXITS  ((SOUTH . START-LOCN) (WEST . CLEARING)))
> { @give gold-ring :to distressed-princess
> x
"You give " GOLD-RING to DISTRESSED-PRINCESS

However! I am classifying playing the game as doing anything possible in lispmoo2, which includes @creating whatever and @verbing what you want as well. For example, I did this:

{ @verb $thing :is (com-@give
                 (if (and (member dobj (get player :inventory))
                          (member iobj (get here :inhabitants)))
          (progn
             (setf (get player :inventory) (remove dobj (get player :inventory)))
            (push dobj (get iobj :inventory))
            (print \"You give \") (princ dobj) (princ \" to \") (princ iobj))
          (progn (print \"You can't or don't want to give \") (princ dobj))))

To allow myself to @give the gold-ring to the distressed-princess. (whom was @create $player :named distressed-princess -ed).

The one million pages of warning every time you execute { x } , generally for typos, all from moonclimb are ignored as they don't proximally cause any real problems. There are a few miles of devlog to be had but it was some kind of completion, even if I didn't get to being gamey again.

Looking forward to playing your game! (Person, whom will ideally want to hang out on Wednesday's show, I'm looking at you mdh)

3 for 3 (I'll let you go back to sleep now.

I fixed the ugliness of my low level interactions using a reader macro in https://lispy-gopher-show.itch.io/lispmoo2/devlog/826908/a-moonew-language-for-i....

To illustrate, above you read me write

(verb-plist :verb 'com-@create :dobj '$room :prep :named :iobj 'start-locn)

which I have now implemented as

{ @create $room :named start-locn

Where { enters this reader. It also accepts additional explicit keys, but evals their arguments.

Alright I did somehow muddle my way through the first step, though I skipped connect

While there isn't any high level interface to my engine, In hypothetical high-level I did this:

1. @create $room named start-locn
2. @create $room named forest
3. LISP> (push 'screwtape (get 'start-locn :inhabitants))
4. @verb $room is (com-north (progn #<find 'north in exits and move PLAYER there>)
5. north

LISPMOO2/MAIN> (funcall *krnl*)
  You head north to FOREST. 
(SCREWTAPE) 
LISPMOO2/MAIN> (symbol-plist 'forest) 
(:OWNER SCREWTAPE :PARENTS ($ROOM $OBJECT) :CONTENTS NIL :INHABITANTS
  (SCREWTAPE) :EXITS NIL) 
LISPMOO2/MAIN>

https://lispy-gopher-show.itch.io/lispmoo2/devlog/826836/defining-north-between-...

Attempting to get anything at all turned in I wrote

https://lispy-gopher-show.itch.io/lispmoo2/devlog/826784/figuring-out-how-my-moo...

just now. I'll try and get the then-implementing-this-plan scratched out in the next 24 hours. I think even just this will be surprisingly interesting (to me personally!). I'm also excited to poke around all the diligent jamming lisp users have gotten to here in my quiesence!

The Lispy Gopher Climate (https://archives.anonradio.net/#screwtape https://mastodon.sdf.org/@screwtape/113393326797991173) after this jam ends, I will mention and poke around in (or if the barrier to entry is very lispy, play) your game and mention what I can.

I accidentally rounded the time of the jam starting, please don't crucify me

https://lispy-gopher-show.itch.io/lispmoo/devlog/821630/lisp-kind-of-society-urg...

Right after this jam started, I heard I was causing my friends some trouble by letting other people know how cool it is to MOO. So starting now, I am going to do my best to write a new playable multiplayable MOO server in common lisp.

This will also accentuate the spritely institute's development, which I consider to be similar.

I'll reply here with my itch phlogs as I go if someone wants to chatter about them.

I'm on the Mastodon if you would like to mutually toot over there. https://mastodon.sdf.org/@screwtape

I'll also be talking about this and this jam on the show on the next two Wednesdays at 000UTC and Friday 1400UTC. https://anonradio.net:8443/anonradio https://archives.anonradio.net/#screwtape.

I had previously written some low level MOO engine infrastructure in lisp (my moonclimb) which I will use for infrastructure.

Oops, I forgot to include

(let ((*standard-output* *inter*))
 (present *branch*))

before the traverse call, though you got what happened, right.

Another great reference for getting started with lisp, using the popular steel bank common lisp is Andrew's https://awkravchuk.itch.io/cl-fast-ecs/devlog/622054/gamedev-in-lisp-part-1-ecs-...

I guess 

> (find-application-frame 'working)

would open the window of the inaugural frame.

oh yeah I got it backwards. that name referred to the defined component name, I would have to put a symbol-name property inside the component if I wanted it. Now I got it working I can actually use it and see ;p. And I would call make-object once for every object, the object having components having component properties.

I had an old version of cl-fast-ecs in my source-registry

Ah, when I referred to using a plist, I meant in sketching component properties I put these properties in the plist as an implementation detail. So I think

(defmacro symbols2ecs (symbols)
 `(ecs:make-object
   ',(loop for symbol in symbols
           for key = (intern (symbol-name symbol) :keyword)
           for plist = (symbol-plist symbol)
           collect (cons key plist))))

Ends up with your spec for me ;p sorry for thinking out loud. I see it's been tested on ECL, I'll figure out why mine wasn't working.

For example if I have an arbitrary number of room entities and doors to other rooms can be created or removed over time, how should I achieve this?

I guess I could fix the exits to be only of type (member :north :east :south :west :up :down) since that's mostly adhered to anyway and then since your ecs is fast, 

for players solely keep the player-room connection in a property of the player entity and just search what players are in a room at a point in time. Which I guess works for a relatively large small number of players. I guess you did this somewhere I should have looked at already in your games..!

[] if I understand, ecs:make-object expects per object an alist where the cars are keywords and cdrs are plists keyed by keywords.

So instead of using symbol-name, I would have a :name property in a plist to construct the input to ecs:make-object. And I guess I would need a :package property if I wanted to refer to the password; actually, is there symbol support or sequence support (I understand sequences of indeterminate length aren't nice for fast searches).

I'll actually try the example when I'm at home.

Thanks <3 

I'm now trying to figure out how I can do (symbol-plist foo)s to your entities + component properties in https://awkravchuk.itch.io/cl-fast-ecs ie so I can use your beam search / A*

The source is secretly stored as an exportable web page https://codeberg.org/tfw/moonclimb/src/branch/main/scratch.org

Also, my repo for starting a lisp image in emacs: https://codeberg.org/tfw/slimeclimorg/src/branch/main/slime-ecl.org

Last postscript, toot to me on the mastodon: https://mastodon.sdf.org/@screwtape

Screenshot didn't attach...?

Related video

Haven't played, but thank you for writing this retrospective treatise.

(I don't normally play games, so your detailed account of your experiences, whys and wherefores were great for me to hear)