pub mod legacy {
use bytes::{BufMut, BytesMut};
use crate::codec::{Decode, DecodeResult, Encode, EncodeResult, Reader};
use crate::error::EncodeError;
use crate::nbt::RawNbt;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ItemStack {
pub id: i16,
pub count: i8,
pub damage: i16,
pub nbt: Option<RawNbt>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct Slot(pub Option<ItemStack>);
impl Slot {
pub const EMPTY: Slot = Slot(None);
#[inline]
pub fn is_empty(&self) -> bool {
self.0.is_none()
}
#[inline]
pub fn item(&self) -> Option<&ItemStack> {
self.0.as_ref()
}
}
impl Decode for Slot {
#[inline]
fn decode(r: &mut Reader<'_>) -> DecodeResult<Self> {
let id = r.read_i16()?;
if id == -1 {
return Ok(Slot(None));
}
Ok(Slot(Some(ItemStack {
id,
count: r.read_i8()?,
damage: r.read_i16()?,
nbt: RawNbt::read_optional(r)?,
})))
}
}
impl Encode for Slot {
#[inline]
fn encode(&self, w: &mut BytesMut) -> EncodeResult {
match &self.0 {
None => w.put_i16(-1),
Some(it) => {
if it.id == -1 {
return Err(EncodeError::Invalid(
"item id -1 is reserved for empty slots",
));
}
w.put_i16(it.id);
w.put_i8(it.count);
w.put_i16(it.damage);
RawNbt::write_optional(&it.nbt, w);
}
}
Ok(())
}
}
}
pub mod modern {
use bytes::{BufMut, BytesMut};
use crate::codec::{Decode, DecodeResult, Encode, EncodeResult, McWrite, Reader};
use crate::nbt::RawNbt;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ItemStack {
pub id: i32,
pub count: i8,
pub nbt: Option<RawNbt>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct Slot(pub Option<ItemStack>);
impl Slot {
pub const EMPTY: Slot = Slot(None);
#[inline]
pub fn is_empty(&self) -> bool {
self.0.is_none()
}
#[inline]
pub fn item(&self) -> Option<&ItemStack> {
self.0.as_ref()
}
}
impl Decode for Slot {
#[inline]
fn decode(r: &mut Reader<'_>) -> DecodeResult<Self> {
if !r.read_bool()? {
return Ok(Slot(None));
}
Ok(Slot(Some(ItemStack {
id: r.read_varint()?,
count: r.read_i8()?,
nbt: RawNbt::read_optional(r)?,
})))
}
}
impl Encode for Slot {
#[inline]
fn encode(&self, w: &mut BytesMut) -> EncodeResult {
match &self.0 {
None => w.put_bool(false),
Some(it) => {
w.put_bool(true);
w.put_varint(it.id);
w.put_i8(it.count);
RawNbt::write_optional(&it.nbt, w);
}
}
Ok(())
}
}
}
#[cfg(feature = "v26_1")]
pub mod v775 {
use bytes::{BufMut, Bytes, BytesMut};
use crate::codec::{DecodeResult, McWrite, Reader};
use crate::defs::p775::types::SlotComponent;
use crate::error::DecodeError;
#[derive(Debug, Clone, Default)]
pub struct ComponentPatch {
bytes: Bytes,
split: u32,
added: u16,
removed: u16,
added_mask: u128,
removed_mask: u128,
}
#[inline]
fn bit(ty: i32) -> u128 {
match u32::try_from(ty) {
Ok(t) if t < 127 => 1u128 << t,
_ => 1u128 << 127,
}
}
#[inline]
fn may_have(mask: u128, ty: i32) -> bool {
mask & (bit(ty) | 1u128 << 127) != 0
}
impl PartialEq for ComponentPatch {
fn eq(&self, other: &Self) -> bool {
self.added == other.added && self.removed == other.removed && self.bytes == other.bytes
}
}
impl Eq for ComponentPatch {}
impl std::hash::Hash for ComponentPatch {
fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
self.bytes.hash(h);
}
}
impl ComponentPatch {
pub const EMPTY: ComponentPatch = ComponentPatch {
bytes: Bytes::new(),
split: 0,
added: 0,
removed: 0,
added_mask: 0,
removed_mask: 0,
};
pub fn read(r: &mut Reader<'_>, added: i32, removed: i32) -> DecodeResult<Self> {
let added_n = r.check_count(i64::from(added), 1)?;
let removed_n = r.check_count(i64::from(removed), 1)?;
let (Ok(added), Ok(removed)) = (u16::try_from(added_n), u16::try_from(removed_n))
else {
return Err(DecodeError::Invalid("component count"));
};
let start = r.position();
let mut added_mask = 0u128;
for _ in 0..added_n {
added_mask |= bit(r.clone().read_varint()?);
SlotComponent::skip(r)?;
}
let split = (r.position() - start) as u32;
let mut removed_mask = 0u128;
for _ in 0..removed_n {
removed_mask |= bit(r.read_varint()?);
}
Ok(ComponentPatch {
bytes: r.bytes_since(start),
split,
added,
removed,
added_mask,
removed_mask,
})
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.added == 0 && self.removed == 0
}
#[must_use]
pub fn added_len(&self) -> usize {
usize::from(self.added)
}
#[must_use]
pub fn removed_len(&self) -> usize {
usize::from(self.removed)
}
#[must_use]
pub fn as_bytes(&self) -> &Bytes {
&self.bytes
}
pub fn iter(&self) -> Components<'_> {
Components {
bytes: self.bytes.slice(..self.split as usize),
pos: 0,
left: self.added,
_p: std::marker::PhantomData,
}
}
pub fn removed(&self) -> impl Iterator<Item = i32> + '_ {
let tail = self.bytes.slice(self.split as usize..);
let mut pos = 0usize;
(0..self.removed).map_while(move |_| {
let mut r = Reader::new(&tail);
r.skip(pos).ok()?;
let v = r.read_varint().ok()?;
pos = r.position();
Some(v)
})
}
#[must_use]
pub fn removes(&self, ty: i32) -> bool {
may_have(self.removed_mask, ty) && self.removed().any(|t| t == ty)
}
#[must_use]
pub fn adds(&self, ty: i32) -> bool {
may_have(self.added_mask, ty) && self.iter().any(|(t, _)| t == ty)
}
#[must_use]
pub fn get(&self, ty: i32) -> Option<Bytes> {
if !may_have(self.added_mask, ty) {
return None;
}
self.iter().filter(|(t, _)| *t == ty).last().map(|(_, b)| b)
}
#[must_use]
pub fn decode(&self, ty: i32) -> Option<DecodeResult<SlotComponent>> {
if !may_have(self.added_mask, ty) {
return None;
}
let mut r = Reader::new(&self.bytes);
let mut last = None;
for _ in 0..self.added {
let start = r.position();
let t = match r.clone().read_varint() {
Ok(t) => t,
Err(e) => return Some(Err(e)),
};
if let Err(e) = SlotComponent::skip(&mut r) {
return Some(Err(e));
}
if t == ty {
last = Some(start);
}
}
let start = last?;
let mut r = Reader::new(&self.bytes);
if let Err(e) = r.skip(start) {
return Some(Err(e));
}
Some(<SlotComponent as crate::codec::Decode>::decode(&mut r))
}
pub fn decode_all(&self) -> DecodeResult<Vec<SlotComponent>> {
let mut r = Reader::new(&self.bytes);
(0..self.added)
.map(|_| <SlotComponent as crate::codec::Decode>::decode(&mut r))
.collect()
}
#[must_use]
pub fn same_components(&self, other: &ComponentPatch) -> bool {
if self == other {
return true;
}
let mut a: Vec<i32> = self.removed().collect();
let mut b: Vec<i32> = other.removed().collect();
a.sort_unstable();
a.dedup();
b.sort_unstable();
b.dedup();
if a != b {
return false;
}
let last = |p: &ComponentPatch| {
let mut v: Vec<(i32, Bytes)> = Vec::new();
for (t, b) in p.iter() {
match v.iter_mut().find(|(k, _)| *k == t) {
Some(e) => e.1 = b,
None => v.push((t, b)),
}
}
v.sort_by_key(|(t, _)| *t);
v
};
last(self) == last(other)
}
#[must_use]
pub fn from_parts(added: &[(i32, &[u8])], removed: &[i32]) -> ComponentPatch {
let mut w = BytesMut::new();
for (t, v) in added {
w.put_varint(*t);
w.put_slice(v);
}
let split = w.len() as u32;
for t in removed {
w.put_varint(*t);
}
ComponentPatch {
bytes: w.freeze(),
split,
added: added.len() as u16,
removed: removed.len() as u16,
added_mask: added.iter().fold(0, |m, (t, _)| m | bit(*t)),
removed_mask: removed.iter().fold(0, |m, t| m | bit(*t)),
}
}
}
#[derive(Debug, Clone)]
pub struct Components<'a> {
bytes: Bytes,
pos: usize,
left: u16,
_p: std::marker::PhantomData<&'a ComponentPatch>,
}
impl Iterator for Components<'_> {
type Item = (i32, Bytes);
fn next(&mut self) -> Option<(i32, Bytes)> {
if self.left == 0 {
return None;
}
self.left -= 1;
let mut r = Reader::new(&self.bytes);
r.skip(self.pos).ok()?;
let mut value = r.clone();
let ty = value.read_varint().ok()?;
let value_start = value.position();
SlotComponent::skip(&mut r).ok()?;
self.pos = r.position();
Some((ty, self.bytes.slice(value_start..self.pos)))
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ItemStack {
pub id: i32,
pub count: i32,
pub components: ComponentPatch,
}
impl ItemStack {
pub fn read(r: &mut Reader<'_>) -> DecodeResult<Option<ItemStack>> {
let count = r.read_varint()?;
if count <= 0 {
return Ok(None);
}
let id = r.read_varint()?;
let added = r.read_varint()?;
let removed = r.read_varint()?;
let components = ComponentPatch::read(r, added, removed)?;
Ok(Some(ItemStack {
id,
count,
components,
}))
}
pub fn write(s: Option<&ItemStack>, w: &mut BytesMut) {
match s {
None => w.put_varint(0),
Some(s) => {
w.put_varint(s.count);
w.put_varint(s.id);
w.put_varint(i32::from(s.components.added));
w.put_varint(i32::from(s.components.removed));
w.put_slice(&s.components.bytes);
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::codec::{Encode, decode_exact};
use bytes::{Bytes, BytesMut};
#[test]
fn legacy_known_answers() {
let b = Bytes::from_static(&[0xff, 0xff]);
assert_eq!(decode_exact::<legacy::Slot>(&b), Ok(legacy::Slot::EMPTY));
let b = Bytes::from_static(&[0x00, 0x01, 0x40, 0x00, 0x00, 0x00]);
let s = decode_exact::<legacy::Slot>(&b).unwrap();
let it = s.item().unwrap();
assert_eq!(
(it.id, it.count, it.damage, it.nbt.is_none()),
(1, 64, 0, true)
);
let mut w = BytesMut::new();
s.encode(&mut w).unwrap();
assert_eq!(&w[..], &b[..]);
let b = Bytes::from_static(&[0x01, 0x14, 0x01, 0x00, 0x05, 0x0a, 0x00, 0x00, 0x00]);
let s = decode_exact::<legacy::Slot>(&b).unwrap();
assert_eq!(s.item().unwrap().nbt.as_ref().unwrap().as_bytes().len(), 4);
}
#[test]
fn modern_known_answers() {
let b = Bytes::from_static(&[0x00]);
assert_eq!(decode_exact::<modern::Slot>(&b), Ok(modern::Slot::EMPTY));
let b = Bytes::from_static(&[0x01, 0xac, 0x02, 0x10, 0x00]);
let s = decode_exact::<modern::Slot>(&b).unwrap();
let it = s.item().unwrap();
assert_eq!((it.id, it.count), (300, 16));
}
}