[nG_getwreck]

Hello, I try adding knockback on this weapon but when I shoot the zombie, the zombie goes to me instead of going away making the zombie to infect me fast.

Can someone fix it?

PS: It goes back to me, if the zombie is running towards me. It doesn't occurs if the zombie is idle (not moving)

PHP Code:

#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <cstrike>
#include <fun>
#include <amxmisc>
#include <zp50_core>
#include <zp50_class_nemesis>
#include <crxknives>

#define CSW_BDRIPPER CSW_KNIFE
#define weapon_guillotine "weapon_mac10"
#define old_event "events/mac10.sc"
#define old_w_model "models/w_mac10.mdl"
#define WEAPON_SECRETCODE 1329419

const pev_catchedspeed = pev_iuser4
#define DEFAULT_AMMO 10
#define DAMAGE 600
#define BDRIP_CLASSNAME "Blood Dripper"
#define WEAPON_ANIMEXT "knife"

#define Get_Ent_Data(%1,%2) get_pdata_int(%1,%2,4)
#define Set_Ent_Data(%1,%2,%3) set_pdata_int(%1,%2,%3,4)

const PDATA_SAFE = 2
const OFFSET_LINUX_WEAPONS = 4
const OFFSET_WEAPONOWNER = 41
const m_flNextAttack = 83
const m_szAnimExtention = 492

new const v_model[] = "models/gcg_csze/v_guillotine.mdl"
new const p_model[] = "models/gcg_csze/p_guillotine.mdl"
new const w_model[] = "models/gcg_csze/w_guillotine.mdl"
new const KNIFE_MODEL[] = "models/gcg_csze/guillotine_projectile.mdl"
new const PECAH_MODEL[] = "models/gcg_csze/gibs_guilotine.mdl"
new const hit_wall[] = "weapons/janus9_stone1.wav"
new const hit_wall2[] = "weapons/janus9_stone2.wav"
new const weapon_sound[6][] = 
{
    "weapons/guillotine_catch2.wav",
    "weapons/guillotine_draw.wav",
    "weapons/guillotine_draw_empty.wav",
    "weapons/guillotine_explode.wav",
    "weapons/guillotine_red.wav",
    "weapons/guillotine-1.wav"
}


new const WeaponResource[3][] = 
{
    "sprites/gcg_csze/weapon_guillotine.txt",
    "sprites/gcg_csze/640hud120.spr",
    "sprites/gcg_csze/guillotine_lost.spr"
}

enum
{
    ANIM_IDLE = 0,
    ANIM_IDLE_EMPTY,
    ANIM_SHOOT,
    ANIM_DRAW,
    ANIM_DRAW_EMPTY,
    ANIM_IDLE_SHOOT,
    ANIM_IDLE_SHOOT2,
    ANIM_CATCH,
    ANIM_LOST
}

new g_MsgDeathMsg, g_endround

new g_had_guillotine[33], g_guillotine_ammo[33], shoot_mode[33], shoot_ent_mode[33], g_pecah, headshot_mode[33], ent_sentuh[33], ent_sentuh_balik[33]
new g_old_weapon[33], g_smokepuff_id, m_iBlood[2], guillotine_korban[33], headshot_korban[33], gmsgScoreInfo, gui_power, gui_knockback

new const ATTRIBUTE_BONUS_XP[] = "GUILLOTINE"

const PRIMARY_WEAPONS_BIT_SUM = 
(1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<
CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90)

public plugin_init()
{
    register_forward(FM_CmdStart, "fw_CmdStart")
    register_forward(FM_SetModel, "fw_SetModel")
    register_think(BDRIP_CLASSNAME, "fw_Think")
    register_touch(BDRIP_CLASSNAME, "*", "fw_touch")
    register_forward(FM_UpdateClientData, "fw_UpdateClientData_Post", 1)
    register_forward(FM_TraceLine, "fw_traceline", 1)
    register_forward(FM_AddToFullPack, "fm_addtofullpack_post", 1)
    RegisterHam(Ham_Weapon_WeaponIdle, weapon_guillotine, "fw_guillotineidleanim", 1)
    RegisterHam(Ham_Killed, "player", "fw_PlayerKilled")
    RegisterHam(Ham_Item_AddToPlayer, weapon_guillotine, "fw_AddToPlayer_Post", 1)
    register_event("CurWeapon", "Event_CurWeapon", "be", "1=1")

    gui_power = register_cvar("zp_gui_power", "2500")
    gui_knockback = register_cvar("zp_gui_knockback", "0")

    register_event("Damage" , "event_Damage" , "b" , "2>0");
    
    register_clcmd("weapon_guillotine", "hook_weapon")
    
    g_MsgDeathMsg = get_user_msgid("DeathMsg")
    gmsgScoreInfo = get_user_msgid("ScoreInfo")
    g_endround = 1
}

public plugin_precache()
{
    precache_model(v_model)
    precache_model(p_model)
    precache_model(w_model)
    precache_model(KNIFE_MODEL)
    g_pecah = precache_model(PECAH_MODEL)
    precache_sound(hit_wall)
    precache_sound(hit_wall2)
    
    for(new i = 0; i < sizeof(weapon_sound); i++) 
        precache_sound(weapon_sound[i])
    
    for(new i = 1; i < sizeof(WeaponResource); i++)
        precache_model(WeaponResource[i])
    
    g_smokepuff_id = engfunc(EngFunc_PrecacheModel, WeaponResource[2])
    m_iBlood[0] = precache_model("sprites/blood.spr")
    m_iBlood[1] = precache_model("sprites/bloodspray.spr")    
}

public crxknives_knife_updated(id, iKnife, bool:bOnConnect)
{
    static iValue

    if(crxknives_get_attribute_int(id, ATTRIBUTE_BONUS_XP, iValue) && iValue == 1)
    {
        g_had_guillotine[id] = 1
    }
    else
    {
        g_had_guillotine[id] = 0
    }
}

public zp_fw_core_cure_post(id)
{
    crxknives_get_attribute_int(id, ATTRIBUTE_BONUS_XP, g_had_guillotine[id])
}

public zp_fw_core_infect_post(id)
{
    remove_guillotine(id)
}

