Ошибки от зомбик-класса _revenant_ice_0

zmuser · 5 Ноя 2023

Вот такая ошибка

L 11/05/2023 - 16:44:44: [ENGINE] Invalid entity 135
L 11/05/2023 - 16:44:44: [AMXX] Displaying debug trace (plugin "yt_class_revenant_ice_0.amxx", version "0.1")
L 11/05/2023 - 16:44:44: [AMXX] Run time error 10: native error (native "entity_set_float")
L 11/05/2023 - 16:44:44: [AMXX] [0] yt_class_revenant_ice_0.sma::ball_think (line 223)
L 11/05/2023 - 16:44:49: [ENGINE] Invalid entity 137
L 11/05/2023 - 16:44:49: [AMXX] Displaying debug trace (plugin "yt_class_revenant_ice_0.amxx", version "0.1")
L 11/05/2023 - 16:44:49: [AMXX] Run time error 10: native error (native "entity_set_float")
L 11/05/2023 - 16:44:49: [AMXX] [0] yt_class_revenant_ice_0.sma::ball_think (line 223)

Еще бывает (не всегда) что шар не исчезает, а летает по карте до тех пор пока не выпустишь новый, так же ИНОГДА если заразить того кого коснулся шар - у него не пропадает свечение, скриншоты приложил

Flymic24 · 7 Ноя 2023

В целом лучше избавься от этого плагина или перепишите его как следует.

Код:

public ball_think(ball)
{
    if(!is_valid_ent(ball))
        return;

    new Float:oldangles[3],Float:angles[3]
    pev(ball,pev_angles,oldangles)
    angles[0] = oldangles[0] + random_float(20.0,100.0)
    angles[1] = oldangles[1] + random_float(10.0,80.0)
    angles[2] = oldangles[2] + random_float(10.0,80.0)
    set_pev(ball,pev_angles,angles)

    new Float:Velocity[3]
    pev(ball,pev_velocity,Velocity)

    if(Velocity[0] < 1.0 && Velocity[2] < 1.0 && Velocity[1] < 1.0) remove_entity(ball)

    entity_set_float(ball, EV_FL_nextthink, get_gametime() + 0.1)

}

-->

Код:

public ball_think(ball)
{
    if(!pev_valid(ball))
        return;
    
    set_pev(ball, pev_nextthink, get_gametime() + 0.1)
    
    new Float:angles[3];    pev(ball,pev_angles,angles)
    angles[0] += random_float(20.0,100.0)
    angles[1] += random_float(10.0,80.0)
    angles[2] += random_float(10.0,80.0)
    set_pev(ball,pev_angles,angles)

    new Float:Velocity[3];    pev(ball,pev_velocity,Velocity)

    if(Velocity[0] < 1.0 && Velocity[2] < 1.0 && Velocity[1] < 1.0)
        remove_entity(ball)
}

zmuser · 7 Ноя 2023

Flymic24, спасибо! Проверю как можно скорее. А почему избавиться? Код плохой или еще какие-то беды? Есть переписанная -

Код:

/*
    Revenant Ice 1.0 (2023)    by R1CHICOREJZ

    Some functions/stocks taken from t3rkecorejz plugins
*/

public stock const PluginName[] =      "[ZP] ZClass: Revenant Ice";
public stock const PluginVersion[] = "1.0 | 2023";
public stock const PluginAuthor[] =     "R1CHICOREJZ";

/* -> Main includes <- */
#include <amxmisc>
#include <fakemeta>
#include <hamsandwich>
#include <reapi>
#include <xs>

/* -> Other includes <- */
#include <zombieplague>
// #include <zmgorod>

/* -> Macroses <- */
#define LOWER_LIMIT_OF_ENTITIES            100

#define PrecacheArray(%0,%1)            for(new i; i < sizeof %1; i++) engfunc(EngFunc_Precache%0, %1[i])

#define _is_user_zombie(%0)             zp_get_user_zombie(%0)
#define _is_ice_zombie_class(%0)         (zp_get_user_zombie_class(%0) == gl_iRevenantIce)
#define _is_user_nemesis(%0)            zp_get_user_nemesis(%0)

