mat/azalea
1
2
Fork 0
mirror of https://github.com/mat-1/azalea.git synced 2025-08-02 06:16:04 +00:00
Code Issues Projects Releases Packages Activity

Merge branch 'main' into auth

Browse source
This commit is contained in:
mat 2022-10-16 22:23:53 -05:00
commit 38e03fc8d0
12 changed files with 79 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,6 +1,6 @@
# Azalea
A collection of Rust crates primarily for creating Minecraft bots.
A collection of Rust crates for making Minecraft bots, clients, and tools.
<p align="center">
<img src="https://cdn.matdoes.dev/images/flowering_azalea.webp" alt="Azalea" height="200">

96
azalea-buf/src/lib.rs
View file

@ -23,7 +23,7 @@ const MAX_STRING_LENGTH: u16 = 32767;
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
use std::{collections::HashMap, io::Cursor};
#[test]
fn test_write_varint() {
@ -74,44 +74,72 @@ mod tests {
#[test]
fn test_read_varint() {
let buf = &mut &vec![0][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 0);
// let buf = &mut &vec![0][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 0);
let buf = vec![0];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 0);
let buf = &mut &vec![1][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 1);
// let buf = &mut &vec![1][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 1);
let buf = vec![1];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 1);
let buf = &mut &vec![2][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 2);
// let buf = &mut &vec![2][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 2);
let buf = vec![2];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2);
let buf = &mut &vec![127][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 127);
// let buf = &mut &vec![127][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 127);
let buf = vec![127];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 127);
let buf = &mut &vec![128, 1][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 128);
// let buf = &mut &vec![128, 1][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 128);
let buf = vec![128, 1];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 128);
let buf = &mut &vec![255, 1][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 255);
// let buf = &mut &vec![255, 1][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 255);
let buf = vec![255, 1];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 255);
let buf = &mut &vec![221, 199, 1][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 25565);
// let buf = &mut &vec![221, 199, 1][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 25565);
let buf = vec![221, 199, 1];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 25565);
let buf = &mut &vec![255, 255, 127][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 2097151);
// let buf = &mut &vec![255, 255, 127][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 2097151);
let buf = vec![255, 255, 127];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2097151);
let buf = &mut &vec![255, 255, 255, 255, 7][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647);
// let buf = &mut &vec![255, 255, 255, 255, 7][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647);
let buf = vec![255, 255, 255, 255, 7];
assert_eq!(
i32::var_read_from(&mut Cursor::new(&buf)).unwrap(),
2147483647
);
let buf = &mut &vec![255, 255, 255, 255, 15][..];
assert_eq!(i32::var_read_from(buf).unwrap(), -1);
// let buf = &mut &vec![255, 255, 255, 255, 15][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), -1);
let buf = vec![255, 255, 255, 255, 15];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), -1);
let buf = &mut &vec![128, 128, 128, 128, 8][..];
assert_eq!(i32::var_read_from(buf).unwrap(), -2147483648);
// let buf = &mut &vec![128, 128, 128, 128, 8][..];
// assert_eq!(i32::var_read_from(buf).unwrap(), -2147483648);
let buf = vec![128, 128, 128, 128, 8];
assert_eq!(
i32::var_read_from(&mut Cursor::new(&buf)).unwrap(),
-2147483648
);
}
#[test]
fn test_read_varint_longer() {
let buf = &mut &vec![138, 56, 0, 135, 56, 123][..];
assert_eq!(i32::var_read_from(buf).unwrap(), 7178);
let buf = vec![138, 56, 0, 135, 56, 123];
assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 7178);
}
#[test]
@ -123,8 +151,7 @@ mod tests {
dbg!(&buf);
let buf = &mut &buf[..];
let result = Vec::<String>::read_from(buf).unwrap();
let result = Vec::<String>::read_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(result, original_vec);
}
@ -133,9 +160,7 @@ mod tests {
let mut buf = Vec::new();
vec![1, 2, 3].var_write_into(&mut buf).unwrap();
let buf = &mut &buf[..];
let result = Vec::<i32>::var_read_from(buf).unwrap();
let result = Vec::<i32>::var_read_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(result, vec![1, 2, 3]);
}
@ -149,19 +174,16 @@ mod tests {
let mut buf = Vec::new();
original_map.var_write_into(&mut buf).unwrap();
let buf = &mut &buf[..];
let result = HashMap::<String, i32>::var_read_from(buf).unwrap();
let result = HashMap::<String, i32>::var_read_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(result, original_map);
}
#[test]
fn test_long() {
let buf: &mut Vec<u8> = &mut Vec::new();
123456u64.write_into(buf).unwrap();
let mut buf: Vec<u8> = Vec::new();
123456u64.write_into(&mut buf).unwrap();
let buf = &mut &buf[..];
assert_eq!(u64::read_from(buf).unwrap(), 123456);
assert_eq!(u64::read_from(&mut Cursor::new(&buf)).unwrap(), 123456);
}
}

