Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 7 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

444 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

442 lines

* In-game Help Menu

* Written by chundo (chundo@mefightclub.com)

* v0.4 Edit by emsit -> Transitional Syntax, added command sm_commands, added command sm_helpmenu_reload, added cvar sm_helpmenu_autoreload, added cvar sm_helpmenu_config_path, added panel/PrintToChat when command does not exist or item value is text

* v0.5 Edit by JoinedSenses -> Additional syntax updating, bug fixes, and an additional CommandExists check for the custom menu handler.

* Licensed under the GPL version 2 or above

#pragma semicolon 1

#pragma newdecls required

#include <sourcemod>

#define PLUGIN_VERSION "0.5"

#define PLUGIN_VERSION "0.4"

enum HelpMenuType {

HelpMenuType_List,

HelpMenuType_Text

}

enum HelpMenu {

String:name[32],

String:title[128],

HelpMenuType:type,

Handle:items,

DataPack:items,

itemct

}

// CVars

ConVar g_cvarWelcome;

ConVar

ConVar g_cvarAdmins;

g_cvarWelcome

ConVar g_cvarRotation;

, g_cvarAdmins

ConVar g_cvarReload;

, g_cvarRotation

ConVar g_cvarConfigPath;

, g_cvarReload

, g_cvarConfigPath;

// Help menus

Handle g_helpMenus = INVALID_HANDLE;

ArrayList g_helpMenus;

// Map cache

Handle g_mapArray = INVALID_HANDLE;

ArrayList g_mapArray;

int g_mapSerial = -1;

// Config parsing

int g_configLevel = -1;

public Plugin myinfo = {

name = "In-game Help Menu",

author = "chundo, emsit",

author = "chundo, emsit, joinedsenses",

description = "Display a help menu to users",

version = PLUGIN_VERSION,

url = "https://forums.alliedmods.net/showthread.php?p=637467"

};

public void OnPluginStart() {

CreateConVar("sm_helpmenu_version", PLUGIN_VERSION, "Help menu version", FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY);

g_cvarWelcome = CreateConVar("sm_helpmenu_welcome", "1", "Show welcome message to newly connected users.", FCVAR_NOTIFY, true, 0.0, true, 1.0);

g_cvarAdmins = CreateConVar("sm_helpmenu_admins", "1", "Show a list of online admins in the menu.", FCVAR_NOTIFY, true, 0.0, true, 1.0);

g_cvarRotation = CreateConVar("sm_helpmenu_rotation", "1", "Shows the map rotation in the menu.", FCVAR_NOTIFY, true, 0.0, true, 1.0);

g_cvarReload = CreateConVar("sm_helpmenu_autoreload", "0", "Automatically reload the configuration file when changing the map.", FCVAR_NOTIFY, true, 0.0, true, 1.0);

g_cvarConfigPath = CreateConVar("sm_helpmenu_config_path", "config/helpmenu.cfg", "Path to configuration file.");

g_cvarConfigPath = CreateConVar("sm_helpmenu_config_path", "configs/helpmenu.cfg", "Path to configuration file.");

RegConsoleCmd("sm_helpmenu", Command_HelpMenu, "Display the help menu.");

RegConsoleCmd("sm_commands", Command_HelpMenu, "Display the help menu.");

RegAdminCmd("sm_helpmenu_reload", Command_HelpMenuReload, ADMFLAG_ROOT, "Reload the configuration file");

char hc[PLATFORM_MAX_PATH];

char buffer[PLATFORM_MAX_PATH];

g_mapArray = CreateArray(32);

g_mapArray = new ArrayList(32);

g_cvarConfigPath.GetString(buffer, sizeof(buffer));

BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);

ParseConfigFile(hc);

AutoExecConfig(false);

}

public void OnMapStart() {

if (g_cvarReload.BoolValue) {

char hc[PLATFORM_MAX_PATH];

char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));

BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);

ParseConfigFile(hc);

}