#define BIT_ADD(%0,%1)                    (%0 |= BIT(%1))
#define BIT_SUB(%0,%1)                    (%0 &= ~BIT(%1))
#define BIT_VALID(%0,%1)                bool: ((%0 & BIT(%1)) ? true : false)

#define Vector3(%0)                        Float: %0[3]
#define IsUserValid(%0)                    bool: (0 < %0 <= 32)

#define ZOMBIE_HURT                        true     // (false - zombies will not have the sound of pain and death)

/* -> Entity: Ball <- */
new const ENTITY_BALL_CLASSNAME[] =     "ent_revice_ball_x";
new const ENTITY_BALL_MODEL[] =         "models/LR_ZP/w_hiddentail2_fix.mdl";
new const ENTITY_BALL_TRAIL[] =            "sprites/laserbeam.spr";
new const ENTITY_BALL_DESTROY[] =        "sprites/pistol_smoke1.spr";
new const ENTITY_GLASS_DESTROY[] =        "models/glassgibs.mdl";
const Float: ENTITY_BALL_SPEED =        600.0;    // Ball Speed
const Float: ENTITY_BALL_LIFETIME =        4.0;    // How long ball still alive
const Float: ENTITY_FREEZE_LIFETIME =    4.0;    // How long player still freeze

/* -> Other Zombie Class Settings <- */
new const ZM_CLASS_GRENADE[] =            "models/LR_ZP/v_zombibomb_rev_ice.mdl";    // Grenade model
const Float: ZM_SKILL_COOLDOWN =         15.0;     // Skill reload time

/* -> Params <- */
new gl_iRevenantIce,

    gl_iMaxEntities,

    gl_bitPlayerSkillActive,
    gl_bitPlayerFrozen,

    Float: g_flSkillWait[MAX_CLIENTS + 1];

enum {
    ModelIndex_BallTrail,
    ModelIndex_DestroySprite,
    ModelIndex_DestroyGlass,
    ModelIndex_List
}

new gl_iszModelIndex[ModelIndex_List];

new Ham:Ham_Player_ResetMaxSpeed = Ham_Item_PreFrame

new Float: g_frozen_gravity[33];                 // store previous gravity when frozen

/* -> Sounds <- */
new const BALL_SOUNDS[][] =
{
    "warcraft3/frostnova.wav",
    "warcraft3/impalehit.wav",
    "warcraft3/impalelaunch1.wav"
}

enum {
    eRevenant_BallDestroy,
    eRevenant_BallFrozen,
    eRevenant_BallUnFrozen
}

#if ZOMBIE_HURT == true
    new const PAIN_SOUNDS[][] =
    {
        "zombi/passzombie_hurt1.wav",
        "zombi/passzombie_hurt2.wav",
        "zombi/passzombie_death1.wav",
        "zombi/passzombie_death2.wav"
    }

    enum {
        eRevSound_HurtOne = 0,
        eRevSound_HurtTwo,
        eRevSound_DeathOne,
        eRevSound_DeathTwo
    }
#endif

/* -> AMX <- */
public plugin_init()
{
    register_plugin(PluginName, PluginVersion, PluginAuthor);
   
    new const GRENADES_ENTITY[][] = { "weapon_hegrenade", "weapon_flashbang", "weapon_smokegrenade" };
   
    /* -> HamSandWich <- */
    for(new i = 0; i < sizeof GRENADES_ENTITY; i++)
        RegisterHam(Ham_Item_Deploy, GRENADES_ENTITY[i], "CGrenade__Deploy_Post", true);

    RegisterHam(Ham_Player_ResetMaxSpeed, "player", "CPlayer_ResetMaxSpeed_Post", true);

    /* -> ReAPI <- */
    RegisterHookChain(RG_CSGameRules_RestartRound, "CSGameRules_RestartRound", false);
    RegisterHookChain(RG_CBasePlayer_Killed, "CBasePlayer_Killed", true);

    #if ZOMBIE_HURT == true
        RegisterHookChain(RH_SV_StartSound, "SV_StartSound");
    #endif

    /* -> Client Commands <- */
    register_clcmd("drop", "Command_HookDrop");

    /* -> Other <- */
    gl_iMaxEntities = global_get(glb_maxEntities);
}

