fix transferserver command

Author: codehz

CommandSupport/dllmain.cpp

@@ -43,6 +43,16 @@ template <> typeid_t<CommandRegistry> Mod::CommandSupport::GetParameterTypeId<Co
 template <> typeid_t<CommandRegistry> Mod::CommandSupport::GetParameterTypeId<Json::Value>() {
   return GETID("?id@?1???$type_id@VCommandRegistry@@VValue@Json@@@@YA?AV?$typeid_t@VCommandRegistry@@@@XZ@4V1@A");
 }
+template <> typeid_t<CommandRegistry> Mod::CommandSupport::GetParameterTypeId<CommandSelector<Actor>>() {
+  return GETID(
+      "?id@?1???$type_id@VCommandRegistry@@V?$CommandSelector@VActor@@@@@@YA?AV?$typeid_t@VCommandRegistry@@@@XZ@4V1@"
+      "A");
+}
+template <> typeid_t<CommandRegistry> Mod::CommandSupport::GetParameterTypeId<CommandSelector<Player>>() {
+  return GETID(
+      "?id@?1???$type_id@VCommandRegistry@@V?$CommandSelector@VPlayer@@@@@@YA?AV?$typeid_t@VCommandRegistry@@@@XZ@4V1@"
+      "A");
+}
 
 void dllenter() {}
 void dllexit() {}

Essentials/dllmain.cpp

