Guides

Roleplay MUDs with Character sheets

Scene logging in roleplay MUDs requires balancing immersive storytelling documentation against player privacy expectations. This guide provides concrete implementation steps for adding granular consent controls to existing communication systems, ensuring players retain agency over their character interactions while enabling legitimate moderation and personal scene review capabilities.

4-6 hours10 steps

Audit Communication Channels

Map all in-character communication verbs (say, emote, whisper, pose) and channels that require logging. Distinguish between IC and OOC pathways to ensure logging only captures roleplay content, not private player coordination or system messages.

⚠ Common Pitfalls

•Logging OOC channels violates player trust
•Missing ephemeral channels like psionics or telepathy creates gaps

Design Consent Flag Architecture

Extend the player object schema to store granular consent levels (0=opt-out, 1=party-only, 2=full-log). Store flags persistently in the player save file and load them during login to ensure consent persists across sessions.

player_consent.c

int set_logging_consent(int level) {
    if(level < 0 || level > 2) return 0;
    this_player()->set_property("rp_log_consent", level);
    return 1;
}

int query_logging_consent() {
    return this_player()->query_property("rp_log_consent") || 0;
}

Implement Scene Container Data Structure

Create a scene object or mapping that stores metadata (participants, timestamp, location) and a circular buffer for content. Index scenes by participant IDs to enable efficient retrieval without scanning entire logs.

scene_object.h

class Scene {
    int created_at;
    string location_id;
    string *participants;
    mapping content_buffer;
    int consent_level;
}

Build Opt-In Command Interface

Implement player-facing commands (consent, scene privacy) that validate input and update the player object's consent flags. Provide clear feedback showing current settings and implications.

cmd_consent.c

int cmd_consent(string arg) {
    if(!arg) {
        write("Current setting: "+query_logging_consent()+"\n");
        return 1;
    }
    int level = to_int(arg);
    if(set_logging_consent(level)) {
        write("Consent level updated.\n");
        return 1;
    }
    return notify_fail("Invalid level. Use 0 (off), 1 (party), or 2 (full).\n");
}

Add Logging Hooks to Communication Verbs

Modify the message processing chain in each communication verb to check the speaker's consent flag before appending to scene buffers. If mixed consent exists in a room, create partial logs visible only to consenting participants.

⚠ Common Pitfalls

•Race conditions between consent check and write operations
•Memory leaks from unflushed buffers in long scenes

Create Access Control for Scene Retrieval

Implement a retrieval command that validates the requester against scene participant lists or admin privileges. Return 404-equivalent for unauthorized access attempts to prevent consent enumeration attacks.

scene_security.c

int can_access_scene(object user, class Scene scene) {
    if(adminp(user)) return 1;
    if(member_array(user->query_name(), scene->participants) != -1) return 1;
    return 0;
}

Implement Automatic Expiration

Add a cron job or heartbeat function that purges scene records older than the retention policy (typically 30-90 days). Log deletion events separately for compliance auditing.

scene_maintenance.c

void expire_old_scenes() {
    int cutoff = time() - (86400 * 30); // 30 days
    foreach(string id, class Scene scene in scene_db) {
        if(scene->created_at < cutoff) {
            log_event("EXPIRE", id);
            map_delete(scene_db, id);
        }
    }
}

Build Administrative Audit Trails

When administrators access logs for moderation, write a separate immutable audit entry recording the admin ID, timestamp, and scene accessed. Store these admin logs with longer retention than standard scenes.

admin_audit.c

void log_admin_access(object admin, string scene_id) {
    string entry = sprintf("%s | %s | %s", ctime(time()),
                          admin->query_name(), scene_id);
    write_file("/log/admin_scene_access", entry + "\n");
}

Handle Mixed-Consent Group Scenes

When multiple players with different consent levels occupy the same room, split the scene buffer into consent-tiered views. Players with level 0 consent appear as "[Redacted]" in logs for players with level 2 consent, while level 1 only logs when all participants consent.

⚠ Common Pitfalls

•Inconsistent redaction leaks information through timing
•Edge cases with consent changes mid-scene

Document Privacy Policy Integration

Link the technical consent flags to visible help files explaining retention periods, access rights, and appeal processes. Ensure the +help consent command outputs match the actual database schema behavior.

⚠ Common Pitfalls

•Help text promising features not implemented
•Retention periods in docs not matching code

What you built

This implementation creates a technical foundation for consent-aware roleplay logging that respects player autonomy while providing moderation capabilities. Regular audits of the consent database against active scenes ensure the system remains compliant with your server's stated privacy policies.