mchpr / mchprs

A multithreaded Minecraft server built for redstone.

Minecraft High-Performance Redstone Server

A Minecraft 1.18.2 creative server built for redstone. Each 256x256 plot runs on a separate thread, allowing for less lag, more concurrency, and many awesome extra features!

MCHPRS is very different from traditional servers. Because this server is tailored to the use of computation redstone, many things that are a part of Vanilla Minecraft servers don't exist here. That being said, MCHPRS comes with many of its own unique features.

MCHPRS has made it possible to run programs such as Graph Rendering, Conway's Game of Life, and Mandelbrot Rendering on CPUs in Minecraft. To accomplish these speeds, we created Redpiler, the "Redstone Compiler".

Table of Contents

• Table of Contents
• Building
• Configuration
  • LuckPerms
• Usage
  • General Commands
  • Plot Ownership
  • Worldedit
• Acknowledgments
• Contributing
• License

Building

If the Rust compiler is not already installed, you can find out how on their official website.

git clone https://github.com/MCHPR/MCHPRS.git
cd MCHPRS
cargo build --release

Once complete, the optimized executable will be located at ./target/release/mchprs or ./target/release/mchprs.exe depending on your operating system.

Configuration

MCHPRS will generate a Config.toml file in the current working directory when starting the server if it does not exist.

The folowing options are available at the toplevel (under no header):

Field	Description	Default
bind_address	Bind address and port	0.0.0.0:25565
motd	Message of the day	"Minecraft High Performance Redstone Server"
chat_format	How to format chat message interpolating username and message with curly braces	<{username}> {message}
max_players	Maximum number of simultaneous players	99999
view_distance	Maximal distance (in chunks) between players and loaded chunks	8
bungeecord	Enable compatibility with BungeeCord	false
whitelist	Whether or not the whitelist (in whitelist.json) shoud be enabled	false
schemati	Mimic the verification and directory layout used by the Open Redstone Engineers Schemati plugin	false
block_in_hitbox	Allow placing blocks inside of players (hitbox logic is simplified)	true
auto_redpiler	Use redpiler automatically	true

To change the plot size edit the constants defined in plot/mod.rs.

LuckPerms

MCHPRS has basic support for LuckPerms with MySQL or MariaDB remote database storage. This implementation has no commands or interface and would have to be manged through LuckPerms running on a proxy (/lpb) or other server (/lp)

To use LuckPerms, append this to your Config.toml:

[luckperms]
# Define the address for the database.
host = "localhost"
# The name of the database the LuckPerms data is in.
db_name = "minecraft"
# Credentials for the database.
username = "minecraft"
password = "minecraft"
# The name of the server, used for server specific permissions.
# See: https://luckperms.net/wiki/Context
server_context = "global"

Usage

General Commands

Command	Alias	Description
/rtps [rtps|unlimited]	None	Set the redstone ticks per second in the plot to [rtps]. (There are two game ticks in a redstone tick)
/radvance [ticks]	/radv	Advances the plot by [ticks] redstone ticks.
/teleport [player]	/tp	Teleports you to [player].
/teleport [x] [y] [z]	/tp	Teleports you to [x] [y] [z]. Supports relative coordinates. Floats can be expressed as described here.
/speed [speed]	None	Sets your flyspeed.
/gamemode [mode]	/gmc, /gmsp	Sets your gamemode.
/container [type] [power]	None	Gives you a container (e.g. barrel) which outputs a specified amount of power when used with a comparator.
/redpiler compile	/rp c	Manually starts redpiler compilation. Available flags: --io-only --optimize --export --update (or in short: -ioeu)
/redpiler reset	/rp r	Stops redpiler.
/toggleautorp	None	Toggles automatic redpiler compilation.
/stop	None	Stops the server.

Plot Ownership

The plot ownership system in MCHPRS is very incomplete. These are the commands that are currently implemented:

Command	Alias	Description
/plot info	/p i	Gets the owner of the plot you are in.
/plot claim	/p c	Claims the plot you are in if it is not already claimed.
/plot auto	/p a	Automatically finds an unclaimed plot and claims.
/plot middle	None	Teleports you to the center of the plot you are in.
/plot visit [player]	/p v	Teleports you to a player's plot.
/plot tp [x] [z]	None	Teleports you to the plot at [x] [y]. Supports relative coordinates.
/plot lock	None	Locks the player into the plot so moving outside of the plot bounds does not transfer you to other plots.
/plot unlock	None	Reverses the locking done by /plot lock.

Worldedit

MCHPRS provides its own implementation of WorldEdit. Visit their documentation for more information. These are the commands that are currently implemented:

Command	Alias	Description
/up	/u	Go upwards some distance
/ascend	/asc	Go up a floor
/descend	/desc	Go down a floor
//pos1	//1	Set position 1
//pos2	//2	Set position 2
//hpos1	//h1	Set position 1 to targeted block
//hpos2	//h2	Set position 2 to targeted block
//sel	None	Clears your worldedit first and second positions.
//set	None	Sets all the blocks in the region
//replace	None	Replace all blocks in a selection with another
//copy	//c	Copy the selection to the clipboard
//cut	//x	Cut the selection to the clipboard
//paste	//v	Paste the clipboard's contents (-a to ignore air, -u to also update)
//undo	None	Undoes the last action (from history)
//redo	None	Redoes the last action (from history)
//rstack	//rs	Stack with more options, Refer to RedstoneTools
//stack	//s	Repeat the contents of the selection
//move	None	Move the contents of the selection
//count	None	Counts the number of blocks matching a mask
//load	None	Loads a schematic from the ./schems/ folder. Make sure the schematic in the Sponge format if there are any issues.
//save	None	Save a schematic to the ./schems/ folder.
//expand	//e	Expand the selection area
//contract	None	Contract the selection area
//shift	None	Shift the selection area
//flip	//f	Flip the contents of the clipboard across the origin
//rotate	//r	Rotate the contents of the clipboard
//update	None	Updates all blocks in the selection (-p to update the entire plot)
//help	None	Displays help for WorldEdit commands

Acknowledgments

• @AL1L for his contributions to worldedit and other various features.
• @DavidGarland for a faster and overall better implementation of get_entry in the in-memory storage. This simple function runs 30% of the runtime for redstone.

Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

License

MIT

mchprs's Issues

Add ability to synchronizing MCHPRS simulation with a real-time clock

Currently, it's difficult to synchronize a program running on a CPU with real-time. For example, running a game at 30fps or applying physics forces at certain intervals. Current solutions involve counting CPU cycles and setting the TPS accordingly, but different code paths or cache misses can make this difficult if not impossible.

As the interest in running more sophisticated programs on MCHPRS grows, I think it would be worthwhile to brainstorm potential solutions.

I propose introducing a clock generator block that pulses at 60hz. This signal could be divided into 30hz and 15hz with clock dividers (i.e. T-flip-flops). This circuit could be connected to a rising-edge monostable. When a CPU wants to synchronize itself, it could stall until it receives a pulse from this circuit.

I'm curious to hear people's thoughts and attempting an implementation if the community is interested.

- Embi

Do MCHPRS and Valence have a future together?

Hello. I'm the author of Valence, a framework for building Minecraft servers in Rust. You can think of Valence as a minimal, unopinionated layer on top of the Minecraft protocol. While I was designing Valence, I had specialized servers such as MCHPRS in mind.

My idea is that MCHPRS could use Valence as a backend for its server implementation. This would be beneficial because the work of supporting the protocol's numerous features and staying up to date with the latest version of the game would be taken care of. You can focus on redplier and redstone without also having to maintain an entire server reimplementation to support this goal.

The project was publicly released only 10 days ago and features are still missing. However, things are moving quickly and the project is gaining traction.

Of course, It is perfectly reasonable to decide not to throw away many lines of working code to depend on an unproven project. If there's something about the design of Valence that makes it unsuitable for your situation, I'd love to see if we can make Valence work for you.

Thanks for reading.

"/p i" shows UUID

"/p i" shouldn't show UUID but should show the plot owner's username

Error messages can be made better.

Here is an example of a panic message:

[2020-06-14 19:37:33][mchprs::server][ERROR] panicked at 'Test panic', src/plot/mod.rs:563:9
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(mchprs::server::MinecraftServer::run::{{closure}}::hcb74677416ce720c), addr: Some(0xfe30f), filename: Some("/home/stack/ledump/MCHPRS/src/server.rs"), lineno: Some(111) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::panicking::rust_panic_with_hook::hb976084785e50594), addr: Some(0x510df4), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panicking.rs"), lineno: Some(474) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::panicking::begin_panic::h2a075d36d1c04664), addr: Some(0x445860), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panicking.rs"), lineno: Some(397) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(mchprs::plot::Plot::run::h84f52a182616e1f4), addr: Some(0x1a7786), filename: Some("/home/stack/ledump/MCHPRS/src/plot/mod.rs"), lineno: Some(563) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(mchprs::plot::Plot::load_and_run::{{closure}}::hca8499e1005a1bee), addr: Some(0xe1570), filename: Some("/home/stack/ledump/MCHPRS/src/plot/mod.rs"), lineno: Some(583) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::sys_common::backtrace::__rust_begin_short_backtrace::h79c420a402059d64), addr: Some(0x169702), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/sys_common/backtrace.rs"), lineno: Some(130) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::thread::Builder::spawn_unchecked::{{closure}}::{{closure}}::he440fcefaf33c335), addr: Some(0xe8692), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/thread/mod.rs"), lineno: Some(475) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(<std::panic::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once::h2e475cb8cb030471), addr: Some(0x10e5b4), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panic.rs"), lineno: Some(318) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::panicking::try::do_call::h7dbae4275ce3398a), addr: Some(0x16aaa4), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panicking.rs"), lineno: Some(303) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some("__rust_maybe_catch_panic"), addr: Some(0x514c76), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libpanic_unwind/lib.rs"), lineno: Some(86) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::panicking::try::h8f2311de3266e101), addr: Some(0x16a7ad), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panicking.rs"), lineno: Some(281) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::panic::catch_unwind::h7ddda0753c0a6cf2), addr: Some(0x10e6d4), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/panic.rs"), lineno: Some(394) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::thread::Builder::spawn_unchecked::{{closure}}::hcbce2b291c203789), addr: Some(0xe810e), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/thread/mod.rs"), lineno: Some(474) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(core::ops::function::FnOnce::call_once{{vtable.shim}}::ha64750213b559526), addr: Some(0x64dcd), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libcore/ops/function.rs"), lineno: Some(232) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(<alloc::boxed::Box<F> as core::ops::function::FnOnce<A>>::call_once::h553ef812d1929d1b), addr: Some(0x50295e), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/liballoc/boxed.rs"), lineno: Some(1017) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(<alloc::boxed::Box<F> as core::ops::function::FnOnce<A>>::call_once::h51b51bce029ae491), addr: Some(0x51419c), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/liballoc/boxed.rs"), lineno: Some(1017) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::sys_common::thread::start_thread::hca943f45f04c8e46), addr: Some(0x51419c), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/sys_common/thread.rs"), lineno: Some(13) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some(std::sys::unix::thread::Thread::new::thread_start::h352e8a5875b189ee), addr: Some(0x51419c), filename: Some("/rustc/4fb7144ed159f94491249e86d5bbd033b5d60550/src/libstd/sys/unix/thread.rs"), lineno: Some(80) }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some("start_thread"), addr: None, filename: None, lineno: None }
[2020-06-14 19:37:33][mchprs::server][ERROR] BacktraceSymbol { name: Some("__clone"), addr: None, filename: None, lineno: None }

While reading this isn't impossible, it can sometimes get hard.

Schematic loading issues.

Occasionally when loader large schematic files, a few blocks seemingly randomly get turned into noteblocks. Usually only redstone dust is affected but it has been observed to affect other blocks too.
Example:

Velocity `modern` player information forwarding (currently only legacy BungeeCord forwarding scheme is supported)

Docker volumes causes server to not respond properly

Hey! I got a small problem with running MCHPRS using docker.
When I run the dockerfile that is in the repo using docker-compose everything is fine, but I woud love to have the /data directory to be a volume that is linked to my local machine so I can more easily add and remove schems and configuration.

