ModuleManager.h

#pragma once

#include <memory>
#include <vector>
#include <string>
#include <bitset>

#include "ESP.h"


enum ModuleType : uint8_t {
	Combat,
	Movement,
	Player,
	World,
	Render,
	Exploit,
	Misc,
	Client,
};

struct ModuleInfo {
	std::string name;
	ModuleType type;
};

const std::vector<ModuleInfo> module_info
{
	{"Aimbot", Combat},
	{"Auto Clicker", Combat},
	{"Criticals", Combat},
	{"Velocity", Combat},

	{"Fly", Movement},
	{"Inv Move", Movement},
	{"Safe Walk", Movement},
	{"Scaffold", Movement},
	{"Speed", Movement},
	{"Spider", Movement},
	{"Sprint", Movement},
	{"Step", Movement},

	{"Auto Armor", Player},
	{"Auto Swap", Player},
	{"Auto Tool", Player},
	{"Chest Stealer", Player},
	{"Inv Manager", Player},
	{"No Fall", Player},
	{"No Slow", Player},
	{"Timer", Player},

	{"Fast Place", World},

	
	{"ESP", Render},
	{"Fullbright", Render},
	{"Hud", Render},
	{"Target Hud", Render},
	{"True Sight", Render},

	{"Fake Damage", Exploit},

	{"Auto Respawn", Misc},
};

const std::vector<std::string> instant_modules
{
	"Fake Damage",
};

#define MODULE_COUNT 28

class ModuleManager {
public:

	bool modules[MODULE_COUNT]{ false };

	ModuleManager() {

		Reset();
		
		// 测试
		Enable("Auto Clicker");
		Enable("Auto Respawn");
		Enable("Auto Swap");
		Enable("Auto Tool");
		Enable("Sprint");
		Enable("No Fall");
		Enable("Inv Move");
		//Enable("ESP");
		Enable("Fullbright");
		Enable("Hud");
		
		//Enable("Target Hud");
		//Enable("Velocity");
	}

	void Reset() {
		memset(modules, 0, MODULE_COUNT);
	}
	void EnableAll() {
		for (int i = 0; i < MODULE_COUNT; i++) {
			modules[i] = true;
		}
	}

	static std::string GetModuleName(int index) {
		return module_info[index].name;
	}
	static ModuleType GetModuleType(int index) {
		return module_info[index].type;
	}

	bool& ModuleOnRef(int index) {
		return modules[index];
	}
	bool& ModuleOnRef(const std::string& name) {
		for (int i = 0; i < module_info.size(); i++) {
			if (module_info[i].name == name) {
				return ModuleOnRef(i);
			}
		}
		return modules[0];
	}

	bool ModuleOn(int index) const{
		return modules[index];
	}
	bool ModuleOn(const std::string& name)  const {
		for (int i = 0; i < module_info.size(); i++) {
			if (module_info[i].name == name) {
				return ModuleOn(i);
			}
		}
		return false;
	}
	void Enable(int index) {
		modules[index] = true;
	}
	void Enable(const std::string& name) {
		for (int i = 0; i < module_info.size(); i++) {
			if (module_info[i].name == name) {
				Enable(i);
			}
		}
	}
	void Disable(int index) {
		modules[index] = false;
	}
	void Disable(const std::string& name) {
		for (int i = 0; i < module_info.size(); i++) {
			if (module_info[i].name == name) {
				Disable(i);
			}
		}
	}

	bool NeedWorldEntities() const {
		return ModuleOn("ESP") && ESP::target_mode == ESP_ALL;
	}


	std::vector<int> GetEnabledModules() const {
		std::vector<int> enabled_modules;
		for (int i = 0; i < module_info.size(); i++) {
			if (ModuleOn(i)) {
				enabled_modules.push_back(i);
			}
		}
		return enabled_modules;
	}

	size_t GetEnabledModuleCount() const {
		return GetEnabledModules().size();
	}
};

inline std::unique_ptr<ModuleManager> p_modmgr = nullptr;