Anyone still making new codebases?

im just curious if development of this old style game is still happening or if people just updating old codebases?

Sure there are new code bases being created. A few recent ones come to mind:

There are a lot of new code bases being worked on all the time over at the MUD Coders Guild. I am personally working on ExVenture.

https://exventure.org

I’m also building a MUD engine from scratch in C++11, much inspired by ROM. Can’t tell much about it though as it is proprietary work. And I am absolutely enjoying this task because I spent 5 years developing a ROM based MUD and I know all the things that I wasn’t happy about in that engine. Perhaps most importantly, it is a full blown graphical RPG that is completely backwards compatible with telnet.

oh good this makes me happy.

i am glad there is still such active development. we been writing our codebase from ground up.
started with simplemud written in python and now its mostly our own code

CoffeeMud has been in continuous development for 18 years now, and boy are my fingers tired!

3 Likes

I see people all over the place working on brand new codebases.

99% of them never go anywhere or ever see release, but people are making them :stuck_out_tongue:

Guilty as charged, here. It’s more of a hobby for me, so the dedication and time commitment is low.

It’s kind of like people who write books but never finish them. Well intended, sometimes not enough talent, not enough time, or not enough desire to finish it.

To anyone starting a new engine these days and writing it in C++: you are going to love constexpr that comes with the C++11 standard. Stuff you’d see in tables.c in that good old ROM codebase can all be specified as constexpr. I’m doing it and I’m loving it. :heart:

I’m writing a MUD codebase in Python, designed for a lightweight, cross platform engine.

About 4-5 years back, I built a fairly complete codebase in node.js. It’s no longer in active development, but people can always fork it on github if they want to take it places: https://github.com/plamzi/Havoc

Given the forever waning level of interest, there’s probably too many new codebases, not too few.

1 Like

Can you post an example?

Here’s a part from the tables.h file of my project:

enum class POSITION {
    NONE = 0, // Must always be zero
    STUNNED,
    SLEEPING,
    RESTING,
    FIGHTING,
    STANDING
};

constexpr const POSITION POS_NONE     = POSITION::NONE;
constexpr const POSITION POS_STUNNED  = POSITION::STUNNED;
constexpr const POSITION POS_SLEEPING = POSITION::SLEEPING;
constexpr const POSITION POS_RESTING  = POSITION::RESTING;
constexpr const POSITION POS_FIGHTING = POSITION::FIGHTING;
constexpr const POSITION POS_STANDING = POSITION::STANDING;

struct position_type {
    POSITION     index;
    const char   *code;
    WORD           adj;
};

constexpr const struct position_type position_table[] = {
    { POS_STUNNED,  "STUNNED",  WORD::STUNNED  },
    { POS_SLEEPING, "SLEEPING", WORD::SLEEPING },
    { POS_RESTING,  "RESTING",  WORD::RESTING  },
    { POS_FIGHTING, "FIGHTING", WORD::FIGHTING },
    { POS_STANDING, "STANDING", WORD::STANDING },
    // Always end with the array terminator:
    { POS_NONE,     "NONE",     WORD::NONE     }
};

constexpr const struct position_type &POSITION_LOOKUP(POSITION index, const struct position_type *table_row =position_table) {
    return table_row->index == index ? *table_row : (table_row->index == POS_NONE ? position_lookup(POS_NONE) : POSITION_LOOKUP(index, ++table_row));
}

constexpr const char *CODE_LOOKUP(POSITION index) {return POSITION_LOOKUP(index).code;}

Anyone who has worked with a ROM codebase before might remember this design :wink: except that with constexpr and enum class it boosts the development process. The constant expression functions you can see in the end allow compile-time evaluation, meaning that the lookup function can be optimized to a compile-time constant. In fact, in C++14 you can easily fill a whole constexpr array programmatically at compile time to generate lookup tables. As a result, the code becomes more robust because if you accidentally delete the POS_NONE array terminator from the position table the code will no longer even compile due to the constexpr function’s failure to evaluate. This design protects you from your own mistakes and helps to enforce a particular design pattern.

1 Like