@@ -2,7 +2,23 @@
 
 // Working in progress
 class TransferCommand : public Command {
-  void execute(CommandOrigin const &, CommandOutput &) { std::wcout << "Executed (WIP)" << std::endl; }
+public:
+  CommandSelector<Player> selector;
+  std::string hostname = "127.0.0.1";
+  int port             = 19132;
+  TransferCommand() { selector.setIncludeDeadPlayers(true); }
+  void execute(CommandOrigin const &origin, CommandOutput &output) {
+    if (port <= 0 || port > 65535) {
+      output.error("commands.transferserver.invalid.port");
+      return;
+    }
+    auto results = selector.results(origin);
+    for (auto &player : results) {
+      TransferPacket pkt{hostname, port};
+      player->sendNetworkPacket(pkt);
+    }
+    output.success("commands.transferserver.successful");
+  }
 };
 
 static struct Settings {
@@ -31,11 +47,15 @@ template <> struct convert<Settings> {
 extern "C" __declspec(dllexport) void ApplySettings(YAML::Node const &node) { yaml_assign(settings, node); }
 
 static void startRegister(CommandRegistry *registry) {
+  using namespace commands;
   if (settings.commands.transferserver) {
     std::string name = "transferserver";
     registry->registerCommand(
-        name, "commands.transferserver.description", CommandPermissionLevel::Normal, CommandFlagNone, CommandFlagNone);
-    registry->registerOverload(name, &CommandRegistry::allocateCommand<TransferCommand>, {});
+        name, "commands.transferserver.description", CommandPermissionLevel::Privileged, CommandFlagNone,
+        CommandFlagNone);
+    registry->registerOverload<TransferCommand>(
+        name, mandatory(&TransferCommand::selector, "target"), mandatory(&TransferCommand::hostname, "hostname"),
+        optional(&TransferCommand::port, "port"));
   }
 }
 

Essentials/pch.h

@@ -6,8 +6,12 @@
 #include <Command/CommandPermissionLevel.h>
 #include <Command/CommandFlag.h>
 #include <Command/CommandParameterData.h>
+#include <Command/CommandOutput.h>
+#include <Actor/ServerPlayer.h>
+#include <Packet/TransferPacket.h>
 #include <iostream>
 #include <yaml-cpp/yaml.h>
 #include <hook.h>
+#include <log.h>
 #include <boost/format.hpp>
 #include <dllentry.h>

MinecraftHeaders/Actor/Actor.h

@@ -0,0 +1,3 @@
+#pragma once
+
+class Actor {};

MinecraftHeaders/Actor/ActorDefinitionIdentifier.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <string>
+#include "../Core/HashedString.h"
+#include "ActorType.h"
+
+class ActorDefinitionIdentifier {
+  std::string ns;             // 0
+  std::string identifier;     // 32
+  std::string event;          // 64
+  std::string fullname;       // 96
+  HashedString canonicalHash; // 128
+
+public:
+  inline HashedString const &getCanonicalHash() const { return canonicalHash; }
+  inline std::string const &getCanonicalName() const { return canonicalHash.getString(); }
+  inline std::string const &getFullName() const { return fullname; }
+  inline std::string const &getIdentifier() const { return identifier; }
+  inline std::string const &getInitEvent() const { return event; }
+  inline std::string const &getNamespace() const { return ns; }
+  inline bool isEmpty() const { return ns.empty() && identifier.empty(); }
+  inline bool isVanilla() const { return ns == "minecraft"; }
+  inline void setIdentifier(std::string const &id) { identifier = id; }
+  inline void setInitEvent(std::string const &e) { event = e; }
+
+  __declspec(dllimport) ActorDefinitionIdentifier(ActorDefinitionIdentifier const &);
+  __declspec(dllimport) ActorDefinitionIdentifier(ActorDefinitionIdentifier &&);
+  __declspec(dllimport) ActorDefinitionIdentifier(std::string, std::string, std::string);
+  __declspec(dllimport) ActorDefinitionIdentifier(std::string const &);
+  __declspec(dllimport) ActorDefinitionIdentifier(ActorType);
+  __declspec(dllimport) ActorDefinitionIdentifier &operator=(ActorDefinitionIdentifier const &);
+  __declspec(dllimport) bool operator==(ActorDefinitionIdentifier const &);
+};

MinecraftHeaders/Actor/ActorType.h

@@ -0,0 +1,3 @@
+#pragma once
+
+enum class ActorType {};

MinecraftHeaders/Actor/Player.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Actor.h"
+#include <hook.h>
+
+class Packet;
+class ServerPlayer;
+
+class Player : public Actor {
+public:
+  inline ServerPlayer *asServerPlayer() const noexcept {
+    return const_cast<ServerPlayer *>(reinterpret_cast<ServerPlayer const *>(this));
+  }
+
+  inline void sendNetworkPacket(Packet &pkt) {
+    CallServerFunction<void>("?sendNetworkPacket@ServerPlayer@@UEBAXAEAVPacket@@@Z", this, &pkt);
+  }
+};

MinecraftHeaders/Actor/ServerPlayer.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "Player.h"
+
+class ServerPlayer : public Player {
+public:
+  // place holder.. all implement in Player.h
+};

MinecraftHeaders/Command/CommandOutput.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "CommandOutputParameter.h"
+
+class CommandOutput {
+public:
+  __declspec(dllimport) void success(std::string const &, std::vector<CommandOutputParameter> const &params = {});
+  __declspec(dllimport) void error(std::string const &, std::vector<CommandOutputParameter> const &params = {});
+  __declspec(dllimport) void addToResultList(std::string const &, Actor const &);
+  template <typename T> void set(char const *name, T value);
+};

MinecraftHeaders/Command/CommandOutputParameter.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "../Core/BlockPos.h"
+
+class Player;
+
+class CommandOutputParameter {
+  std::string str;
+  int type;
+
+public:
+  __declspec(dllimport) CommandOutputParameter(std::string const &);
+  __declspec(dllimport) CommandOutputParameter(int);
+  __declspec(dllimport) CommandOutputParameter(BlockPos);
+  __declspec(dllimport) CommandOutputParameter(std::vector<Player const *> const &);
+  __declspec(dllimport) CommandOutputParameter(std::vector<std::string> const &);
+
+  inline CommandOutputParameter(std::string str, int type) : str(str), type(type) {}
+};

MinecraftHeaders/Command/CommandPosition.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../Core/Vec3.h"
+
+class CommandPosition {
+public:
+  Vec3 vec;
+  bool mx, my, mz, op;
+};

MinecraftHeaders/Command/CommandRegistry.h

@@ -18,7 +18,7 @@ class HardNonTerminal;
 class CommandRegistry {
 public:
 #pragma region struct
-  class ParseToken;
+  struct ParseToken;
   struct Symbol {
     unsigned val;
   };
@@ -62,9 +62,6 @@ class CommandRegistry {
     return true;
   }
 
-  template <typename Type>
-  bool parse(void *, ParseToken const &, CommandOrigin const &, int, std::string &, std::vector<std::string> &) const;
-
   __declspec(dllimport) void registerCommand(
       std::string const &, char const *, CommandPermissionLevel, CommandFlag, CommandFlag);
   __declspec(dllimport) void registerAlias(std::string const &, std::string const &);
@@ -73,6 +70,10 @@ class CommandRegistry {
   __declspec(dllimport) Signature const *findCommand(std::string const &) const;
   __declspec(dllimport) void registerOverloadInternal(Signature &, Overload &);
 
+  template <typename Type>
+  __declspec(dllimport) bool parse(
+      void *, ParseToken const &, CommandOrigin const &, int, std::string &, std::vector<std::string> &) const;
+
   __declspec(dllimport) Symbol addEnumValuesInternal(
       std::string const &, std::vector<std::pair<unsigned long, unsigned long>> const &, typeid_t<CommandRegistry>,
       bool (CommandRegistry::*)(
@@ -87,11 +88,16 @@ class CommandRegistry {
   unsigned addEnumValues(std::string const &, std::vector<std::string> const &);
 
 public:
+  template <typename T> inline static auto getParseFn() { return &CommandRegistry::parse<T>; }
+
   template <typename T> inline static std::unique_ptr<Command> allocateCommand() { return std::make_unique<T>(); }
   inline void registerOverload(
       std::string const &name, Overload::FactoryFn factory, std::initializer_list<CommandParameterData> args) {
     Signature *signature = const_cast<Signature *>(findCommand(name));
     auto &overload       = signature->overloads.emplace_back(CommandVersion{}, factory, args);
     registerOverloadInternal(*signature, overload);
   }
+  template <typename T, typename... Params> inline void registerOverload(std::string const &name, Params... params) {
+    registerOverload(name, &allocateCommand<T>, {params...});
+  }
 };

MinecraftHeaders/Command/CommandSelector.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "CommandSelectorBase.h"
+#include "CommandSelectorResults.h"
+#include <type_traits>
+
+class Player;
+class Actor;
+class CommandOrigin;
+
+template <typename T> class CommandSelector : public CommandSelectorBase {
+public:
+  inline CommandSelector() : CommandSelectorBase(std::is_same_v<T, Player>) {}
+  __declspec(dllimport) CommandSelectorResults<T> results(CommandOrigin const &) const;
+};

MinecraftHeaders/Command/CommandSelectorBase.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+#include <string>
+#include <cstdint>
+#include "../Core/Vec3.h"
+#include "../Core/BlockPos.h"
+#include "CommandPosition.h"
+#include "InvertableFilter.h"
+#include "../Actor/ActorDefinitionIdentifier.h"
+
+class CommandOrigin;
+class Actor;
+class ActorDefinitionIdentifier;
+
+class CommandSelectorBase {
+  uint32_t version;                                                                     // 0
+  uint32_t type;                                                                        // 4
+  uint32_t order;                                                                       // 8
+  std::vector<InvertableFilter<std::string>> namefilters;                               // 16
+  std::vector<InvertableFilter<ActorDefinitionIdentifier>> typefilter2;                 // 40
+  std::vector<InvertableFilter<std::string>> tagfilters;                                // 64
+  std::vector<std::function<bool(CommandOrigin const &, Actor const &)>> customfilters; // 88
+  CommandPosition position;                                                             // 112
+  BlockPos box;                                                                         // 128
+  float radiusMin;                                                                      // 140
+  float radiusMax;                                                                      // 144 = 0x7f7fffff (float max)
+  uint64_t resultCount;                                                                 // 152 = 0xFFFFFFFF
+  bool includeDeadPlayers;                                                              // 160
+  bool flag161;                                                                         // 161
+  bool flag162;                                                                         // 162
+  bool flag163;                                                                         // 163
+  bool playerOnly;                                                                      // 164
+  bool explicitIdSelector;                                                              // 165
+
+public:
+  inline bool isExplicitIdSelector() const { return explicitIdSelector; }
+  inline void addNameFilter(InvertableFilter<std::string> const &filter) { namefilters.emplace_back(filter); }
+  inline void addTagFilter(InvertableFilter<std::string> const &filter) {
+    if (isExplicitIdSelector()) explicitIdSelector = false;
+    tagfilters.emplace_back(filter);
+  }
+  inline void setIncludeDeadPlayers(bool value) { includeDeadPlayers = value; }
+  inline void setResultCount(uint64_t value) { resultCount = value; }
+
+  __declspec(dllimport) void addFilter(std::function<bool(CommandOrigin const &, Actor const &)>);
+  __declspec(dllimport) void addTypeFilter(InvertableFilter<std::string> const &);
+  __declspec(dllimport) CommandSelectorBase();
+  __declspec(dllimport) void setBox(BlockPos);
+  __declspec(dllimport) void setPosition(CommandPosition);
+  __declspec(dllimport) void setRadiusMin(float);
+  __declspec(dllimport) void setRadiusMax(float);
+  __declspec(dllimport) bool compile(CommandOrigin const &, std::string &);
+
+protected:
+  __declspec(dllimport) CommandSelectorBase(bool isPlayer);
+};

MinecraftHeaders/Command/CommandSelectorResults.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+
+template <typename T> class CommandSelectorResults {
+  std::shared_ptr<std::vector<T *>> data;
+
+public:
+  auto begin() { return data->begin(); }
+  auto end() { return data->end(); }
+  auto count() const { return data->size(); }
+  auto empty() const { return data->empty(); }
+};

MinecraftHeaders/Command/InvertableFilter.h

@@ -0,0 +1,6 @@
+#pragma once
+
+template <typename T> struct InvertableFilter {
+  T value;
+  bool inverted;
+};

MinecraftHeaders/Core/BlockPos.h

@@ -0,0 +1,6 @@
+#pragma once
+
+class BlockPos {
+public:
+  int x, y, z;
+};

MinecraftHeaders/Core/HashedString.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+class HashedString {
+  std::string str;
+  uint64_t hash;
+
+public:
+  std::string const &getString() const { return str; }
+
+  __declspec(dllimport) HashedString(HashedString const &rhs);
+  __declspec(dllimport) HashedString(HashedString &&rhs);
+  __declspec(dllimport) HashedString(char const *rhs);
+  __declspec(dllimport) HashedString(std::string const &rhs);
+  __declspec(dllimport) bool operator==(HashedString const &rhs) const;
+  __declspec(dllimport) bool operator!=(HashedString const &rhs) const;
+};