public plugin_precache()
{
    /* -> Register Zombie Class <- */
    gl_iRevenantIce = zp_register_zombie_class(
        "RevenantIce", // Name
        "RevenantI_desc", // Description
        "revenant_ice_zombie", // Model
        "v_knife_revenant_ice.mdl", // Claw
        // ADMIN_BAN, // Zombie Access     / _ (not required)
        8000, // Health Points
        240, // Speed
        0.77, // Gravity
        0.8) // Knockback

    /* -> Precache Models <- */
    engfunc(EngFunc_PrecacheModel, ZM_CLASS_GRENADE);
    engfunc(EngFunc_PrecacheModel, ENTITY_BALL_MODEL);
    gl_iszModelIndex[ModelIndex_BallTrail] = engfunc(EngFunc_PrecacheModel, ENTITY_BALL_TRAIL);
    gl_iszModelIndex[ModelIndex_DestroySprite] = engfunc(EngFunc_PrecacheModel, ENTITY_BALL_DESTROY);
    gl_iszModelIndex[ModelIndex_DestroyGlass] = engfunc(EngFunc_PrecacheModel, ENTITY_GLASS_DESTROY);

    /* -> Precache Sounds <- */
    PrecacheArray(Sound, BALL_SOUNDS);

    #if ZOMBIE_HURT == true
        PrecacheArray(Sound, PAIN_SOUNDS);
    #endif

    UTIL_PrecacheSoundsFromModel(ZM_CLASS_GRENADE);
}

public plugin_natives() register_native("zp_is_revenant_ice_zombie", "zpr_native_rev_ice_zombie", 1)

/*
    This Native, returns already assigned zombie class (true or false)

    Example for use:
       
        if (zp_is_revenant_ice_zombie(id))
            client_print(id, print_chat, "Your Zombie Class is Revenant Ice");
        else client_print(id, print_chat, "Your Zombie Class is not Revenant Ice");
*/

public bool: zpr_native_rev_ice_zombie(const pPlayer)
{
    return zp_get_user_zombie_class(pPlayer) == gl_iRevenantIce ? true : false;
}

Reset_Value(pPlayer)
{
    if (BIT_VALID(gl_bitPlayerSkillActive, pPlayer))
        BIT_SUB(gl_bitPlayerSkillActive, pPlayer);

    if (BIT_VALID(gl_bitPlayerFrozen, pPlayer))
        BIT_SUB(gl_bitPlayerFrozen, pPlayer);

    g_flSkillWait[pPlayer] = 0.0;
}

public client_putinserver(pPlayer) Reset_Value(pPlayer);
public client_disconnected(pPlayer) Reset_Value(pPlayer);

/* -> Zombie Plague <- */
public zp_user_humanized_post(pPlayer) Reset_Value(pPlayer);
public zp_user_infected_post(pPlayer) Reset_Value(pPlayer);

/* -> Ham: Grenade <- */
public CGrenade__Deploy_Post(iItem) {
    new pPlayer = get_member(iItem, m_pPlayer);
    if(!_is_user_zombie(pPlayer) || _is_user_nemesis(pPlayer)) return;

    if(_is_ice_zombie_class(pPlayer))
        set_entvar(pPlayer, var_viewmodel, ZM_CLASS_GRENADE);
}

/* -> Ham: Speed <- */
public CPlayer_ResetMaxSpeed_Post(pPlayer)
{
    if (!is_user_alive(pPlayer) || !BIT_VALID(gl_bitPlayerFrozen, pPlayer))
        return;

    set_entvar(pPlayer, var_velocity, NULL_VECTOR);
    set_entvar(pPlayer, var_maxspeed, 1.0);
}

