[Scag]

I wanted to write an extension, so I wrote one.

SM Memory exposes your basic cstdlib memory functions for SourceMod plugins to use, giving them more control over memory allocation and deallocation.

With that said, when would you ever want to use an extension that does something like this?
The answer: Never.

SourceMod gives you enough control already. You shouldn't be using this extension just for the sake of raw pointers.

There are only 2 possible cases I could think of in which this extension would ever be useful.

Case 1:

Spoiler

When disassembling CTFWeaponBase::ApplyOnHitAttributes, victims are checked for a mad milk condition. If they're in said condition, a healing effect is applied (damage * 0.6). However if I were to want to modify that percentage, I would run headlong into an assembly issue:


The address of flt_1196D10 contains the 0.6 floating point value. The value this address is pointing to is being loaded into register xmm0.

If I wanted to alter or patch over the value going into that register, I would have a rough, rough time. There are no immediate loads in SSE, and I'm limited on bytes, so...

I'm given two options here.

A: I scour over .rodata to find another float value that has the percentage I want, but what if I want to make my own cvar to let server owners adjust that value at will?

B: I jmp into and out of my own asm to allow myself more bytes to work with which would probably bring me to the point of insanity.

Both of these options suck, but with SM-Memory, I can just allocate my own pointer and give it the value that I want. I can then patch over flt_1196D10 with my new pointer address.

PHP Code:

#pragma semicolon 1
#pragma newdecls required

#include <smmem>

float g_Value;
Address g_Addr;
Address g_Old;

ConVar cvMilk;

public void OnPluginStart()
{
    GameData conf = LoadGameConfigFile("tf2.milk");
    g_Addr = conf.GetAddress("ApplyOnHitAttributes");
    g_Addr += view_as< Address >(conf.GetOffset("Milk_Offset"));
    g_Old = Deref(g_Addr);
    delete conf;

    cvMilk = CreateConVar("sm_milk_pct", "0.5", "Milk damage to health %", FCVAR_NOTIFY);
    cvMilk.AddChangeHook(OnMilkCVarChange);
    AutoExecConfig(true, "TF2Milk");
    Patch();
}

public void OnMilkCVarChange(ConVar convar, const char[] old, const char[] neww)
{
    Patch();
}

public void Patch()
{
    // This method *requires* the var to be global, otherwise Very Bad Things will happen!
    g_Value = cvMilk.FloatValue;
    Address addr = AddressOf(g_Value);
    WriteVal(g_Addr, addr);
}

public void OnPluginEnd()
{
    WriteVal(g_Addr, g_Old);
} 


On a scale of 1 to hard, that was about a 3. And there are definitely similar cases out there!

Case 2

Spoiler

You need to allocate an object to pass into an SDKCall as a parameter. I didn't write an example for this one because I couldn't find a prime example. But it can happen!

Case 2.5:

Spoiler

CUtlVectors.

Everyone knows them, yet there is no real feasible way to add or remove values to them.

I made a wrapper to work with them. Valve allocates their memory in their own way, but reallocing them should still work.

PHP Code:

#include <smmem_vec>
#include <smmem_stocks>
#include <sdkhooks>
#include <sdktools>

public void OnPluginStart()
{
    for (int i = MaxClients; i; --i)
        if (IsClientInGame(i))
            OnClientPutInServer(i);

    RegAdminCmd("sm_adddonk", CmdAddDonk, ADMFLAG_ROOT);
}

public void OnClientPutInServer(int client)
{
    SDKHook(client, SDKHook_PreThink, OnThink);
}

stock CUtlVector GetHealerVector(int client)
{
    return CUtlVector(GetEntityAddress(client) + view_as< Address >(FindSendPropInfo("CTFPlayer", "m_nHalloweenBombHeadStage") + 8));
}

#if 0
struct healers_t
{
    EHANDLE    pHealer;
    float    flAmount;
    float   flHealAccum;
    float    flOverhealBonus;
    float    flOverhealDecayMult;
    bool    bDispenserHeal;
    EHANDLE pHealScorer;
    int        iKillsWhileBeingHealed;
    float    flHealedLastSecond;
};
#endif

#define SIZEOF_HEALERS 36