public fw_PlayerKilled(id)
{
    remove_guillotine(id)
}

public hook_weapon(id)
{
    engclient_cmd(id, weapon_guillotine)
    return
}

public get_guillotine(id)
{
    if(!is_user_alive(id))
        return
    drop_weapons(id, 1)
    g_had_guillotine[id] = 1
    g_guillotine_ammo[id] = DEFAULT_AMMO
    
    give_item(id, weapon_guillotine)
    update_ammo(id)
    
    //static weapon_ent; weapon_ent = fm_find_ent_by_owner(-1, weapon_guillotine, id)
    //if(pev_valid(weapon_ent)) cs_set_weapon_ammo(weapon_ent, 1)
}

public remove_guillotine(id)
{
    g_had_guillotine[id] = 0
    static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
    ancur(Ent)
}

public refill_guillotine(id)
{    
    if(g_had_guillotine[id]) g_guillotine_ammo[id] = 15
    
    if(get_user_weapon(id) == CSW_BDRIPPER && g_had_guillotine[id]) update_ammo(id)
}
    
public fw_UpdateClientData_Post(id, sendweapons, cd_handle)
{
    if(!is_user_alive(id) || !is_user_connected(id))
        return FMRES_IGNORED    
    if(get_user_weapon(id) == CSW_BDRIPPER && g_had_guillotine[id])
        set_cd(cd_handle, CD_flNextAttack, get_gametime() + 0.001) 
    
    return FMRES_HANDLED
}

public message_DeathMsg(msg_id, msg_dest, id)
{
   static szTruncatedWeapon[33], iAttacker, iVictim
   
   get_msg_arg_string(4, szTruncatedWeapon, charsmax(szTruncatedWeapon))
   
   iAttacker = get_msg_arg_int(1)
   iVictim = get_msg_arg_int(2)
   
   if(!is_user_connected(iAttacker) || iAttacker == iVictim) return PLUGIN_CONTINUE
   
   if(get_user_weapon(iAttacker) == CSW_BDRIPPER)
   {
      if(g_had_guillotine[iAttacker])
         set_msg_arg_string(4, "knife")
   }
   
   return PLUGIN_CONTINUE
}

public fw_TraceAttack_Sg(Victim, Attacker, Float:Damage, Float:Direction[3], TraceHandle, DamageBit, ptr)
{         
   return HAM_IGNORED
}

public Event_CurWeapon(id)
{
    if(!is_user_alive(id))
        return
        
    if(get_user_weapon(id) == CSW_BDRIPPER && g_had_guillotine[id])
    {
        set_pev(id, pev_viewmodel2, v_model)
        set_pev(id, pev_weaponmodel2, p_model)
        set_pdata_string(id, m_szAnimExtention * 4, WEAPON_ANIMEXT, -1 , 20)
        if(g_old_weapon[id] != CSW_BDRIPPER && g_guillotine_ammo[id] >= 1) set_weapon_anim(id, ANIM_DRAW)
        
        if(g_old_weapon[id] != CSW_BDRIPPER && g_guillotine_ammo[id] == 0 && headshot_mode[id] == 0) set_weapon_anim(id, ANIM_DRAW_EMPTY)
        if(g_old_weapon[id] != CSW_BDRIPPER && g_guillotine_ammo[id] == 0) set_weapon_anim(id, ANIM_DRAW_EMPTY)
        update_ammo(id)
    }
    
    g_old_weapon[id] = get_user_weapon(id)
}

public fw_guillotineidleanim(Weapon)
{
    new id = get_pdata_cbase(Weapon, 41, 4)

    if(!is_user_alive(id) || zp_core_is_zombie(id) || !g_had_guillotine[id] || get_user_weapon(id) != CSW_BDRIPPER)
        return HAM_IGNORED;
    
    if(shoot_mode[id] == 0 && g_guillotine_ammo[id] >= 1) 
        return HAM_SUPERCEDE;
    
    if(headshot_mode[id] == 0 && shoot_mode[id] == 1 && get_pdata_float(Weapon, 48, 4) <= 0.25) 
    {
        set_weapon_anim(id, ANIM_IDLE_SHOOT)
        set_pdata_float(Weapon, 48, 20.0, 4)
        return HAM_SUPERCEDE;
    }
    
    if(headshot_mode[id] == 1 && shoot_mode[id] == 1 && get_pdata_float(Weapon, 48, 4) <= 0.25) 
    {
        set_weapon_anim(id, ANIM_IDLE_SHOOT2)
        set_pdata_float(Weapon, 48, 20.0, 4)
        return HAM_SUPERCEDE;
    }
    
    if(g_guillotine_ammo[id] == 0 && get_pdata_float(Weapon, 48, 4) <= 0.25) 
    {
        set_weapon_anim(id, ANIM_IDLE_EMPTY)
        set_pdata_float(Weapon, 48, 20.0, 4)
        return HAM_SUPERCEDE;
    }

    return HAM_IGNORED;
}

public fw_CmdStart(id, uc_handle, seed)
{
    if(!is_user_alive(id) || !is_user_connected(id))
        return
    if(get_user_weapon(id) != CSW_BDRIPPER || !g_had_guillotine[id])
        return
    
    static ent; ent = fm_get_user_weapon_entity(id, CSW_BDRIPPER)
    //if(!pev_valid(ent))
    //    return
    if(get_pdata_float(ent, 46, OFFSET_LINUX_WEAPONS) > 0.0 || get_pdata_float(ent, 47, OFFSET_LINUX_WEAPONS) > 0.0) 
        return
    
    static CurButton
    CurButton = get_uc(uc_handle, UC_Buttons)
    
    if(CurButton & IN_ATTACK)
    {
        CurButton &= ~IN_ATTACK
        set_uc(uc_handle, UC_Buttons, CurButton)
        
        //if(g_guillotine_ammo[id] == 0)
        //    return
        if(shoot_mode[id] == 0 && get_pdata_float(id, 83, 5) <= 0.0)
        {
            //g_guillotine_ammo[id]--
            //update_ammo(id)
            shoot_mode[id] = 1
            FireKnife(id)
            set_weapon_anim(id, ANIM_SHOOT)
            emit_sound(id, CHAN_WEAPON, weapon_sound[5], 1.0, ATTN_NORM, 0, PITCH_NORM)
            set_weapons_timeidle(id, CSW_BDRIPPER, 0.7)
            set_player_nextattackx(id, 0.7)
        }
    }
}