/* -> ReAPI: Emit Sound Forward <- */
public CSGameRules_RestartRound()
{
    new szPlayers[MAX_PLAYERS], iPlayersNum, pPlayer = NULLENT;
    get_players_ex(szPlayers, iPlayersNum, GetPlayers_ExcludeHLTV);

    for (new i; i < iPlayersNum; i++)
    {
        pPlayer = szPlayers[i];
        if (!is_user_connected(pPlayer))
            continue;
       
        Reset_Value(pPlayer);
    }

    UTIL_DestroyEntitiesByClass(ENTITY_BALL_CLASSNAME);
}

public CBasePlayer_Killed(pPlayer) Reset_Value(pPlayer);

/* -> Emit Sound Forward <- */
#if ZOMBIE_HURT == true
    public SV_StartSound(recipients, pPlayer, channel, sample[], volume, Float:attn, flags, pitch)
    {
        // Replace these next sounds for zombies only
        if(!is_user_connected(pPlayer))
            return HC_CONTINUE;

        if(!_is_user_zombie(pPlayer) || !_is_ice_zombie_class(pPlayer) || _is_user_nemesis(pPlayer))
            return HC_CONTINUE;

        // Zombie being hit
        if(sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't') // hits
        {
            // if (zp_get_user_on_fire(pPlayer))
            //     return HC_SUPERCEDE; // Block sounds
           
            rh_emit_sound2(pPlayer, 0, CHAN_STATIC, PAIN_SOUNDS[random_num(eRevSound_HurtOne, eRevSound_HurtTwo)]);
            return HC_SUPERCEDE; // also block default hits sounds
        }
        else if (sample[7] == 'd') // Death Sound
        {
            if (sample[8] == 'i' && sample[9] == 'e')
            {
                rh_emit_sound2(pPlayer, 0, CHAN_STATIC, PAIN_SOUNDS[random_num(eRevSound_DeathOne, eRevSound_DeathTwo)]);
            }
            else if (sample[8] == 'e' && sample[9] == 'a')
            {
                rh_emit_sound2(pPlayer, 0, CHAN_STATIC, PAIN_SOUNDS[random_num(eRevSound_DeathOne, eRevSound_DeathTwo)]);
            }
            return HC_SUPERCEDE; // also block default death sounds
        }
        else if (sample[0] == 'p' && sample[1] == 'l') // fix headshot sound
        {
            if (sample[7] == 'h' && sample[10] == 'd')
            {
                // if (zp_get_user_on_fire(pPlayer))
                //     return HC_SUPERCEDE; // Block sounds
               
                rh_emit_sound2(pPlayer, 0, CHAN_STATIC, PAIN_SOUNDS[random_num(eRevSound_HurtOne, eRevSound_HurtTwo)]);
                return HC_SUPERCEDE; // also block default hs sounds
            }
        }
        return HC_CONTINUE;
    }
#endif

/* -> Start Ice Ability <- */
public Command_HookDrop(const pPlayer)
{
    if(!is_user_alive(pPlayer) || !_is_user_zombie(pPlayer) || !_is_ice_zombie_class(pPlayer) || _is_user_nemesis(pPlayer)) return PLUGIN_CONTINUE;

    new pActiveItem = get_member(pPlayer, m_pActiveItem);
    if(is_nullent(pActiveItem) || (get_member(pActiveItem, m_iId) != WEAPON_KNIFE)) return PLUGIN_CONTINUE;

    if(BIT_VALID(gl_bitPlayerSkillActive, pPlayer)) return PLUGIN_HANDLED;

    static Float: flGameTime; flGameTime = get_gametime();
    if(g_flSkillWait[pPlayer] <= flGameTime)
    {
        if(CPlayer_Create_Ball(pPlayer))
        {
            // rh_emit_sound2(pPlayer, 0, CHAN_STATIC, ABILITY_SOUNDS[eWitchSound_Laugh]);
            BIT_ADD(gl_bitPlayerSkillActive, pPlayer);
        }
    }
    else client_print(pPlayer, print_center, "Reload skill [%i seconds until next use]", floatround(g_flSkillWait[pPlayer] - flGameTime));

    return PLUGIN_HANDLED;
}

