AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Scripting Help (https://forums.alliedmods.net/forumdisplay.php?f=11)
-   -   argument type mismatch (https://forums.alliedmods.net/showthread.php?t=335634)

itoxicreal 12-19-2021 23:25

argument type mismatch
 
1 Attachment(s)
banshee.inl(48 ) : error 035: argument type mismatch (argument 5)
finger.inl(104) : error 035: argument type mismatch (argument 5)

hey can someone help me I'm trying to compile but it gives me errors


https://imgur.com/CHcBq6Q

the 3 files inside zpclasses

Code:

new const banshee_name[] = "Witch"
new const banshee_info[] = "\y[ Мыши \r[G]\y ]"
new const banshee_model[] = "witch"
new const banshee_clawmodel[] = "v_knife_witch_zombi.mdl"
new const banshee_bmodel[] = "v_bomb.mdl"
const banshee_health = 4600
const banshee_speed = 280
const Float:banshee_gravity = 0.69
const Float:banshee_knockback = 0.1

new const SOUND_FIRE[] = "banshee/fire.wav"
new const SOUND_BAT_HIT[] = "infect_zm.wav"
new const SOUND_BAT_MISS[] = "banshee/fail.wav"
new const MODEL_BAT[] = "models/bat_witch.mdl"
new const BAT_CLASSNAME[] = "banchee_bat"
new spr_skull

new cvar_flytime, cvar_catchtime,
 cvar_banshee_timewait

new g_stop[33]
new g_bat_time[33]
new g_bat_stat[33]
new g_bat_enemy[33]
new Float:g_b_temp_speed[33]
new banshee_cooldown_time[33] = 0
new banshee_cooldown[33] = 0

enum (+= 100)
{
        TASK_BOT_USE_SKILL = 2367,
        TASK_REMOVE_STAT
}

#define ID_BOT_USE_SKILL (taskid - TASK_BOT_USE_SKILL)
#define ID_TASK_REMOVE_STAT (taskid - TASK_REMOVE_STAT)

BansheePrecache()
{
        precache_sound(SOUND_FIRE)
        precache_sound(SOUND_BAT_HIT)
        precache_sound(SOUND_BAT_MISS)
       
        precache_model(MODEL_BAT)
       
        spr_skull = precache_model("sprites/ef_bat.spr")
       
        g_Banshee = zp_register_zombie_class(banshee_name, banshee_info, banshee_model, banshee_clawmodel, banshee_bmodel, banshee_health, banshee_speed, banshee_gravity, banshee_knockback)
}

BansheeInit()
{
        register_event("DeathMsg", "EventDeath", "a")
       
        register_clcmd("drop", "cmd_bat")
       
        register_forward(FM_PlayerPreThink,"fw_PlayerPreThink")
       
        RegisterHam(Ham_Touch,"info_target","EntityTouchPost",1)
        RegisterHam(Ham_Think,"info_target","EntityThink")
       
        cvar_flytime = register_cvar("zp_banshee_fly_time", "3.0")
        cvar_catchtime = register_cvar("zp_banshee_catch_time", "10.0")
        cvar_banshee_timewait  = register_cvar("zp_banshee_bat_cooldown", "25.0")
}

BansheePIS(id)
{
        reset_value_player(id)
}

BansheeDisc(id)
{
        reset_value_player(id)
}

public BansheeHLTV()
{
        for(new id = 1; id <= g_maxplayers; id++)
        {
                if (!is_user_connected(id)) continue;
               
                reset_value_player(id)
        }
}

public EventDeath()
{
        new id = read_data(2)
       
        reset_value_player(id)
}

BansheeInfectPost(id)
{
        reset_value_player(id)
       
        if(zp_get_user_nemesis(id)) return;
       
        if(zp_get_user_zombie_class(id) == g_Banshee)
        {
                if(is_user_bot(id))
                {
                        set_task(random_float(5.0,15.0), "bot_use_skill", id+TASK_BOT_USE_SKILL)
                        return
                }
               
                ChatColor(id, "%L", 0, "BANSHEE_INFECT", get_pcvar_float(cvar_banshee_timewait))
        }
}

BansheeHumanizedPost(id)
{
        reset_value_player(id)
}

public cmd_bat(id)
{
        if(!is_user_alive(id) || !zp_get_user_zombie(id) || zp_get_user_nemesis(id) || g_roundend) return PLUGIN_CONTINUE
       
        if(zp_get_user_zombie_class(id) == g_Banshee && !g_bat_time[id])
        {
                g_bat_time[id] = 1
               
                set_task(get_pcvar_float(cvar_banshee_timewait),"clear_stat",id+TASK_REMOVE_STAT)
               
                new ent = engfunc(EngFunc_CreateNamedEntity,engfunc(EngFunc_AllocString,"info_target"))
               
                if(!pev_valid(ent)) return PLUGIN_HANDLED
               
                new Float:vecAngle[3],Float:vecOrigin[3],Float:vecVelocity[3],Float:vecForward[3]
                fm_get_user_startpos(id,5.0,2.0,-1.0,vecOrigin)
                pev(id,pev_angles,vecAngle)
               
                engfunc(EngFunc_MakeVectors,vecAngle)
                global_get(glb_v_forward,vecForward)
               
                velocity_by_aim(id,850,vecVelocity)
               
                set_pev(ent,pev_origin,vecOrigin)
                set_pev(ent,pev_angles,vecAngle)
                set_pev(ent,pev_classname,BAT_CLASSNAME)
                set_pev(ent,pev_movetype,MOVETYPE_FLY)
                set_pev(ent,pev_solid,SOLID_BBOX)
                engfunc(EngFunc_SetSize,ent,{-20.0,-15.0,-8.0},{20.0,15.0,8.0})
               
                engfunc(EngFunc_SetModel,ent,MODEL_BAT)
                set_pev(ent,pev_animtime,get_gametime())
                set_pev(ent,pev_framerate,1.0)
                set_pev(ent,pev_owner,id)
                set_pev(ent,pev_velocity,vecVelocity)
                set_pev(ent,pev_nextthink,get_gametime()+get_pcvar_float(cvar_flytime))
                emit_sound(ent, CHAN_WEAPON, SOUND_FIRE, 1.0, ATTN_NORM, 0, PITCH_NORM)
               
                g_stop[id] = ent
               
                PlayWeaponAnimation(id, 2)
                pev(id, pev_maxspeed, g_b_temp_speed[id])
                set_pev(id,pev_maxspeed,0.1)
               
                banshee_cooldown_time[id] = floatround(get_pcvar_float(cvar_banshee_timewait))
               
                set_task(1.0, "ShowBansheeHUD", id, _, _, "b")
               
                return PLUGIN_HANDLED
        }
       
        return PLUGIN_CONTINUE
}

public fw_PlayerPreThink(id)
{
        if(!is_user_alive(id)) return FMRES_IGNORED
       
        if(g_bat_stat[id])
        {
                new owner, Float:ownerorigin[3]
                owner = g_bat_enemy[id]
                if(!is_user_alive(owner)) {
                        static ent
                        ent = fm_find_ent_by_owner(-1, BAT_CLASSNAME, owner)
                        set_pev(ent,pev_nextthink,get_gametime())
                       
                        g_bat_enemy[id] = 0
                        g_bat_stat[id] = 0
                        return FMRES_IGNORED
                }
                pev(owner,pev_origin,ownerorigin)
                static Float:vec[3]
                aim_at_origin(id,ownerorigin,vec)
                engfunc(EngFunc_MakeVectors, vec)
                global_get(glb_v_forward, vec)
                vec[0] *= 150.0
                vec[1] *= 150.0
                vec[2] -= 1.0
                set_pev(id,pev_velocity,vec)
        }
       
        return FMRES_IGNORED
}

public EntityThink(ent)
{
        if(!pev_valid(ent)) return HAM_IGNORED
       
        new classname[32]
        pev(ent,pev_classname,classname,31)
       
        if(equal(classname,BAT_CLASSNAME))
        {
                static Float:origin[3];
                pev(ent,pev_origin,origin);
               
                message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
                write_byte(TE_EXPLOSION); // TE_EXPLOSION
                write_coord(floatround(origin[0])); // origin x
                write_coord(floatround(origin[1])); // origin y
                write_coord(floatround(origin[2])); // origin z
                write_short(spr_skull); // sprites
                write_byte(40); // scale in 0.1's
                write_byte(30); // framerate
                write_byte(14); // flags
                message_end(); // message end
               
                emit_sound(ent, CHAN_WEAPON, SOUND_BAT_MISS, 1.0, ATTN_NORM, 0, PITCH_NORM)
               
                new owner = pev(ent, pev_owner)
                g_stop[owner] = 0
                set_pev(owner,pev_maxspeed,g_b_temp_speed[owner])
               
                engfunc(EngFunc_RemoveEntity,ent)
        }
       
        return HAM_IGNORED
}

public EntityTouchPost(ent,ptd)
{
        if(!pev_valid(ent)) return HAM_IGNORED
       
        new classname[32]
        pev(ent,pev_classname,classname,31)
       
        if(equal(classname,BAT_CLASSNAME))
        {
                if(!pev_valid(ptd) || (0 < ptd && ptd <= g_maxplayers && is_user_alive(ptd) && (zp_get_user_zombie(ptd) || zp_get_user_survivor(ptd))))
                {
                        static Float:origin[3];
                        pev(ent,pev_origin,origin);
                       
                        message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
                        write_byte(TE_EXPLOSION); // TE_EXPLOSION
                        write_coord(floatround(origin[0])); // origin x
                        write_coord(floatround(origin[1])); // origin y
                        write_coord(floatround(origin[2])); // origin z
                        write_short(spr_skull); // sprites
                        write_byte(40); // scale in 0.1's
                        write_byte(30); // framerate
                        write_byte(14); // flags
                        message_end(); // message end
                       
                        emit_sound(ent, CHAN_WEAPON, SOUND_BAT_MISS, 1.0, ATTN_NORM, 0, PITCH_NORM)
                       
                        new owner = pev(ent, pev_owner)
                        g_stop[owner] = 0
                        set_pev(owner,pev_maxspeed,g_b_temp_speed[owner])
                       
                        engfunc(EngFunc_RemoveEntity,ent)
                       
                        return HAM_IGNORED
                }
               
                new owner = pev(ent,pev_owner)
               
                if(0 < ptd && ptd <= g_maxplayers && is_user_alive(ptd) && ptd != owner)
                {
                        g_bat_enemy[ptd] = owner
                       
                        set_pev(ent,pev_nextthink,get_gametime()+get_pcvar_float(cvar_catchtime))
                        set_task(get_pcvar_float(cvar_catchtime),"clear_stat2",ptd+TASK_REMOVE_STAT)
                        set_pev(ent,pev_movetype,MOVETYPE_FOLLOW)
                        set_pev(ent,pev_aiment,ptd)
                       
                        emit_sound(owner, CHAN_VOICE, SOUND_BAT_HIT, 1.0, ATTN_NORM, 0, PITCH_NORM)
                       
                        g_bat_stat[ptd] = 1
                }
        }
       
        return HAM_IGNORED
}

public clear_stat(taskid)
{
        new id = ID_TASK_REMOVE_STAT
       
        g_bat_stat[id] = 0
        g_bat_time[id] = 0
       
        banshee_cooldown[id] = 0
        banshee_cooldown_time[id] = 0
       
        ChatColor(id, "%L",0,"BANSHEE_RESET") 
}

public ShowBansheeHUD(id)
{
        if(!banshee_cooldown_time[id]){
        remove_task(id)
        return
        }
       
        if(is_user_alive(id) && zp_get_user_zombie(id))
        {
                banshee_cooldown_time[id]--
               
                set_hudmessage(200, 100, 0, 0.80, 0.87, 0, 1.0, 1.1, 0.0, 0.0, -1)
                show_hudmessage(id, "[ %L %d ]", id, "COUNTDOWN", banshee_cooldown_time[id])
        }
        else
        {
                remove_task(id)
        }
}

public clear_stat2(idx)
{
        new id = idx-TASK_REMOVE_STAT
       
        g_bat_enemy[id] = 0
        g_bat_stat[id] = 0
}

public bot_use_skill(taskid)
{
        new id = ID_BOT_USE_SKILL
       
        if (!is_user_alive(id)) return;
       
        cmd_bat(id)
       
        set_task(random_float(5.0,15.0), "bot_use_skill", id+TASK_BOT_USE_SKILL)
}

fm_get_user_startpos(id,Float:forw,Float:right,Float:up,Float:vStart[])
{
        new Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
       
        pev(id, pev_origin, vOrigin)
        pev(id, pev_v_angle, vAngle)
       
        engfunc(EngFunc_MakeVectors, vAngle)
       
        global_get(glb_v_forward, vForward)
        global_get(glb_v_right, vRight)
        global_get(glb_v_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
}

aim_at_origin(id, Float:target[3], Float:angles[3])
{
        static Float:vec[3]
        pev(id,pev_origin,vec)
        vec[0] = target[0] - vec[0]
        vec[1] = target[1] - vec[1]
        vec[2] = target[2] - vec[2]
        engfunc(EngFunc_VecToAngles,vec,angles)
        angles[0] *= -1.0
        angles[2] = 0.0
}

PlayWeaponAnimation(id, animation)
{
        set_pev(id, pev_weaponanim, animation)
        message_begin(MSG_ONE, SVC_WEAPONANIM, {0, 0, 0}, id)
        write_byte(animation)
        write_byte(pev(id, pev_body))
        message_end()
}

reset_value_player(id)
{
        g_stop[id] = 0
        g_bat_time[id] = 0
        g_bat_stat[id] = 0
        g_bat_enemy[id] = 0
       
        remove_task(id+TASK_BOT_USE_SKILL)
        remove_task(id+TASK_REMOVE_STAT)
}



Code:

new const finger_name[] = { "Sting Finger" }
new const finger_info[] = { "\y[ Урон \r[E] \y]" }
new const finger_model[] = { "finger" }
new const finger_clawmodel[] = { "v_knife_zombieresident.mdl" }
new const finger_bmodel[] = "v_bomb.mdl"
const finger_health = 4400
const finger_speed = 270
const Float:finger_gravity = 0.9 //Гравитация в обычном режиме
const Float:finger_knockback = 0.2 //Отдача

new cvar_fin_gravity_time, cvar_fin_gravity_cooldown, cvar_fin_hands_cooldown,
cvar_fin_gravity, cvar_fin_hands_dmg, cvar_fin_hands_distance

const FINGER_MAX_STRING = 128;

new bitsum_is_alive, bitsum_is_string

enum _:FINGER_ANIMATIONS
{
        LongDamageAnim  = 8,
        GravAnim,
        EndGrav,
};

enum _:SCREEN_FADE
{
        grav_red  = 255,
        grav_green      =255 ,
        grav_blue        = 255,
        long_red  = 0,
        long_green  = 255,
        long_blue    = 0,
};

enum _:FINGER_SOUNDS
{
        SKILL_2 = 0,
        SKILL_1,
        OVER_SKILL_GRAV
};

new g_Stinger_sound[FINGER_SOUNDS][FINGER_MAX_STRING] =
{
        "apokalipsis/resident_skill2.wav",
        "apokalipsis/resident_skill1.wav",
        "apokalipsis/resident_tw.wav"
};


new        g_damage_use[ 33 ] ,
    g_gravity_use[ 33] ,
    g_coldown[ 33 ] ,
    g_clodown_grav[33] ,
    g_coldown_dmg_time[33] ,
        g_coldown_grav_time[33] ;
       
#define get_bit_alive(%1) (bitsum_is_alive & (1 << (%1-1)))
#define get_bit_string(%1) (bitsum_is_string & (1 << (%1-1)))
#define TASK_SHOWHUD 45543
#define TASK_SHOWHUD2 73664
#define ID_SHOWHUD (taskid - TASK_SHOWHUD)
#define ID_SHOWHUD2 (taskid - TASK_SHOWHUD2)
   
FingerInit()
{
        register_forward(FM_CmdStart , "fm_cmdstart" ) ;

        RegisterHam(Ham_Spawn, "player", "fw_PlayerSpawn_Post", 1)
               
        cvar_fin_gravity_time = register_cvar("zp_finger_gravity_time", "10.0")
        cvar_fin_gravity_cooldown = register_cvar("zp_finger_gravity_cooldown", "25.0")
        cvar_fin_hands_cooldown = register_cvar("zp_finger_hands_cooldown", "10.0")
        cvar_fin_gravity = register_cvar("zp_finger_gravity", "0.3")
        cvar_fin_hands_dmg = register_cvar("zp_finger_hands_damage", "125")
        cvar_fin_hands_distance = register_cvar("zp_finger_hands_distance", "400")
}

public fw_PlayerSpawn_Post(id)
{
        if(!is_user_alive(id))
                return
               
        bitsum_is_alive |= (1<<(id-1))

        if(zp_get_user_zombie(id) && zp_get_user_zombie_class(id) == g_Finger)
                bitsum_is_string |= (1<<(id-1))
        else
                bitsum_is_string &= ~(1<<(id-1))
}

public fw_PlayerKilled(victim, attacker, shouldgib)
{
        bitsum_is_alive &= ~(1<<(victim-1))
        bitsum_is_string &= ~(1<<(victim-1))

        if(zp_get_user_zombie(victim) && zp_get_user_zombie_class(victim) == g_Finger && !zp_get_user_nemesis(victim))
        {
                set_entity_visibility(victim,0)
        }       
}

FingerPrecache()
{
        g_Finger = zp_register_zombie_class(finger_name, finger_info, finger_model, finger_clawmodel, finger_bmodel, finger_health, finger_speed, finger_gravity, finger_knockback) ;
       
        static i ;
       
        for(i = 0; i < sizeof g_Stinger_sound; i++)
                precache_sound(g_Stinger_sound[i])       
}

FingerInfectPost(player)
{
        if(zp_get_user_zombie_class(player) == g_Finger && !zp_get_user_nemesis(player))
        {
                bitsum_is_string |= (1<<(player-1))
                g_damage_use[player] = false
                g_gravity_use[player] = false
               
                g_coldown[player] = false
                g_clodown_grav[player] = false
                               
                g_coldown_dmg_time[player] = floatround(get_pcvar_float(cvar_fin_hands_cooldown))
                g_coldown_grav_time[player] = floatround(get_pcvar_float(cvar_fin_gravity_cooldown))

                ChatColor(player , "%L" , LANG_PLAYER , "FINGER")
                {
                        return PLUGIN_HANDLED
                }
        }
       
        return PLUGIN_CONTINUE       
}

FingerHumanizedPost(id) bitsum_is_string &= ~(1<<(id-1))

FingerDisc(id)
{
        g_damage_use[id] = false
        g_gravity_use[id] = false
        bitsum_is_string &= ~(1<<(id-1))
}
       
public fm_cmdstart(player , UC_Handle , seed)
{
        if (!get_bit_string(player) || g_roundend)
                return PLUGIN_HANDLED
       
        static gButton, gOldButton
                       
        gButton = get_uc(UC_Handle, UC_Buttons)
        gOldButton = pev(player, pev_oldbuttons)
               
        if(!g_clodown_grav[player] && gButton & IN_RELOAD && !(gOldButton & IN_RELOAD))
                        UTIL_Gravity(player)

        if(!g_coldown[player] && gButton & IN_USE && !(gOldButton & IN_USE))
                        UTIL_LongDamage(player)

        return PLUGIN_HANDLED
}

stock UTIL_Gravity(player)
{
        g_gravity_use[player] = true
 
        UTIL_PlayAnim(player , GravAnim)
                                 
        g_clodown_grav[player] = true
                                 
        UTIL_ScreenFade(player , 255 , 255 , 255)
                                 
        set_pdata_float(player , 83, 1.0 , 5)
                     
        set_pev( player, pev_gravity, get_pcvar_float(cvar_fin_gravity))
                                 
        set_task(get_pcvar_float(cvar_fin_gravity_time) , "remove_abil" , player ) 
                                 
        g_coldown_grav_time[player] = floatround(get_pcvar_float(cvar_fin_gravity_cooldown))
                                 
        set_task(1.0, "ShowFingerHUD_grav", player+TASK_SHOWHUD, _, _, "a",g_coldown_grav_time[player])
                                 
        set_task(get_pcvar_float(cvar_fin_gravity_cooldown) , "reset_grav" , player)
       
        engfunc( EngFunc_EmitSound, player, CHAN_ITEM, g_Stinger_sound[0], 1.0, ATTN_NORM, 0, PITCH_NORM)       
}       

public ShowFingerHUD_grav(taskid)
{
        if(get_bit_string(ID_SHOWHUD))
        {
                g_coldown_grav_time[ID_SHOWHUD] -= 1
                set_hudmessage(200, 100, 0, 0.59, 0.94, 0, 6.0, 1.1, 0.0, 0.0, -1)
                show_hudmessage(ID_SHOWHUD, "[ %L ]", LANG_PLAYER, "GRAV_USE" , g_coldown_grav_time[ID_SHOWHUD])
        }
        else
                remove_task(taskid)
}

public remove_abil(player)
{
        if (!get_bit_string(player))
                return
       
        g_gravity_use[player] = false 
       
        set_pev( player, pev_gravity, finger_gravity )
       
        UTIL_PlayAnim(player , EndGrav)
         
        UTIL_ScreenFade(player , grav_red , grav_green , grav_blue)
       
        ChatColor(player , "%L" , LANG_PLAYER , "FINGER_GRAV_OVER" )
       
        engfunc( EngFunc_EmitSound, player, CHAN_ITEM, g_Stinger_sound[2], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public reset_grav(player)
{
        if (!get_bit_string(player))
                return
       
        g_clodown_grav[player] = 0
               
        ChatColor(player , "%L" , LANG_PLAYER , "FINGER_GRAV_ALLREADY" )
}       

stock UTIL_LongDamage(player)
{
        g_damage_use[player] = true 
               
        UTIL_PlayAnim( player , LongDamageAnim )

        g_coldown[player] = 1
               
        UTIL_ScreenFade(player , long_red , long_green , long_blue)
               
        set_pdata_float(player , 83, 1.0 , 5)
               
        Skill(player)
               
        set_task(get_pcvar_float(cvar_fin_hands_cooldown), "reset_abil" , player)
               
        g_coldown_dmg_time[player] = floatround(get_pcvar_float(cvar_fin_hands_cooldown))
               
        set_task(1.0, "ShowFingerHUD", player+TASK_SHOWHUD2, _, _, "a",g_coldown_dmg_time[player])
       
        engfunc( EngFunc_EmitSound, player, CHAN_ITEM, g_Stinger_sound[1], 1.0, ATTN_NORM, 0, PITCH_NORM)
       
        return FMRES_IGNORED
}

public ShowFingerHUD(taskid)
{
        if(get_bit_string(ID_SHOWHUD2))
        {
                g_coldown_dmg_time[ID_SHOWHUD2] -= 1
                set_hudmessage(0, 255, 255, -1.0, 0.89, 0, 6.0, 1.1, 0.0, 0.0, -1)
                show_hudmessage(ID_SHOWHUD2, "[ %L ]", LANG_PLAYER, "DMG_USE" , g_coldown_dmg_time[ID_SHOWHUD2])
        }
        else
                remove_task(taskid)
}

stock Skill(player)
{       
        static gBody , gTarget 
        get_user_aiming(player , gTarget , gBody , get_pcvar_num(cvar_fin_hands_distance))
       
        if(!(0 < gTarget < 33) || !get_bit_alive(gTarget))
                return
       
        new Float:flDamage
        flDamage=get_pcvar_float(cvar_fin_hands_dmg)       
        switch(gBody)
        {
                case HIT_STOMACH: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 2.0
                case HIT_HEAD: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 3.0
                case HIT_LEFTARM: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 1.0
                case HIT_RIGHTARM: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 1.0
                case HIT_LEFTLEG: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 0.5
                case HIT_RIGHTLEG: flDamage=get_pcvar_num(cvar_fin_hands_dmg) * 0.5
        }
        if(flDamage >= pev(gTarget, pev_health))
        {
                if(zp_infect_user(gTarget, player, 0, 1)) return
        }
        else               
                ExecuteHam(Ham_TakeDamage, gTarget, player, player, flDamage, DMG_SLASH)
}

public reset_abil(player)
{
        if (!get_bit_string(player))
                return
       
        g_damage_use[player] = false
        g_coldown[player] = 0
               
        ChatColor(player , "%L" , LANG_PLAYER , "FINGER_DMG_ALLREADY" ) 
}
       
stock UTIL_ScreenFade( player, r = 0, g = 0, b = 0)
{
        message_begin( MSG_ONE_UNRELIABLE, g_msgScreenFade, .player = player );
        write_short(  1 << 12  );
        write_short(  1 << 12  );
        write_short( 0x0000 );
        write_byte( r );
        write_byte( g );
        write_byte( b );
        write_byte( 80 );
        message_end( );
}
       
stock UTIL_PlayAnim(player , seq)
{
        set_pev(player, pev_weaponanim, seq)
       
        message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = player)
        write_byte(seq)
        write_byte(pev(player, pev_body))
        message_end()
}

Code:

new bool:g_bIsConnected[33]
new g_maxplayers
new g_roundend

new g_msgSayText, g_msgScreenFade

new g_Finger, g_Banshee


new Float:g_fLastUse[33]

#define TASK_COOLDOWN 4578
#define TASK_END 457845

#define ID_COOLDOWN (taskid - TASK_COOLDOWN)
#define ID_END (taskid - TASK_END)

/*Main*/
public ZombiesInit()
{       
        FingerInit()
        BansheeInit()
       
        register_event("HLTV", "EventHLTV", "a", "1=0", "2=0")
        g_msgSayText = get_user_msgid("SayText")
        g_msgScreenFade = get_user_msgid("ScreenFade")
        g_maxplayers = get_maxplayers()
}

public ZombiesPrecache()
{
        FingerPrecache()
        BansheePrecache()
}

public zp_user_infected_post(id, infector, nemesis)
{
        FingerInfectPost(id)
        BansheeInfectPost(id)
}

public zp_user_humanized_post(id)
{
        FingerHumanizedPost(id)
        BansheeHumanizedPost(id)
}

public client_putinserver(id)
{
        g_bIsConnected[id] = true
        BansheePIS(id)
}

public client_disconnect(id)
{
        FingerDisc(id)
        BansheeDisc(id)
}

public EventHLTV()
{
        g_roundend = 0
       
        BansheeHLTV()
}

public zp_round_ened()
{
        g_roundend = 1
}

stock ChatColor(id, const input[], any:...)
{
        static iPlayersNum[32], iCount; iCount = 1
        static szMsg[191]
       
        vformat(szMsg, charsmax(szMsg), input, 3)
       
        replace_all(szMsg, 190, "!g", "^4") // Green Color
        replace_all(szMsg, 190, "!y", "^1") // Default Color
        replace_all(szMsg, 190, "!team", "^3") // Team Color
        replace_all(szMsg, 190, "!team2", "^0") // Team2 Color
       
        if(id) iPlayersNum[0] = id
        else get_players(iPlayersNum, iCount, "ch")
               
        for (new i = 0; i < iCount; i++)
        {
                if (g_bIsConnected[iPlayersNum[i]])
                {
                        message_begin(MSG_ONE_UNRELIABLE, g_msgSayText, _, iPlayersNum[i])
                        write_byte(iPlayersNum[i])
                        write_string(szMsg)
                        message_end()
                }
        }
}

zp_colored_print(target, const message[], any:...)
{
        static buffer[512], i, argscount
        argscount = numargs()
        vformat(buffer, charsmax(buffer), message, 3)
       
        replace_all(buffer, charsmax(buffer), "!g", "^x04") // Green Color
        replace_all(buffer, charsmax(buffer), "!y", "^x01") // Default Color
       
        // Send to everyone
        if (!target)
        {
                static player
                for (player = 1; player <= g_maxplayers; player++)
                {
                        // Not connected
                        if (!is_user_connected(player))
                                continue;
                       
                        // Remember changed arguments
                        static changed[5], changedcount // [5] = max LANG_PLAYER occurencies
                        changedcount = 0
                       
                        // Replace LANG_PLAYER with player id
                        for (i = 2; i < argscount; i++)
                        {
                                if (getarg(i) == LANG_PLAYER)
                                {
                                        setarg(i, 0, player)
                                        changed[changedcount] = i
                                        changedcount++
                                }
                        }
                       
                        // Send it
                        message_begin(MSG_ONE_UNRELIABLE, g_msgSayText, _, player)
                        write_byte(player)
                        write_string(buffer)
                        message_end()
                       
                        // Replace back player id's with LANG_PLAYER
                        for (i = 0; i < changedcount; i++)
                                setarg(changed[i], 0, LANG_PLAYER)
                }
        }
        // Send to specific target
        else
        {                       
                // Send it
                message_begin(MSG_ONE, g_msgSayText, _, target)
                write_byte(target)
                write_string(buffer)
                message_end()
        }
}

public task_ShowCooldown(taskid)
{
        if(!is_user_connected(ID_COOLDOWN) || !is_user_alive(ID_COOLDOWN) || !zp_get_user_zombie(ID_COOLDOWN) || zp_get_user_nemesis(ID_COOLDOWN) || get_gametime()-g_fLastUse[ID_COOLDOWN]>0.0)
        {
                remove_task(taskid)
                return
        }
       
        set_hudmessage(200, 100, 0, 0.59, 0.94, 0, 6.0, 1.1, 0.0, 0.0, -1)
        show_hudmessage(ID_COOLDOWN, "%L", ID_COOLDOWN, "COOLDOWN",floatround(get_gametime()-g_fLastUse[ID_COOLDOWN]))
}


zXCaptainXz 12-20-2021 09:55

Re: argument type mismatch
 
Your problem lies in those 2 lines:

banshee.inl
Code:

g_Banshee = zp_register_zombie_class(banshee_name, banshee_info, banshee_model, banshee_clawmodel, banshee_bmodel, banshee_health, banshee_speed, banshee_gravity, banshee_knockback)
finger.inl
Code:

g_Finger = zp_register_zombie_class(finger_name, finger_info, finger_model, finger_clawmodel, finger_bmodel, finger_health, finger_speed, finger_gravity, finger_knockback) ;
In include/zombieplague.inc, zp_register_zombie_class is defined as follows:

Code:

native zp_register_zombie_class(const name[], const info[], const model[], const clawmodel[], hp, speed, Float:gravity, Float:knockback)
This doesn’t support custom bomb models. So you should update your include/zombieplague.inc and plugin so that it supports custom bomb models. Or you can remove the custom bomb by making these changes:

banshee.inl

Code:

g_Banshee = zp_register_zombie_class(banshee_name, banshee_info, banshee_model, banshee_clawmodel, banshee_bmodel, banshee_health, banshee_speed, banshee_gravity, banshee_knockback)
—>

Code:

g_Banshee = zp_register_zombie_class(banshee_name, banshee_info, banshee_model, banshee_clawmodel, banshee_health, banshee_speed, banshee_gravity, banshee_knockback)
finger.inl

Code:

g_Finger = zp_register_zombie_class(finger_name, finger_info, finger_model, finger_clawmodel, finger_bmodel, finger_health, finger_speed, finger_gravity, finger_knockback) ;
—>

Code:

g_Finger = zp_register_zombie_class(finger_name, finger_info, finger_model, finger_clawmodel, finger_health, finger_speed, finger_gravity, finger_knockback) ;
You could also remove anything else related to the custom bomb to prevent unnecessary downloads.


All times are GMT -4. The time now is 11:40.

Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.