Система хендлов

using Plugify;
using static s2sdk.s2sdk;

public unsafe class EntityTracker : Plugin
{
    // Хранить хендлы сущностей, а не указатели!
    private Dictionary<int, int> trackedEntities = new Dictionary<int, int>();

    public void OnPluginStart()
    {
        HookEvent("player_spawn", Event_OnPlayerSpawn, HookMode.Post);
    }

    public void Event_OnPlayerSpawn(string name, nint @event, bool dontBroadcast)
    {
        int playerSlot = GetEventPlayerSlot(@event, "userid", 0);

        // Получить хендл сущности (безопасно для долгосрочного хранения)
        int entityHandle = PlayerSlotToEntHandle(playerSlot);

        // Хранить хендл вместо указателя
        trackedEntities[playerSlot] = entityHandle;

        PrintToServer($"Tracking player {playerSlot} with handle {entityHandle}\n");
    }

    public void CheckTrackedEntities()
    {
        foreach (var kvp in trackedEntities.ToList())
        {
            int playerSlot = kvp.Key;
            int entityHandle = kvp.Value;

            // Проверить хендл перед использованием
            if (IsValidEntHandle(entityHandle))
            {
                nint entity = EntHandleToEntPointer(entityHandle);
                PrintToServer($"Player {playerSlot} is still valid\n");
            }
            else
            {
                // Сущность больше не существует, удалить из отслеживания
                trackedEntities.Remove(playerSlot);
                PrintToServer($"Player {playerSlot} disconnected, stopped tracking\n");
            }
        }
    }
}

using Plugify;
using static s2sdk.s2sdk;

public unsafe class PlayerManager : Plugin
{
    public void OnPluginStart()
    {
        AddConsoleCommand("player_info", "Show player information",
            ConVarFlag.LinkedConcommand | ConVarFlag.Release,
            Command_PlayerInfo, HookMode.Post);
    }

    public ResultType Command_PlayerInfo(int caller, CommandCallingContext context, string[] arguments)
    {
        if (caller == -1) return ResultType.Handled;

        // caller это playerSlot (0-63)
        PrintToServer($"Player Slot: {caller}\n");

        // ✅ ПРЕДПОЧТИТЕЛЬНО: Сначала получить хендл для проверки и использования
        int entityHandle = PlayerSlotToEntHandle(caller);
        if (!IsValidEntHandle(entityHandle))
        {
            PrintToServer("Invalid player entity\n");
            return ResultType.Handled;
        }

        // Получить другие представления
        int entityIndex = EntHandleToEntIndex(entityHandle);
        nint clientPtr = PlayerSlotToClientPtr(caller);
        nint entity = EntHandleToEntPointer(entityHandle);

        PrintToServer($"Entity Index: {entityIndex}\n");
        PrintToServer($"Entity Handle: {entityHandle}\n");
        PrintToServer($"Entity Ptr: 0x{entity:X}\n");
        PrintToServer($"Client Ptr: 0x{clientPtr:X}\n");

        // Получить свойства сущности используя хендл (SDK требует хендлы!)
        string classname = GetEntityClassname(entityHandle);
        PrintToServer($"Classname: {classname}\n");

        return ResultType.Handled;
    }
}

using Plugify;
using static s2sdk.s2sdk;

public unsafe class EntityManager : Plugin
{
    public void OnPluginStart()
    {
        AddConsoleCommand("list_entities", "List all entities",
            ConVarFlag.LinkedConcommand | ConVarFlag.Release,
            Command_ListEntities, HookMode.Post);
    }

    public ResultType Command_ListEntities(int caller, CommandCallingContext context, string[] arguments)
    {
        if (arguments.Length < 2)
        {
            PrintToServer("Usage: list_entities <classname>\n");
            return ResultType.Handled;
        }

        string targetClass = arguments[1];
        int count = 0;

        // Итерация по всем сущностям
        for (int i = 0; i < 2048; i++)
        {
            // Конвертировать индекс в хендл
            int handle = EntIndexToEntHandle(i);

            // Проверить перед использованием
            if (!IsValidEntHandle(handle))
                continue;

            string classname = GetEntityClassname(handle);
            if (classname.Contains(targetClass))
            {
                PrintToServer($"Found {classname} at index {i}, handle {handle}\n");
                count++;
            }
        }

        PrintToServer($"Found {count} entities matching '{targetClass}'\n");
        return ResultType.Handled;
    }
}