/* -> Create Ice Ball <- */
public CPlayer_Create_Ball(const pPlayer)
{
    if(gl_iMaxEntities - engfunc(EngFunc_NumberOfEntities) <= LOWER_LIMIT_OF_ENTITIES) return NULLENT;

    new pEntity = rg_create_entity("info_target");
    if(is_nullent(pEntity)) return NULLENT;

    new Float: vecOrigin[3]; get_entvar(pPlayer, var_origin, vecOrigin);
    new Float: vecViewOfs[3]; get_entvar(pPlayer, var_view_ofs, vecViewOfs);
    new Float: vecViewAngle[3]; get_entvar(pPlayer, var_v_angle, vecViewAngle);
    new Float: vecForward[3]; angle_vector(vecViewAngle, ANGLEVECTOR_FORWARD, vecForward);
    new Float: vecVelocity[3]; xs_vec_copy(vecForward, vecVelocity);

    // Start Origin
    xs_vec_mul_scalar(vecForward, 10.0, vecForward);
    xs_vec_add(vecViewOfs, vecForward, vecViewOfs);
    xs_vec_add(vecOrigin, vecViewOfs, vecOrigin);

    // Speed for missile
    xs_vec_mul_scalar(vecVelocity, ENTITY_BALL_SPEED, vecVelocity);

    set_entvar(pEntity, var_classname, ENTITY_BALL_CLASSNAME);
    set_entvar(pEntity, var_solid, SOLID_TRIGGER);
    set_entvar(pEntity, var_movetype, MOVETYPE_BOUNCEMISSILE);
    set_entvar(pEntity, var_owner, pPlayer);
    set_entvar(pEntity, var_velocity, vecVelocity);
    set_entvar(pEntity, var_origin, vecOrigin);
    set_entvar(pEntity, var_ltime, get_gametime() + ENTITY_BALL_LIFETIME);
    set_entvar(pEntity, var_nextthink, get_gametime());

    UTIL_SetEntityAnim(pEntity);
    UTIL_TE_BEAMFOLLOW(MSG_BROADCAST, pEntity, gl_iszModelIndex[ModelIndex_BallTrail], 10, 5, {100, 255, 255}, 150);

    engfunc(EngFunc_SetModel, pEntity, ENTITY_BALL_MODEL);
    engfunc(EngFunc_SetSize, pEntity, Float: {-5.0, -5.0, -5.0}, Float: {5.0, 5.0, 5.0});

    SetTouch(pEntity, "CBall_Touch");
    SetThink(pEntity, "CBall_Think");

    return true;
}

/* -> Ball touch players <- */
public CBall_Touch(const pEntity, const pToucher)
{
    if (is_nullent(pEntity) || !IsUserValid(pToucher)) return;

    new pOwner = get_entvar(pEntity, var_owner);
    if (pToucher == pOwner) return;

    if (!is_user_alive(pToucher))
    {
        CBall_Destroy(pEntity, pOwner);
        return;
    }

    if (!_is_user_zombie(pToucher) && !BIT_VALID(gl_bitPlayerFrozen, pToucher))
    {
        // Set the frozen flag
        BIT_ADD(gl_bitPlayerFrozen, pToucher);

        log_amx("Player Touched");

        // Set rendering for player
        UTIL_SetEntityRendering(pToucher, kRenderFxGlowShell, Float: { 100.0, 255.0, 255.0 }, _, 10.0) // Player glowing

        CBall_TouchPlayer(pToucher);
        CPlayer_Set_SkillWait(pOwner, ZM_SKILL_COOLDOWN);

        client_print_color(pOwner, print_team_grey, "^3[RevICE] ^4You`re froze: %n", pToucher)
        client_print_color(pToucher, print_team_grey, "^3[RevICE] ^4You`re frozen by: %n", pOwner)

        set_entvar(pEntity, var_fuser1, pToucher);
        set_entvar(pEntity, var_ltime, get_gametime() + ENTITY_BALL_LIFETIME);
        set_entvar(pEntity, var_nextthink, get_gametime() + ENTITY_FREEZE_LIFETIME);
        set_entvar(pEntity, var_effects, EF_NODRAW);

        SetThink(pEntity, "CBall_ResetThink");
        SetTouch(pEntity, "");
    }
}

