bhavanki/grounds

An extensible MUSH / MUD server written in Java.

Grounds

An extensible MUSH/MUD server written in Java.

Features

Grounds is under active development, so features are all new and/or still being worked on to a large extent. There are definitely bugs and missing features.

• Arbitrary attributes. Every thing has an unlimited set of named, typed attributes. Some are special, like "name" and "description". Make up any others you need.
• Role-based permissions. Every thing in a universe has a security policy that permits categories of actions that affect it only by specified roles. For example, a player can't read another thing's attributes unless the player has a role with READ permission. Roles include a few wizardly ones plus ordinary ones.
• SSH and telnet connectivity. The game server accepts connections over SSH, so that all traffic is encrypted, or telnet, or both.
• Command-line editing. Grounds uses JLine to deliver powerful command line editing features.
• Extensibility through plugins. Extensions in a universe can call on external plugins, written in any language, that may be executed as commands.
• Reaction to events. Extensions can also listen for events, such as players arriving or leaving locations, or saying things, and react by running plugins to respond.
• Chat. Players can message each other over OOC, named chat channels. This feature is implemented completely in a plugin!
• Events. Players can maintain a list of upcoming events. This feature is implemented completely in a plugin!
• Mail. Players can communicate over an internal mail system.
• Combat. The Grapple combat system lets players fight for victory against each other or NPCs.

Requirements

• JDK 17 or higher
• Apache Maven 3.6.0 or higher (building only)
• protoc 3.19.3 or higher (building only)

On macOS, Homebrew can install protoc via brew install protobuf.

Running

In normal multi-user mode:

$ java -jar grounds-<version>.jar \
  --properties etc/server.properties --universe mygame.json

In single-user mode:

$ java -jar grounds-<version>.jar \
  --properties etc/server.properties --single-user

Instructions on building a new universe are in the documentation.

Connecting

You can use a normal SSH or telnet client.

$ ssh -p 4768 <username>@<hostname-or-ip-address>
$ telnet -p 4769 <hostname-or-ip-address>

After authenticating with your password, you can pick the player you want to use and go have fun.

Building

$ mvn package

Documentation

https://bhavanki.github.io/grounds

Plans

• Fleshed-out event systems
• More fun stuff

License

MIT License

See the telnet package README for additional license information pertaining to telnet code in Grounds.

Other Credits

Default banner logo from www.patorjk.com, Ivrit / Standard font

grounds's Issues

LOOK command should be able to show the description of Things and Players.

An argument could also be made for Links, but that would probably require a source description AND a destination description.

Sandbox softcode

Protect the game runtime from softcoded command scripts using some sort of sandbox. Ideas:

• https://sourceforge.net/p/dw-sandbox/wiki/Home/ (long abandoned)
• https://tersesystems.com/blog/2015/12/29/sandbox-experiment/

Add mute controls

Let a player mute another player. This may require adding sender information to messages that are passed around.

Build guest flow

Handle guest access. Where do they go? What can they do? How can they communicate with players?

Implement PAGE

Implement a PAGE command for sending a message to another player from afar.

Auto-selection of initial player does not check if player is already occupied

If one actor is already playing as a player, and another actor who may only play as that same player logs in, then the second actor is assigned to the player as well. I'm not actually sure what should happen in this case.

Ignore SHUTDOWN in RunCommand

If RunCommand encounters SHUTDOWN as a command, it will dutifully request server shutdown. That's bad. Make it ignore it instead.

Figure out the bracketed paste issue with SSH

There was a problem with SSH when "bracketed paste" was turned on in the client. Figure out what is going on there.

Add autocompletion for player arguments to commands

Basic command autocompletion was added in 07eedcb. Add completion for command arguments that represent players. This should work by looking through the players visible to the player issuing the command. That list should be generated by running a pseudo-command akin to LOOK, but just for getting that player list. So, this would be a command that is run in order to complete a different command.

Delete API domain socket on Control-C

I like to use Control-C to stop the server, but then the API domain socket isn't deleted. When the server is started again, the API won't work.

Upgrade to JUnit 5

Add more chat commands

There are some chat commands that still need to be implemented. Among them:

• list the available chat channels
• list what channels you are joined to
• list the members of a channel (admin only?)

Implement DESTROY

Implement a command to destroy (delete) things and universes, anything that the BUILD command can build. Think about when destruction should cascade vs. should be blocked; what to do with things that were contents of a destroyed thing; etc.

Handle when players are disconnected

At the moment, players linger where they are after their actor leaves. Should they? Maybe they should go to some designated home instead, or some off-grid holding pen until they are in use.

Join guests to chat

When a new guest logs in, they should be joined to a guest chat channel (or something configurable) so that other players do not need to be located at the guest home in order to interact with them.

Open up some actor commands to wizards

All actor manipulation commands are restricted to GOD at the moment, but it makes sense for thaumaturges to be permitted to use some if them, if not all.

Open up the WHO command to non-wizards

Let ordinary players (not guests) see who is logged in.

Track actor IP addresses

Make the IP address for each connected actor available to wizards. This is the basis for other potential controls, including IP bans.

Implement chat access controls

There are no rules for which channels a player may join or leave, but there should be, for things like wizard-only channels or channels restricted to distinct groups of players on a team or in a faction or what have you.

Allow setting attributes from YAML files

SetAttrCommand can only read JSON files. When setting a script attribute, it's very annoying because JSON doesn't allow multiline strings. Enhance the command so that it can parse YAML, which allows multiline strings.

Figure out listen patterns

PennMUSH objects can listen for ... commands? Utterances? Something, and then do something in response. Figure out how that could work here.

There is some attempt at this in the code, with sending messages to things, and other stuff, but it doesn't seem quite right.

Implement BOOT

Implement a command to kick an actor off the server.

Allow an actor to be logged in multiple times

Let someone login more than once, playing a different player in each session.

Let actor control ANSI usage

Implement an actor preference system, whose first goal is to let an actor decide not to receive ANSI color codes from the server.

Set up autosave

Nothing is automatically saving off the state of the multiverse as the game runs. That's necessary so that GOD doesn't need to keep popping in to do so.

Finish help text

Write help text for the actor and role command sets, and make sure the help command can provide them.

Implement event calendar

Create a way for players to organize play sessions, special events, and other scheduled occurrences.

Implement mail system

Implement a softcode system for mail between players.

Replace security manager with modules

Right now, Grounds uses the Java security manager to try to prevent softcode (scripted commands) from unlimited access to the universe. Unfortunately, there are plans to deprecate and remove the security manager completely from the JDK.

https://openjdk.java.net/jeps/411

The alternative is probably to adopt Java Modules. This means that Grounds will be a module, and only export pieces of itself that softcode, or anything else, may access. That's not too bad.

The harder part is using dependencies in a modular way. Many dependencies have already adopted modules, but notably Apache Mina (SSH) hasn't.