Feat commander

Phoenix/Client/CMakeLists.txt

@@ -8,8 +8,8 @@ add_subdirectory(Source)
 add_executable(${PROJECT_NAME} ${clientSources} ${clientHeaders})
 target_link_libraries(${PROJECT_NAME} PRIVATE Phoenix)
 
-set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../Quartz/ThirdParty)
-target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/SDL2/include ${dependencies}/../Quartz/Engine/Include ${dependencies}/luamod/include ${dependencies}/imgui/include)
+set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../../Quartz/ThirdParty)
+target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/SDL2/include ${dependencies}/../Engine/Include ${dependencies}/luamod/include ${dependencies}/imgui/include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../Core/Include)
 

Phoenix/Client/Source/main.cpp

@@ -21,10 +21,9 @@ int main(int argc, char* argv[])
     // ===== Compare server mods.txt and local mods.txt, update if needed =====
 
     // ===== Load lua =====
-    voxels::BlockRegistry registry = voxels::BlockRegistry();
-	registry.registerBlock("core:dirt", "Dirt");
-	registry.registerBlock("core:cobble", "CobbleStone");
-	registry.registerBlock("core:stone", "Stone");
+	voxels::BlockRegistry::get()->registerBlock("core:dirt", "Dirt");
+	voxels::BlockRegistry::get()->registerBlock("core:cobble", "CobbleStone");
+	voxels::BlockRegistry::get()->registerBlock("core:stone", "Stone");
 	// TODO: Replace these manual calls to register blocks with a call to run lua files based on what modules need loaded
 
     // ===== Launch renderer outputting to main window =====

Phoenix/Core/CMakeLists.txt

@@ -8,8 +8,8 @@ add_subdirectory(Source)
 add_library(${PROJECT_NAME} STATIC ${phoenixSources} ${phoenixHeaders})
 target_link_libraries(${PROJECT_NAME} PRIVATE QuartzEngine)
 
-set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../Quartz/ThirdParty)
-target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/../Quartz/Engine/Include)
+set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../../Quartz/ThirdParty)
+target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/../Engine/Include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Include)
 
 foreach(FILE ${phoenixSources}) 

Phoenix/Core/Include/Core/Voxels/Blocks.hpp

@@ -28,6 +28,8 @@
 
 #pragma once
 
+#include <Quartz/Utilities/Singleton.hpp>
+
 #include <string>
 #include <vector>
 
@@ -54,21 +56,22 @@ namespace phoenix
 		};
 
 		/// @brief Stores universal block definitions
-		class BlockRegistry
+		class BlockRegistry : public qz::utils::Singleton<BlockRegistry>
 		{
 		private:
 			std::vector<RegisteredBlock> Blocks;
 			int                          i;
 
 		public:
 			BlockRegistry();
-			~BlockRegistry();
 
 			/// @brief Registers a block in the registry
-			int                registerBlock(const std::string& uniqueName,
-			                                 const std::string& displayName);
+			int registerBlock(const std::string& uniqueName,
+			                  const std::string& displayName);
+			/// @brief Get the Display name for a block in the registry
 			const std::string& getDisplayName(int blockId);
-			int                getBlockId(const std::string& uniqueName);
+			/// @brief Get the ID for a block in the registry
+			int getBlockId(const std::string& uniqueName);
 		};
 
 		/// @breif Metadata for a block, this is only created if a block needs

Phoenix/Core/Source/Voxels/Blocks.cpp

@@ -28,8 +28,6 @@
 
 #include <Core/Voxels/Blocks.hpp>
 
-#include <string>
-
 using namespace phoenix::voxels;
 
 RegisteredBlock::RegisteredBlock(const std::string& unique, int id,
@@ -40,13 +38,11 @@ RegisteredBlock::~RegisteredBlock() = default;
 
 BlockRegistry::BlockRegistry() : i(0) {};
 
-BlockRegistry::~BlockRegistry() {};
-
 int BlockRegistry::registerBlock(const std::string& uniqueName,
                                  const std::string& displayName)
 {
 	i++;
-	Blocks[i] = RegisteredBlock(uniqueName, i, displayName);
+	Blocks.push_back(RegisteredBlock(uniqueName, i, displayName));
 	return i;
 };
 

Phoenix/Server/CMakeLists.txt

@@ -8,8 +8,8 @@ add_subdirectory(Source)
 add_executable(${PROJECT_NAME} ${serverSources} ${serverHeaders})
 target_link_libraries(${PROJECT_NAME} PRIVATE Phoenix)
 
-set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../Quartz/ThirdParty)
-target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/SDL2/include ${dependencies}/../Quartz/Engine/Include ${dependencies}/luamod/include ${dependencies}/imgui/include)
+set(dependencies ${CMAKE_CURRENT_LIST_DIR}/../../Quartz/ThirdParty)
+target_include_directories(${PROJECT_NAME} PRIVATE ${dependencies}/SDL2/include ${dependencies}/../Engine/Include ${dependencies}/luamod/include ${dependencies}/imgui/include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Include)
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../Core/Include)
 

Phoenix/Server/Source/main.cpp

@@ -1,5 +1,8 @@
 #include <Core/Voxels/Blocks.hpp>
 #include <Server/Main.hpp>
+
+#include <Quartz/Utilities/Commander.hpp>
+
 #include <iostream>
 #include <stdio.h>
 