When I start the container with docker-compose everything seems to work just fine. Everything builds the way it should and everything runs with no problem. But my issue arrives when I try to log into the server. I get a message that I joined the server but the world won’t load and everything seems to be frozen. After a few seconds I get timed out, but the server stays up like nothing happened. It’ll just show a message that I left the server.

Is this a bug or am I doing something wrong (probably the most likely)?

version: "3.9"

services:
    mchprs:
        container_name: mchprs_server
        restart: unless-stopped
        build:
            context: .
            dockerfile: dockerfile
        ports:
            - "25565:25565"
        volumes:
            - ./server:/data

FROM rustlang/rust:nightly-slim

RUN apt-get update \
    && apt-get install -y \
    git pkg-config libssl-dev

RUN git clone https://github.com/MCHPR/MCHPRS.git
WORKDIR /MCHPRS
RUN cargo install --path . \
    && cargo clean


VOLUME [ "/data" ]
WORKDIR /data

CMD ["mchprs"]

plot crashes when compiling redpiler.

whenever redpiler runs the plot crashes and sends this error in console:
[ERROR] plot panicked at 'divide by zero error when dividing duration by scalar', library\core\src\time.rs:979:9 please fix this as its ruening everything

/container barrel <value> does not work.

Hello! When I write /container barrel 14, the server kicks me out. It says "Packet 0/22 (qk) was larger than I expected, found 1217 bytes extra whilst reading packet 22." When I rejoin, the barrel is there, filled with just redstone dust, and it's one signal strength longer than it should be. The server doesn't crash at all, it just appears to be a java error.

Thanks!

/tp is case sensitive

make it so that /tp isn't case sensitive

Players cannot join when RTPS really high

Didn't do much testing on this issue but i found I couldn't login when someone set the RTPS to 35000. Got 'Connection timed out'

Incorrect redstone connection

Config option documentation

Documentation for config options so that people know what they do and such. I could write this later or someone else could do it.

You can only flick a lever when you are holding an item in your hand.

This is an odd one.

Support for more types of containers.

Currently only furnaces and barrels are supported by loading them from a schematic. In the future, more types of containers should be supported and players should be able to place them in the world.

Plot crashes when doing `//count air`

MCHPRS Version: 0.4.1

2023-07-02T06:59:08.131137Z ERROR mchprs_core::server: plot panicked at 'Argument was not a Pattern', crates/core/src/plot/worldedit/mod.rs:228:18
   0: mchprs_core::server::MinecraftServer::run::{{closure}}
   1: <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/alloc/src/boxed.rs:1987:9
      std::panicking::rust_panic_with_hook
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/panicking.rs:695:13
   2: std::panicking::begin_panic_handler::{{closure}}
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/panicking.rs:580:13
   3: std::sys_common::backtrace::__rust_end_short_backtrace
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/sys_common/backtrace.rs:150:18
   4: rust_begin_unwind
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/panicking.rs:578:5
   5: core::panicking::panic_fmt
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/core/src/panicking.rs:67:14
   6: mchprs_core::plot::worldedit::execute::execute_count
   7: mchprs_core::plot::worldedit::execute_command
   8: mchprs_core::plot::Plot::handle_commands
   9: mchprs_core::plot::Plot::update
  10: std::sys_common::backtrace::__rust_begin_short_backtrace
  11: core::ops::function::FnOnce::call_once{{vtable.shim}}
  12: <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/alloc/src/boxed.rs:1973:9
      <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/alloc/src/boxed.rs:1973:9
      std::sys::unix::thread::Thread::new::thread_start
             at /rustc/90c541806f23a127002de5b4038be731ba1458ca/library/std/src/sys/unix/thread.rs:108:17
  13: <unknown>
  14: <unknown>

Auto-generate Config.toml from binary

When downloading the server binary and running it, it requires the Config file yet the only way to get the default one is from the repo. More of an ease of use type of thing

Not existing whitelist.json crashes server on startup

When starting the server with the whitelist activated, the server crashes with the error:
ERROR mchprs_core::server: plot panicked at 'called 'Result::unwrap()' on an 'Err' value: Os { code: 2, kind: NotFound, message: "No such file or directory" }', crates/core/src/server.rs:160:63