public void OnClientPostAdminCheck(int client) {

if (g_cvarWelcome.BoolValue) {

CreateTimer(15.0, Timer_WelcomeMessage, client);

}

public Action Timer_WelcomeMessage(Handle timer, any client) {

if (g_cvarWelcome.BoolValue && Client_IsValidHuman(client, true, false, true)) {

PrintToChat(client, "\x05[SM] \x01For help, type \x04!helpmenu\x01 in chat");

}

bool ParseConfigFile(const char[] file) {

if (g_helpMenus != INVALID_HANDLE) {

delete g_helpMenus;

ClearArray(g_helpMenus);

SMCParser parser = new SMCParser();

CloseHandle(g_helpMenus);

parser.OnEnterSection = Config_NewSection;

g_helpMenus = INVALID_HANDLE;

parser.OnLeaveSection = Config_EndSection;

}

parser.OnKeyValue = Config_KeyValue;

parser.OnEnd = Config_End;

Handle parser = SMC_CreateParser();

SMC_SetReaders(parser, Config_NewSection, Config_KeyValue, Config_EndSection);

SMC_SetParseEnd(parser, Config_End);

int line = 0;

int col = 0;

char error[128];

SMCError result = SMC_ParseFile(parser, file, line, col);

SMCError result = parser.ParseFile(file, line, col);

CloseHandle(parser);

if (result != SMCError_Okay) {

SMC_GetErrorString(result, error, sizeof(error));

parser.GetErrorString(result, error, sizeof(error));

LogError("%s on line %d, col %d of %s", error, line, col, file);

}

delete parser;

return (result == SMCError_Okay);

}

public SMCResult Config_NewSection(Handle parser, const char[] section, bool quotes) {

public SMCResult Config_NewSection(SMCParser parser, const char[] section, bool quotes) {

g_configLevel++;

if (g_configLevel == 1) {

int hmenu[HelpMenu];

strcopy(hmenu[name], sizeof(hmenu[name]), section);

hmenu[items] = CreateDataPack();

hmenu[items] = new DataPack();

hmenu[itemct] = 0;

if (g_helpMenus == INVALID_HANDLE) {

if (g_helpMenus == null) {

g_helpMenus = CreateArray(sizeof(hmenu));

g_helpMenus = new ArrayList(sizeof(hmenu));

}

PushArrayArray(g_helpMenus, hmenu[0]);

}

return SMCParse_Continue;

}

public SMCResult Config_KeyValue(Handle parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes) {

public SMCResult Config_KeyValue(SMCParser parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes) {

int msize = GetArraySize(g_helpMenus);

int msize = g_helpMenus.Length;

int hmenu[HelpMenu];

GetArrayArray(g_helpMenus, msize-1, hmenu[0]);

switch (g_configLevel) {

case 1: {

if (strcmp(key, "title", false) == 0)

strcopy(hmenu[title], sizeof(hmenu[title]), value);

if (strcmp(key, "type", false) == 0) {

if (strcmp(value, "text", false) == 0) {

hmenu[type] = HelpMenuType_Text;

} else {

}

else {

hmenu[type] = HelpMenuType_List;

}

case 2: {

WritePackString(hmenu[items], key);

hmenu[items].WriteString(key);

WritePackString(hmenu[items], value);

hmenu[items].WriteString(value);

hmenu[itemct]++;

}

SetArrayArray(g_helpMenus, msize-1, hmenu[0]);

return SMCParse_Continue;

}

public SMCResult Config_EndSection(Handle parser) {

public SMCResult Config_EndSection(SMCParser parser) {

g_configLevel--;

if (g_configLevel == 1) {

int hmenu[HelpMenu];

int msize = GetArraySize(g_helpMenus);

int msize = g_helpMenus.Length;

GetArrayArray(g_helpMenus, msize-1, hmenu[0]);

ResetPack(hmenu[items]);

hmenu[items].Reset();

}

return SMCParse_Continue;

}

public void Config_End(Handle parser, bool halted, bool failed) {

public void Config_End(SMCParser parser, bool halted, bool failed) {

if (failed) {

SetFailState("Plugin configuration error");

}

public Action Command_HelpMenu(int client, int args) {

Help_ShowMainMenu(client);

return Plugin_Handled;

}

public Action Command_HelpMenuReload(int client, int args) {

char hc[PLATFORM_MAX_PATH];

char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));

BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);

ParseConfigFile(hc);

PrintToChat(client, "\x05[SM] \x01Configuration file has been reloaded");

return Plugin_Handled;

}

void Help_ShowMainMenu(int client) {

Menu menu = CreateMenu(Help_MainMenuHandler);

Menu menu = new Menu(Help_MainMenuHandler);

menu.SetTitle("Help Menu");

int msize = GetArraySize(g_helpMenus);

int msize = g_helpMenus.Length;

int hmenu[HelpMenu];

char menuid[10];

for (int i = 0; i < msize; ++i) {

Format(menuid, sizeof(menuid), "helpmenu_%d", i);

GetArrayArray(g_helpMenus, i, hmenu[0]);

menu.AddItem(menuid, hmenu[name]);

}

if (g_cvarRotation.BoolValue) {

menu.AddItem("maplist", "Map Rotation");

}

if (g_cvarAdmins.BoolValue) {

menu.AddItem("admins", "List Online Admins");

}

menu.ExitBackButton = false;

menu.Display(client, MENU_TIME_FOREVER);

}

public int Help_MainMenuHandler(Menu menu, MenuAction action, int param1, int param2) {

int Help_MainMenuHandler(Menu menu, MenuAction action, int param1, int param2) {

switch(action) {

case MenuAction_Select: {

char buf[64];

int msize = GetArraySize(g_helpMenus);

int msize = g_helpMenus.Length;

if (param2 == msize) { // Maps

Menu mapMenu = CreateMenu(Help_MenuHandler);

Menu mapMenu = new Menu(Help_MenuHandler);

mapMenu.ExitBackButton = true;

ReadMapList(g_mapArray, g_mapSerial, "default");

Format(buf, sizeof(buf), "Current Rotation (%d maps)\n ", GetArraySize(g_mapArray));

Format(buf, sizeof(buf), "Current Rotation (%d maps)\n ", g_helpMenus.Length);

mapMenu.SetTitle(buf);

if (g_mapArray != INVALID_HANDLE) {

if (g_mapArray != null) {

int mapct = GetArraySize(g_mapArray);

int mapct = g_helpMenus.Length;

char mapname[64];

for (int i = 0; i < mapct; ++i) {

GetArrayString(g_mapArray, i, mapname, sizeof(mapname));

g_mapArray.GetString(i, mapname, sizeof(mapname));

mapMenu.AddItem(mapname, mapname, ITEMDRAW_DISABLED);

}

mapMenu.Display(param1, MENU_TIME_FOREVER);

} else if (param2 == msize+1) { // Admins

}

Menu adminMenu = CreateMenu(Help_MenuHandler);

else if (param2 == msize+1) { // Admins

Menu adminMenu = new Menu(Help_MenuHandler);

adminMenu.ExitBackButton = true;

adminMenu.SetTitle("Online Admins");

int maxc = GetMaxClients();

char aname[64];

for (int i = 1; i < maxc; ++i) {

if (Client_IsValidHuman(i, true, false, true) && (GetUserFlagBits(i)) == ADMFLAG_ROOT){

GetClientName(i, aname, sizeof(aname));

adminMenu.AddItem(aname, aname, ITEMDRAW_DISABLED);

}

adminMenu.Display(param1, MENU_TIME_FOREVER);

} else { // Menu from config file

}

else { // Menu from config file

if (param2 <= msize) {

int hmenu[HelpMenu];

GetArrayArray(g_helpMenus, param2, hmenu[0]);

char mtitle[512];

Format(mtitle, sizeof(mtitle), "%s\n ", hmenu[title]);

if (hmenu[type] == HelpMenuType_Text) {

Panel cpanel = CreatePanel();

cpanel.SetTitle(mtitle);

char text[128];

char junk[128];

for (int i = 0; i < hmenu[itemct]; ++i) {

ReadPackString(hmenu[items], junk, sizeof(junk));

hmenu[items].ReadString(junk, sizeof(junk));

ReadPackString(hmenu[items], text, sizeof(text));

hmenu[items].ReadString(text, sizeof(text));

cpanel.DrawText(text);

}

for (int j = 0; j < 7; ++j) {

cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);

}

cpanel.DrawText(" ");

cpanel.DrawItem("Back", ITEMDRAW_CONTROL);

cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);

cpanel.DrawText(" ");

cpanel.DrawItem("Exit", ITEMDRAW_CONTROL);

ResetPack(hmenu[items]);

hmenu[items].Reset();

cpanel.Send(param1, Help_MenuHandler, MENU_TIME_FOREVER);

delete cpanel;

} else {

}

Menu cmenu = CreateMenu(Help_CustomMenuHandler);

else {

Menu cmenu = new Menu(Help_CustomMenuHandler);

cmenu.ExitBackButton = true;

cmenu.SetTitle(mtitle);

char cmd[128];

char desc[128];

for (int i = 0; i < hmenu[itemct]; ++i) {

ReadPackString(hmenu[items], cmd, sizeof(cmd));

hmenu[items].ReadString(cmd, sizeof(cmd));

ReadPackString(hmenu[items], desc, sizeof(desc));

hmenu[items].ReadString(desc, sizeof(desc));

int drawstyle = ITEMDRAW_DEFAULT;

if (strlen(cmd) == 0) {

drawstyle = ITEMDRAW_DISABLED;

}

cmenu.AddItem(cmd, desc, drawstyle);

}

ResetPack(hmenu[items]);

hmenu[items].Reset();

cmenu.Display(param1, MENU_TIME_FOREVER);

}

//case MenuAction_Cancel: {

// if (param2 == MenuCancel_ExitBack) {

// Help_ShowMainMenu(param1);

// }

//}

case MenuAction_End: {

delete menu;

}

public int Help_MenuHandler(Menu menu, MenuAction action, int param1, int param2) {

int Help_MenuHandler(Menu menu, MenuAction action, int param1, int param2) {

switch(action) {

case MenuAction_Select: {

if (menu == null && param2 == 8) {

Help_ShowMainMenu(param1);

}

case MenuAction_Cancel: {

if (param2 == MenuCancel_ExitBack) {

Help_ShowMainMenu(param1);

}

case MenuAction_End: {

delete menu;

}

public int Help_CustomMenuHandler(Menu menu, MenuAction action, int param1, int param2) {

int Help_CustomMenuHandler(Menu menu, MenuAction action, int param1, int param2) {

switch(action) {

case MenuAction_Select: {

char itemval[128];

menu.GetItem(param2, itemval, sizeof(itemval));

if (strlen(itemval) > 0) {

char command[64];

SplitString(itemval, " ", command, sizeof(command));

if (CommandExist(command, sizeof(command))) {

if (CommandExist(command, sizeof(command)) || CommandExist(itemval, sizeof(itemval))) {

FakeClientCommand(param1, itemval);

} else {

}

else {

Panel panel = CreatePanel();

panel.SetTitle("Description\n ");

panel.DrawText(itemval);

for (int j = 0; j < 7; ++j) {

panel.DrawItem(" ", ITEMDRAW_NOTEXT);

}

panel.DrawText(" ");

panel.DrawItem("Back", ITEMDRAW_CONTROL);

panel.DrawItem(" ", ITEMDRAW_NOTEXT);

panel.DrawText(" ");

panel.DrawItem("Exit", ITEMDRAW_CONTROL);

panel.Send(param1, Help_MenuHandler, MENU_TIME_FOREVER);

delete panel;

PrintToChat(param1, "\x05[SM] \x01%s", itemval);

}

case MenuAction_Cancel: {

if (param2 == MenuCancel_ExitBack) {

Help_ShowMainMenu(param1);

}

case MenuAction_End: {

delete menu;

}

stock bool Client_IsValidHuman(int client, bool connected = true, bool nobots = true, bool InGame = false) {

bool Client_IsValidHuman(int client, bool connected = true, bool nobots = true, bool InGame = false) {

if (!Client_IsValid(client, connected)) {

return false;

}

if (nobots && IsFakeClient(client)) {

return false;

}

if (InGame) {

return IsClientInGame(client);

}

return true;

}

stock bool Client_IsValid(int client, bool checkConnected = true) {

bool Client_IsValid(int client, bool checkConnected = true) {

if (client > 4096) {

client = EntRefToEntIndex(client);

}

if (client < 1 || client > MaxClients) {

return false;

}

if (checkConnected && !IsClientConnected(client)) {

return false;

}

return true;

}

stock bool CommandExist(char[] command, int commandLen) {

//remove the character '!' from the beginning of the command

if (command[0] == '!') {

strcopy(command, commandLen, command[1]);

}

if (CommandExists(command)) {

return true;

}

//if the command does not exist and has a prefix 'sm_'

if (!strncmp(command, "sm_", 3)) {

return false;

}

//add the prefix 'sm_' to the beginning of the command

Format(command, commandLen, "sm_%s", command);

if (CommandExists(command)) {

return true;

}

return false;

}

Saved diffs

Original text

Open file

/*
 * In-game Help Menu
 * Written by chundo (chundo@mefightclub.com)
 * v0.4 Edit by emsit -> Transitional Syntax, added command sm_commands, added command sm_helpmenu_reload, added cvar sm_helpmenu_autoreload, added cvar sm_helpmenu_config_path, added panel/PrintToChat when command does not exist or item value is text
 *
 * Licensed under the GPL version 2 or above
 */

#pragma semicolon 1
#pragma newdecls required

#include <sourcemod>

#define PLUGIN_VERSION "0.4"

enum HelpMenuType {
	HelpMenuType_List,
	HelpMenuType_Text
}

enum HelpMenu {
	String:name[32],
	String:title[128],
	HelpMenuType:type,
	Handle:items,
	itemct
}

// CVars
ConVar g_cvarWelcome;
ConVar g_cvarAdmins;
ConVar g_cvarRotation;
ConVar g_cvarReload;
ConVar g_cvarConfigPath;

// Help menus
Handle g_helpMenus = INVALID_HANDLE;

// Map cache
Handle g_mapArray = INVALID_HANDLE;
int g_mapSerial = -1;

// Config parsing
int g_configLevel = -1;

public Plugin myinfo = {
	name = "In-game Help Menu",
	author = "chundo, emsit",
	description = "Display a help menu to users",
	version = PLUGIN_VERSION,
	url = "https://forums.alliedmods.net/showthread.php?p=637467"
};

public void OnPluginStart() {
	CreateConVar("sm_helpmenu_version", PLUGIN_VERSION, "Help menu version", FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY);
	g_cvarWelcome = CreateConVar("sm_helpmenu_welcome", "1", "Show welcome message to newly connected users.", FCVAR_NOTIFY, true, 0.0, true, 1.0);
	g_cvarAdmins = CreateConVar("sm_helpmenu_admins", "1", "Show a list of online admins in the menu.", FCVAR_NOTIFY, true, 0.0, true, 1.0);
	g_cvarRotation = CreateConVar("sm_helpmenu_rotation", "1", "Shows the map rotation in the menu.", FCVAR_NOTIFY, true, 0.0, true, 1.0);
	g_cvarReload = CreateConVar("sm_helpmenu_autoreload", "0", "Automatically reload the configuration file when changing the map.", FCVAR_NOTIFY, true, 0.0, true, 1.0);
	g_cvarConfigPath = CreateConVar("sm_helpmenu_config_path", "config/helpmenu.cfg", "Path to configuration file.");

RegConsoleCmd("sm_helpmenu", Command_HelpMenu, "Display the help menu.");
	RegConsoleCmd("sm_commands", Command_HelpMenu, "Display the help menu.");
	RegAdminCmd("sm_helpmenu_reload", Command_HelpMenuReload, ADMFLAG_ROOT, "Reload the configuration file");

char hc[PLATFORM_MAX_PATH];
	char buffer[PLATFORM_MAX_PATH];
	g_mapArray = CreateArray(32);

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
	BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
	ParseConfigFile(hc);

AutoExecConfig(false);
}

public void OnMapStart() {
	if (g_cvarReload.BoolValue) {
		char hc[PLATFORM_MAX_PATH];
		char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
		BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
		ParseConfigFile(hc);
	}
}

public void OnClientPostAdminCheck(int client) {
	if (g_cvarWelcome.BoolValue) {
		CreateTimer(15.0, Timer_WelcomeMessage, client);
	}
}

public Action Timer_WelcomeMessage(Handle timer, any client) {
	if (g_cvarWelcome.BoolValue && Client_IsValidHuman(client, true, false, true)) {
		PrintToChat(client, "\x05[SM] \x01For help, type \x04!helpmenu\x01 in chat");
	}
}

bool ParseConfigFile(const char[] file) {
	if (g_helpMenus != INVALID_HANDLE) {
		ClearArray(g_helpMenus);
		CloseHandle(g_helpMenus);
		g_helpMenus = INVALID_HANDLE;
	}

Handle parser = SMC_CreateParser();
	SMC_SetReaders(parser, Config_NewSection, Config_KeyValue, Config_EndSection);
	SMC_SetParseEnd(parser, Config_End);

int line = 0;
	int col = 0;
	char error[128];
	SMCError result = SMC_ParseFile(parser, file, line, col);
	CloseHandle(parser);

if (result != SMCError_Okay) {
		SMC_GetErrorString(result, error, sizeof(error));
		LogError("%s on line %d, col %d of %s", error, line, col, file);
	}

return (result == SMCError_Okay);
}

public SMCResult Config_NewSection(Handle parser, const char[] section, bool quotes) {
	g_configLevel++;
	if (g_configLevel == 1) {
		int hmenu[HelpMenu];
		strcopy(hmenu[name], sizeof(hmenu[name]), section);
		hmenu[items] = CreateDataPack();
		hmenu[itemct] = 0;
		if (g_helpMenus == INVALID_HANDLE) {
			g_helpMenus = CreateArray(sizeof(hmenu));
		}
		PushArrayArray(g_helpMenus, hmenu[0]);
	}

return SMCParse_Continue;
}

public SMCResult Config_KeyValue(Handle parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes) {
	int msize = GetArraySize(g_helpMenus);
	int hmenu[HelpMenu];
	GetArrayArray(g_helpMenus, msize-1, hmenu[0]);
	switch (g_configLevel) {
		case 1: {
			if (strcmp(key, "title", false) == 0)
				strcopy(hmenu[title], sizeof(hmenu[title]), value);
			if (strcmp(key, "type", false) == 0) {
				if (strcmp(value, "text", false) == 0) {
					hmenu[type] = HelpMenuType_Text;
				} else {
					hmenu[type] = HelpMenuType_List;
				}
			}
		}
		case 2: {
			WritePackString(hmenu[items], key);
			WritePackString(hmenu[items], value);
			hmenu[itemct]++;
		}
	}
	SetArrayArray(g_helpMenus, msize-1, hmenu[0]);

return SMCParse_Continue;
}
public SMCResult Config_EndSection(Handle parser) {
	g_configLevel--;
	if (g_configLevel == 1) {
		int hmenu[HelpMenu];
		int msize = GetArraySize(g_helpMenus);
		GetArrayArray(g_helpMenus, msize-1, hmenu[0]);
		ResetPack(hmenu[items]);
	}

return SMCParse_Continue;
}

public void Config_End(Handle parser, bool halted, bool failed) {
	if (failed) {
		SetFailState("Plugin configuration error");
	}
}

public Action Command_HelpMenu(int client, int args) {
	Help_ShowMainMenu(client);

return Plugin_Handled;
}

public Action Command_HelpMenuReload(int client, int args) {
	char hc[PLATFORM_MAX_PATH];
	char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
	BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
	ParseConfigFile(hc);

PrintToChat(client, "\x05[SM] \x01Configuration file has been reloaded");

return Plugin_Handled;
}

void Help_ShowMainMenu(int client) {
	Menu menu = CreateMenu(Help_MainMenuHandler);
	menu.SetTitle("Help Menu");

int msize = GetArraySize(g_helpMenus);
	int hmenu[HelpMenu];
	char menuid[10];

for (int i = 0; i < msize; ++i) {
		Format(menuid, sizeof(menuid), "helpmenu_%d", i);
		GetArrayArray(g_helpMenus, i, hmenu[0]);
		menu.AddItem(menuid, hmenu[name]);
	}

if (g_cvarRotation.BoolValue) {
		menu.AddItem("maplist", "Map Rotation");
	}
	if (g_cvarAdmins.BoolValue) {
		menu.AddItem("admins", "List Online Admins");
	}

menu.ExitBackButton = false;
	menu.Display(client, MENU_TIME_FOREVER);
}

public int Help_MainMenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			char buf[64];
			int msize = GetArraySize(g_helpMenus);
			if (param2 == msize) { // Maps
				Menu mapMenu = CreateMenu(Help_MenuHandler);
				mapMenu.ExitBackButton = true;
				ReadMapList(g_mapArray, g_mapSerial, "default");
				Format(buf, sizeof(buf), "Current Rotation (%d maps)\n ", GetArraySize(g_mapArray));
				mapMenu.SetTitle(buf);

if (g_mapArray != INVALID_HANDLE) {
					int mapct = GetArraySize(g_mapArray);
					char mapname[64];
					for (int i = 0; i < mapct; ++i) {
						GetArrayString(g_mapArray, i, mapname, sizeof(mapname));
						mapMenu.AddItem(mapname, mapname, ITEMDRAW_DISABLED);
					}
				}
				mapMenu.Display(param1, MENU_TIME_FOREVER);
			} else if (param2 == msize+1) { // Admins
				Menu adminMenu = CreateMenu(Help_MenuHandler);
				adminMenu.ExitBackButton = true;
				adminMenu.SetTitle("Online Admins");
				int maxc = GetMaxClients();
				char aname[64];

for (int i = 1; i < maxc; ++i) {
					if (Client_IsValidHuman(i, true, false, true) && (GetUserFlagBits(i)) == ADMFLAG_ROOT){
						GetClientName(i, aname, sizeof(aname));
						adminMenu.AddItem(aname, aname, ITEMDRAW_DISABLED);
					}
				}
				adminMenu.Display(param1, MENU_TIME_FOREVER);
			} else { // Menu from config file
				if (param2 <= msize) {
					int hmenu[HelpMenu];
					GetArrayArray(g_helpMenus, param2, hmenu[0]);
					char mtitle[512];
					Format(mtitle, sizeof(mtitle), "%s\n ", hmenu[title]);
					if (hmenu[type] == HelpMenuType_Text) {
						Panel cpanel = CreatePanel();
						cpanel.SetTitle(mtitle);
						char text[128];
						char junk[128];

for (int i = 0; i < hmenu[itemct]; ++i) {
							ReadPackString(hmenu[items], junk, sizeof(junk));
							ReadPackString(hmenu[items], text, sizeof(text));
							cpanel.DrawText(text);
						}
						for (int j = 0; j < 7; ++j) {
							cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);
						}

cpanel.DrawText(" ");
						cpanel.DrawItem("Back", ITEMDRAW_CONTROL);
						cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);
						cpanel.DrawText(" ");
						cpanel.DrawItem("Exit", ITEMDRAW_CONTROL);
						ResetPack(hmenu[items]);
						cpanel.Send(param1, Help_MenuHandler, MENU_TIME_FOREVER);
						delete cpanel;
					} else {
						Menu cmenu = CreateMenu(Help_CustomMenuHandler);
						cmenu.ExitBackButton = true;
						cmenu.SetTitle(mtitle);
						char cmd[128];
						char desc[128];

for (int i = 0; i < hmenu[itemct]; ++i) {
							ReadPackString(hmenu[items], cmd, sizeof(cmd));
							ReadPackString(hmenu[items], desc, sizeof(desc));
							int drawstyle = ITEMDRAW_DEFAULT;
							if (strlen(cmd) == 0) {
								drawstyle = ITEMDRAW_DISABLED;
							}
							cmenu.AddItem(cmd, desc, drawstyle);
						}

ResetPack(hmenu[items]);
						cmenu.Display(param1, MENU_TIME_FOREVER);
					}
				}
			}
		}
		//case MenuAction_Cancel: {
		//	if (param2 == MenuCancel_ExitBack) {
		//		Help_ShowMainMenu(param1);
		//	}
		//}
		case MenuAction_End: {
			delete menu;
		}
	}
}

public int Help_MenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			if (menu == null && param2 == 8) {
				Help_ShowMainMenu(param1);
			}
		}
		case MenuAction_Cancel: {
			if (param2 == MenuCancel_ExitBack) {
				Help_ShowMainMenu(param1);
			}
		}
		case MenuAction_End: {
			delete menu;
		}
	}
}

public int Help_CustomMenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			char itemval[128];
			menu.GetItem(param2, itemval, sizeof(itemval));
			if (strlen(itemval) > 0) {
				char command[64];
				SplitString(itemval, " ", command, sizeof(command));

if (CommandExist(command, sizeof(command))) {
					FakeClientCommand(param1, itemval);
				} else {
					Panel panel = CreatePanel();
					panel.SetTitle("Description\n ");

panel.DrawText(itemval);

for (int j = 0; j < 7; ++j) {
						panel.DrawItem(" ", ITEMDRAW_NOTEXT);
					}

panel.DrawText(" ");
					panel.DrawItem("Back", ITEMDRAW_CONTROL);
					panel.DrawItem(" ", ITEMDRAW_NOTEXT);
					panel.DrawText(" ");
					panel.DrawItem("Exit", ITEMDRAW_CONTROL);
					panel.Send(param1, Help_MenuHandler, MENU_TIME_FOREVER);
					delete panel;

PrintToChat(param1, "\x05[SM] \x01%s", itemval);
				}
			}
		}
		case MenuAction_Cancel: {
			if (param2 == MenuCancel_ExitBack) {
				Help_ShowMainMenu(param1);
			}
		}
		case MenuAction_End: {
			delete menu;
		}
	}
}

stock bool Client_IsValidHuman(int client, bool connected = true, bool nobots = true, bool InGame = false) {
	if (!Client_IsValid(client, connected)) {
		return false;
	}

if (nobots && IsFakeClient(client)) {
		return false;
	}

if (InGame) {
		return IsClientInGame(client);
	}

return true;
}

stock bool Client_IsValid(int client, bool checkConnected = true) {
	if (client > 4096) {
		client = EntRefToEntIndex(client);
	}

if (client < 1 || client > MaxClients) {
		return false;
	}

if (checkConnected && !IsClientConnected(client)) {
		return false;
	}

return true;
}

stock bool CommandExist(char[] command, int commandLen) {
	//remove the character '!' from the beginning of the command
	if (command[0] == '!') {
		strcopy(command, commandLen, command[1]);
	}

if (CommandExists(command)) {
		return true;
	}

//if the command does not exist and has a prefix 'sm_'
	if (!strncmp(command, "sm_", 3)) {
		return false;
	}

//add the prefix 'sm_' to the beginning of the command
	Format(command, commandLen, "sm_%s", command);
	if (CommandExists(command)) {
		return true;
	}

return false;
}

Changed text

Open file

#pragma semicolon 1
#pragma newdecls required
#include <sourcemod>
#define PLUGIN_VERSION "0.5"

enum HelpMenuType {
	HelpMenuType_List,
	HelpMenuType_Text
}

enum HelpMenu {
	String:name[32],
	String:title[128],
	HelpMenuType:type,
	DataPack:items,
	itemct
}

// CVars
ConVar
	g_cvarWelcome
	, g_cvarAdmins
	, g_cvarRotation
	, g_cvarReload
	, g_cvarConfigPath;

// Help menus
ArrayList g_helpMenus;

// Map cache
ArrayList g_mapArray;
int g_mapSerial = -1;

// Config parsing
int g_configLevel = -1;

public Plugin myinfo = {
	name = "In-game Help Menu",
	author = "chundo, emsit, joinedsenses",
	description = "Display a help menu to users",
	version = PLUGIN_VERSION,
	url = "https://forums.alliedmods.net/showthread.php?p=637467"
};

char hc[PLATFORM_MAX_PATH];
	char buffer[PLATFORM_MAX_PATH];
	g_mapArray = new ArrayList(32);

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
	BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
	ParseConfigFile(hc);

AutoExecConfig(false);
}

public void OnMapStart() {
	if (g_cvarReload.BoolValue) {
		char hc[PLATFORM_MAX_PATH];
		char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
		BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
		ParseConfigFile(hc);
	}
}

public void OnClientPostAdminCheck(int client) {
	if (g_cvarWelcome.BoolValue) {
		CreateTimer(15.0, Timer_WelcomeMessage, client);
	}
}

bool ParseConfigFile(const char[] file) {
	delete g_helpMenus;
	SMCParser parser = new SMCParser();
	parser.OnEnterSection = Config_NewSection;
	parser.OnLeaveSection = Config_EndSection;
	parser.OnKeyValue = Config_KeyValue;
	parser.OnEnd = Config_End;

int line = 0;
	int col = 0;
	char error[128];
	SMCError result = parser.ParseFile(file, line, col);
	if (result != SMCError_Okay) {
		parser.GetErrorString(result, error, sizeof(error));
		LogError("%s on line %d, col %d of %s", error, line, col, file);
	}
	delete parser;
	return (result == SMCError_Okay);
}

public SMCResult Config_NewSection(SMCParser parser, const char[] section, bool quotes) {
	g_configLevel++;
	if (g_configLevel == 1) {
		int hmenu[HelpMenu];
		strcopy(hmenu[name], sizeof(hmenu[name]), section);
		hmenu[items] = new DataPack();
		hmenu[itemct] = 0;
		if (g_helpMenus == null) {
			g_helpMenus = new ArrayList(sizeof(hmenu));
		}
		PushArrayArray(g_helpMenus, hmenu[0]);
	}

return SMCParse_Continue;
}

public SMCResult Config_KeyValue(SMCParser parser, const char[] key, const char[] value, bool key_quotes, bool value_quotes) {
	int msize = g_helpMenus.Length;
	int hmenu[HelpMenu];
	GetArrayArray(g_helpMenus, msize-1, hmenu[0]);
	switch (g_configLevel) {
		case 1: {
			if (strcmp(key, "title", false) == 0)
				strcopy(hmenu[title], sizeof(hmenu[title]), value);
			if (strcmp(key, "type", false) == 0) {
				if (strcmp(value, "text", false) == 0) {
					hmenu[type] = HelpMenuType_Text;
				}
				else {
					hmenu[type] = HelpMenuType_List;
				}
			}
		}
		case 2: {
			hmenu[items].WriteString(key);
			hmenu[items].WriteString(value);
			hmenu[itemct]++;
		}
	}
	SetArrayArray(g_helpMenus, msize-1, hmenu[0]);

return SMCParse_Continue;
}
public SMCResult Config_EndSection(SMCParser parser) {
	g_configLevel--;
	if (g_configLevel == 1) {
		int hmenu[HelpMenu];
		int msize = g_helpMenus.Length;
		GetArrayArray(g_helpMenus, msize-1, hmenu[0]);
		hmenu[items].Reset();
	}

return SMCParse_Continue;
}

public void Config_End(SMCParser parser, bool halted, bool failed) {
	if (failed) {
		SetFailState("Plugin configuration error");
	}
}

public Action Command_HelpMenu(int client, int args) {
	Help_ShowMainMenu(client);
	return Plugin_Handled;
}

public Action Command_HelpMenuReload(int client, int args) {
	char hc[PLATFORM_MAX_PATH];
	char buffer[PLATFORM_MAX_PATH];

g_cvarConfigPath.GetString(buffer, sizeof(buffer));
	BuildPath(Path_SM, hc, sizeof(hc), "%s", buffer);
	ParseConfigFile(hc);

PrintToChat(client, "\x05[SM] \x01Configuration file has been reloaded");

return Plugin_Handled;
}

void Help_ShowMainMenu(int client) {
	Menu menu = new Menu(Help_MainMenuHandler);
	menu.SetTitle("Help Menu");

int msize = g_helpMenus.Length;
	int hmenu[HelpMenu];
	char menuid[10];

for (int i = 0; i < msize; ++i) {
		Format(menuid, sizeof(menuid), "helpmenu_%d", i);
		GetArrayArray(g_helpMenus, i, hmenu[0]);
		menu.AddItem(menuid, hmenu[name]);
	}

if (g_cvarRotation.BoolValue) {
		menu.AddItem("maplist", "Map Rotation");
	}
	if (g_cvarAdmins.BoolValue) {
		menu.AddItem("admins", "List Online Admins");
	}

menu.ExitBackButton = false;
	menu.Display(client, MENU_TIME_FOREVER);
}

int Help_MainMenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			char buf[64];
			int msize = g_helpMenus.Length;
			if (param2 == msize) { // Maps
				Menu mapMenu = new Menu(Help_MenuHandler);
				mapMenu.ExitBackButton = true;
				ReadMapList(g_mapArray, g_mapSerial, "default");
				Format(buf, sizeof(buf), "Current Rotation (%d maps)\n ", g_helpMenus.Length);
				mapMenu.SetTitle(buf);

if (g_mapArray != null) {
					int mapct = g_helpMenus.Length;
					char mapname[64];
					for (int i = 0; i < mapct; ++i) {
						g_mapArray.GetString(i, mapname, sizeof(mapname));
						mapMenu.AddItem(mapname, mapname, ITEMDRAW_DISABLED);
					}
				}
				mapMenu.Display(param1, MENU_TIME_FOREVER);
			}
			else if (param2 == msize+1) { // Admins
				Menu adminMenu = new Menu(Help_MenuHandler);
				adminMenu.ExitBackButton = true;
				adminMenu.SetTitle("Online Admins");
				int maxc = GetMaxClients();
				char aname[64];

for (int i = 1; i < maxc; ++i) {
					if (Client_IsValidHuman(i, true, false, true) && (GetUserFlagBits(i)) == ADMFLAG_ROOT){
						GetClientName(i, aname, sizeof(aname));
						adminMenu.AddItem(aname, aname, ITEMDRAW_DISABLED);
					}
				}
				adminMenu.Display(param1, MENU_TIME_FOREVER);
			}
			else { // Menu from config file
				if (param2 <= msize) {
					int hmenu[HelpMenu];
					GetArrayArray(g_helpMenus, param2, hmenu[0]);
					char mtitle[512];
					Format(mtitle, sizeof(mtitle), "%s\n ", hmenu[title]);
					if (hmenu[type] == HelpMenuType_Text) {
						Panel cpanel = CreatePanel();
						cpanel.SetTitle(mtitle);
						char text[128];
						char junk[128];

for (int i = 0; i < hmenu[itemct]; ++i) {
							hmenu[items].ReadString(junk, sizeof(junk));
							hmenu[items].ReadString(text, sizeof(text));
							cpanel.DrawText(text);
						}
						for (int j = 0; j < 7; ++j) {
							cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);
						}

cpanel.DrawText(" ");
						cpanel.DrawItem("Back", ITEMDRAW_CONTROL);
						cpanel.DrawItem(" ", ITEMDRAW_NOTEXT);
						cpanel.DrawText(" ");
						cpanel.DrawItem("Exit", ITEMDRAW_CONTROL);
						hmenu[items].Reset();
						cpanel.Send(param1, Help_MenuHandler, MENU_TIME_FOREVER);
						delete cpanel;
					}
					else {
						Menu cmenu = new Menu(Help_CustomMenuHandler);
						cmenu.ExitBackButton = true;
						cmenu.SetTitle(mtitle);
						char cmd[128];
						char desc[128];

for (int i = 0; i < hmenu[itemct]; ++i) {
							hmenu[items].ReadString(cmd, sizeof(cmd));
							hmenu[items].ReadString(desc, sizeof(desc));
							int drawstyle = ITEMDRAW_DEFAULT;
							if (strlen(cmd) == 0) {
								drawstyle = ITEMDRAW_DISABLED;
							}
							cmenu.AddItem(cmd, desc, drawstyle);
						}

hmenu[items].Reset();
						cmenu.Display(param1, MENU_TIME_FOREVER);
					}
				}
			}
		}
		//case MenuAction_Cancel: {
		//	if (param2 == MenuCancel_ExitBack) {
		//		Help_ShowMainMenu(param1);
		//	}
		//}
		case MenuAction_End: {
			delete menu;
		}
	}
}

int Help_MenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			if (menu == null && param2 == 8) {
				Help_ShowMainMenu(param1);
			}
		}
		case MenuAction_Cancel: {
			if (param2 == MenuCancel_ExitBack) {
				Help_ShowMainMenu(param1);
			}
		}
		case MenuAction_End: {
			delete menu;
		}
	}
}

int Help_CustomMenuHandler(Menu menu, MenuAction action, int param1, int param2) {
	switch(action) {
		case MenuAction_Select: {
			char itemval[128];
			menu.GetItem(param2, itemval, sizeof(itemval));
			if (strlen(itemval) > 0) {
				char command[64];
				SplitString(itemval, " ", command, sizeof(command));

if (CommandExist(command, sizeof(command)) || CommandExist(itemval, sizeof(itemval))) {
					FakeClientCommand(param1, itemval);
				}
				else {
					Panel panel = CreatePanel();
					panel.SetTitle("Description\n ");

panel.DrawText(itemval);

for (int j = 0; j < 7; ++j) {
						panel.DrawItem(" ", ITEMDRAW_NOTEXT);
					}

bool Client_IsValidHuman(int client, bool connected = true, bool nobots = true, bool InGame = false) {
	if (!Client_IsValid(client, connected)) {
		return false;
	}

if (nobots && IsFakeClient(client)) {
		return false;
	}

if (InGame) {
		return IsClientInGame(client);
	}

return true;
}

bool Client_IsValid(int client, bool checkConnected = true) {
	if (client > 4096) {
		client = EntRefToEntIndex(client);
	}

if (client < 1 || client > MaxClients) {
		return false;
	}

if (checkConnected && !IsClientConnected(client)) {
		return false;
	}

return true;
}

stock bool CommandExist(char[] command, int commandLen) {
	//remove the character '!' from the beginning of the command
	if (command[0] == '!') {
		strcopy(command, commandLen, command[1]);
	}

if (CommandExists(command)) {
		return true;
	}

//if the command does not exist and has a prefix 'sm_'
	if (!strncmp(command, "sm_", 3)) {
		return false;
	}

//add the prefix 'sm_' to the beginning of the command
	Format(command, commandLen, "sm_%s", command);
	if (CommandExists(command)) {
		return true;
	}

return false;
}