using Plugify;
using static s2sdk.s2sdk;

public unsafe class SafeEntityAccess : Plugin
{
    private int storedEntityHandle = -1;

    public void StoreEntity(int playerSlot)
    {
        // Конвертировать слот игрока в хендл для хранения
        storedEntityHandle = PlayerSlotToEntHandle(playerSlot);
        PrintToServer($"Stored entity handle: {storedEntityHandle}\n");
    }

    public void AccessStoredEntity()
    {
        // Проверить хендл (быстро и эффективно)
        if (!IsValidEntHandle(storedEntityHandle))
        {
            PrintToServer("Stored entity is no longer valid\n");
            storedEntityHandle = -1;
            return;
        }

        // Не нужна проверка IsValidEntPointer - проверки хендла достаточно!
        // Использование IsValidEntPointer здесь было бы дорогостоящим и избыточным

        // Использовать хендл напрямую с функциями SDK
        string classname = GetEntityClassname(storedEntityHandle);
        int health = GetEntityHealth(storedEntityHandle);

        PrintToServer($"Entity {classname} has {health} health\n");
    }

    public void OnTick()
    {
        // Проверять сохраненную сущность каждый тик
        AccessStoredEntity();
    }
}

using Plugify;
using static s2sdk.s2sdk;

public unsafe class ConversionDemo : Plugin
{
    public void DemonstrateConversions(int playerSlot)
    {
        PrintToServer("=== Демонстрация конвертации сущностей ===\n");

        // Начальная точка: слот игрока
        PrintToServer($"Player Slot: {playerSlot}\n");

        // 1. Слот игрока в хендл сущности (предпочтительно - проверить один раз!)
        int entityHandle = PlayerSlotToEntHandle(playerSlot);
        if (!IsValidEntHandle(entityHandle))
        {
            PrintToServer("Invalid entity\n");
            return;
        }

        // 2. Получить другие представления из хендла
        int entityIndex = EntHandleToEntIndex(entityHandle);
        PrintToServer($"Entity Index: {entityIndex}\n");
        PrintToServer($"Entity Handle: {entityHandle}\n");

        // 3. Получить указатель из проверенного хендла (не нужно проверять указатель!)
        nint entity = EntHandleToEntPointer(entityHandle);
        PrintToServer($"Entity Pointer: 0x{entity:X}\n");

        // 4. Слот игрока в указатель клиента
        nint clientPtr = PlayerSlotToClientPtr(playerSlot);
        PrintToServer($"Client Pointer: 0x{clientPtr:X}\n");

        // 5. Слот игрока в индекс клиента
        int clientIndex = PlayerSlotToClientIndex(playerSlot);
        PrintToServer($"Client Index: {clientIndex}\n");

        PrintToServer("\n=== Обратные конвертации ===\n");

        // 6. Индекс сущности обратно в хендл
        int handleFromIndex = EntIndexToEntHandle(entityIndex);
        PrintToServer($"Index→Handle: {handleFromIndex}\n");

        // 7. Хендл обратно в указатель
        nint entityFromHandle = EntHandleToEntPointer(handleFromIndex);
        PrintToServer($"Handle→Pointer: 0x{entityFromHandle:X}\n");

        // 8. Указатель клиента обратно в слот игрока
        int slotFromClient = ClientPtrToPlayerSlot(clientPtr);
        PrintToServer($"ClientPtr→Slot: {slotFromClient}\n");

        // 9. Индекс клиента обратно в слот игрока
        int slotFromIndex = ClientIndexToPlayerSlot(clientIndex);
        PrintToServer($"ClientIndex→Slot: {slotFromIndex}\n");

        // Проверить, что все конвертации ведут обратно к тем же значениям
        bool allMatch = (handleFromIndex == entityHandle) &&
                       (entityFromHandle == entity) &&
                       (slotFromClient == playerSlot) &&
                       (slotFromIndex == playerSlot);

        PrintToServer($"\nAll conversions match: {allMatch}\n");
    }
}