majjo/Pumpkin
1
0
Fork 0
mirror of https://github.com/Pumpkin-MC/Pumpkin.git synced 2026-08-31 08:22:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

deny more clippy lints

Browse Source
This commit is contained in:
Snowiiii
2024-10-24 19:30:24 +02:00
parent 7de3e0e995
commit 4bb52a7711
10 changed files with 61 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pumpkin-protocol/Cargo.toml
View File

@@ -18,7 +18,7 @@ log.workspace = true
num-traits.workspace = true
num-derive.workspace = true
bytes = "1.7"
bytes = "1.8"
flate2 = "1.0"

2
pumpkin/Cargo.toml
View File

@@ -30,7 +30,7 @@ num-derive.workspace = true
serde.workspace = true
serde_json = "1.0"
bytes = "1.7"
bytes = "1.8"
rand = "0.8.5"

18
pumpkin/src/entity/mod.rs
View File

@@ -90,22 +90,28 @@ impl Entity {
/// Updates the entity's position, block position, and chunk position.
///
/// This function calculates the new position, block position, and chunk position based on the provided coordinates. If any of these values change, the corresponding fields are updated.
#[expect(clippy::float_cmp)]
pub fn set_pos(&self, x: f64, y: f64, z: f64) {
let pos = self.pos.load();
if pos.x != x || pos.y != y || pos.z != z {
self.pos.store(Vector3::new(x, y, z));
let i = x.floor() as i32;
let j = y.floor() as i32;
let k = z.floor() as i32;
let floor_x = x.floor() as i32;
let floor_y = y.floor() as i32;
let floor_z = z.floor() as i32;
let block_pos = self.block_pos.load();
let block_pos_vec = block_pos.0;
if i != block_pos_vec.x || j != block_pos_vec.y || k != block_pos_vec.z {
let new_block_pos = Vector3::new(i, j, k);
if floor_x != block_pos_vec.x
|| floor_y != block_pos_vec.y
|| floor_z != block_pos_vec.z
{
let new_block_pos = Vector3::new(floor_x, floor_y, floor_z);
self.block_pos.store(WorldPosition(new_block_pos));
let chunk_pos = self.chunk_pos.load();
if get_section_cord(i) != chunk_pos.x || get_section_cord(k) != chunk_pos.z {
if get_section_cord(floor_x) != chunk_pos.x
|| get_section_cord(floor_z) != chunk_pos.z
{
self.chunk_pos.store(Vector2::new(
get_section_cord(new_block_pos.x),
get_section_cord(new_block_pos.z),

1
pumpkin/src/entity/player.rs
View File

@@ -368,6 +368,7 @@ impl Player {
}
}
#[expect(clippy::too_many_lines)]
pub async fn handle_play_packet(
self: &Arc<Self>,
server: &Arc<Server>,

71
pumpkin/src/main.rs
View File

@@ -1,25 +1,20 @@
#![deny(clippy::all)]
#![warn(clippy::pedantic)]
#![deny(clippy::pedantic)]
// #![warn(clippy::restriction)]
#![warn(clippy::cargo)]
#![deny(clippy::cargo)]
// REMOVE SOME WHEN RELEASE
#![expect(clippy::cargo_common_metadata)]
#![expect(clippy::multiple_crate_versions)]
#![expect(clippy::while_float)]
#![expect(clippy::significant_drop_in_scrutinee)]
#![expect(clippy::significant_drop_tightening)]
#![expect(clippy::future_not_send)]
#![expect(clippy::single_call_fn)]
#![expect(clippy::cast_sign_loss)]
#![expect(clippy::cast_possible_truncation)]
#![expect(clippy::cast_possible_wrap)]
#![expect(clippy::too_many_lines)]
#![expect(clippy::missing_panics_doc)]
#![expect(clippy::missing_errors_doc)]
#![expect(clippy::module_name_repetitions)]
#![expect(clippy::struct_excessive_bools)]
#![expect(clippy::many_single_char_names)]
#![expect(clippy::float_cmp)]
#[cfg(target_os = "wasi")]
compile_error!("Compiling for WASI targets is not supported!");
@@ -31,6 +26,13 @@ use server::{ticker::Ticker, Server};
use std::io::{self};
use tokio::io::{AsyncBufReadExt, BufReader};
use std::sync::Arc;
use pumpkin_config::{ADVANCED_CONFIG, BASIC_CONFIG};
use pumpkin_core::text::{color::NamedColor, TextComponent};
use rcon::RCONServer;
use std::time::Instant;
// Setup some tokens to allow us to identify which event is for which socket.
pub mod client;
@@ -87,20 +89,11 @@ const fn convert_logger_filter(level: pumpkin_config::logging::LevelFilter) -> L
#[tokio::main]
async fn main() -> io::Result<()> {
use std::sync::Arc;
use pumpkin_config::{ADVANCED_CONFIG, BASIC_CONFIG};
use pumpkin_core::text::{color::NamedColor, TextComponent};
use rcon::RCONServer;
use std::time::Instant;
init_logger();
// let rt = tokio::runtime::Builder::new_multi_thread()
// .enable_all()
// .build()
// .unwrap();
ctrlc::set_handler(|| {
log::warn!(
"{}",
@@ -138,26 +131,7 @@ async fn main() -> io::Result<()> {
log::info!("You now can connect to the server, Listening on {}", addr);
if use_console {
let server = server.clone();
tokio::spawn(async move {
let stdin = tokio::io::stdin();
let mut reader = BufReader::new(stdin);
loop {
let mut out = String::new();
reader
.read_line(&mut out)
.await
.expect("Failed to read console line");
if !out.is_empty() {
let dispatcher = server.command_dispatcher.clone();
dispatcher
.handle_command(&mut commands::CommandSender::Console, &server, &out)
.await;
}
}
});
setup_console(server.clone());
}
if rcon.enabled {
let server = server.clone();
@@ -171,6 +145,7 @@ async fn main() -> io::Result<()> {
ticker.run(&server).await;
});
}
loop {
// Asynchronously wait for an inbound socket.
let (connection, address) = listener.accept().await?;
@@ -208,7 +183,7 @@ async fn main() -> io::Result<()> {
while !player
.client
.closed
.load(std::sync::atomic::Ordering::Relaxed)
.load(core::sync::atomic::Ordering::Relaxed)
{
let open = player.client.poll().await;
if open {
@@ -221,3 +196,25 @@ async fn main() -> io::Result<()> {
});
}
}
fn setup_console(server: Arc<Server>) {
tokio::spawn(async move {
let stdin = tokio::io::stdin();
let mut reader = BufReader::new(stdin);
loop {
let mut out = String::new();
reader
.read_line(&mut out)
.await
.expect("Failed to read console line");
if !out.is_empty() {
let dispatcher = server.command_dispatcher.clone();
dispatcher
.handle_command(&mut commands::CommandSender::Console, &server, &out)
.await;
}
}
});
}

11
pumpkin/src/rcon/mod.rs
View File

@@ -1,7 +1,4 @@
use std::{
io::{self},
net::SocketAddr,
};
use std::net::SocketAddr;
use packet::{ClientboundPacket, Packet, PacketError, ServerboundPacket};
use pumpkin_config::{RCONConfig, ADVANCED_CONFIG};
@@ -20,13 +17,13 @@ pub enum RCONError {
#[error("command exceeds the maximum length")]
CommandTooLong,
#[error("{}", _0)]
Io(io::Error),
Io(std::io::Error),
}
pub struct RCONServer;
impl RCONServer {
pub async fn new(config: &RCONConfig, server: Arc<Server>) -> Result<Self, io::Error> {
pub async fn new(config: &RCONConfig, server: Arc<Server>) -> Result<Self, std::io::Error> {
assert!(config.enabled, "RCON is not enabled");
let listener = tokio::net::TcpListener::bind(config.address).await.unwrap();
@@ -141,7 +138,7 @@ impl RCONClient {
Ok(())
}
async fn read_bytes(&mut self) -> io::Result<bool> {
async fn read_bytes(&mut self) -> std::io::Result<bool> {
let mut buf = [0; 1460];
let n = self.connection.read(&mut buf).await?;
if n == 0 {

6
pumpkin/src/server/connection_cache.rs
View File

@@ -3,7 +3,6 @@ use std::{
fs::File,
io::{Cursor, Read},
path::Path,
sync::LazyLock,
};
use base64::{engine::general_purpose, Engine as _};
@@ -15,8 +14,7 @@ use pumpkin_protocol::{
use super::CURRENT_MC_VERSION;
static DEFAULT_ICON: LazyLock<&[u8]> =
LazyLock::new(|| include_bytes!("../../../assets/default_icon.png"));
const DEFAULT_ICON: &[u8] = include_bytes!("../../../assets/default_icon.png");
fn load_icon_from_file<P: AsRef<Path>>(path: P) -> Result<String, Box<dyn error::Error>> {
let mut icon_file = File::open(path)?;
@@ -112,7 +110,7 @@ impl CachedStatus {
log::info!("Loading server favicon from '{}'", icon_path);
match load_icon_from_file(icon_path).or_else(|err| {
log::warn!("Failed to load icon from '{}': {}", icon_path, err);
load_icon_from_bytes(DEFAULT_ICON.as_ref())
load_icon_from_bytes(DEFAULT_ICON)
}) {
Ok(result) => Some(result),
Err(err) => {

13
pumpkin/src/server/key_store.rs
View File

@@ -1,14 +1,13 @@
use num_bigint::BigInt;
use pumpkin_protocol::client::login::CEncryptionRequest;
use rand::rngs::OsRng;
use rsa::{traits::PublicKeyParts as _, Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey};
use rsa::{traits::PublicKeyParts as _, Pkcs1v15Encrypt, RsaPrivateKey};
use sha1::Sha1;
use sha2::Digest;
use crate::client::EncryptionError;
pub struct KeyStore {
pub _public_key: RsaPublicKey,
pub private_key: RsaPrivateKey,
pub public_key_der: Box<[u8]>,
}
@@ -16,7 +15,7 @@ pub struct KeyStore {
impl KeyStore {
pub fn new() -> Self {
log::debug!("Creating encryption keys...");
let (public_key, private_key) = Self::generate_keys();
let private_key = Self::generate_private_key();
let public_key_der = rsa_der::public_key_to_der(
&private_key.n().to_bytes_be(),
@@ -24,19 +23,17 @@ impl KeyStore {
)
.into_boxed_slice();
Self {
_public_key: public_key,
private_key,
public_key_der,
}
}
fn generate_keys() -> (RsaPublicKey, RsaPrivateKey) {
fn generate_private_key() -> RsaPrivateKey {
// Found out that OsRng is faster than rand::thread_rng here
let mut rng = OsRng;
let priv_key = RsaPrivateKey::new(&mut rng, 1024).expect("failed to generate a key");
let pub_key = RsaPublicKey::from(&priv_key);
(pub_key, priv_key)
// let pub_key = RsaPublicKey::from(&priv_key);
RsaPrivateKey::new(&mut rng, 1024).expect("failed to generate a key")
}
pub fn encryption_request<'a>(

1
pumpkin/src/server/mod.rs
View File

@@ -72,7 +72,6 @@ impl Server {
// First register default command, after that plugins can put in their own
let command_dispatcher = default_dispatcher();
log::info!("Loading Plugins");
let world = World::load(Dimension::OverWorld.into_level(
// TODO: load form config

1
pumpkin/src/world/mod.rs
View File

@@ -118,6 +118,7 @@ impl World {
}
}
#[expect(clippy::too_many_lines)]
pub async fn spawn_player(&self, base_config: &BasicConfiguration, player: Arc<Player>) {
// This code follows the vanilla packet order
let entity_id = player.entity_id();