public FireKnife(id)
{
    static Float:StartOrigin[3], Float:velocity[3], Float:angles[3], Float:anglestrue[3], Float:jarak_max[3]
    get_position(id, 2.0, 0.0, 0.0, StartOrigin)
    get_position(id, 700.0, 0.0, 0.0, jarak_max)
    
    pev(id,pev_v_angle,angles)
    static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
    if(!pev_valid(Ent)) return
    anglestrue[0] = 360.0 - angles[0]
    anglestrue[1] = angles[1]
    anglestrue[2] = angles[2]
    
    // Set info for ent
    set_pev(Ent, pev_movetype, MOVETYPE_FLY)
    set_pev(Ent, pev_owner, id)
    set_pev(Ent, pev_iuser1, id)
    set_pev(Ent, pev_fuser1, get_gametime() + 4.0)
    set_pev(Ent, pev_nextthink, halflife_time() + 0.01)
    
    entity_set_string(Ent, EV_SZ_classname, BDRIP_CLASSNAME)
    engfunc(EngFunc_SetModel, Ent, KNIFE_MODEL)
    set_pev(Ent, pev_mins, Float:{-1.0, -1.0, -1.0})
    set_pev(Ent, pev_maxs, Float:{1.0, 1.0, 1.0})
    set_pev(Ent, pev_origin, StartOrigin)
    set_pev(Ent, pev_angles, anglestrue)
    set_pev(Ent, pev_gravity, 0.01)
    set_pev(Ent, pev_solid, SOLID_BBOX)
    set_pev(Ent, pev_frame, 1.0)
    set_pev(Ent, pev_framerate, 30.0)
    set_pev(Ent, pev_sequence, 0)
    
    //ExecuteHamB(Ham_Weapon_PrimaryAttack, ent)
    set_pev(Ent, pev_catchedspeed, 1100)
    velocity_by_aim( id, 1400, velocity )
    set_pev( Ent, pev_velocity, velocity )
    set_pev(Ent, pev_vuser1, velocity)
    set_pev(Ent, pev_vuser2, jarak_max)
    shoot_ent_mode[id] = 0
    set_pev(Ent, pev_iuser4, 0)
    ent_sentuh[id] = 1
    ent_sentuh_balik[id] = 0
}

public fm_addtofullpack_post(es, e, user, host, host_flags, player, p_set)
{
    if(!player)
        return FMRES_IGNORED
        
    if(!is_user_connected(host) || !is_user_alive(user))
        return FMRES_IGNORED
        
    if(!zp_core_is_zombie(user) || headshot_korban[user] != 1)
        return FMRES_IGNORED
        
    if(host == user)
        return FMRES_IGNORED
    
    new Float:PlayerOrigin[3]//, Float:anglesss[3]
    pev(user, pev_origin, PlayerOrigin)
    
    PlayerOrigin[2] += 25.0
    
    //engfunc(EngFunc_GetBonePosition, user, 8, PlayerOrigin, anglesss)
   
    engfunc(EngFunc_SetOrigin, guillotine_korban[user], PlayerOrigin)
   
    return FMRES_HANDLED
}

public fw_Think(Ent)
{
    if(!pev_valid(Ent)) 
        return
    
    //new id; id = pev(Ent, pev_owner)
    static Float:pulang[3], Float:StartOriginz[3], pemilix, Float:brangkat[3], Float:jarak_max[3], Float:origin_asli[3], korban
    pemilix = pev(Ent, pev_iuser1)
    pev(Ent, pev_origin, StartOriginz)
    korban = pev(Ent, pev_iuser2)
    
    if(headshot_korban[korban] == 1)
    {
        action_thanatos(Ent, korban, pemilix)
        if(get_gametime() - 0.2 > pev(Ent, pev_fuser3))
        {
            Damage_guillotine(Ent, korban)
        }
    }
    
    if(ent_sentuh_balik[pemilix] == 0 && shoot_ent_mode[pemilix] == 1)
    {
        ent_sentuh_balik[pemilix] = 1
        pev(pemilix, pev_origin, origin_asli)
        origin_asli[2] += 0.1
    }
    
    if(ent_sentuh[pemilix] == 1)
    {
        ent_sentuh[pemilix] = 0
        pev(Ent, pev_vuser2, jarak_max)
        pev(Ent, pev_vuser1, brangkat)
        get_speed_vector(StartOriginz, origin_asli, 1400.0, pulang)
                    
        if(shoot_ent_mode[pemilix] == 1)
        {
            set_pev(Ent, pev_velocity, pulang)
        }
        else set_pev(Ent, pev_velocity, brangkat)
    }
    
    if(shoot_ent_mode[pemilix] == 0 && get_distance_f(StartOriginz, jarak_max) <= 10.0)
    {
        shoot_ent_mode[pemilix] = 1
        ent_sentuh[pemilix] = 1
        set_pev(Ent, pev_owner, 0)
    }
    
    if(shoot_ent_mode[pemilix] == 1 && get_distance_f(StartOriginz, origin_asli) <= 40.0)
    {
        if(is_user_alive(pemilix) && is_user_connected(pemilix) && get_user_weapon(pemilix) == CSW_BDRIPPER && g_had_guillotine[pemilix]) balik(Ent)
        else ancur(Ent)
        //balik(Ent)
    }
    else if(headshot_korban[korban] == 1) set_pev(Ent, pev_nextthink, get_gametime() + 0.2)
    else set_pev(Ent, pev_nextthink, halflife_time() + 0.001)
}

stock get_speed_vector(const Float:origin1[3],const Float:origin2[3],Float:speed, Float:new_velocity[3])
{
   new_velocity[0] = origin2[0] - origin1[0]
   new_velocity[1] = origin2[1] - origin1[1]
   new_velocity[2] = origin2[2] - origin1[2]
   static Float:num; num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
   new_velocity[0] *= num
   new_velocity[1] *= num
   new_velocity[2] *= num
   
   return 1;
}