2
azalea-buf/src/read.rs
View file

@ -57,7 +57,7 @@ fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8],
fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result<String, BufReadError> {
let length = u32::var_read_from(buf)?;
// i don't know why it's multiplied by 4 but it's like that in mojang's code so
if length as u32 > max_length * 4 {
if length > max_length * 4 {
return Err(BufReadError::StringLengthTooLong {
length,
max_length: max_length * 4,

16
azalea-chat/src/style.rs
View file

@ -274,7 +274,7 @@ impl TryFrom<ChatFormatting> for TextColor {
}
}
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Default)]
pub struct Style {
// these are options instead of just bools because None is different than false in this case
pub color: Option<TextColor>,
@ -288,20 +288,8 @@ pub struct Style {
}
impl Style {
pub fn default() -> Self {
Self::empty()
}
pub fn empty() -> Self {
Self {
color: None,
bold: None,
italic: None,
underlined: None,
strikethrough: None,
obfuscated: None,
reset: false,
}
Self::default()
}
pub fn deserialize(json: &Value) -> Style {

4
azalea-nbt/src/decode.rs
View file

@ -98,7 +98,7 @@ impl Tag {
if length * 4 > (stream.get_ref().len() - stream.position() as usize) {
return Err(Error::UnexpectedEof);
}
let mut ints = Vec::with_capacity(length as usize);
let mut ints = Vec::with_capacity(length);
for _ in 0..length {
ints.push(stream.read_i32::<BE>()?);
}
@ -111,7 +111,7 @@ impl Tag {
if length * 8 > (stream.get_ref().len() - stream.position() as usize) {
return Err(Error::UnexpectedEof);
}
let mut longs = Vec::with_capacity(length as usize);
let mut longs = Vec::with_capacity(length);
for _ in 0..length {
longs.push(stream.read_i64::<BE>()?);
}

3
azalea-physics/src/collision/discrete_voxel_shape.rs
View file

@ -338,8 +338,7 @@ impl From<&DiscreteVoxelShape> for BitSetDiscreteVoxelShape {
for y in 0..y_size {
for z in 0..z_size {
if shape.is_full(x, y, z) {
storage
.set(Self::get_index_from_size(x, y, z, y_size, z_size) as usize);
storage.set(Self::get_index_from_size(x, y, z, y_size, z_size));
}
}
}

2
azalea-protocol/src/read.rs
View file

@ -106,7 +106,7 @@ fn parse_frame(buffer: &mut BytesMut) -> Result<BytesMut, FrameSplitterError> {
Ok(data)
}
fn frame_splitter<'a>(buffer: &'a mut BytesMut) -> Result<Option<Vec<u8>>, FrameSplitterError> {
fn frame_splitter(buffer: &mut BytesMut) -> Result<Option<Vec<u8>>, FrameSplitterError> {
// https://tokio.rs/tokio/tutorial/framing
let read_frame = parse_frame(buffer);
match read_frame {

2
azalea-protocol/src/write.rs
View file

@ -29,7 +29,7 @@ fn packet_encoder<P: ProtocolPacket + std::fmt::Debug>(
packet: &P,
) -> Result<Vec<u8>, PacketEncodeError> {
let mut buf = Vec::new();
(packet.id() as u32).var_write_into(&mut buf)?;
packet.id().var_write_into(&mut buf)?;
packet.write(&mut buf)?;
if buf.len() > MAXIMUM_UNCOMPRESSED_LENGTH as usize {
return Err(PacketEncodeError::TooBig {

14
azalea-world/src/bit_storage.rs
View file

@ -120,21 +120,21 @@ impl BitStorage {
let values_per_long = 64 / bits;
let magic_index = values_per_long - 1;
let (divide_mul, divide_add, divide_shift) = MAGIC[magic_index as usize];
let (divide_mul, divide_add, divide_shift) = MAGIC[magic_index];
let calculated_length = (size + values_per_long - 1) / values_per_long;
let mask = (1 << bits) - 1;
let using_data = if let Some(data) = data {
if data.len() != calculated_length as usize {
if data.len() != calculated_length {
return Err(BitStorageError::InvalidLength {
got: data.len(),
expected: calculated_length as usize,
expected: calculated_length,
});
}
data
} else {
vec![0; calculated_length as usize]
vec![0; calculated_length]
};
Ok(BitStorage {
@ -179,7 +179,7 @@ impl BitStorage {
}
let cell_index = self.cell_index(index as u64);
let cell = &self.data[cell_index as usize];
let cell = &self.data[cell_index];
let bit_index = (index - cell_index * self.values_per_long as usize) * self.bits;
cell >> bit_index & self.mask
}
@ -193,7 +193,7 @@ impl BitStorage {
assert!(index < self.size);
assert!(value <= self.mask);
let cell_index = self.cell_index(index as u64);
let cell = &mut self.data[cell_index as usize];
let cell = &mut self.data[cell_index];
let bit_index = (index - cell_index * self.values_per_long as usize) * self.bits;
let old_value = *cell >> (bit_index as u64) & self.mask;
*cell = *cell & !(self.mask << bit_index) | (value & self.mask) << bit_index;
@ -209,7 +209,7 @@ impl BitStorage {
assert!(index < self.size);
assert!(value <= self.mask);
let cell_index = self.cell_index(index as u64);
let cell = &mut self.data[cell_index as usize];
let cell = &mut self.data[cell_index];
let bit_index = (index - cell_index * self.values_per_long as usize) * self.bits;
*cell = *cell & !(self.mask << bit_index) | (value & self.mask) << bit_index;
}

2
azalea-world/src/entity/data.rs
View file

@ -110,7 +110,7 @@ impl McBufReadable for EntityDataValue {
if val == 0 {
None
} else {
Some((val - 1) as u32)
Some(val - 1)
}
}),
18 => EntityDataValue::Pose(Pose::read_from(buf)?),

4
azalea-world/src/palette.rs
View file

@ -149,7 +149,7 @@ impl PalettedContainer {
}
Palette::Linear(palette) => {
if let Some(index) = palette.iter().position(|v| *v == value) {
return index as usize;
return index;
}
let capacity = 2usize.pow(self.bits_per_entry.into());
if capacity > palette.len() {
@ -162,7 +162,7 @@ impl PalettedContainer {
Palette::Hashmap(palette) => {
// TODO? vanilla keeps this in memory as a hashmap, but also i don't care
if let Some(index) = palette.iter().position(|v| *v == value) {
return index as usize;
return index;
}
let capacity = 2usize.pow(self.bits_per_entry.into());
if capacity > palette.len() {

3
azalea/Cargo.toml
View file

@ -1,8 +1,7 @@
[package]
description = "Advertisement crate for Azalea."
description = "A framework for creating Minecraft bots."
edition = "2021"
license = "MIT"
name = "azalea"
version = "0.1.0"