/* -> Reset think for ball <- */
public CBall_ResetThink(const pEntity)
{
    if(is_nullent(pEntity))
        return;  

    new pToucher; pToucher = get_entvar(pEntity, var_fuser1);
    if (BIT_VALID(gl_bitPlayerFrozen, pToucher))
    {
        log_amx("Player BIT_SUB");
        BIT_SUB(gl_bitPlayerFrozen, pToucher);
        CPlayer_RemoveFreezeEffects(pToucher);
        UTIL_KillEntity(pEntity);
    }

    set_entvar(pEntity, var_nextthink, get_gametime());
}

/* -> Ball thinking <- */
public CBall_Think(const pEntity)
{
    if(is_nullent(pEntity)) return;

    new pOwner = get_entvar(pEntity, var_owner);
    if (get_entvar(pEntity, var_ltime) < get_gametime())
    {
        CBall_Destroy(pEntity, pOwner);
        return;
    }

    set_entvar(pEntity, var_nextthink, get_gametime());
}

/* -> Ball destroyed <- */
public CBall_Destroy(const pEntity, const pOwner)
{
    if (is_nullent(pEntity)) return;

    new Float: vecOrigin[3]; get_entvar(pEntity, var_origin, vecOrigin);

    rh_emit_sound2(pEntity, 0, CHAN_WEAPON, BALL_SOUNDS[eRevenant_BallDestroy]);
    UTIL_TE_EXPLOSION(MSG_PAS, gl_iszModelIndex[ModelIndex_DestroySprite], vecOrigin, 10.0, 5, 30, 2|4|8);

    CPlayer_Set_SkillWait(pOwner, ZM_SKILL_COOLDOWN);
    UTIL_KillEntity(pEntity);
}

/* -> Ball "destroyed" on toucher <- */
public CBall_TouchPlayer(const pToucher)
{
    // Sound & explosion (sprite)
    new Float: vecOrigin[3]; get_entvar(pToucher, var_origin, vecOrigin);

    rh_emit_sound2(pToucher, 0, CHAN_WEAPON, BALL_SOUNDS[eRevenant_BallFrozen]);
    UTIL_TE_EXPLOSION(MSG_PAS, gl_iszModelIndex[ModelIndex_DestroySprite], vecOrigin, 10.0, 5, 30, 2|4|8);

    // Save player's old gravity (bugfix)
    get_entvar(pToucher, var_gravity, g_frozen_gravity[pToucher]);
   
    // Prevent from jumping
    if (get_entvar(pToucher, var_flags) & FL_ONGROUND)
        set_entvar(pToucher, var_gravity, 999999.9) // set really high
    else
        set_entvar(pToucher, var_gravity, 0.000001) // no gravity

    // Set speed
    ExecuteHamB(Ham_Player_ResetMaxSpeed, pToucher)
}

/* -> Remove freeze effects <- */
public CPlayer_RemoveFreezeEffects(const pToucher)
{
    // Sound & render
    rh_emit_sound2(pToucher, 0, CHAN_WEAPON, BALL_SOUNDS[eRevenant_BallUnFrozen]);
    UTIL_SetEntityRendering(pToucher);

    // Set user gravity, which was saved
    set_entvar(pToucher, var_gravity, g_frozen_gravity[pToucher]);

    // Reset speed
    ExecuteHamB(Ham_Player_ResetMaxSpeed, pToucher)

    // Glass shatter
    new Vector3(vecVelocity);
    vecVelocity[0] = random_float(-50.0, 50.0);
    vecVelocity[1] = random_float(-50.0, 50.0);
    vecVelocity[2] = 25.0;

    new Float: vecOrigin[3]; get_entvar(pToucher, var_origin, vecOrigin);
    UTIL_TE_BREAKMODEL(MSG_BROADCAST, vecOrigin, Float: { 16.0, 16.0, 16.0 }, vecVelocity, 10, gl_iszModelIndex[ModelIndex_DestroyGlass], 10, 25, 0x01); // 0x01 - glass
}