stock hook_ent(victim, attacker, Float:speed)
{
   if(!pev_valid(victim) || !pev_valid(attacker))
      return
   
   static Float:fl_Velocity[3]
   static Float:EntOrigin[3], Float:VicOrigin[3]
   
   pev(victim, pev_origin, EntOrigin)
   pev(attacker, pev_origin, VicOrigin)
   
   static Float:distance_f
   distance_f = get_distance_f(EntOrigin, VicOrigin)
   
   if (distance_f > 60.0)
   {
      new Float:fl_Time = distance_f / speed
      
      fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
      fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
      fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
      } else {
      fl_Velocity[0] = 0.0
      fl_Velocity[1] = 0.0
      fl_Velocity[2] = 0.0
   }
   
   entity_set_vector(victim, EV_VEC_velocity, fl_Velocity)
}

stock hook_ent2(ent, Float:VicOrigin[3], Float:speed, type)
{
   static Float:fl_Velocity[3]
   static Float:EntOrigin[3]
   static Float:EntVelocity[3]
   
   pev(ent, pev_velocity, EntVelocity)
   pev(ent, pev_origin, EntOrigin)
   static Float:distance_f
   distance_f = get_distance_f(EntOrigin, VicOrigin)
   
   static Float:fl_Time; fl_Time = distance_f / speed
   
   if(type == 1)
   {
      fl_Velocity[0] = ((VicOrigin[0] - EntOrigin[0]) / fl_Time) * 1.5
      fl_Velocity[1] = ((VicOrigin[1] - EntOrigin[1]) / fl_Time)
      fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time      
      } else if(type == 2) {
      fl_Velocity[0] = ((EntOrigin[0] - VicOrigin[0]) / fl_Time) * 1.5
      fl_Velocity[1] = ((EntOrigin[1] - VicOrigin[1]) / fl_Time) 
      fl_Velocity[2] = (EntOrigin[2] - VicOrigin[2]) / fl_Time
   }
   
   xs_vec_add(EntVelocity, fl_Velocity, fl_Velocity)
   set_pev(ent, pev_velocity, fl_Velocity)
}

public event_Damage(id)
{
    if(!get_pcvar_num(gui_knockback))
        return PLUGIN_CONTINUE;

    if(!is_user_alive(id))
        return PLUGIN_CONTINUE;

    new weapon , attacker = get_user_attacker(id , weapon);

    if(!is_user_alive(attacker))
        return PLUGIN_CONTINUE;

    if(weapon == CSW_BDRIPPER)
    {
        new Float:vec[3];
        new Float:oldvelo[3];
        get_user_velocity(id, oldvelo);
        create_velocity_vector(id , attacker , vec);
        vec[0] += oldvelo[0];
        vec[1] += oldvelo[1];
        set_user_velocity(id , vec);
    }

    return PLUGIN_CONTINUE;
}

public fw_touch(Ent, Id)
{
    // If ent is valid
    if(!pev_valid(Ent))
        return
    if(pev(Ent, pev_movetype) == MOVETYPE_NONE)
        return
    static classnameptd[32]
    pev(Id, pev_classname, classnameptd, 31)
    if (equali(classnameptd, "func_breakable")) ExecuteHamB( Ham_TakeDamage, Id, 0, 0, 80.0, DMG_GENERIC )
    
    // Get it's origin
    new Float:originF[3], pemilix
    pemilix = pev(Ent, pev_iuser1)
    pev(Ent, pev_origin, originF)
    // Alive...
    
    if(is_user_alive(Id) && zp_core_is_zombie(Id))
    {
        Damage_guillotine(Ent, Id)
        set_pev(Ent, pev_owner, Id)
        ent_sentuh[pemilix] = 1
        create_blood(originF)
        create_blood(originF)
    }
    
    else if(shoot_ent_mode[pemilix] == 1 && Id == pemilix)
    {
        if(is_user_alive(pemilix) && is_user_connected(pemilix) && get_user_weapon(pemilix) == CSW_BDRIPPER && g_had_guillotine[pemilix]) balik(Ent)
        else ancur(Ent)
    }
    
    else if(is_user_alive(Id) && !zp_core_is_zombie(Id))
    {
        set_pev(Ent, pev_owner, Id)
        ent_sentuh[pemilix] = 1
    }
    
    else
    {
        set_pev(Ent, pev_owner, 0)

        if(shoot_ent_mode[pemilix] == 0)
        {
            shoot_ent_mode[pemilix] = 1
            engfunc(EngFunc_EmitSound, Ent, CHAN_WEAPON, hit_wall, 1.0, ATTN_STATIC, 0, PITCH_NORM)
            ent_sentuh[pemilix] = 1
        }
        else ancur(Ent)
    }
}

public ancur(Ent)
{
    if(!pev_valid(Ent))
        return
    static Float:origin2[3], pemilix, Float:origin3[3]
    pemilix = pev(Ent, pev_iuser1)
    entity_get_vector(Ent, EV_VEC_origin, origin2)
    pev(Ent, pev_origin, origin3)
    
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, origin2, 0)
    write_byte(TE_BREAKMODEL)
    engfunc(EngFunc_WriteCoord, origin2[0])
    engfunc(EngFunc_WriteCoord, origin2[1])
    engfunc(EngFunc_WriteCoord, origin2[2])
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, random_num(-25, 25))
    engfunc(EngFunc_WriteCoord, random_num(-25, 25))
    engfunc(EngFunc_WriteCoord, 5)
    write_byte(5)
    write_short(g_pecah)
    write_byte(10)
    write_byte(17)
    write_byte(0x00)
    message_end()
    
    engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, origin2, 0)
    write_byte(TE_BREAKMODEL)
    engfunc(EngFunc_WriteCoord, origin2[0])
    engfunc(EngFunc_WriteCoord, origin2[1])
    engfunc(EngFunc_WriteCoord, origin2[2])
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, 25)
    engfunc(EngFunc_WriteCoord, random_num(-25, 25))
    engfunc(EngFunc_WriteCoord, random_num(-25, 25))
    engfunc(EngFunc_WriteCoord, 5)
    write_byte(5)
    write_short(g_pecah)
    write_byte(10)
    write_byte(17)
    write_byte(0x00)
    message_end()
    
    //fake_smokes(origin3)
    engfunc(EngFunc_EmitSound, Ent, CHAN_WEAPON, hit_wall2, 1.0, ATTN_STATIC, 0, PITCH_NORM)
    shoot_mode[pemilix] = 0
    remove_entity(Ent)
    
    if(!is_user_alive(pemilix) || !is_user_connected(pemilix) || get_user_weapon(pemilix) != CSW_BDRIPPER || !g_had_guillotine[pemilix])
        return
    
    set_weapon_anim(pemilix, ANIM_LOST)
    set_weapons_timeidle(pemilix, CSW_BDRIPPER, 2.5)
    set_player_nextattackx(pemilix, 2.5)
    set_task(1.3, "reload2", pemilix)
    set_task(1.4, "reload", pemilix)
}

