mclib 0.0.1

Utils and helpers for Minecraft protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::types::base::MCType;
use crate::types::long::MCLong;
use crate::types::ubyte::MCUByte;
use crate::types::varint::MCVarInt;
use std::io::Read;

#[derive(Debug, Clone)]
pub enum PalletedContainer<const INDIRECT_MAX_BITS: u8> {
    SingleValued(MCVarInt),
    Indirect {
        bits_per_entry: MCUByte,
        pallete: Vec<MCVarInt>,
        data: Vec<MCLong>,
    },
    Direct {
        bits_per_entry: MCUByte,
        data: Vec<MCLong>,
    },
}

impl<const INDIRECT_MAX_BITS: u8> MCType for PalletedContainer<INDIRECT_MAX_BITS> {
    fn pack(&self) -> Vec<u8> {
        match self {
            PalletedContainer::SingleValued(block_id) => {
                let mut result = Vec::new();
                result.extend(MCUByte::from(0).pack()); // bits_per_entry
                result.extend(block_id.pack());
                result.extend(MCVarInt::from(0).pack()); // data array len
                result
            }
            PalletedContainer::Indirect {
                bits_per_entry,
                pallete,
                data,
            } => {
                let mut result = Vec::new();
                result.extend(bits_per_entry.pack());
                result.extend(pallete.pack());
                result.extend(data.pack());
                result
            }
            PalletedContainer::Direct {
                bits_per_entry,
                data,
            } => {
                let mut result = Vec::new();
                result.extend(bits_per_entry.pack());
                result.extend(data.pack());
                result
            }
        }
    }

    fn unpack(src: &mut dyn Read) -> Self {
        // TODO for block and biome
        let bits_per_entry = MCUByte::unpack(src);
        if bits_per_entry == 0 {
            let value = MCVarInt::unpack(src);
            let _data_len = MCVarInt::unpack(src);
            Self::SingleValued(value)
        } else if <MCUByte as Into<u8>>::into(bits_per_entry.clone()) <= INDIRECT_MAX_BITS {
            let pallete_length = MCVarInt::unpack(src).into();
            let mut pallete = Vec::new();
            for _ in 0..pallete_length {
                pallete.push(MCVarInt::unpack(src));
            }
            let mut data = Vec::new();
            let data_length = MCVarInt::unpack(src).into();
            for _ in 0..data_length {
                data.push(MCLong::unpack(src));
            }
            Self::Indirect {
                bits_per_entry,
                pallete,
                data,
            }
        } else {
            let mut data = Vec::new();
            let data_length = MCVarInt::unpack(src).into();
            for _ in 0..data_length {
                data.push(MCLong::unpack(src));
            }
            Self::Direct {
                bits_per_entry,
                data,
            }
        }
    }
}