Allow higher than 100000 maximum rtps

Probably should increase the redstone speed even more, useful for the latest high performance CPU owners

Config.toml does not generate

I am running my server on an aarch64 raspberry pi. When I tried starting the server it gave a similar error as I have gotten previously so I checked if the Config file had generated. I have worked around this issue by copying the Config.toml file from an older version of MCHPRS.

Illegal block placement

The server allows a player to place a block so that it intersects with the player, which causes the player to be moved up or along to clear the block, or, if the block is placed at head height, causes them to crawl.

The notchian server will not allow blocks to be placed in these circumstances.

Tripwire Hooks can be loaded from schematics, but are not placeable.

A new placeable TripwireHook item should be created. You can find the appropriate item id here.

//set and //replace kills the plot thread

it leaves this error message: " panicked at 'index out of bounds: the len is 0 but the index is 0', /usr/src/rustc-1.41.0/src/libcore/slice/mod.rs:2806:10"

piston implementation

Teleport to infinity and NaN!

Coordinates are parsed to IEEE754 floats with Rust's parse method, which allows for infinity, -infinity, inf, -inf, nan and -nan (and is not case-sensitive).

This causes some weird behavior such as:

• //tp inf 10 inf teleports the player a bit outside the world barrier
• //tp NaN 10 10 hangs my client (I had to kill my client and delete the player's file to fix it)
• //tp 0 inf 0 hangs my client (I had to kill my client and delete the player's file to fix it)

[Suggestion] Add a tool to monitor redstone wire signal strength over time

The idea is to make a command that when assigned to a redstone wire, it will log its signal strength over time, and will output it in real time, or as a .csv or something similar. This may help in debugging redstone circuits, as you can analyze the data much easier.

Observer implementation

It seemed like a relatively simple redstone component and I wanted to implement one :D.

Observers are however a bit different to other redstone components as they react to any state change of the block behind them instead of responding to absolute redstone signals.
The observer should also only respond to the block it is looking at for this a few changes need to be made that allows the block to see where the updates come from.

A few notable things that update observers are:

• all sides of redstone including the top
• all sides of repeaters, comparators and other observers
• locking repeaters
• torches
• redstone lamps, trapdoors
• buttons, levers and pressure plates

Cant place basic Redstone components (Observer, pistons, slime etc.)

I started MCHPRS through ubuntu server and i cant place observers pistons and other components. Is there any way to modify it ?

opening containers with power level 16 crashes the plot

Compile error `regex` in Ubuntu Linux

After I cloned the project On my Linux machine and tried to compile it I get this error:

error[E0554]: `#![feature]` may not be used on the stable release channel
   --> /home/bgopc/.cargo/registry/src/github.com-1ecc6299db9ec823/regex-1.8.1/src/lib.rs:644:42
    |
644 | #![cfg_attr(feature = "pattern", feature(pattern))]
    |                                          ^^^^^^^

For more information about this error, try `rustc --explain E0554`.
error: could not compile `regex` due to previous error

I reCloned the project a few times but nothing seemed to fix it, I have rust programming experience and I'm on my main linux Machine
rustc version: 1.65.0
cargo version: 1.65.0

Plot crashing command

I discovered that /p v [anything here] 0 command can crash plot due to subtraction overflow. Its very easy to fix by e.g. making plot id start with 0 or by adding a simple check.

Door blocks are not removed correctly

When a door is placed, the lower half is removed but not the upper half.
Beds do not exhibit the same bug.

A player tried to connect using the wrong version

client version is 1.18.2
When I log in I am prompted that the version is 1.15.2

Create new release

Could you please create a new release?