public geri_tepme2(Owner, Id)
{ 
   static Float:StartOrigin[3], Float:TargetOrigin[3]
   get_position(Owner, 0.0, 0.0, 0.0, StartOrigin)
   static Float:Velocity[3]
   fm_get_aim_origin(Owner, TargetOrigin)
   get_speed_vector(StartOrigin, TargetOrigin, 2000.0, Velocity)
   set_pev(Id, pev_velocity, Velocity)
}

public action_thanatos(Ent, victim, id)
{         
   if(!pev_valid(Ent))   
      return
   
   if(headshot_mode[id] == 1)
   {
      
      //geri_tepme2(id, victim)
      
      set_task(0.01, "action_thanatos", Ent)
   }
}

public reload(id)
{
    if(!is_user_alive(id) || !is_user_connected(id) || get_user_weapon(id) != CSW_BDRIPPER || !g_had_guillotine[id] || g_guillotine_ammo[id] == 0)
        return
    
    set_weapon_anim(id, ANIM_DRAW)
}

public reload2(id)
{
    if(!is_user_alive(id) || !is_user_connected(id) || get_user_weapon(id) != CSW_BDRIPPER || !g_had_guillotine[id] || g_guillotine_ammo[id] == 0)
        return
    
    set_weapon_anim(id, ANIM_IDLE_SHOOT2)
}

public balik(Ent)
{
    if(!pev_valid(Ent))
        return
    static id
    id = pev(Ent, pev_iuser1)
    
    set_weapons_timeidle(id, CSW_BDRIPPER, 1.0)
    set_player_nextattackx(id, 1.0)
    shoot_mode[id] = 0
    g_guillotine_ammo[id]++
    update_ammo(id)
    set_weapon_anim(id, ANIM_CATCH)
    emit_sound(id, CHAN_WEAPON, weapon_sound[0], 1.0, ATTN_NORM, 0, PITCH_NORM) 
    remove_entity(Ent)
}

/*new Float:g_fDamageMulti[] = 
{
1.0,
1.1,
1.2,
1.3,
1.4,
1.5,
1.6,
1.7,
1.8,
1.9,
2.0,
2.1,
2.2,
2.3
}*/

public geri_tepme(Owner, Id)
{ 
   static Float:StartOrigin[3], Float:TargetOrigin[3]
   get_position(Owner, 0.0, 0.0, 0.0, StartOrigin)
   static Float:Velocity[3]
   fm_get_aim_origin(Owner, TargetOrigin)
   get_speed_vector(StartOrigin, TargetOrigin, 2000.0, Velocity)
   set_pev(Id, pev_velocity, Velocity)                    
}

public Damage_guillotine(Ent, Id)
{
    static Owner; Owner = pev(Ent, pev_iuser1)
    static Attacker; 
    if(!is_user_alive(Owner)) 
    {
        Attacker = 0
        return
    } else Attacker = Owner
    
    if(g_endround)
        return

    new bool:bIsHeadShot; // never make that one static
    new Float:flAdjustedDamage, bool:death
        
    switch( Get_MissileWeaponHitGroup(Ent) ) 
    {
        case HIT_GENERIC: flAdjustedDamage = DAMAGE * 1.0 
        case HIT_STOMACH: flAdjustedDamage = DAMAGE * 1.2 
        case HIT_LEFTLEG, HIT_RIGHTLEG: flAdjustedDamage = DAMAGE * 1.0
        case HIT_LEFTARM, HIT_RIGHTARM: flAdjustedDamage = DAMAGE * 1.0
        case HIT_HEAD, HIT_CHEST:
        {
            flAdjustedDamage = DAMAGE * 3.0
            bIsHeadShot = true
            if(headshot_mode[Owner] == 0) set_task(2.0, "balik_bro", Ent+1858941 )
            headshot_mode[Owner] = 1
            headshot_korban[Id] = 1
            guillotine_korban[Id] = Ent
            set_pev(Ent, pev_iuser2, Id)
            fakedamage(Id, "Guillotine", 1.0, 256) 
            set_pev(Ent, pev_renderamt, 255)
            set_pev(Ent, pev_solid, SOLID_NOT)
            set_pev(Ent, pev_fuser3, 0.0)
        }
    }
    if(pev(Id, pev_health) <= flAdjustedDamage) death = true 
    
    if(is_user_alive(Id))
    {
        if( bIsHeadShot && death)
        {
            if(task_exists( Ent+1858941 )) remove_task( Ent + 1858941 )
            set_pev(Ent, pev_sequence, 0)
            headshot_korban[pev(Ent, pev_iuser2)] = 0
            headshot_mode[Owner] = 0
            shoot_ent_mode[Owner] = 1
            ent_sentuh[Owner] = 1
            ent_sentuh_balik[Owner] = 0
            set_pev(Ent, pev_solid, SOLID_BBOX)
            set_pev(Ent, pev_nextthink, halflife_time() + 0.01)
    
            kill(Attacker, Id, 1)
            
            death = false            
        }
        if(death)
        {
            kill(Attacker, Id, 0)
            
            death = false            
        }
        else ExecuteHamB(Ham_TakeDamage, Id, Ent, Attacker, flAdjustedDamage, DMG_BULLET)
    }
}