stock CUtlVector GetDonkVector(int wep)
{
    return CUtlVector(GetEntityAddress(wep) + view_as< Address >(FindSendPropInfo("CTFGrenadeLauncher", "m_iGoalTube") + 20));
}
public void OnThink(int client)
{
    CUtlVector vec = GetHealerVector(client);
    int struc;
    for (int i = 0; i < vec.Count(); ++i)
    {
        struc = vec.Element(i, SIZEOF_HEALERS);
        if (struc)
        {
            PrintToChatAll("client = %N", client);
            int pHealer = GetEntityFromHandle(Deref(struc));
            PrintToChatAll("pHealer = %N", pHealer);
            float flAmount = Deref(struc + 4);
            PrintToChatAll("flAmount = %.2f", flAmount);
            float flHealAccum = Deref(struc + 8);
            PrintToChatAll("flHealAccum = %.2f", flHealAccum);
            float flOverhealBonus = Deref(struc + 12);
            PrintToChatAll("flOverhealBonus = %.2f", flOverhealBonus);
            float flOverhealDecayMult = Deref(struc + 16);
            PrintToChatAll("flOverhealDecayMult = %.2f", flOverhealDecayMult);
            bool bDispenserHeal = Deref(struc + 20, NumberType_Int8);
            PrintToChatAll("bDispenserHeal = %d", bDispenserHeal);
            int pHealScorer = GetEntityFromHandle(Deref(struc + 24));
            PrintToChatAll("pHealScorer = %N", pHealScorer);
            int iKillsWhileBeingHealed = Deref(struc + 28);
            PrintToChatAll("iKillsWhileBeingHealed = %d", iKillsWhileBeingHealed);
            float flHealedLastSecond = Deref(struc + 32);
            PrintToChatAll("flHealedLastSecond = %.2f", flHealedLastSecond);
        }
    }

    if (client == 1)
    {
        vec = GetDonkVector(GetPlayerWeaponSlot(client, 0))
        for (int i = 0; i < vec.Count(); ++i)
        {
            struc = vec.Element(i, 8);
            if (struc)
            {
                PrintToChat(client, "m_hVictim = %d", GetEntityFromHandle(Deref(struc)));
                PrintToChat(client, "m_flExpireTime - currtime = %.2f", view_as< float >(Deref(struc + 4)) - GetGameTime());
            }
        }
    }
}

public Action CmdAddDonk(int client, int args)
{
    if (args < 2)
        return Plugin_Handled;

    char arg[32]; GetCmdArg(1, arg, sizeof(arg));
    int target = FindTarget(client, arg);
    if (target == -1)
        return Plugin_Handled;

    int donker = GetPlayerWeaponSlot(client, 0);
    if (!HasEntProp(donker, Prop_Send, "m_iGoalTube"))
        return Plugin_Handled;

    CUtlVector m_vecDonkVictims = GetDonkVector(donker);

    PrintToChat(client, "0x%X", GetEntityHandle(target));
    for (int i = 0; i < m_vecDonkVictims.Count(); ++i)
    {
        PrintToChat(client, "0x%X", m_vecDonkVictims.GetEx(i, 8));
    }
    int index = m_vecDonkVictims.FindEx(GetEntityHandle(target), 8);
    int donk;
    if (index == -1)
        donk = m_vecDonkVictims.Get(m_vecDonkVictims.AddToTail(0, 8), 8);
    else donk = m_vecDonkVictims.Get(index, 8);

    WriteVal(donk, GetEntityHandle(target));
    GetCmdArg(2, arg, sizeof(arg));
    WriteVal(donk + 4, GetGameTime() + StringToFloat(arg));

    ReplyToCommand(client, "Set target %N time to %.2f", target, GetGameTime() + StringToFloat(arg));
    return Plugin_Handled;
} 


Also worth mentioning that you're in control of what you do with the memory, therefore you are responsible for it. There's no safety net, no precautions, no nothing. It's all on you. Everything remains as is even if your plugin unloads. This is why I can't stress this enough when I say that you really shouldn't use this extension unless absolutely necessary.

I can go on and on about how this isn't a safe extension to use, but surely that's gotten through your head. TLDR; only use it for things it's needed for.

Note, if you're running 64-bit SourceMod, you'll need to build the ext yourself. Releases will not work at all with 64-bit servers.

Releases
Source