mc-core 0.1.1

MinecraftRS - Minimal core implementation of Minecraft backend.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Codec basics for ECS entities' components.

use std::marker::PhantomData;

use hecs::{Component, EntityBuilder, EntityRef};
use nbt::CompoundTag;


/// This trait describes a specific way of encoding, decoding and building a default variant
/// of a component structure for an entity. This trait should usually be implemented for each
/// component of an entity, however because it doesn't provide any type restriction you can
/// encode, decode and add whatever default value you want.
///
/// Structures implementing this trait can be zero-sized and defined statically, doing this
/// allows you to make `&'static dyn EntityCodec` references that can be used as constants to
/// define default codecs for an entity component structure.
pub trait EntityCodec: Send + Sync {

    /// Encode components stored accessible from the given entity reference into given destination
    /// compound tag.
    fn encode(&self, src: &EntityRef, dst: &mut CompoundTag) -> Result<(), String>;

    /// Decode given source compound tag and add decoded components into the given entity builder.
    fn decode(&self, src: &CompoundTag, dst: &mut EntityBuilder) -> Result<(), String>;

    /// Add default components to the given entity builder.
    fn default(&self, dst: &mut EntityBuilder);

}


/// This trait is a simpler specification of `EntityCodec` with the restriction of allowing only
/// one component (implementing `hecs::Component`) to be encoded or decoded. The component type
/// also have to implement `Default` to provide a default `EntityCodec::default` implementation.
///
/// Implementing this trait automatically means that you are implementing `EntityCodec` on `Self`,
/// with `encode`, `decode` and `default` automatically defined to delegate to this trait.
pub trait SingleEntityCodec {

    /// Component type, an associated type is used to allow only on implementation per codec struct.
    type Comp: Default + Component;

    fn encode(&self, src: &Self::Comp, dst: &mut CompoundTag);
    fn decode(&self, src: &CompoundTag) -> Self::Comp;

}

impl<C, D> EntityCodec for C
where
    C: Send + Sync,
    C: SingleEntityCodec<Comp=D>,
    D: Default + Component
{

    fn encode(&self, src: &EntityRef, dst: &mut CompoundTag) -> Result<(), String> {
        if let Some(comp) = src.get::<D>() {
            <Self as SingleEntityCodec>::encode(self, &*comp, dst);
        }
        Ok(())
    }

    fn decode(&self, src: &CompoundTag, dst: &mut EntityBuilder) -> Result<(), String> {
        dst.add(<Self as SingleEntityCodec>::decode(self, src));
        Ok(())
    }

    fn default(&self, dst: &mut EntityBuilder) {
        dst.add(D::default());
    }

}


/// A useful structure that implements the method `EntityCodec::default` and add to the given
/// builder the `Default:default()` value of the generic type `T`. Actually, `EntityCodec` is
/// only implemented when your type `T` is `Default + Component`. This bound cannot be defined
/// in the structure definition for now because it would not be possible to define it statically.
pub struct DefaultEntityCodec<T>(PhantomData<*const T>);
unsafe impl<T> Send for DefaultEntityCodec<T> {}
unsafe impl<T> Sync for DefaultEntityCodec<T> {}

impl<T> DefaultEntityCodec<T> {
    pub const fn new() -> Self {
        Self(PhantomData)
    }
}

#[allow(unused_variables)]
impl<T> EntityCodec for DefaultEntityCodec<T>
where
    T: Default + Component
{

    fn encode(&self, src: &EntityRef, dst: &mut CompoundTag) -> Result<(), String> {
        Ok(())
    }

    fn decode(&self, src: &CompoundTag, dst: &mut EntityBuilder) -> Result<(), String> {
        Ok(())
    }

    fn default(&self, dst: &mut EntityBuilder) {
        dst.add(<T as Default>::default());
    }

}


/// A null codec, this codec make nothing and can be used as a temporary placeholder.
pub struct NullEntityCodec;

#[allow(unused_variables)]
impl EntityCodec for NullEntityCodec {

    fn encode(&self, src: &EntityRef, dst: &mut CompoundTag) -> Result<(), String> {
        Ok(())
    }

    fn decode(&self, src: &CompoundTag, dst: &mut EntityBuilder) -> Result<(), String> {
        Ok(())
    }

    fn default(&self, dst: &mut EntityBuilder) { }

}