stock turn_to_target(ent, Float:Ent_Origin[3], target, Float:Vic_Origin[3]) 
{
   if(target) 
   {
      new Float:newAngle[3]
      entity_get_vector(ent, EV_VEC_angles, newAngle)
      new Float:x = Vic_Origin[0] - Ent_Origin[0]
      new Float:z = Vic_Origin[1] - Ent_Origin[1]
      
      new Float:radians = floatatan(z/x, radian)
      newAngle[1] = radians * (180 / 3.14)
      if (Vic_Origin[0] < Ent_Origin[0])
         newAngle[1] -= 180.0
      
      entity_set_vector(ent, EV_VEC_angles, newAngle)
   }
}

public balik_bro(Ent)
{
    Ent -= 1858941
    
    if(!pev_valid(Ent))
        return
    
    static pemilix; pemilix = pev(Ent, pev_iuser1)
    set_pev(Ent, pev_sequence, 0)
    headshot_korban[pev(Ent, pev_iuser2)] = 0
    headshot_mode[pemilix] = 0
    shoot_ent_mode[pemilix] = 1
    ent_sentuh[pemilix] = 1
    ent_sentuh_balik[pemilix] = 0
    set_pev(Ent, pev_solid, SOLID_BBOX)
    set_pev(Ent, pev_nextthink, halflife_time() + 0.01)
}

public fw_SetModel(entity, model[])
{
    if(!pev_valid(entity))
        return FMRES_IGNORED
    
    static Classname[64]
    pev(entity, pev_classname, Classname, sizeof(Classname))
    
    if(!equal(Classname, "weaponbox"))
        return FMRES_IGNORED
    
    static id
    id = pev(entity, pev_owner)
    
    if(equal(model, old_w_model))
    {
        static weapon
        weapon = fm_get_user_weapon_entity(entity, CSW_BDRIPPER)
        
        if(!pev_valid(weapon))
            return FMRES_IGNORED
        
        if(g_had_guillotine[id])
        {
            set_pev(weapon, pev_impulse, WEAPON_SECRETCODE)
            set_pev(weapon, pev_iuser4, g_guillotine_ammo[id])
            engfunc(EngFunc_SetModel, entity, w_model)
            
            g_had_guillotine[id] = 0
            g_guillotine_ammo[id] = 0
            
            return FMRES_SUPERCEDE
        }
    }

    return FMRES_IGNORED;
}

public fw_AddToPlayer_Post(ent, id)
{
    if(pev(ent, pev_impulse) == WEAPON_SECRETCODE)
    {
        g_had_guillotine[id] = 1
        g_guillotine_ammo[id] = pev(ent, pev_iuser4)
        
        set_pev(ent, pev_impulse, 0)
    }            
    
    /* 
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("WeaponList"), _, id)
    write_string((g_had_guillotine[id] == 1 ? "weapon_guillotine" : "weapon_mac10"))
    write_byte(6)
    write_byte(100)
    write_byte(-1)
    write_byte(-1)
    write_byte(0)
    write_byte(13)
    write_byte(CSW_BDRIPPER)
    write_byte(0)*/
}

public update_ammo(id)
{
    if(!is_user_alive(id))
        return

    static weapon_ent; weapon_ent = fm_get_user_weapon_entity(id, CSW_BDRIPPER)
    if(!pev_valid(weapon_ent)) return
    
    cs_set_weapon_ammo(weapon_ent, g_guillotine_ammo[id])    
    //cs_set_user_bpammo(id, CSW_BDRIPPER, g_guillotine_ammo[id])
    
    engfunc(EngFunc_MessageBegin, MSG_ONE_UNRELIABLE, get_user_msgid("CurWeapon"), {0, 0, 0}, id)
    write_byte(1)
    write_byte(CSW_BDRIPPER)
    write_byte(-1)
    message_end()
    
    message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("AmmoX"), _, id)
    write_byte(1)
    write_byte(g_guillotine_ammo[id])
    message_end()
}

public fw_traceline(Float:v1[3],Float:v2[3],noMonsters,id,ptr)
{
    if(!is_user_alive(id))
        return HAM_IGNORED    
    if(get_user_weapon(id) != CSW_BDRIPPER || !g_had_guillotine[id])
        return HAM_IGNORED

    // get crosshair aim
    static Float:aim[3];
    get_aim(id,v1,aim);
    
    // do another trace to this spot
    new trace = create_tr2();
    engfunc(EngFunc_TraceLine,v1,aim,noMonsters,id,trace);
    
    // copy ints
    set_tr2(ptr,TR_AllSolid,get_tr2(trace,TR_AllSolid));
    set_tr2(ptr,TR_StartSolid,get_tr2(trace,TR_StartSolid));
    set_tr2(ptr,TR_InOpen,get_tr2(trace,TR_InOpen));
    set_tr2(ptr,TR_InWater,get_tr2(trace,TR_InWater));
    set_tr2(ptr,TR_pHit,get_tr2(trace,TR_pHit));
    set_tr2(ptr,TR_iHitgroup,get_tr2(trace,TR_iHitgroup));

    // copy floats
    get_tr2(trace,TR_flFraction,aim[0]);
    set_tr2(ptr,TR_flFraction,aim[0]);
    get_tr2(trace,TR_flPlaneDist,aim[0]);
    set_tr2(ptr,TR_flPlaneDist,aim[0]);
    
    // copy vecs
    get_tr2(trace,TR_vecEndPos,aim);
    set_tr2(ptr,TR_vecEndPos,aim);
    get_tr2(trace,TR_vecPlaneNormal,aim);
    set_tr2(ptr,TR_vecPlaneNormal,aim);

    // get rid of new trace
    free_tr2(trace);

    return FMRES_IGNORED;
}

get_aim(id,Float:source[3],Float:ret[3])
{
    static Float:vAngle[3], Float:pAngle[3], Float:dir[3], Float:temp[3];

    // get aiming direction from forward global based on view angle and punch angle
    pev(id,pev_v_angle,vAngle);
    pev(id,pev_punchangle,pAngle);
    xs_vec_add(vAngle,pAngle,temp);
    engfunc(EngFunc_MakeVectors,temp);
    global_get(glb_v_forward,dir);
    
    /* vecEnd = vecSrc + vecDir * flDistance; */
    xs_vec_mul_scalar(dir,8192.0,temp);
    xs_vec_add(source,temp,ret);
}

