earthmc 2.0.1

Async client for interacting with the EarthMC API
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

use derive_builder::Builder;
use serde::{Deserialize, Serialize};

use crate::model::{
    location::{PositionXYZ, PositionXZ},
    named_uuid::NamedUuidOpt,
};

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LocationInfo {
    pub location: PositionXZ,
    pub is_wilderness: bool,
    pub town: NamedUuidOpt,
    pub nation: NamedUuidOpt,
}

#[derive(Clone, Serialize, Builder)]
#[serde(transparent)]
pub struct LocationQuery {
    #[builder(default)]
    values: Vec<[f32; 2]>,
}

impl LocationQueryBuilder {
    pub fn insert(
        &mut self,
        position: PositionXZ,
    ) -> &mut LocationQueryBuilder {
        self.values
            .get_or_insert_with(Vec::new)
            .push([position.x, position.z]);
        self
    }
}

pub mod position_xyz_object {
    use serde::{Deserialize, Serialize};

    use super::PositionXYZ;

    #[derive(Deserialize, Serialize)]
    pub(crate) struct PositionXYZObject {
        pub(crate) x: i32,
        pub(crate) y: i32,
        pub(crate) z: i32,
    }

    pub fn serialize<S>(
        position: &PositionXYZ,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        PositionXYZObject {
            x: position.x,
            y: position.y,
            z: position.z,
        }
        .serialize(serializer)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<PositionXYZ, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        PositionXYZObject::deserialize(deserializer).map(|position| {
            PositionXYZ {
                x: position.x,
                y: position.y,
                z: position.z,
            }
        })
    }
}