Esempio n. 1
0
static cell_t sm_GetClientName(IPluginContext *pCtx, const cell_t *params)
{
    int index = params[1];

    if (index == 0)
    {
        static ConVar *hostname = NULL;
        if (!hostname)
        {
            hostname = bridge->FindConVar("hostname");
            if (!hostname)
            {
                return pCtx->ThrowNativeError("Could not find \"hostname\" cvar");
            }
        }
        pCtx->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), bridge->GetCvarString(hostname), NULL);
        return 1;
    }

    if ((index < 1) || (index > playerhelpers->GetMaxClients()))
    {
        return pCtx->ThrowNativeError("Client index %d is invalid", index);
    }

    IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(index);
    if (!pPlayer->IsConnected())
    {
        return pCtx->ThrowNativeError("Client %d is not connected", index);
    }

    pCtx->StringToLocalUTF8(params[2], static_cast<size_t>(params[3]), pPlayer->GetName(), NULL);
    return 1;
}
void PlayerManager::ProcessCommandTarget(cmd_target_info_t *info)
{
	CPlayer *pTarget, *pAdmin;
	int max_clients, total = 0;

	max_clients = GetMaxClients();

	if (info->max_targets < 1)
	{
		info->reason = COMMAND_TARGET_NONE;
		info->num_targets = 0;
	}

	if (info->admin == 0)
	{
		pAdmin = NULL;
	}
	else
	{
		pAdmin = GetPlayerByIndex(info->admin);
	}

	if (info->pattern[0] == '#')
	{
		int userid = atoi(&info->pattern[1]);
		int client = GetClientOfUserId(userid);

		/* See if a valid userid matched */
		if (client > 0)
		{
			IGamePlayer *pTarget = GetPlayerByIndex(client);
			if (pTarget != NULL)
			{
				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags)) == COMMAND_TARGET_VALID)
				{
					info->targets[0] = client;
					info->num_targets = 1;
					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);
					info->target_name_style = COMMAND_TARGETNAME_RAW;
				}
				else
				{
					info->num_targets = 0;
				}
				return;
			}
		}

		/* Do we need to look for a steam id? */
		if (strncmp(&info->pattern[1], "STEAM_", 6) == 0)
		{
			size_t p, len;
			char new_pattern[256];

			strcpy(new_pattern, "STEAM_");
			len = strlen(&info->pattern[7]);
			for (p = 0; p < len; p++)
			{
				new_pattern[6 + p] = info->pattern[7 + p];
				if (new_pattern[6 + p] == '_')
				{
					new_pattern[6 + p] = ':';
				}
			}
			new_pattern[6 + p] = '\0';

			for (int i = 1; i <= max_clients; i++)
			{
				if ((pTarget = GetPlayerByIndex(i)) == NULL)
				{
					continue;
				}
				if (!pTarget->IsConnected() || !pTarget->IsAuthorized())
				{
					continue;
				}
				if (strcmp(pTarget->GetAuthString(), new_pattern) == 0)
				{
					if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))
						== COMMAND_TARGET_VALID)
					{
						info->targets[0] = i;
						info->num_targets = 1;
						strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);
						info->target_name_style = COMMAND_TARGETNAME_RAW;
					}
					else
					{
						info->num_targets = 0;
					}
					return;
				}
			}
		}

		/* See if an exact name matches */
		for (int i = 1; i <= max_clients; i++)
		{
			if ((pTarget = GetPlayerByIndex(i)) == NULL)
			{
				continue;
			}
			if  (!pTarget->IsConnected())
			{
				continue;
			}
			if (strcmp(pTarget->GetName(), &info->pattern[1]) == 0)
			{
				if ((info->reason = FilterCommandTarget(pAdmin, pTarget, info->flags))
					== COMMAND_TARGET_VALID)
				{
					info->targets[0] = i;
					info->num_targets = 1;
					strncopy(info->target_name, pTarget->GetName(), info->target_name_maxlength);
					info->target_name_style = COMMAND_TARGETNAME_RAW;
				}
				else
				{
					info->num_targets = 0;
				}
				return;
			}
		}
	}

	if (strcmp(info->pattern, "@me") == 0 && info->admin != 0)
	{
		info->targets[0] = info->admin;
		info->num_targets = 1;
		strncopy(info->target_name, pAdmin->GetName(), info->target_name_maxlength);
		info->target_name_style = COMMAND_TARGETNAME_RAW;
		return;
	}

	if ((info->flags & COMMAND_FILTER_NO_MULTI) != COMMAND_FILTER_NO_MULTI)
	{
		bool is_multi = false;
		bool bots_only = false;
		int skip_client = -1;

		if (strcmp(info->pattern, "@all") == 0)
		{
			is_multi = true;
			strncopy(info->target_name, "all players", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
		}
		else if (strcmp(info->pattern, "@dead") == 0)
		{
			is_multi = true;
			if ((info->flags & COMMAND_FILTER_ALIVE) == COMMAND_FILTER_ALIVE)
			{
				info->num_targets = 0;
				info->reason = COMMAND_TARGET_NOT_ALIVE;
				return;
			}
			info->flags |= COMMAND_FILTER_DEAD;
			strncopy(info->target_name, "all dead players", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
		}
		else if (strcmp(info->pattern, "@alive") == 0)
		{
			is_multi = true;
			if ((info->flags & COMMAND_FILTER_DEAD) == COMMAND_FILTER_DEAD)
			{
				info->num_targets = 0;
				info->reason = COMMAND_TARGET_NOT_DEAD;
				return;
			}
			strncopy(info->target_name, "all alive players", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
			info->flags |= COMMAND_FILTER_ALIVE;
		}
		else if (strcmp(info->pattern, "@bots") == 0)
		{
			is_multi = true;
			if ((info->flags & COMMAND_FILTER_NO_BOTS) == COMMAND_FILTER_NO_BOTS)
			{
				info->num_targets = 0;
				info->reason = COMMAND_FILTER_NO_BOTS;
				return;
			}
			strncopy(info->target_name, "all bots", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
			bots_only = true;
		}
		else if (strcmp(info->pattern, "@humans") == 0)
		{
			is_multi = true;
			strncopy(info->target_name, "all humans", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
			info->flags |= COMMAND_FILTER_NO_BOTS;
		}
		else if (strcmp(info->pattern, "@!me") == 0)
		{
			is_multi = true;
			strncopy(info->target_name, "all players", info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_ML;
			skip_client = info->admin;
		}

		if (is_multi)
		{
			for (int i = 1; i <= max_clients && total < info->max_targets; i++)
			{
				if ((pTarget = GetPlayerByIndex(i)) == NULL)
				{
					continue;
				}
				if (FilterCommandTarget(pAdmin, pTarget, info->flags) > 0)
				{
					if ((!bots_only || pTarget->IsFakeClient())
						&& skip_client != i)
					{
						info->targets[total++] = i;
					}
				}
			}

			info->num_targets = total;
			info->reason = (info->num_targets) ? COMMAND_TARGET_VALID : COMMAND_TARGET_EMPTY_FILTER;
			return;
		}
	}

	List<ICommandTargetProcessor *>::iterator iter;
	for (iter = target_processors.begin(); iter != target_processors.end(); iter++)
	{
		ICommandTargetProcessor *pProcessor = (*iter);
		if (pProcessor->ProcessCommandTarget(info))
		{
			return;
		}
	}

	/* Check partial names */
	int found_client = 0;
	CPlayer *pFoundClient = NULL;
	for (int i = 1; i <= max_clients; i++)
	{
		if ((pTarget = GetPlayerByIndex(i)) == NULL)
		{
			continue;
		}

		if (stristr(pTarget->GetName(), info->pattern) != NULL)
		{
			if (found_client)
			{
				info->num_targets = 0;
				info->reason = COMMAND_TARGET_AMBIGUOUS;
				return;
			}
			else
			{
				found_client = i;
				pFoundClient = pTarget;
			}
		}
	}

	if (found_client)
	{
		if ((info->reason = FilterCommandTarget(pAdmin, pFoundClient, info->flags)) 
			== COMMAND_TARGET_VALID)
		{
			info->targets[0] = found_client;
			info->num_targets = 1;
			strncopy(info->target_name, pFoundClient->GetName(), info->target_name_maxlength);
			info->target_name_style = COMMAND_TARGETNAME_RAW;
		}
		else
		{
			info->num_targets = 0;
		}
	}
	else
	{
		info->num_targets = 0;
		info->reason = COMMAND_TARGET_NONE;
	}
}
Esempio n. 3
0
bool SDKTools::ProcessCommandTarget(cmd_target_info_t *info)
{
	IGamePlayer *pAdmin = info->admin ? playerhelpers->GetGamePlayer(info->admin) : NULL;

	if (strcmp(info->pattern, "@aim") == 0)
	{
		/* The server can't aim, of course. */
		if (pAdmin == NULL)
		{
			return false;
		}

		int player_index;
		if ((player_index = GetClientAimTarget(pAdmin->GetEdict(), true)) < 1)
		{
			info->reason = COMMAND_TARGET_NONE;
			info->num_targets = 0;
			return true;
		}

		IGamePlayer *pTarget = playerhelpers->GetGamePlayer(player_index);

		if (pTarget == NULL)
		{
			info->reason = COMMAND_TARGET_NONE;
			info->num_targets = 0;
			return true;
		}

		info->reason = playerhelpers->FilterCommandTarget(pAdmin, pTarget, info->flags);
		if (info->reason != COMMAND_TARGET_VALID)
		{
			info->num_targets = 0;
			return true;
		}

		info->targets[0] = player_index;
		info->num_targets = 1;
		info->reason = COMMAND_TARGET_VALID;
		info->target_name_style = COMMAND_TARGETNAME_RAW;
		snprintf(info->target_name, info->target_name_maxlength, "%s", pTarget->GetName());
		return true;
	}
	else if (strcmp(info->pattern, "@spec") == 0)
	{
		const char *teamname = tools_GetTeamName(1);
		if (strcasecmp(teamname, "spectator") != 0)
			return false;
		info->num_targets = 0;
		for (int i = 1; i <= playerhelpers->GetMaxClients(); i++)
		{
			IGamePlayer *player = playerhelpers->GetGamePlayer(i);
			if (player == NULL || !player->IsInGame())
				continue;
			IPlayerInfo *plinfo = player->GetPlayerInfo();
			if (plinfo == NULL)
				continue;
			if (plinfo->GetTeamIndex() == 1 &&
			    playerhelpers->FilterCommandTarget(pAdmin, player, info->flags) ==
				COMMAND_TARGET_VALID)
			{
				info->targets[info->num_targets++] = i;
			}
		}
		info->reason = info->num_targets > 0 ? COMMAND_TARGET_VALID : COMMAND_TARGET_EMPTY_FILTER;
		info->target_name_style = COMMAND_TARGETNAME_ML;
		snprintf(info->target_name, info->target_name_maxlength, "all spectators");
		return true;
	}

	return false;
}
Esempio n. 4
0
		void Line(std::string &line, const dlib::incoming_things& incoming, dlib::outgoing_things& outgoing)
		{
			size_t posStart, posEnd, posTemp;

			// Search for "gets"
			for (posStart = line.find("ec::GET["); posStart != std::string::npos; posStart = line.find("ec::GET["))
			{
				std::string get = &line[posStart+8];
				posEnd = get.find(']');

				get = get.substr(0, posEnd);

				std::string result = incoming.queries[get];
				if (result.empty())
					result = "Unknown GET[" + get + ']';

				// Delete functioncall
				line.erase(posStart, posEnd+9);
				line.insert(posStart, result);
			}

			// Now interpret all functions
			for (posStart = line.find("ec::"); posStart != std::string::npos; posStart = line.find("ec::"))
			{
				std::vector<std::string> params;
				std::string function = &line[posStart+4], arg, result;

				posTemp = function.find('(');
				posEnd = function.find(')');

				arg = function.substr(posTemp+1, posEnd-posTemp-1);
				if (line.find(";") != std::string::npos)
					params = dlib::split(arg.c_str(), ";");
				else
					params.emplace_back(arg);
				function = function.substr(0, posTemp);

				if (function == "GetMapName")
				{
					result = gamehelpers->GetCurrentMap();
				}
				else if (function == "GetGameFolder")
				{
					result = g_pSM->GetGameFolderName();
				}
				else if (function == "GetHTMLFormatedPlayerInfo")
				{
					IGamePlayer *player = Helper::GetPlayerByIP(incoming.foreign_ip);
					if (player)
					{
						result = "<b>" + std::string(player->GetName()) + "</b>";
						result += "<br/>IP: ";
						result += player->GetIPAddress();
						result += "<br/>Auth:";
						result += player->GetAuthString();
						result += "<br/>Steam:";
						result += player->GetSteamAccountID();

						AdminId adminID = player->GetAdminId();
						if (adminID != INVALID_ADMIN_ID)
							result += "<br/>You are an admin";
						else
							result += "<br/>You are no admin";
					}
					else
					{
						result = "You are not connected!";
					}
				}
				else if (function == "GetNavHidingSpots")
				{
					if (Navigation::gNavMesh)
						result = dlib::cast_to_string(Navigation::gHidingSpotsCount);
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavAreas")
				{
					if (Navigation::gNavMesh && Navigation::gNavMesh->GetAreas())
						result = dlib::cast_to_string(Navigation::gNavMesh->GetAreas()->Size());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavPlaces")
				{
					if (Navigation::gNavMesh && Navigation::gNavMesh->GetPlaces())
						result = dlib::cast_to_string(Navigation::gNavMesh->GetPlaces()->Size());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavLadders")
				{
					if (Navigation::gNavMesh && Navigation::gNavMesh->GetLadders())
						result = dlib::cast_to_string(Navigation::gNavMesh->GetLadders()->Size());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavMagicNumber")
				{
					if (Navigation::gNavMesh)
						result = dlib::cast_to_string(Navigation::gNavMesh->GetMagicNumber());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavSaveBSPSize")
				{
					if (Navigation::gNavMesh)
						result = dlib::cast_to_string(Navigation::gNavMesh->GetSaveBSPSize());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavVersion")
				{
					if (Navigation::gNavMesh)
						result = dlib::cast_to_string(Navigation::gNavMesh->GetVersion());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "GetNavSubVersion")
				{
					if (Navigation::gNavMesh)
						result = dlib::cast_to_string(Navigation::gNavMesh->GetSubVersion());
					else
						result = "Navigation not loaded.";
				}
				else if (function == "IsLANServer")
				{
					result = gamehelpers->IsLANServer() ? "true" : "false";
				}
				else if (function == "GetMaxClients")
				{
					result = dlib::cast_to_string(playerhelpers->GetMaxClients());
				}
				else if (function == "GetPlayerCount")
				{
					result = dlib::cast_to_string(playerhelpers->GetNumPlayers());
				}
				else if (function == "GetEntityClassname")
				{
					if (params.size() == 1)
					{
						CBaseEntity *entity = gamehelpers->ReferenceToEntity(dlib::string_cast<int>(params.at(0)));
						if (entity)
							result = gamehelpers->GetEntityClassname(entity);
						else
							result = "Entity(" + params.at(0) + ") is invalid!";
					}
					else
					{
						result = "Usage:GetEntityClassname(entity)";
					}
				}
				else if (function == "ServerCommand")
				{
					if (params.size() == 1)
					{
						gamehelpers->ServerCommand(params.at(0).append("\n").c_str());
						result = "";
					}
					else
					{
						result = "Usage:ServerCommand(COMMAND)";
					}
				}
				else if (function == "ReadFile")
				{
					if (params.size() == 1)
					{
						result = HTTP::ReadFile(lastFilePath.substr(0, lastFilePath.find_last_of('/')+1) + params.at(0), incoming, outgoing);
					}
					else
					{
						result = "Usage:ReadFile(filename)";
					}
				}
				else if (function == "MostRecentVersion")
				{
					std::string newVersion;

					newVersion = LGN::get_most_recent_version();
					if (!newVersion.empty())
					{
						result = newVersion;
					}
					else
					{
						result = "Unable to receive the most recent version";
					}
				}
				else if (function == "CurrentVersion")
				{
					result = SMEXT_CONF_VERSION;
				}
				else
				{
					IGamePlayer *player = Helper::GetPlayerByIP(incoming.foreign_ip);
					if (player)
						ForwardFunction(player->GetUserId(), function, arg, result);
					else
						ForwardFunction(0, function, arg, result);
				}

				// Delete functioncallname
				line.erase(posStart, posEnd+5);

				// Insert the result
				line.insert(posStart, result);
			}
		}
Esempio n. 5
0
static cell_t FormatActivitySource(IPluginContext *pContext, const cell_t *params)
{
    int value;
    int client;
    int target;
    IGamePlayer *pTarget;
    AdminId aidTarget;
    const char *identity[2] = { "Console", "ADMIN" };

    client = params[1];
    target = params[2];

    if ((pTarget = playerhelpers->GetGamePlayer(target)) == NULL)
    {
        return pContext->ThrowNativeError("Invalid client index %d", target);
    }
    if (!pTarget->IsConnected())
    {
        return pContext->ThrowNativeError("Client %d not connected", target);
    }

    value = bridge->GetActivityFlags();

    if (client != 0)
    {
        IGamePlayer *pPlayer;

        if ((pPlayer = playerhelpers->GetGamePlayer(client)) == NULL)
        {
            return pContext->ThrowNativeError("Invalid client index %d", client);
        }
        if (!pPlayer->IsConnected())
        {
            return pContext->ThrowNativeError("Client %d not connected", client);
        }

        identity[0] = pPlayer->GetName();

        AdminId id = pPlayer->GetAdminId();
        if (id == INVALID_ADMIN_ID
                || !adminsys->GetAdminFlag(id, Admin_Generic, Access_Effective))
        {
            identity[1] = "PLAYER";
        }
    }

    int mode = 1;
    bool bShowActivity = false;

    if ((aidTarget = pTarget->GetAdminId()) == INVALID_ADMIN_ID
            || !adminsys->GetAdminFlag(aidTarget, Admin_Generic, Access_Effective))
    {
        /* Treat this as a normal user */
        if ((value & kActivityNonAdmins) || (value & kActivityNonAdminsNames))
        {
            if ((value & 2) || (target == client))
            {
                mode = 0;
            }
            bShowActivity = true;
        }
    }
    else
    {
        /* Treat this as an admin user */
        bool is_root = adminsys->GetAdminFlag(aidTarget, Admin_Root, Access_Effective);
        if ((value & kActivityAdmins)
                || (value & kActivityAdminsNames)
                || ((value & kActivityRootNames) && is_root))
        {
            if ((value & kActivityAdminsNames) || ((value & kActivityRootNames) && is_root) || (target == client))
            {
                mode = 0;
            }
            bShowActivity = true;
        }
    }

    /* Otherwise, send it back to the script. */
    pContext->StringToLocalUTF8(params[3], params[4], identity[mode], NULL);

    return bShowActivity ? 1 : 0;
}
Esempio n. 6
0
static cell_t _ShowActivity2(IPluginContext *pContext,
                             const cell_t *params,
                             const char *tag,
                             cell_t fmt_param)
{
    char message[255];
    char buffer[255];
    int value = bridge->GetActivityFlags();
    unsigned int replyto = playerhelpers->GetReplyTo();
    int client = params[1];

    const char *name = "Console";
    const char *sign = "ADMIN";
    if (client != 0)
    {
        IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client);
        if (!pPlayer || !pPlayer->IsConnected())
        {
            return pContext->ThrowNativeError("Client index %d is invalid", client);
        }
        name = pPlayer->GetName();
        AdminId id = pPlayer->GetAdminId();
        if (id == INVALID_ADMIN_ID
                || !adminsys->GetAdminFlag(id, Admin_Generic, Access_Effective))
        {
            sign = "PLAYER";
        }

        g_pSM->SetGlobalTarget(client);
        {
            DetectExceptions eh(pContext);
            g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
            if (eh.HasException())
                return 0;
        }

        /* We don't display directly to the console because the chat text
        * simply gets added to the console, so we don't want it to print
        * twice.
        */
        g_pSM->Format(message, sizeof(message), "%s%s", tag, buffer);
        gamehelpers->TextMsg(client, TEXTMSG_DEST_CHAT, message);
    }
    else
    {
        g_pSM->SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
        {
            DetectExceptions eh(pContext);
            g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
            if (eh.HasException())
                return 0;
        }

        g_pSM->Format(message, sizeof(message), "%s%s\n", tag, buffer);
        bridge->ConPrint(message);
    }

    if (value == kActivityNone)
    {
        return 1;
    }

    int maxClients = playerhelpers->GetMaxClients();
    for (int i = 1; i <= maxClients; i++)
    {
        IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(i);
        if (!pPlayer->IsInGame()
                || pPlayer->IsFakeClient()
                || i == client)
        {
            continue;
        }
        AdminId id = pPlayer->GetAdminId();
        g_pSM->SetGlobalTarget(i);
        if (id == INVALID_ADMIN_ID
                || !adminsys->GetAdminFlag(id, Admin_Generic, Access_Effective))
        {
            /* Treat this as a normal user */
            if ((value & kActivityNonAdmins) || (value & kActivityNonAdminsNames))
            {
                const char *newsign = sign;
                if ((value & kActivityNonAdminsNames))
                {
                    newsign = name;
                }

                {
                    DetectExceptions eh(pContext);
                    g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
                    if (eh.HasException())
                        return 0;
                }

                g_pSM->Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
                gamehelpers->TextMsg(i, TEXTMSG_DEST_CHAT, message);
            }
        }
        else
        {
            /* Treat this as an admin user */
            bool is_root = adminsys->GetAdminFlag(id, Admin_Root, Access_Effective);
            if ((value & kActivityAdmins)
                    || (value & kActivityAdminsNames)
                    || ((value & kActivityRootNames) && is_root))
            {
                const char *newsign = sign;
                if ((value & kActivityAdminsNames) || ((value & kActivityRootNames) && is_root))
                {
                    newsign = name;
                }

                {
                    DetectExceptions eh(pContext);
                    g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, fmt_param);
                    if (eh.HasException())
                        return 0;
                }

                g_pSM->Format(message, sizeof(message), "%s%s: %s", tag, newsign, buffer);
                gamehelpers->TextMsg(i, TEXTMSG_DEST_CHAT, message);
            }
        }
    }

    return 1;
}
CBaseEntity *Hook_GiveNamedItem(char const *szClassname, int iSubType, CEconItemView *cscript, bool b)
{
	#if defined TF2ITEMS_DEBUG_HOOKING || defined TF2ITEMS_DEBUG_HOOKING_GNI
		 g_pSM->LogMessage(myself, "GiveNamedItem called.");
	#endif // TF2ITEMS_DEBUG_HOOKING

	#ifdef TF2ITEMS_DEBUG_ITEMS
		 g_pSM->LogMessage(myself, "---------------------------------------");
		 g_pSM->LogMessage(myself, ">>> Start of GiveNamedItem call.");
	#endif

	CBasePlayer *player = META_IFACEPTR(CBasePlayer);

	if (cscript == NULL || szClassname == NULL)
	{
#if defined TF2ITEMS_DEBUG_HOOKING_GNI
		g_pSM->LogMessage(myself, "(cscript == NULL || szClassname == NULL), RETURN_META_VALUE(MRES_IGNORED, NULL);");
#endif // TF2ITEMS_DEBUG_HOOKING_GNI

		RETURN_META_VALUE(MRES_IGNORED, NULL);
	}

	// Retrieve client index.
	edict_t *playerEdict = gameents->BaseEntityToEdict((CBaseEntity *)player);
	IGamePlayer * pPlayer = playerhelpers->GetGamePlayer(playerEdict);
	int client = gamehelpers->IndexOfEdict(playerEdict);

	if (g_pVTable == NULL)
	{
		g_pVTable = cscript->m_pVTable;
		g_pVTable_Attributes = cscript->m_pVTable_Attributes;
	}

#ifdef TF2ITEMS_DEBUG_ITEMS

	/*char *roflmelon = new char[32];
	sprintf(roflmelon, "debug_item_%d_%d.txt", cscript->m_iAccountID, cscript->m_iItemDefinitionIndex);
	FILE *fp = fopen(roflmelon, "wb");
	fwrite(cscript, sizeof(CEconItemView), 1, fp);
	fclose(fp);*/
	
	g_pSM->LogMessage(myself, "---------------------------------------");
	g_pSM->LogMessage(myself, ">>> Client = %s", pPlayer->GetName());
	g_pSM->LogMessage(myself, ">>> szClassname = %s", szClassname);
	g_pSM->LogMessage(myself, ">>> iSubType = %d", iSubType);
	g_pSM->LogMessage(myself, ">>> b = %s", b?"true":"false");
	g_pSM->LogMessage(myself, "---------------------------------------");
	g_pSM->LogMessage(myself, ">>> m_iItemDefinitionIndex = %u", cscript->m_iItemDefinitionIndex);
	g_pSM->LogMessage(myself, ">>> m_iEntityQuality = %u", cscript->m_iEntityQuality);
	g_pSM->LogMessage(myself, ">>> m_iEntityLevel = %u", cscript->m_iEntityLevel);
	g_pSM->LogMessage(myself, ">>> m_iItemID = %lu", cscript->m_iItemID);
	g_pSM->LogMessage(myself, ">>> m_iItemIDHigh = %u", cscript->m_iItemIDHigh);
	g_pSM->LogMessage(myself, ">>> m_iItemIDLow = %u", cscript->m_iItemIDLow);
	g_pSM->LogMessage(myself, ">>> m_iAccountID = %u", cscript->m_iAccountID);
	g_pSM->LogMessage(myself, ">>> m_iPosition = %u", cscript->m_iInventoryPosition);
	g_pSM->LogMessage(myself, ">>> m_bInitialized = %s", cscript->m_bInitialized?"true":"false");
	g_pSM->LogMessage(myself, "---------------------------------------");
	for (int i = 0; i < ((cscript->m_Attributes.Count() > 16)?0:cscript->m_Attributes.Count()); i++)
	{
		g_pSM->LogMessage(myself, ">>> m_iAttributeDefinitionIndex = %u", cscript->m_Attributes.Element(i).m_iAttributeDefinitionIndex);
		g_pSM->LogMessage(myself, ">>> m_flValue = %f", cscript->m_Attributes.Element(i).m_flValue);
		g_pSM->LogMessage(myself, "---------------------------------------");
	}
	g_pSM->LogMessage(myself, ">>> Size of CEconItemView = %d", sizeof(CEconItemView));
	g_pSM->LogMessage(myself, ">>> Size of CEconItemAttribute = %d", sizeof(CEconItemAttribute));
	g_pSM->LogMessage(myself, ">>> No. of Attributes = %d", cscript->m_Attributes.Count());
	g_pSM->LogMessage(myself, "---------------------------------------");
#endif

	// Summon forward
	cell_t cellResults = 0;
	cell_t cellOverrideHandle = 0;
	g_pForwardGiveItem->PushCell(client);
	g_pForwardGiveItem->PushString(szClassname);
	g_pForwardGiveItem->PushCell(cscript->m_iItemDefinitionIndex);
	g_pForwardGiveItem->PushCellByRef(&cellOverrideHandle);
	g_pForwardGiveItem->Execute(&cellResults);

	// Determine what to do
	switch(cellResults) {
		case Pl_Continue:
			{
				RETURN_META_VALUE(MRES_IGNORED, NULL);
			}
		case Pl_Changed:
			{
				TScriptedItemOverride *pScriptedItemOverride = GetScriptedItemOverrideFromHandle(cellOverrideHandle);
				if (pScriptedItemOverride == NULL) {
					RETURN_META_VALUE(MRES_IGNORED, NULL);
				}

				// Execute the new attributes set and we're done!
				char *finalitem = (char *)szClassname;

				CEconItemView newitem;
				CSCICopy(cscript, &newitem);

				// Override based on the flags passed to this object.
				if (pScriptedItemOverride->m_bFlags & OVERRIDE_CLASSNAME)
				{
					finalitem = pScriptedItemOverride->m_strWeaponClassname;
				}

				if (pScriptedItemOverride->m_bFlags & OVERRIDE_ITEM_DEF)
				{
					newitem.m_iItemDefinitionIndex = pScriptedItemOverride->m_iItemDefinitionIndex;
				}

				if (pScriptedItemOverride->m_bFlags & OVERRIDE_ITEM_LEVEL)
				{
					newitem.m_iEntityLevel = pScriptedItemOverride->m_iEntityLevel;
				}

				if (pScriptedItemOverride->m_bFlags & OVERRIDE_ITEM_QUALITY)
				{
					newitem.m_iEntityQuality = pScriptedItemOverride->m_iEntityQuality;
				}

				if (pScriptedItemOverride->m_bFlags & OVERRIDE_ATTRIBUTES)
				{
#ifndef NO_FORCE_QUALITY
					// Even if we don't want to override the item quality, do if it's set to 0.
					if (newitem.m_iEntityQuality == 0 && !(pScriptedItemOverride->m_bFlags & OVERRIDE_ITEM_QUALITY) && pScriptedItemOverride->m_iCount > 0) newitem.m_iEntityQuality = 6;
#endif

					if (!(pScriptedItemOverride->m_bFlags & PRESERVE_ATTRIBUTES))
					{
						newitem.m_bDoNotIterateStaticAttributes = true;
					}

					newitem.m_Attributes.RemoveAll();
					newitem.m_Attributes.AddMultipleToTail(pScriptedItemOverride->m_iCount, pScriptedItemOverride->m_Attributes);
				}

				if (cscript->m_iEntityQuality == 0)
				{
					newitem.m_iEntityQuality = 0;
				}

				RETURN_META_VALUE_MNEWPARAMS(MRES_HANDLED, NULL, MHook_GiveNamedItem, (finalitem, iSubType, &newitem, ((pScriptedItemOverride->m_bFlags & FORCE_GENERATION) == FORCE_GENERATION)));
			}
		case Pl_Handled:
		case Pl_Stop:
			{
				RETURN_META_VALUE(MRES_SUPERCEDE, NULL);
			}
	}
	
	RETURN_META_VALUE(MRES_IGNORED, NULL);
}