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
//! MC Protocol constants.

use std::io::prelude::*;
use std::io;
use std::str::FromStr;

use num::FromPrimitive;

use packet::Protocol;

use rustc_serialize::json::{Json, ToJson};

macro_rules! enum_protocol_impl {
    ($name:ty, $repr:ty, $dec_repr:ident) => {
        impl Protocol for $name {
            type Clean = $name;

            fn proto_len(value: &$name) -> usize { <$repr as Protocol>::proto_len(&(*value as $repr)) }

            fn proto_encode(value: &$name, mut dst: &mut Write) -> io::Result<()> {
                let repr = *value as $repr;
                try!(<$repr as Protocol>::proto_encode(&repr, dst));
                Ok(())
            }

            fn proto_decode(mut src: &mut Read) -> io::Result<$name> {
                let value = try!(<$repr as Protocol>::proto_decode(src));
                match FromPrimitive::$dec_repr(value) {
                    Some(x) => Ok(x),
                    None => Err(io::Error::new(io::ErrorKind::InvalidInput, "invalid enum"))
                }
            }
        }
    }
}

enum_protocol_impl!(Dimension, i8, from_i8);

#[repr(i8)]
#[derive(Clone, Copy, Debug, NumFromPrimitive, PartialEq)]
pub enum Dimension {
    Nether = -1,
    Overworld = 0,
    End = 1
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Color {
    Black       = 0x0,
    DarkBlue    = 0x1,
    DarkGreen   = 0x2,
    DarkCyan    = 0x3,
    DarkRed     = 0x4,
    Purple      = 0x5,
    Gold        = 0x6,
    Gray        = 0x7,
    DarkGray    = 0x8,
    Blue        = 0x9,
    BrightGreen = 0xa,
    Cyan        = 0xb,
    Red         = 0xc,
    Pink        = 0xd,
    Yellow      = 0xe,
    White       = 0xf
}

impl AsRef<str> for Color {
    fn as_ref(&self) -> &str {
        match *self {
            Color::Black => "black",
            Color::DarkBlue => "dark_blue",
            Color::DarkGreen => "dark_green",
            Color::DarkCyan => "dark_aqua",
            Color::DarkRed => "dark_red",
            Color::Purple => "dark_purple",
            Color::Gold => "gold",
            Color::Gray => "gray",
            Color::DarkGray => "dark_gray",
            Color::Blue => "blue",
            Color::BrightGreen => "green",
            Color::Cyan => "aqua",
            Color::Red => "red",
            Color::Pink => "light_purple",
            Color::Yellow => "yellow",
            Color::White => "white"
        }
    }
}

impl FromStr for Color {
    type Err = ();

    fn from_str(string: &str) -> Result<Color, ()> {
        match string {
            "black"        => Ok(Color::Black),
            "dark_blue"    => Ok(Color::DarkBlue),
            "dark_green"   => Ok(Color::DarkGreen),
            "dark_aqua"    => Ok(Color::DarkCyan),
            "dark_red"     => Ok(Color::DarkRed),
            "dark_purple"  => Ok(Color::Purple),
            "gold"         => Ok(Color::Gold),
            "gray"         => Ok(Color::Gray),
            "dark_gray"    => Ok(Color::DarkGray),
            "blue"         => Ok(Color::Blue),
            "green"        => Ok(Color::BrightGreen),
            "aqua"         => Ok(Color::Cyan),
            "red"          => Ok(Color::Red),
            "light_purple" => Ok(Color::Pink),
            "yellow"       => Ok(Color::Yellow),
            "white"        => Ok(Color::White),
            _              => Err(())
        }
    }
}

impl ToJson for Color {
    fn to_json(&self) -> Json {
        self.as_ref().to_json()
    }
}