The latest release contains security concerns (eg. #65) and doesn't support 1.18.2.
I'm packaging MCHPRS in nixpkgs, which would enable easy deployment for Nix users. Creating a new release would help to get this packaging effort accepted upstream.

Error when building

'git' is not recognized as an internal or external command,
operable program or batch file.

Worldedit //rotate and //flip commands

Crash on debian

Don't have a lot of time, will update this later. It does this in release mode also.

Backtrace:

   Compiling mchprs v0.3.0 (/home/oliver/mchprs)
    Finished dev [unoptimized + debuginfo] target(s) in 2.91s
     Running `target/debug/mchprs`
[2020-12-21 02:29:54][mchprs::server][INFO] Starting server...
[2020-12-21 02:29:54][mchprs::server][ERROR] panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 98, kind: AddrInUse, message: "Address already in use" }', src/network/mod.rs:97:56
[2020-12-21 02:29:55][mchprs::server][INFO] Done! Start took 796.341627ms
[2020-12-21 02:29:55][mchprs::server][ERROR] panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 98, kind: AddrInUse, message: "Address already in use" }', src/network/mod.rs:97:56
   0: mchprs::server::MinecraftServer::run::{{closure}}
             at src/server.rs:144
   1: std::panicking::rust_panic_with_hook
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:595
   2: std::panicking::begin_panic_handler::{{closure}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:497
   3: std::sys_common::backtrace::__rust_end_short_backtrace
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/sys_common/backtrace.rs:141
   4: rust_begin_unwind
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:493
   5: core::panicking::panic_fmt
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/panicking.rs:92
   6: core::option::expect_none_failed
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/option.rs:1268
   7: core::result::Result<T,E>::unwrap
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/result.rs:973
   8: mchprs::network::NetworkServer::listen
             at src/network/mod.rs:97
   9: mchprs::network::NetworkServer::new::{{closure}}
             at src/network/mod.rs:127
  10: std::sys_common::backtrace::__rust_begin_short_backtrace
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/sys_common/backtrace.rs:125
  11: std::thread::Builder::spawn_unchecked::{{closure}}::{{closure}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/thread/mod.rs:474
  12: <std::panic::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panic.rs:322
  13: std::panicking::try::do_call
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:379
  14: __rust_try
  15: std::panicking::try
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:343
  16: std::panic::catch_unwind
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panic.rs:396
  17: std::thread::Builder::spawn_unchecked::{{closure}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/thread/mod.rs:473
  18: core::ops::function::FnOnce::call_once{{vtable.shim}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/ops/function.rs:227
  19: <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/alloc/src/boxed.rs:1328
      <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/alloc/src/boxed.rs:1328
      std::sys::unix::thread::Thread::new::thread_start
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/sys/unix/thread.rs:71
  20: start_thread
  21: clone

[2020-12-21 02:29:55][mchprs::server][ERROR] panicked at 'Client receiver channel disconnected!', src/network/mod.rs:140:21
[2020-12-21 02:29:55][mchprs::server][ERROR] panicked at 'Client receiver channel disconnected!', src/network/mod.rs:140:21
   0: mchprs::server::MinecraftServer::run::{{closure}}
             at src/server.rs:144
   1: std::panicking::rust_panic_with_hook
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:595
   2: std::panicking::begin_panic::{{closure}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:520
   3: std::sys_common::backtrace::__rust_end_short_backtrace
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/sys_common/backtrace.rs:141
   4: std::panicking::begin_panic
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:519
   5: mchprs::network::NetworkServer::update
             at src/network/mod.rs:140
   6: mchprs::server::MinecraftServer::update
             at src/server.rs:596
   7: mchprs::server::MinecraftServer::run
             at src/server.rs:200
   8: mchprs::main
             at src/main.rs:4
   9: core::ops::function::FnOnce::call_once
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/ops/function.rs:227
  10: std::sys_common::backtrace::__rust_begin_short_backtrace
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/sys_common/backtrace.rs:125
  11: std::rt::lang_start::{{closure}}
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/rt.rs:66
  12: core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/core/src/ops/function.rs:259
      std::panicking::try::do_call
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:379
      std::panicking::try
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panicking.rs:343
      std::panic::catch_unwind
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/panic.rs:396
      std::rt::lang_start_internal
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/rt.rs:51
  13: std::rt::lang_start
             at /rustc/1f5bc176b0e54a8e464704adcd7e571700207fe9/library/std/src/rt.rs:65
  14: main
  15: __libc_start_main
  16: _start

Dropping items doesn't actually remove them from the inventory.

Dropping an item may look fine on the client side, but the server still thinks the item is still there.

Undo/Redo support.

Making a mistake can be very costly without the //undo command.

An idea would be to create a WorldEditClipboard of the region before starting the operation, and then paste it there when the player runs //undo.

Running current commit failed when having 2 players in a world

022-01-18 23:43:23][mchprs::server][ERROR] plot panicked at 'index out of bounds: the len is 1 but the index is 1', src/plot/mod.rs:999:28

Keep getting error "plot panicked"

Hey! I've been getting this error a lot lately and don't know how to fix it. Because of this error i can't get onto my server anymore. Any idea how to fix this?

[2022-12-07 18:40:35][mchprs_core::server][ERROR] plot panicked at 'called `Result::unwrap()` on an `Err` value: error loading plot 0,0

Caused by:
    0: error loading plot save file at ./world/plots/p0,0
    1: plot data deserialization error
    2: tag for enum is not valid, found 101', crates/core/src/plot/mod.rs:995:18
   0: backtrace::capture::Backtrace::new
   1: mchprs_core::server::MinecraftServer::run::{{closure}}
   2: <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/alloc/src/boxed.rs:2032:9
      std::panicking::rust_panic_with_hook
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/std/src/panicking.rs:692:13
   3: std::panicking::begin_panic_handler::{{closure}}
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/std/src/panicking.rs:579:13
   4: std::sys_common::backtrace::__rust_end_short_backtrace
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/std/src/sys_common/backtrace.rs:137:18
   5: rust_begin_unwind
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/std/src/panicking.rs:575:5
   6: core::panicking::panic_fmt
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/core/src/panicking.rs:65:14
   7: core::result::unwrap_failed
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/core/src/result.rs:1791:5
   8: mchprs_core::plot::Plot::load
   9: std::sys_common::backtrace::__rust_begin_short_backtrace
  10: core::ops::function::FnOnce::call_once{{vtable.shim}}
  11: <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/alloc/src/boxed.rs:2000:9
      <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/alloc/src/boxed.rs:2000:9
      std::sys::unix::thread::Thread::new::thread_start
             at /rustc/b7bc90fea3b441234a84b49fdafeb75815eebbab/library/std/src/sys/unix/thread.rs:108:17
  12: _pthread_from_mach_thread_np

Commands through the server terminal

A way to interact with the server from the host device. Like a 'normal' Minecraft server.

It would be really nice to restart the server periodically for instance.

Add a command to save the whole plot to a schematic

Useful when you want to quickly save the whole plot. Maybe /plot save name.schematic?

Pterodactyl egg

I'd love to deploy MCHPRS with Pterodactyl. Sadly there are no eggs available and using the Linux executable like a normal jar doest work properly (Ram doest get detected properly, because it's using docker containers)

Could you please create an egg (egg = deployment script) for it?

https://pterodactyl.io/

OOB read

There is a Out Of Bounds read when doing the commands

//set <- the len is 0 but the index is 0
//replace <- the len is 0 but the index is 0
//replace [id] <- the len is 1 but the index is 1

causing a panic and disconnecting the user from the plot.

Signs not working

Signs appear not to be working. When I try to place them they just act like all of the other blocks that have no been added yet. I believe that they are supposed to work as they appear to be implemented in https://github.com/MCHPR/MCHPRS/blob/master/src/blocks/mod.rs#L481-L490 and a couple other lines.

Comments in the config file get removed if a config option is missing

This is because of the way that the config file is overwritten when it it detected that an option is missing.

Wrong version in `Cargo.toml`

v0.4 is tagged but Cargo.toml still indicates 0.3:
https://github.com/MCHPR/MCHPRS/blob/fec9b7098595fcec172c533cad1e4ad557b75568/Cargo.toml#L6C12-L6C17

Entities use 350 degree circles instead of 360?

While writing my pull request I noticed that all the clientbound packets use 350 degrees, shouldn't this be 359 or 360?

For example:

buf.write_byte((self.yaw % 350f32 / 350f32 * 256f32) as i8);

Shouldn't 350f32 be 360f32? Since this happens for every packet and not just a single one I thought I'd open an issue first in case I am overlooking something. 😅

[Question] Redpiler on a GPU?

Is it possible to make Redpiler utilize the GPU for even higher performance with something like Vulkano?