0319635a8b
<!-- Please make sure that your PR is aligned with the guidelines in CONTRIBUTING.md to the best of your ability. --> <!-- Good PRs have tests! Make sure you have sufficient test coverage. --> ## Description <!-- Describe the changes you've made. You may include any justification you want here. --> Dropping items is heavily coupled to inventories. Clients also predict state changes when they try to drop items, so we need to be able to replicate that change in order to stay in sync. This will also remove `DropItem` events in favor of just `DropItemStack` events. Having 2 event streams that basically mean the same thing seems verbose and error prone. As of right now, these changes require the event loop to have a reference to the client's inventory. This seems like something we are going to need to do a lot more of to complete #199. ## Test Plan <!-- Explain how you tested your changes, and include any code that you used to test this. --> <!-- If there is an example that is sufficient to use in place of a playground, replace the playground section with a note that indicates this. --> <details> <summary>Playground</summary> ```rust use tracing::info; use valence::client::despawn_disconnected_clients; use valence::client::event::{default_event_handler, DropItemStack}; use valence::prelude::*; #[allow(unused_imports)] use crate::extras::*; const SPAWN_Y: i32 = 64; pub fn build_app(app: &mut App) { app.add_plugin(ServerPlugin::new(()).with_connection_mode(ConnectionMode::Offline)) .add_system_to_stage(EventLoop, default_event_handler) .add_startup_system(setup) .add_system(init_clients) .add_system(despawn_disconnected_clients) .add_system(toggle_gamemode_on_sneak) .add_system(drop_items); } fn setup(world: &mut World) { let mut instance = world .resource::<Server>() .new_instance(DimensionId::default()); for z in -5..5 { for x in -5..5 { instance.insert_chunk([x, z], Chunk::default()); } } for z in -25..25 { for x in -25..25 { instance.set_block([x, SPAWN_Y, z], BlockState::GRASS_BLOCK); } } world.spawn(instance); } fn init_clients( mut clients: Query<&mut Client, Added<Client>>, instances: Query<Entity, With<Instance>>, ) { let instance = instances.get_single().unwrap(); for mut client in &mut clients { client.set_position([0.5, SPAWN_Y as f64 + 1.0, 0.5]); client.set_instance(instance); client.set_game_mode(GameMode::Creative); } } fn drop_items(clients: Query<&Client>, mut drop_stack_events: EventReader<DropItemStack>) { if drop_stack_events.is_empty() { return; } for event in drop_stack_events.iter() { info!("drop stack: {:?}", event); } } ``` </details> <!-- You need to include steps regardless of whether or not you are using a playground. --> Steps: 1. `cargo test -p valence --tests` 2. Run playground `cargo run -p playground` 3. Open creative menu 4. Pick an item and click to drop it outside of the creative menu 5. Pick an entire stack of an item, place it in your hotbar 6. Hover over the item, press your drop key to drop an item from the stack 7. Press shift to switch to survival 8. Select the item stack in your hotbar, press your drop key to drop an item from the stack 9. Open your inventory, grab the stack, hover outside the window and click to drop the entire stack 10. Grab another stack from creative, place it in your hotbar 11. switch back to survival, select the stack, and press your control + drop key to drop the entire stack 12. For each item you dropped, you should see a log message with the event #### Related <!-- Link to any issues that have context for this or that this PR fixes. --> |
||
|---|---|---|
| .github | ||
| assets | ||
| crates | ||
| extracted | ||
| extractor | ||
| .gitignore | ||
| Cargo.toml | ||
| CODE_OF_CONDUCT.md | ||
| CONTRIBUTING.md | ||
| LICENSE.txt | ||
| README.md | ||
| rustfmt.toml | ||
A Rust framework for building Minecraft: Java Edition servers.
Built on top of Bevy ECS, Valence is an effort to create a Minecraft compatible server completely from scratch in Rust. You can think of Valence as a game engine for Minecraft servers. It doesn't do much by default, but by writing game logic yourself and leveraging Bevy's powerful plugin system, you can make almost anything.
Opinionated features like dynamic scripting, dedicated executables, and vanilla game mechanics are all expected to be built as optional plugins. This level of modularity is desirable for those looking to build highly custom experiences in Minecraft such as minigame servers.
Goals
Valence aims to be the following:
- Complete. Abstractions for the full breadth of the Minecraft protocol.
- Flexible. Valence provides direct access to the lowest levels of Minecraft's protocol when necessary.
- Modular. Pick and choose the features you actually need.
- Intuitive. An API that is easy to use and difficult to misuse. Extensive documentation and examples are important.
- Efficient. Optimal use of system resources with multiple CPU cores in mind. Valence uses very little memory and can support thousands of players at the same time without lag (assuming you have the bandwidth).
- Up to date. Targets the most recent stable version of Minecraft. Support for multiple versions at once is not planned. However, you can use a proxy with ViaBackwards to achieve backwards compatibility with older clients.
Current Status
Valence is still early in development with many features unimplemented or incomplete. Expect to encounter bugs, limitations, and breaking changes. Here are some noteworthy achievements:
valence_nbt: A speedy new library for Minecraft's Named Binary Tag (NBT) format.valence_protocol: A library for working with Minecraft's protocol. Does not depend on Valence and can be used in other projects.- Authentication, encryption, and compression
- Block states
- Chunks
- Entities and metadata
- Bounding volume hierarchy for fast spatial entity queries
- Player list and player skins
- Dimensions, biomes, and worlds
- JSON Text API
- A Fabric mod for extracting data from the game into JSON files. These files are processed by a build script to generate Rust code for the project. The JSON files can be used in other projects as well.
- Inventories
- Items
- Particles
- Anvil file format (read only)
- Proxy support (Velocity, Bungeecord and Waterfall)
Here is a short video (outdated) showing the examples and some of Valence's capabilities.
Getting Started
Running the Examples
After cloning the repository, run
cargo r -r --example
to view the list of examples. I recommend giving parkour, conway, terrain, and cow_sphere a try.
Next, open your Minecraft client and connect to the address localhost.
If all goes well you should be playing on the server.
Adding Valence as a Dependency
Valence is published to crates.io. Run cargo add valence to add it to your
project. Documentation is available here.
However, the crates.io version is likely outdated. To use the most recent development version, add Valence as a git dependency
[dependencies]
valence = { git = "https://github.com/valence-rs/valence" }
View the latest documentation by running cargo d --open in your project.
Contributing
Contributions are welcome! Please see CONTRIBUTING.md. You can also join the Discord to discuss the project and ask questions.
License
Code is licensed under MIT while the Valence logo is under CC BY-NC-ND 4.0
Funding
If you would like to contribute financially, consider sponsoring me (rj00a) on GitHub or Patreon.
I would love to continue working on Valence and your support would help me do that. Thanks!