/* -> Set player countdown and remove BIT <- */
public CPlayer_Set_SkillWait(const pPlayer, const Float: flWaitTime)
{
    g_flSkillWait[pPlayer] = get_gametime() + flWaitTime;
    BIT_SUB(gl_bitPlayerSkillActive, pPlayer);
}

/* -! Stocks !- */

/* -> Destroy All Entities by ClassName <- */
stock UTIL_DestroyEntitiesByClass(const szClassName[])
{
    static pEntity; pEntity = NULLENT;
    while ((pEntity = rg_find_ent_by_class(pEntity, szClassName)) > 0)
        UTIL_KillEntity(pEntity);
}

/* -> Destroy Entity <- */
stock UTIL_KillEntity(const pEntity)
{
    set_entvar(pEntity, var_flags, FL_KILLME);
    set_entvar(pEntity, var_nextthink, get_gametime());
}

/* -> Precache Sounds From Model <- */
stock UTIL_PrecacheSoundsFromModel(const szModelPath[])
{
    new pFile;
    if(!(pFile = fopen(szModelPath,"rt")))
        return;

    new szSoundPath[MAX_RESOURCE_PATH_LENGTH];
    new iNumSeq, iSeqIndex;
    new iEvent, iNumEvents, iEventIndex;

    fseek(pFile, 164, SEEK_SET);
    fread(pFile, iNumSeq, BLOCK_INT);
    fread(pFile, iSeqIndex, BLOCK_INT);

    for(new i = 0; i < iNumSeq; i++)
    {
        fseek(pFile, iSeqIndex + 48 + 176 * i, SEEK_SET);
        fread(pFile, iNumEvents, BLOCK_INT);
        fread(pFile, iEventIndex, BLOCK_INT);
        fseek(pFile, iEventIndex + 176 * i, SEEK_SET);

        for(new k = 0; k < iNumEvents; k++)
        {
            fseek(pFile, iEventIndex + 4 + 76 * k, SEEK_SET);
            fread(pFile, iEvent, BLOCK_INT);
            fseek(pFile, 4, SEEK_CUR);

            if(iEvent!=5004)
                continue;

            fread_blocks(pFile, szSoundPath, 64, BLOCK_CHAR);

            if(strlen(szSoundPath))
            {
                new szBuffer[MAX_RESOURCE_PATH_LENGTH];

                strtolower(szSoundPath);
                format(szBuffer, charsmax(szBuffer), "sound/%s", szSoundPath);
                engfunc(EngFunc_PrecacheGeneric, szBuffer);
            }
        }
    }

    fclose(pFile);
}

/* -> Entity Animation <- */
stock UTIL_SetEntityAnim(const pEntity, const iSequence = 0)
{
    set_entvar(pEntity, var_frame, 1.0);
    set_entvar(pEntity, var_framerate, 1.0);
    set_entvar(pEntity, var_animtime, get_gametime());
    set_entvar(pEntity, var_sequence, iSequence);
}

/* -> TE_EXPLOSION <- */
stock UTIL_TE_EXPLOSION(const iDest, const iszModelIndex, const Vector3(vecOrigin), const Float: flUp, const iScale, const iFramerate, const bitsFlags = TE_EXPLFLAG_NODLIGHTS|TE_EXPLFLAG_NOSOUND|TE_EXPLFLAG_NOPARTICLES)
{
    message_begin_f(iDest, SVC_TEMPENTITY, vecOrigin);
    write_byte(TE_EXPLOSION);
    write_coord_f(vecOrigin[0]);
    write_coord_f(vecOrigin[1]);
    write_coord_f(vecOrigin[2] - flUp);
    write_short(iszModelIndex);
    write_byte(iScale); // Scale
    write_byte(iFramerate); // Framerate
    write_byte(bitsFlags); // Flags
    message_end();
}