@@ -10,29 +13,42 @@ using namespace phoenix;
 int main(int argc, char* argv[])
 {
 
-    // ===== Launch core =====
+// ===== Launch core =====
     // Likely a single command from Quartz that launches the logger + any other critical tools
 
 	// ===== Load Voxel data / Load lua =====
-	voxels::BlockRegistry registry = voxels::BlockRegistry();
-	registry.registerBlock("core:dirt", "Dirt");
-	registry.registerBlock("core:cobble", "CobbleStone");
-	registry.registerBlock("core:stone", "Stone");
+	std::cout << "Program started \n";
+	//voxels::BlockRegistry *registry = registry->get();
+	voxels::BlockRegistry::get()->registerBlock("core:dirt", "Dirt");
+	voxels::BlockRegistry::get()->registerBlock("core:cobble", "CobbleStone");
+	voxels::BlockRegistry::get()->registerBlock("core:stone", "Stone");
 	// TODO: Replace these manual calls to register blocks with a call to run lua files
 
+	std::cout << voxels::BlockRegistry::get()->getDisplayName(1);
+	std::cout << std::to_string(voxels::BlockRegistry::get()->getBlockId("core::dirt"));
+
+	// TODO: Replace these example functions with other, permanent, systems.
+	//qz::utils::CommandBook commandBook = qz::utils::CommandBook();
+
+	qz::utils::CommandBook::get()->add("getBlockName", 
+					"Gets the name of a block based on provided ID number",
+					"all",
+					[](std::vector<std::string>&& args){
+						std::cout << voxels::BlockRegistry::get()->getDisplayName(std::stoi(args[0]));
+					});
+
 	// ===== Load save data =====
 	// Save::Load(argv[0]) //This will detect internally if a new map needs generated based on if save exists
 
-	// ===== Launch network connection listener =====
+// ===== Launch network connection listener =====
 	// std::thread listener (Network::Listener);
 
-	// ===== Enter main loop watching for CLI input =====
-	/*bool run = true;
-	while (run == true){
-		// Listen for CLI instructions
-	}*/
+// ===== Enter main loop watching for CLI input =====
+	qz::utils::Commander kirk = qz::utils::Commander(std::cout, std::cin);
+	kirk.post();
 
 	// ===== Begin shutdown =====
+	std::cout << "Begin Shutdown \n \n";
 
 	// Send signal for listener to terminate
 	// Confirm map has saved

Quartz/Engine/Include/Quartz/Utilities/CMakeLists.txt

@@ -9,6 +9,7 @@ set(utilityHeaders
 	${currentDir}/HandleAllocator.hpp
 	${currentDir}/EnumTools.hpp
 	${currentDir}/Singleton.hpp
+	${currentDir}/Commander.hpp
 	${currentDir}/Plugin.hpp
 
 	PARENT_SCOPE

Quartz/Engine/Include/Quartz/Utilities/Commander.hpp

@@ -0,0 +1,143 @@
+// Copyright 2019 Genten Studios
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors
+// may be used to endorse or promote products derived from this software without
+// specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <Quartz/Utilities/Singleton.hpp>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace qz
+{
+	namespace utils
+	{
+		typedef std::function<void(std::vector<std::string> args)> function;
+
+		/**
+		 * @brief The command book stores commands and information on them to be
+		 * used by a commander
+		 */
+
+		struct CommandBook : public Singleton<CommandBook>
+		{
+			std::vector<std::string> m_command;
+			std::vector<std::string> m_help;
+			std::vector<std::string> m_permission;
+			std::vector<function>    m_functions;
+
+			/**
+			 * @brief Registers a command in the command registry
+			 *
+			 * @param command The keyword for calling the command
+			 * @param permission What permission is required to run this command
+			 */
+			void add(const std::string& command, const std::string& help,
+			         const std::string& permission, function f);
+
+			/**
+			 * @brief Searches for a command
+			 *
+			 * @param command The command to search for
+			 * @return index command is located at or -1 if its not found
+			 */
+			int find(const std::string& command);
+
+			/**
+			 * @brief Gets next open space in book
+			 *
+			 * @return Returns the next open space in arrays as an integer
+			 */
+			int getPage();
+
+		private:
+			/**
+			 * @brief Counter that keep track of next space in the arrays (eg
+			 * next page in the book)
+			 */
+			int m_page;
+		};
+
+		/**
+		 * @brief The Commander handles comand line functions. It accepts an in
+		 * and out stream on creation and can interact with the command line or
+		 * another interface.
+		 *
+		 */
+		class Commander
+		{
+		private:
+			CommandBook*  m_book;
+			std::ostream& m_out;
+			std::istream& m_in;
+
+		public:
+			/**
+			 * @brief Initializes a commander that can run and execute commands
+			 *
+			 * @param book The command book that the commander uses to route
+			 * commands to functions
+			 * @param out An output stream the commander outputs results to
+			 * @param in An input stream the commander accepts input to
+			 */
+			Commander(std::ostream& out, std::istream& in);
+			~Commander();
+
+			/**
+			 * @brief Calls a command
+			 *
+			 * @param command The keyword for calling the command.
+			 * @return Returns True if the function was called and False if the
+			 * function could not be found
+			 */
+			bool run(const std::string&               command,
+			         const std::vector<std::string>&& args);
+
+			/**
+			 * @brief Returns helpstring for command
+			 *
+			 * @param args array of input, args[0] is the command helpstring is
+			 * returned for, all other array values are not used
+			 * @return Returns True if successful and False if it could not find
+			 * the innputted command
+			 */
+			bool help(const std::vector<std::string>&& args);
+
+			/**
+			 * @brief Returns string listing available commands
+			 */
+			void list();
+
+			/**
+			 * @brief Listens for commands.
+			 */
+			void post();
+		};
+	}; // namespace utils
+} // namespace qz

Quartz/Engine/Source/Utilities/CMakeLists.txt

@@ -6,6 +6,7 @@ set(utilitySources
 
 	${currentDir}/Logger.cpp
 	${currentDir}/FileIO.cpp
+	${currentDir}/Commander.cpp
 	${currentDir}/Plugin.cpp
 
 	PARENT_SCOPE