@icedquinn I am going to experiment with spritely goblins/scheme as a base but I keep having false starts. I am not sure it's worth it tbh but like Urbit I want to take a chance on something weird to see if it's secretly wonderful
@sun honestly pulp fantasy would just be for the learning experience. practically every mud is already exactly high fantasy grindy as shit. then there is discworld which is all of those things (but actually highly well made.)
cyberpunk life sims like. they don't exist. nobody's ever done it. not even graphically (there's nivalis but they're in an indefinite delay loop.)
@sun its really nothing. you shit text over a pipe, maybe pay attention to a couple telnet codes. the rest of the stuff is spiffy but optional (like MXP and MCCP are things you can negociate that says "its ok to shit html3 tags at me" or some sideband json data) but those are mostly for funny clients in the commercial games
@icedquinn I'll just ask you for info right now then if you have anything to share. I know simple ones just have strings for objects, and flags that are simple boolean or numeric variables. to what extent are MUDs object-oriented, where you actually define objects and interaction rules like in RDF or something
@sun hellmoo (now samsara) was one of the few in an apocalypse setting, yeah. though i think they bungled some priorities.
most of them are about typing k mob and going to bed. that's something about multiplayers i always wanted out of. like killing gangsters is a part of life but i always enjoyed the other shit more :bloboctopus:
@icedquinn I have been thinking a lot about programming a MUD by using Turtle or something to declaratively define objects, rooms, and with verbs you can use to interact with them that call an elixir function or something
there is a clear distinction between a room, a player, and an object, generally. in the MUSH lineage it stays this way. there are some attributes and rules that exist in the "hardcode" (the C half) and then a bizzare and shitty functional scripting language (the "softcode") that can control room locks and some stuff. MUSH isn't really for games, its a glorified chatroom.
MUX kind of the same but furries, and i think parts are coded in forth instead.
LPMud and Lambda are full object oriented scripting languages. Though in Lambda the object is, literally, objects, as in you can pick them up and toss them off a bridge assuming you coded the verbs. Both of those basically don't 'have' hard code, the hard code is just the interpreter and the whole game is softcode. MOOs (because the engine was called LambdaMOO) tend to be pretty spiffy and nice.
MUDs usually come from like, DikuMUD or CircleMUD. These are kinda shit. Most of the behavior is hardcode and theres some data files to make template monsters. They play very generic cause you have to edit the C to do anything and most people won't.
evennia is python and uses django to persist objects, so you have a mixture of classical python objects and then in-game objects that get persisted.
if you decide to do it yourself, the most annoying part i got stuck with is the command parser. MOO has a pretty silly syntax for it (there are certain words that break up propositions but those are coded in, which is why hellmoo gets very weird shit like 'switch lantern to on') this is basically having to know how to separate a query in to atoms and find which are verbs and on which objects.
you get the 'fun' of armageddonmu, where 'drink bottle' resolves to drinking the bottle of bleach instead of the water bottle and then you die and have to spend another 800 hours grinding.
@sun i dunno how easy it is to do verbs in evennia yet. in lambda they're weird because the parsers generic and verbs live with objects.
it would probably be cleaner to do what CLOS does, define all the verbs in the game in one shot ('generic functions' but with NLP syntax) and then just implement them on the objects that use it, so you can avoid 'switch lantern to on'
@apropos@icedquinn I definitely can jump right in if I use Elixir, if I decide to use Guile I have a lot of prerequisite learning ahead of me before I even get to fun stuff
@apropos@sun someone did write a mud engine in elixir. i did not use it, though. i'm not sure how well it would work because there's lots of string parsing and mutable state which are both things BEAM hates.
evennia has a proxy to hold the sockets and do ssl/compression/etc, so the backend reboots and aside from a world announcement nothing really stops
@apropos@sun i'd like to have known erlang or something but i always kind of avoid using it. beam is weak in like literally every area, other than it just doesn't go down. :blobcatgooglynotlikethis:
@icedquinn@apropos I tried to implement a couple things in elixir that required a lot of mutable state and it was insanely annoying but at least you can write a NIF in Python or Rust really easily that you just call
@sun@apropos if you don't plan on handing out builder privileges, sure.
lambda et all do it in a silly way because 1) they were made in the early 90s and 2) levels of code privileges could be doled out, like in lambda's actual original instance anyone could just make an object and slap verbs on it.
you could finagle a little DSL for parsing if you don't plan on letting players or coders slap verbs on stuff adhoc. like i said, write a parser that consumes stuff like 'put <item> in <item>' and converts that to some action code, like a clos generic function, and then let individual object types implement the action code. its cleaner :blobcatdunno:
@icedquinn@apropos the reason that spritely goblins seemed interesting is that it has a way to persist all your state automatically and you can time travel debug an entire constellation of remote servers
@icedquinn@apropos another thing I am looking at is, using llamacpp and taking natural language as input, and coercing output using ebnf grammar to module function calls that are then fed to a script parser
@icedquinn@apropos its a library built on top of GNU Guile that manages objects and ACLs in a distributed network environment. One of the people involved is one of the primary ActivityPub authors
@sun@apropos as for matching objects idk. i didn't succeed in figuring that one out, but i suspect its one of those O(n^2) things where you have to iterate every object in a room and grade how much the text matches
@icedquinn@apropos with Nimble I could probably make somethign that takes natural language, turns it into RDF triples and applies them directly to function calls with the appropriate parameters
@shibao@icedquinn@apropos I had trouble finding something to persist state in a sane way, I wrote my own thing but it amounted to having to write the entire state document with every change, which sucks ass
lambda it all lives in RAM between the times we dump it to disk. evennia lives on django, so they inherit python metaprogramming to deal with the persisting.
@shibao@apropos@icedquinn I know that you break up state in an actual game by having linked together rooms but just more genereally I wonder what you do when your state gets big
@sun@shitposter.world@icedquinn@blob.cat@apropos@fsebugoutzone.org nah that's exactly how you'd do it! regions in a server world or whatever, you can basically construct your topography how you'd normally use entire machines in beam and then beam handles actually translating it to your machines seamlessly. if you have thousands of the same entity, might make sense to use an ecs like system tho
@gentoobro@apropos@sun there's a few annoyances with it too. maybe i should fire up nim and tinker with that algorithm again idk.
there's some silly bits like objects having nicknames (so it will say something like "a can of peach soda (a.k.a. can, soda)") and you'd probably want to bias it towards selecting full names over nicknames (since nicknames will be more ambiguous)
theres also syntax for picking one of these in a multimatch. if you have 'bottle of gamer bathwater' and 'botanical garden' and you type 'get bot' it will go :blobcatdunno: so you end up having to type like, 'get 2.bot' or 'get the second bot'
I would try making a ranking system for potential matches, including context of the proposed action. For example, "get bot" would prefer the bottle over the garden because the bottle has the "gettable" flag and it's notably hard to pick up a botanical garden. Likewise, it's hard to dig in a bottle and it makes no sense to walk to the garden when you're already standing in it.
As for the parser, try making a sliding window of 3 or 4 words to extract small noun clauses. Of course, I assume you're already using articles as a signal for nouns, and prepositions as a signal for noun or pronoun clauses. Words in between a preposition and a noun are likely adjectives too.
@gentoobro@apropos@sun you probably could try to put some per-verb coefficient on objects but afaik nobody has. (ex. a 50% weight on 'drink' verbs for bleach)
lambda was originally meant to be a social metaverse so they prioritized untrusted user scripting and adding verbs to stuff. shoving intelligence in to the parser makes the game less flexible so they didn't do it there.