Implement camera facing target.

While at it, fix passing on of command args.

Author: conqp

src/minecraft/bedrock_edition.rs

@@ -5,7 +5,7 @@ mod camera;
 use std::future::Future;
 
 use crate::minecraft::java_edition::TargetSelector;
-use crate::minecraft::{parse_response, Entity, Error};
+use crate::minecraft::{parse_response, Entity, Error, Serialize};
 use crate::Minecraft;
 
 /// Extension trait for `Source RCON` clients for the `Minecraft: Bedrock Edition`.
@@ -41,6 +41,6 @@ where
     }
 
     fn camera(&mut self, target: Entity<TargetSelector>) -> camera::Proxy<'_, Self> {
-        camera::Proxy::new(self, target)
+        camera::Proxy::new(self, vec![target.serialize()])
     }
 }

src/minecraft/bedrock_edition/camera.rs

@@ -3,8 +3,7 @@ use std::borrow::Cow;
 pub use color::Color;
 pub use time::Time;
 
-use crate::minecraft::java_edition::TargetSelector;
-use crate::minecraft::{Entity, Error, Serialize};
+use crate::minecraft::{Error, Serialize};
 use crate::RCon;
 
 mod color;
@@ -15,17 +14,18 @@ mod time;
 #[derive(Debug)]
 pub struct Proxy<'client, T> {
     client: &'client mut T,
-    target: Entity<TargetSelector>,
+    args: Vec<Cow<'client, str>>,
 }
 
 impl<'client, T> Proxy<'client, T> {
-    pub(crate) const fn new(client: &'client mut T, target: Entity<TargetSelector>) -> Self {
-        Self { client, target }
+    pub(crate) fn new(client: &'client mut T, args: Vec<Cow<'client, str>>) -> Self {
+        Self { client, args }
     }
 
     /// Return a proxy with available set options.
-    pub fn set<'preset>(self, preset: Cow<'preset, str>) -> set::Proxy<'client, 'preset, T> {
-        set::Proxy::new(self.client, preset)
+    pub fn set(mut self, preset: Cow<'client, str>) -> set::Proxy<'client, T> {
+        self.args.extend([Cow::Borrowed("set"), preset]);
+        set::Proxy::new(self.client, self.args)
     }
 }
 
@@ -34,9 +34,10 @@ where
     T: RCon + Send,
 {
     /// Clear the camera view.
-    pub async fn clear(self) -> Result<String, Error> {
+    pub async fn clear(mut self) -> Result<String, Error> {
+        self.args.push(Cow::Borrowed("clear"));
         self.client
-            .run_utf8(format!("{} clear", self.target.serialize()))
+            .run_utf8(self.args.join(" "))
             .await
             .map_err(Into::into)
     }

src/minecraft/bedrock_edition/camera/set.rs

@@ -1,23 +1,23 @@
-use std::borrow::Cow;
-
-use crate::minecraft::util::EscapeString;
 use crate::minecraft::Error;
 use crate::RCon;
+use std::borrow::Cow;
+
+mod target;
 
 /// Camera actions proxy.
 #[derive(Debug)]
-pub struct Proxy<'client, 'preset, T> {
+pub struct Proxy<'client, T> {
     client: &'client mut T,
-    preset: Cow<'preset, str>,
+    args: Vec<Cow<'client, str>>,
 }
 
-impl<'client, 'preset, T> Proxy<'client, 'preset, T> {
-    pub(crate) const fn new(client: &'client mut T, preset: Cow<'preset, str>) -> Self {
-        Self { client, preset }
+impl<'client, T> Proxy<'client, T> {
+    pub(crate) const fn new(client: &'client mut T, args: Vec<Cow<'client, str>>) -> Self {
+        Self { client, args }
     }
 }
 
-impl<T> Proxy<'_, '_, T>
+impl<T> Proxy<'_, T>
 where
     T: RCon + Send,
 {
@@ -26,15 +26,15 @@ where
     /// TODO: investigate what this actually is. The wiki is quite sparse on this.
     ///
     /// See: <https://minecraft.fandom.com/wiki/Commands/camera>
-    pub async fn default(self, default: Option<Cow<'_, str>>) -> Result<String, Error> {
-        let mut args = vec![Cow::Borrowed("set"), self.preset];
+    pub async fn default(mut self, default: Option<Cow<'_, str>>) -> Result<String, Error> {
+        self.args.push(Cow::Borrowed("default"));
 
         if let Some(default) = default {
-            args.push(default.quote().into());
+            self.args.push(default);
         }
 
         self.client
-            .run_utf8(args.join(" "))
+            .run_utf8(self.args.join(" "))
             .await
             .map_err(Into::into)
     }

src/minecraft/bedrock_edition/camera/set/target.rs

@@ -0,0 +1,11 @@
+use crate::minecraft::java_edition::TargetSelector;
+use crate::minecraft::Entity;
+
+/// Facing target.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Target {
+    /// Facing an entity.
+    Entity(Entity<TargetSelector>),
+    /// Facing a position. Parameters in order are `x`, `y` and `z`.
+    Position(f32, f32, f32),
+}