/* -> TE_BEAMFOLLOW <- */
stock UTIL_TE_BEAMFOLLOW(const iDest, const pEntity, const iszModelIndex, const iLife, const iWidth, const iColor[3], const iBrightness)
{
    message_begin_f(iDest, SVC_TEMPENTITY);
    write_byte(TE_BEAMFOLLOW);
    write_short(pEntity); // Entity: attachment to follow
    write_short(iszModelIndex); // Model Index
    write_byte(iLife); // Life in 0.1's
    write_byte(iWidth); // Line width in 0.1's
    write_byte(iColor[0]); // Red
    write_byte(iColor[1]); // Green
    write_byte(iColor[2]); // Blue
    write_byte(iBrightness); // Brightness
    message_end();
}

/* -> TE_BREAKMODEL <- */
stock UTIL_TE_BREAKMODEL(const iDest, const Vector3(vecOrigin), const Vector3(vecSize), const Vector3(vecVelocity), const iRandomVelocity, const iszModelIndex, const iCount, const iLife, const bitsFlags)
{
    message_begin_f(iDest, SVC_TEMPENTITY, vecOrigin);
    write_byte(TE_BREAKMODEL);
    write_coord_f(vecOrigin[0]); // Origin X
    write_coord_f(vecOrigin[1]); // Origin Y
    write_coord_f(vecOrigin[2]); // Origin Z
    write_coord_f(vecSize[0]); // Size X
    write_coord_f(vecSize[1]); // Size Y
    write_coord_f(vecSize[2]); // Size Z
    write_coord_f(vecVelocity[0]); // Velocity X
    write_coord_f(vecVelocity[1]); // Velocity Y
    write_coord_f(vecVelocity[2]); // Velocity Z
    write_byte(iRandomVelocity); // Random Velocity in 10's
    write_short(iszModelIndex); // Model Index
    write_byte(iCount); // Count
    write_byte(iLife); // Life in 0.1's
    write_byte(bitsFlags); // Flags
    message_end();
}

/* -> Set Entity Rendering <- */
stock UTIL_SetEntityRendering(const pEntity, const iRenderFx = kRenderFxNone, const Float:flRenderColor[3] = { 255.0, 255.0, 255.0 }, const iRenderMode = kRenderNormal, const Float: flRenderAmount = 16.0)
{
    set_entvar(pEntity, var_renderfx, iRenderFx);
    set_entvar(pEntity, var_rendercolor, flRenderColor);
    set_entvar(pEntity, var_rendermode, iRenderMode);
    set_entvar(pEntity, var_renderamt, flRenderAmount);
}

Но он тут под REhlds, а у меня обычный hlds, из-за этого ошибки в консоле и опять же неправильная работа плагина :( Подумал этот будет лучше, но судя по твоим словам - нет. Или можно как-то заставить reHlds версию работать на обычной? Если да, то готов опять поставить re-версию и с ошибками вернуться сюда =)

Nordic Warrior · 7 Ноя 2023

zmuser, почему не ставите rehlds, если не секрет?

zmuser · 8 Ноя 2023

Nordic Warrior, да просто страшно что другие плагины полетят, заново настраивать. В принципе можно попробовать, но перед этим резервную копию создать)) может этим и займусь сейчас, посмотрю что и как

Nordic Warrior · 8 Ноя 2023

zmuser, вероятность этого достаточно небольшая, не запуститься могут обычно плагины, использующие модуль orpheu, но они не часто встречаются. В крайнем случае, можно обратиться на этот же форум

zmuser · 8 Ноя 2023

Nordic Warrior, у меня из орфея вроде ничего нет, буду надеяться что все будет ок))
Немного отошел от темы, но можешь подсказать какая сейчас актуальная версия reHlds'а? У меня предлагает установить ReHlds-3.13.0.788-dev_mpatch, все верно?

Nordic Warrior · 8 Ноя 2023

zmuser, верно

Ошибки от зомбик-класса _revenant_ice_0

zmuser

Download all Attachments

Flymic24

zmuser

Nordic Warrior

zmuser

Nordic Warrior

zmuser

Nordic Warrior

Пользователи, просматривающие эту тему