public fake_smokes(Float:Origin[3])
{
    static TE_FLAG
    
    TE_FLAG |= TE_EXPLFLAG_NODLIGHTS
    TE_FLAG |= TE_EXPLFLAG_NOSOUND
    TE_FLAG |= TE_EXPLFLAG_NOPARTICLES
    
    engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, Origin, 0)
    write_byte(TE_EXPLOSION)
    engfunc(EngFunc_WriteCoord, Origin[0])
    engfunc(EngFunc_WriteCoord, Origin[1])
    engfunc(EngFunc_WriteCoord, Origin[2])
    write_short(g_smokepuff_id)
    write_byte(6)
    write_byte(25)
    write_byte(TE_FLAG)
    message_end()
}

stock set_weapon_anim(id, anim)
{
    if(!is_user_alive(id))
        return
    
    set_pev(id, pev_weaponanim, anim)
    
    message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, {0, 0, 0}, id)
    write_byte(anim)
    write_byte(pev(id, pev_body))
    message_end()
}

stock kill(k, v, headshot)
{
    //cs_set_user_money(k, cs_get_user_money(k) + 500)
    
    set_user_frags(k, get_user_frags(k) + 1)
    
    set_msg_block(g_MsgDeathMsg,BLOCK_ONCE)
    set_msg_block(gmsgScoreInfo,BLOCK_ONCE)
    user_kill(v,1)
    
    new kteam = get_user_team(k);
    new vteam = get_user_team(v);
    
    new kfrags = get_user_frags(k);
    new kdeaths = get_user_deaths(k);
    
    new vfrags = get_user_frags(v);
    new vdeaths = get_user_deaths(v);
    
    emessage_begin(MSG_ALL, gmsgScoreInfo);
    ewrite_byte(k);
    ewrite_short(kfrags);
    ewrite_short(kdeaths);
    ewrite_short(0);
    ewrite_short(kteam);
    emessage_end();
    
    emessage_begin(MSG_ALL, gmsgScoreInfo);
    ewrite_byte(v);
    ewrite_short(vfrags);
    ewrite_short(vdeaths);
    ewrite_short(0);
    ewrite_short(vteam);
    emessage_end();
    
    emessage_begin(MSG_BROADCAST, g_MsgDeathMsg)
    ewrite_byte(k)
    ewrite_byte(v)
    ewrite_byte(headshot)
    ewrite_string("Blood Dripper")
    emessage_end()
}


stock create_blood(const Float:origin[3])
{
    // Show some blood :)
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY) 
    write_byte(TE_BLOODSPRITE)
    engfunc(EngFunc_WriteCoord, origin[0])
    engfunc(EngFunc_WriteCoord, origin[1])
    engfunc(EngFunc_WriteCoord, origin[2])
    write_short(m_iBlood[1])
    write_short(m_iBlood[0])
    write_byte(75)
    write_byte(8)
    message_end()
    
    message_begin(MSG_BROADCAST, SVC_TEMPENTITY) 
    write_byte(TE_BLOODSPRITE)
    engfunc(EngFunc_WriteCoord, origin[0])
    engfunc(EngFunc_WriteCoord, origin[1])
    engfunc(EngFunc_WriteCoord, origin[2])
    write_short(m_iBlood[1])
    write_short(m_iBlood[0])
    write_byte(75)
    write_byte(12)
    message_end()
}

stock drop_weapons(id, dropwhat)
{
    static weapons[32], num, i, weaponid
    num = 0
    get_user_weapons(id, weapons, num)
     
    for (i = 0; i < num; i++)
    {
        weaponid = weapons[i]
          
        if (dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM))
        {
            static wname[32]
            get_weaponname(weaponid, wname, sizeof wname - 1)
            engclient_cmd(id, "drop", wname)
        }
    }
}

stock Get_MissileWeaponHitGroup( iEnt )
{
    new Float:flStart[ 3 ], Float:flEnd[ 3 ];
    
    pev( iEnt, pev_origin, flStart );
    pev( iEnt, pev_velocity, flEnd );
    xs_vec_add( flStart, flEnd, flEnd );
    
    new ptr = create_tr2();
    engfunc( EngFunc_TraceLine, flStart, flEnd, 0, iEnt, ptr );
    
    new iHitGroup, Owner, nOhead, head
    Owner = pev(iEnt, pev_iuser1)
    nOhead = get_tr2( ptr, TR_iHitgroup )
    head = set_tr2( ptr, TR_iHitgroup, HIT_HEAD )
    
    iHitGroup = headshot_mode[Owner] ? head : nOhead
    
    free_tr2( ptr );
    
    return iHitGroup;
}

stock get_position(id,Float:forw, Float:right, Float:up, Float:vStart[])
{
   static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
   
   pev(id, pev_origin, vOrigin)
   pev(id, pev_view_ofs, vUp) //for player
   xs_vec_add(vOrigin, vUp, vOrigin)
   pev(id, pev_v_angle, vAngle) // if normal entity ,use pev_angles
   
   angle_vector(vAngle, ANGLEVECTOR_FORWARD, vForward) //or use EngFunc_AngleVectors
   angle_vector(vAngle, ANGLEVECTOR_RIGHT, vRight)
   angle_vector(vAngle, ANGLEVECTOR_UP, vUp)
   
   vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
   vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
   vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
}

stock set_weapons_timeidle(id, WeaponId ,Float:TimeIdle)
{
    if(!is_user_alive(id))
        return
        
    static entwpn; entwpn = fm_get_user_weapon_entity(id, WeaponId)
    if(!pev_valid(entwpn)) 
        return
        
    set_pdata_float(entwpn, 48, TimeIdle + 0.2, OFFSET_LINUX_WEAPONS)
}

stock set_player_nextattackx(id, Float:nexttime)
{
    if(!is_user_alive(id))
        return
        
    set_pdata_float(id, m_flNextAttack, nexttime, 5)
}

