1.14 protocol support (477) (#132). Closes #72

Adds 1.14 (477) protocol support, based on:

https://wiki.vg/index.php?title=Pre-release_protocol&oldid=14723

* New packets: SetDifficulty, LockDifficulty, UpdateJigsawBlock, UpdateViewPosition, UpdateViewDistance

* New metadata: Optional VarInt (17) and Pose (18)

* Add new join game variant with view distance, without difficulty

* Add new server difficulty variant, with locked boolean

* Implement recipe parsing changes, add stonecutting recipe type

Author: iceiix

README.md

@@ -23,6 +23,7 @@ Join with your favorite IRC client or [Matrix](https://matrix.to/#/#_espernet_#s
 
 | Game version | Protocol version | Supported? |
 | ------ | --- | --- |
+| 1.14 | 477 | ✓ |
 | 19w02a | 452 | ✓ |
 | 18w50a | 451 | ✓ |
 | 1.13.2 | 404 | ✓ |

src/protocol/mod.rs

@@ -38,7 +38,7 @@ use flate2::Compression;
 use std::time::{Instant, Duration};
 use crate::shared::Position;
 
-pub const SUPPORTED_PROTOCOLS: [i32; 12] = [404, 451, 452, 340, 316, 315, 210, 109, 107, 74, 47, 5];
+pub const SUPPORTED_PROTOCOLS: [i32; 13] = [477, 452, 451, 404, 340, 316, 315, 210, 109, 107, 74, 47, 5];
 
 // TODO: switch to using thread_local storage?, see https://doc.rust-lang.org/std/macro.thread_local.html
 pub static mut CURRENT_PROTOCOL_VERSION: i32 = SUPPORTED_PROTOCOLS[0];

src/protocol/packet.rs

@@ -57,6 +57,9 @@ state_packets!(
                 field transaction_id: VarInt =,
                 field location: Position =,
             }
+            packet SetDifficulty {
+                field new_difficulty: u8 =,
+            }
             /// TabComplete is sent by the client when the client presses tab in
             /// the chat box.
             packet TabComplete {
@@ -202,6 +205,9 @@ state_packets!(
             packet KeepAliveServerbound_i32 {
                 field id: i32 =,
             }
+            packet LockDifficulty {
+                field locked: bool =,
+            }
             /// PlayerPosition is used to update the player's position.
             packet PlayerPosition {
                 field x: f64 =,
@@ -370,6 +376,12 @@ state_packets!(
                 field slot: i16 =,
                 field clicked_item: Option<item::Stack> =,
             }
+            packet UpdateJigsawBlock {
+                field location: Position =,
+                field attachment_type: String =,
+                field target_pool: String =,
+                field final_state: String =,
+            }
             packet UpdateStructureBlock {
                 field location: Position =,
                 field action: VarInt =,
@@ -753,6 +765,10 @@ state_packets!(
             packet ServerDifficulty {
                 field difficulty: u8 =,
             }
+            packet ServerDifficulty_Locked {
+                field difficulty: u8 =,
+                field locked: bool =,
+            }
             /// TabCompleteReply is sent as a reply to a tab completion request.
             /// The matches should be possible completions for the command/chat the
             /// player sent.
@@ -1055,6 +1071,23 @@ state_packets!(
             }
             /// JoinGame is sent after completing the login process. This
             /// sets the initial state for the client.
+            packet JoinGame_i32_ViewDistance {
+                /// The entity id the client will be referenced by
+                field entity_id: i32 =,
+                /// The starting gamemode of the client
+                field gamemode: u8 =,
+                /// The dimension the client is starting in
+                field dimension: i32 =,
+                /// The max number of players on the server
+                field max_players: u8 =,
+                /// The level type of the server
+                field level_type: String =,
+                /// The render distance (2-32)
+                field view_distance: VarInt =,
+                /// Whether the client should reduce the amount of debug
+                /// information it displays in F3 mode
+                field reduced_debug_info: bool =,
+            }
             packet JoinGame_i32 {
                 /// The entity id the client will be referenced by
                 field entity_id: i32 =,
@@ -1377,6 +1410,15 @@ state_packets!(
             packet SetCurrentHotbarSlot {
                 field slot: u8 =,
             }
+            /// UpdateViewPosition is used to determine what chunks should be remain loaded.
+            packet UpdateViewPosition {
+                field chunk_x: VarInt =,
+                field chunk_z: VarInt =,
+            }
+            /// UpdateViewDistance is sent by the integrated server when changing render distance.
+            packet UpdateViewDistance {
+                field view_distance: VarInt =,
+            }
             /// ScoreboardDisplay is used to set the display position of a scoreboard.
             packet ScoreboardDisplay {
                 field position: u8 =,
@@ -2396,6 +2438,11 @@ pub enum RecipeData {
         experience: f32,
         cooking_time: VarInt,
     },
+    Stonecutting {
+        group: String,
+        ingredient: RecipeIngredient,
+        result: Option<item::Stack>,
+    },
 }
 
 impl Default for RecipeData {
@@ -2413,8 +2460,35 @@ pub struct Recipe {
 
 impl Serializable for Recipe {
     fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
-        let id = String::read_from(buf)?;
-        let ty = String::read_from(buf)?;
+        let (id, ty, namespace) = {
+            let a = String::read_from(buf)?;
+            let b = String::read_from(buf)?;
+
+            let protocol_version = unsafe { crate::protocol::CURRENT_PROTOCOL_VERSION };
+
+            // 1.14+ swaps recipe identifier and type, and adds namespace to type
+            if protocol_version >= 477 {
+                let ty = a;
+                let id = b;
+
+                if let Some(at) = ty.find(':') {
+                    let (namespace, ty) = ty.split_at(at + 1);
+                    let ty: String = ty.into();
+                    let namespace: String = namespace.into();
+                    (id, ty, namespace)
+                } else {
+                    (id, ty, "minecraft:".to_string())
+                }
+            } else {
+                let ty = b;
+                let id = a;
+                (id, ty, "minecraft:".to_string())
+            }
+        };
+
+        if namespace != "minecraft:" {
+            panic!("unrecognized recipe type namespace: {}", namespace);
+        }
 
         let data =
         match ty.as_ref() {
@@ -2473,13 +2547,18 @@ impl Serializable for Recipe {
                 experience: Serializable::read_from(buf)?,
                 cooking_time: Serializable::read_from(buf)?,
             },
-            "campfire" => RecipeData::Campfire {
+            "campfire" | "campfire_cooking" => RecipeData::Campfire {
                 group: Serializable::read_from(buf)?,
                 ingredient: Serializable::read_from(buf)?,
                 result: Serializable::read_from(buf)?,
                 experience: Serializable::read_from(buf)?,
                 cooking_time: Serializable::read_from(buf)?,
             },
+            "stonecutting" => RecipeData::Stonecutting {
+                group: Serializable::read_from(buf)?,
+                ingredient: Serializable::read_from(buf)?,
+                result: Serializable::read_from(buf)?,
+            },
             _ => panic!("unrecognized recipe type: {}", ty)
         };
 

src/protocol/versions.rs

@@ -1,5 +1,6 @@
 use crate::protocol::*;
 
+mod v1_14;
 mod v19w02a;
 mod v18w50a;
 mod v1_13_2;
@@ -16,6 +17,8 @@ pub fn translate_internal_packet_id_for_version(version: i32, state: State, dir:
     match version {
         // https://wiki.vg/Protocol_History
         // https://wiki.vg/Protocol_version_numbers#Versions_after_the_Netty_rewrite
+
+        477 => v1_14::translate_internal_packet_id(state, dir, id, to_internal),
 
         // 19w02a
         452 => v19w02a::translate_internal_packet_id(state, dir, id, to_internal),

src/server/mod.rs

@@ -388,6 +388,7 @@ impl Server {
                 match pck {
                     Ok(pck) => handle_packet!{
                         self pck {
+                            JoinGame_i32_ViewDistance => on_game_join_i32_viewdistance,
                             JoinGame_i32 => on_game_join_i32,
                             JoinGame_i8 => on_game_join_i8,
                             JoinGame_i8_NoDebug => on_game_join_i8_nodebug,
@@ -666,6 +667,10 @@ impl Server {
         });
     }
 
+    fn on_game_join_i32_viewdistance(&mut self, join: packet::play::clientbound::JoinGame_i32_ViewDistance) {
+        self.on_game_join(join.gamemode, join.entity_id)
+    }
+
     fn on_game_join_i32(&mut self, join: packet::play::clientbound::JoinGame_i32) {
         self.on_game_join(join.gamemode, join.entity_id)
     }

src/types/metadata.rs

@@ -322,6 +322,14 @@ impl Metadata {
                 }
                 15 => panic!("TODO: particle"),
                 16 => m.put_raw(index, VillagerData::read_from(buf)?),
+                17 => {
+                    if bool::read_from(buf)? {
+                        m.put_raw(index, Option::<protocol::VarInt>::read_from(buf)?);
+                    } else {
+                        m.put_raw::<Option<protocol::VarInt>>(index, None);
+                    }
+                },
+                18 => m.put_raw(index, PoseData::read_from(buf)?),
                 _ => return Err(protocol::Error::Err("unknown metadata type".to_owned())),
             }
         }
@@ -405,6 +413,14 @@ impl Metadata {
                     u8::write_to(&16, buf)?;
                     val.write_to(buf)?;
                 }
+                Value::OptionalVarInt(ref val) => {
+                    u8::write_to(&17, buf)?;
+                    val.write_to(buf)?;
+                }
+                Value::Pose(ref val) => {
+                    u8::write_to(&18, buf)?;
+                    val.write_to(buf)?;
+                }
                 _ => panic!("unexpected metadata"),
             }
         }
@@ -478,6 +494,8 @@ pub enum Value {
     NBTTag(nbt::NamedTag),
     Particle(ParticleData),
     Villager(VillagerData),
+    OptionalVarInt(Option<protocol::VarInt>),
+    Pose(PoseData),
 }
 
 #[derive(Debug)]
@@ -639,6 +657,38 @@ impl Serializable for VillagerData {
     }
 }
 
+#[derive(Debug)]
+pub enum PoseData {
+    Standing,
+    FallFlying,
+    Sleeping,
+    Swimming,
+    SpinAttack,
+    Sneaking,
+    Dying,
+}
+
+impl Serializable for PoseData {
+    fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, protocol::Error> {
+        let n = protocol::VarInt::read_from(buf)?;
+        Ok(match n.0 {
+            0 => PoseData::Standing,
+            1 => PoseData::FallFlying,
+            2 => PoseData::Sleeping,
+            3 => PoseData::Swimming,
+            4 => PoseData::SpinAttack,
+            5 => PoseData::Sneaking,
+            6 => PoseData::Dying,
+            _ => panic!("unknown pose data: {}", n.0),
+        })
+    }
+
+    fn write_to<W: io::Write>(&self, _buf: &mut W) -> Result<(), protocol::Error> {
+        unimplemented!()
+    }
+}
+
+
 
 pub trait MetaValue {
     fn unwrap(_: &Value) -> &Self;
@@ -862,6 +912,31 @@ impl MetaValue for VillagerData {
     }
 }
 
+impl MetaValue for Option<protocol::VarInt> {
+    fn unwrap(value: &Value) -> &Self {
+        match *value {
+            Value::OptionalVarInt(ref val) => val,
+            _ => panic!("incorrect key"),
+        }
+    }
+    fn wrap(self) -> Value {
+        Value::OptionalVarInt(self)
+    }
+}
+
+impl MetaValue for PoseData {
+    fn unwrap(value: &Value) -> &Self {
+        match *value {
+            Value::Pose(ref val) => val,
+            _ => panic!("incorrect key"),
+        }
+    }
+    fn wrap(self) -> Value {
+        Value::Pose(self)
+    }
+}
+
+
 #[cfg(test)]
 mod test {
     use super::*;