Guides

LP MUD with open-source tools

This guide outlines the technical process for deploying a modern LP MUD environment using the FluffOS driver and a standard mudlib architecture. It focuses on the critical intersection of driver configuration and the LPC master object initialization sequence.

2-4 hours6 steps
LP MUD with open-source tools hero illustration
1

Compile the FluffOS Driver

Clone the FluffOS repository and use CMake to generate the build files. Ensure you enable WebSocket support if you plan to use modern web-based clients.

build_driver.sh
git clone https://github.com/fluffos/fluffos.git
cd fluffos
mkdir build
cd build
cmake .. -DPACKAGE_CRYPTO=ON -DPACKAGE_COMPRESS=ON
make -j$(nproc)
sudo make install

⚠ Common Pitfalls

  • •Missing PCRE or OpenSSL headers will cause CMake to fail silently on specific packages.
  • •Using an outdated GCC version (less than 9) will result in compilation errors due to C++17 requirements.
2

Configure the Mudlib Directory and Config File

Create your mudlib root and define the driver configuration file. This file tells the driver where the mudlib resides, which port to listen on, and the location of the master object.

config.cfg
name : MyLPMUD
address server ip : 0.0.0.0
mud port : 4000
websocket port : 4001
mudlib directory : /home/mud/lib
binary directory : /home/mud/bin
master file : /secure/master
simulated efun file : /secure/simul_efun
debug log file : /log/debug.log

⚠ Common Pitfalls

  • •Incorrect absolute paths in the config file will prevent the driver from booting.
  • •Ensure the 'binary directory' is writable by the user running the driver for LPC-to-C caching.
3

Initialize the Master Object

The master object (/secure/master.c) is the first object loaded. It handles security, defines access permissions, and determines where the driver looks for include files.

/secure/master.c
object connect() {
    return clone_object("/secure/login");
}

mixed privs_file(string file) {
    return explode(file, "/")[1];
}

string *define_include_dirs() {
    return ({ "/include" });
}

⚠ Common Pitfalls

  • •If the master object contains a syntax error, the driver will crash immediately upon startup.
  • •Failing to implement 'connect()' will result in players being disconnected immediately upon entry.
4

Set Up Simulated Efuns (simul_efun)

Simul_efuns allow you to define globally accessible functions that behave like built-in driver functions. This is essential for mudlib-wide logic like path normalization or custom logging.

/secure/simul_efun.c
string format_name(string name) {
    return capitalize(lower_case(name));
}

int user_exists(string name) {
    return file_size("/data/users/" + name + ".o") > 0;
}

⚠ Common Pitfalls

  • •Avoid circular dependencies where the simul_efun object requires an object that hasn't been loaded yet.
  • •Overloading built-in efuns can lead to confusing bugs if not documented for other developers.
5

Establish the Inheritance Tree for Rooms

LP MUDs rely heavily on inheritance. Create a base room object that all world rooms will inherit. This ensures consistent behavior for movement and descriptions.

/std/room.c
inherit "/std/container";

private string short_desc;
private string long_desc;

void set_short(string str) { short_desc = str; }
void set_long(string str) { long_desc = str; }

string query_short() { return short_desc; }
string query_long() { return long_desc; }

⚠ Common Pitfalls

  • •Deep inheritance trees (more than 5-6 levels) can significantly impact memory usage and load times.
  • •Forgetting to call ::create() in child objects will prevent base room variables from initializing.
6

Implement Live Coding Workflows

Utilize the 'update' command logic to reload objects in memory without restarting the driver. This is the core advantage of LPC development.

/cmds/wiz/update.c
int do_update(string filename) {
    object obj = find_object(filename);
    if (obj) destruct(obj);
    load_object(filename);
    write("Object " + filename + " reloaded successfully.\n");
    return 1;
}

⚠ Common Pitfalls

  • •Destructing a base class without updating the inheriting children will leave the children running on the old code (stale copies).
  • •Updating the master object or simul_efun object can be dangerous and may require a specific 'reclaim_objects' call.

What you built

With the FluffOS driver compiled and the master object initialized, you have a functional LP MUD core. From here, focus on expanding the mudlib's standard library (/std) and implementing a robust 'init' system for player commands. Regular backups of the /data directory are essential as this is where persistent player and world state is stored.