stock create_velocity_vector(victim,attacker,Float:velocity[3])
{
    if(!is_user_alive(victim) || !is_user_alive(attacker))
        return 0;

    new Float:vicorigin[3];
    new Float:attorigin[3];
    entity_get_vector(victim   , EV_VEC_origin , vicorigin);
    entity_get_vector(attacker , EV_VEC_origin , attorigin);

    new Float:origin2[3]
    origin2[0] = vicorigin[0] - attorigin[0];
    origin2[1] = vicorigin[1] - attorigin[1];

    new Float:largestnum = 0.0;

    if(floatabs(origin2[0])>largestnum) largestnum = floatabs(origin2[0]);
    if(floatabs(origin2[1])>largestnum) largestnum = floatabs(origin2[1]);

    origin2[0] /= largestnum;
    origin2[1] /= largestnum;

    velocity[0] = ( origin2[0] * (get_pcvar_float(gui_power) * 3000) ) / get_entity_distance(victim , attacker);
    velocity[1] = ( origin2[1] * (get_pcvar_float(gui_power) * 3000) ) / get_entity_distance(victim , attacker);
    if(velocity[0] <= 20.0 || velocity[1] <= 20.0)
        velocity[2] = random_float(200.0 , 275.0);

    return 1;
} 


[DeMNiX]

did u try to swap attacker's and victim's origins here?

    new Float:origin2[3]
    origin2[0] = vicorigin[0] - attorigin[0];
    origin2[1] = vicorigin[1] - attorigin[1];

=>

    new Float:origin2[3]
    origin2[0] = attorigin[0] - vicorigin[0];
    origin2[1] = attorigin[1] - vicorigin[1];

[OciXCrom]

new Float:fVelocity[3]
velocity_by_aim(iAttacker, 750, fVelocity)
fVelocity[2] = 150.0
set_pev(iVictim, pev_velocity, fVelocity)

[Natsheh]

Originally Posted by OciXCrom new Float:fVelocity[3] velocity_by_aim(iAttacker, 750, fVelocity) fVelocity[2] = 150.0 set_pev(iVictim, pev_velocity, fVelocity)

What is this supposed to achieve?


If I were you I would totally get rid of this function create_velocity_vector(victim,attacker,Float: velocity[3])
Since it's really confusing and doesn't make alot of sense.

[OciXCrom]

Originally Posted by Natsheh What is this supposed to achieve?

This is the simplest of knockback codes I that use in my plugins and works properly.

By the way, didn't look at the code, but if you're trying to add knockback in my Knife Models plugin, it already exists - https://amxx-bg.info/viewtopic.php?t=9012

[Natsheh]

I've remembered, i made something efficient about knockback awhile ago, here you go.

Spoiler

#include <amxmodx>
#include <fakemeta>
#include <xs>

#define VERSION "1.0"
#define AUTHOR "Natsheh"


entity_explosion_knockback(victim, Float:fExpOrigin[3], Float:fExpShockwaveRadius=500.0, Float:fExpShockwavePower=500.0)
{
    new Float:fOrigin[3], Float:fDistVec[3];
    pev(victim, pev_origin, fOrigin);
    
    xs_vec_sub(fOrigin, fExpOrigin, fDistVec);
    
    new Float:g_fTemp;
    // victim is in the range of the shockwave explosion!
    if((g_fTemp=xs_vec_len(fDistVec)) <= fExpShockwaveRadius)
    {
        new Float:fPower = fExpShockwavePower * ( 1.0 - ( g_fTemp / floatmax(fExpShockwaveRadius, 1.0) ) ), Float:fVelo[3], Float:fKnockBackVelo[3];
        
        pev(victim, pev_velocity, fVelo);
        xs_vec_normalize(fDistVec, fKnockBackVelo);
        xs_vec_mul_scalar(fKnockBackVelo, fPower, fKnockBackVelo);
        xs_vec_add(fVelo, fKnockBackVelo, fVelo);
        set_pev(victim, pev_velocity, fVelo);
    }
} 

entity_damage_knockback(victim, Float:fDirection[3], Float:fForce)
{
    static Float:fVelo[3], Float:fVec[3];
    pev(victim, pev_velocity, fVelo);
    xs_vec_mul_scalar(fDirection, fForce, fVec);
    xs_vec_add(fVelo, fVec, fVelo);
    set_pev(victim, pev_velocity, fVelo);
}

how to properly use it inside event_damage

Spoiler

PHP Code:

public event_Damage(id)
{
    if(!get_pcvar_num(gui_knockback))
        return PLUGIN_CONTINUE;

    if(!is_user_alive(id))
        return PLUGIN_CONTINUE;

    new weapon , attacker = get_user_attacker(id , weapon);

    if(!is_user_alive(attacker))
        return PLUGIN_CONTINUE;

    if(weapon == CSW_BDRIPPER)
    {
        new Float:fVicOrigin[3], Float:fAttOrigin[3], Float:fDirection[3];
        pev(id, pev_origin, fVicOrigin);
        pev(attacker, pev_origin, fAttOrigin);
        const ARG_DAMAGE_TAKE = 2
        xs_vec_sub(fAttOrigin, fVicOrigin, fDirection);
        xs_vec_normalize(fDirection, fDirection);
        entity_damage_knockback(id, fDirection, float(read_data(ARG_DAMAGE_TAKE )));
;    }

    return PLUGIN_CONTINUE;
}

entity_damage_knockback(victim, Float:fDirection[3], Float:fForce)
{
    static Float:fVelo[3], Float:fVec[3];
    pev(victim, pev_velocity, fVelo);
    xs_vec_mul_scalar(fDirection, fForce, fVec);
    xs_vec_add(fVelo, fVec, fVelo);
    set_pev(victim, pev_velocity, fVelo);
} 


also i forgot to mention this is not the correct forum for requests.

Originally Posted by OciXCrom new Float:fVelocity[3] velocity_by_aim(iAttacker, 750, fVelocity) fVelocity[2] = 150.0 set_pev(iVictim, pev_velocity, fVelocity)

i get that you're pushing the victim back using the attacker aim direction but why you're setting his z velocity to 150, and why you're not adding the knockback velocity to the victim's velocity, it would be preferred.

[nG_getwreck]

Originally Posted by OciXCrom This is the simplest of knockback codes I that use in my plugins and works properly. By the way, didn't look at the code, but if you're trying to add knockback in my Knife Models plugin, it already exists - https://amxx-bg.info/viewtopic.php?t=9012

But the weapon base is mac 10, it might not work.