Discord sunucumuz açılmıştır, hepinizi bekleriz

https://discord.gg/43gGDQe6tS

Silah Yasaklı Kod Hatası

Eklenti sorunlarınız ve özel eklenti istekleriniz

Moderatör: Moderatörler

Cevapla

Konu Sahibi
CycL0Ne
Mesajlar: 839
Kayıt: Çrş Şub 13, 2019 5:51 pm
Server Ip/DNS: 213.238.173.144
Clan İsmi: BLacK MasK Bas

Silah Yasaklı Kod Hatası

Mesaj gönderen CycL0Ne »

Servere yüklemeye çalışıyorum bu silahı ama yasaklı kod hatası alıyorum yardımcı olur musunuz ?
Bu mesaja eklenen dosyaları görüntülemek için gerekli izinlere sahip değilsiniz.
Link:
Linklerini gizle
Linki Kopyala
Başa dön
Kullanıcı avatarı

LoseBasgan
Mesajlar: 1402
Kayıt: Sal Oca 29, 2019 11:28 pm
Clan İsmi: MoonGaming

Silah Yasaklı Kod Hatası

Mesaj gönderen LoseBasgan »

Kod: Tümünü seç

#include < amxmodx >
#include < cstrike >
#include < fakemeta >
#include < hamsandwich >
#include < zombieplague >
#include < xs > 

new const PLUGIN_VERSION[ ]    =  "0.0.1";

const OFFSET_WEAPONOWNER    =      41
const OFFSET_LINUX    =    5
const OFFSET_LINUX_WEAPONS     =      4

const WEAP_KEY   =	545464464
const MAX_PLAYERS   = 32

const m_flNextPrimaryAttack = 46;
const m_iClip =	51;
const m_fInReload = 54;
const m_flNextAttack = 83;
const m_pActiveItem = 373;
const m_flTimeWeaponIdle	= 48; 

enum _:Coord_e 
{ 
	Float:x,
	Float:y, 
	Float:z 
};

enum ( <<= 1 ) 
{ 
	angles = 1, 
	v_angle, 
	punchangle 
};

enum _:Angle_e 
{ 
	Float:pitch, 
	Float:yaw, 
	Float:roll 
};

enum ( <<=1 )
{
	DROP_PRIMARY = 1,
	DROP_SECONDARY
};	

const IDLE = 0 
const RELOAD = 3
const DRAW = 4
const SHOOT_1 = 1
const SHOOT_END = 2 

#define HoldCBaseWeapon(%0)	( get_user_weapon( %0 ) == g_iWeaponID  && g_pveaponA[ %0 ] )
#define IsValidPrivateData(%0)	( pev_valid( %0 ) == 2 )

#define VectorScale(%1,%2,%3)    ( %3[ x ] = %2 * %1[ x ], %3[ y ] = %2 * %1[ y ], %3[ z ] = %2 * %1[ z ] )
#define VectorAdd(%1,%2,%3)      ( %3[ x ] = %1[ x ] + %2[ x ], %3[ y ] = %1[ y ] + %2[ y ], %3[ z ] = %1[ z ] + %2[ z ] )

#define PRECACHE_MODEL(%0)		engfunc(EngFunc_PrecacheModel, %0)
#define PRECACHE_SOUND(%0)		engfunc(EngFunc_PrecacheSound, %0)
#define PRECACHE_GENERIC(%0)		engfunc(EngFunc_PrecacheGeneric, %0)

new const WEAPON_SOUND_FIRE[ ] = "weapons/poisongun-1.wav";

new const WEAPON_LIST[ ]   =   "weapon_antidoter_sh";
new const WEAPON_BASE_NAME[ ]   =  "weapon_m249";

const Float: RELOAD_TIME  =   5.0 

const AMMO__WEAPON   	=  200 
const CLIP__WEAPON  	=  100 

const Float: POISON__DAMAGE  	 =   150.0 
const Float: POISON__RADIUS 	 =  100.0  
const Float: POISON__SPEED    	 =  600.0 
const Float: WEAPON__SPEED 		 = 0.07 
const Float: RECOIL		 	     = 0.05 

new const EXTRA_ITEM_NAME[ ]    =   "Bocek Ilaci";  

new V_MODEL[ ] = "models/v_poisongun.mdl";
new P_MODEL[ ] = "models/p_poisongun.mdl";
new W_MODEL[ ] = "models/w_poisongun.mdl";

new R_MODEL[ ] = "sprites/ef_smoke_poison.spr";

new const HUD_SPRITES[ ] [ ] = 
{
	"sprites/640hud7.spr" , 
	"sprites/640hud75.spr"
};

new g_iItem , g_iMaxPlayers , g_iForwardIndex ;
new Float:cl_pushangle[ MAX_PLAYERS + 1 ][ 3 ]

new g_pveaponA[ MAX_PLAYERS + 1 ] ;
	
new g_iClipAmmo[ MAX_PLAYERS + 1 ], 
	g_TmpClip[ MAX_PLAYERS + 1 ] , 
	g_iWeaponID = 0;

new const POISON__CLASSNAME[ ]  =   "Poison_Ent";	

const WEAPONS_PRIMARY_BITSUM 	= (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);
const WEAPONS_SECONDARY_BITSUM 	= (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE);

public plugin_precache( )
{
	PRECACHE_MODEL( V_MODEL );
	PRECACHE_MODEL( P_MODEL );
	PRECACHE_MODEL( W_MODEL );
	PRECACHE_MODEL( R_MODEL );
	PRECACHE_SOUNDS_FROM_MODEL( V_MODEL );
	
	PRECACHE_SOUND(WEAPON_SOUND_FIRE);
	
	static iFile
	
	for( iFile = 0 ; iFile < sizeof HUD_SPRITES; iFile++ ) 
	{
		PRECACHE_GENERIC( HUD_SPRITES[ iFile ] )
	}	
	
	static szFile [ 128 ];
	formatex ( szFile , charsmax( szFile ) , "sprites/%s.txt" , WEAPON_LIST );
	PRECACHE_GENERIC( szFile );
}

public plugin_init()
{
	register_plugin( "[CSO] Extra Item Antidoter" , PLUGIN_VERSION , "" );
	register_clcmd( WEAPON_LIST, "weapon_hook_an" );
	
	register_forward( FM_SetModel, "Forward_SetModel" , false );
	register_forward( FM_UpdateClientData, "Forward_UpdateClientData" , true );
	register_forward( FM_CmdStart , "Forward_CmdStart" ) ;
	
	RegisterHam( Ham_Item_AddToPlayer, WEAPON_BASE_NAME, "CBaseWeapon__AddToPlayer__Pre" , .Post = false );
	RegisterHam( Ham_Item_Deploy, WEAPON_BASE_NAME , "CBaseWeapon__Deploy__Post", .Post = true );
	RegisterHam( Ham_Weapon_PrimaryAttack, WEAPON_BASE_NAME, "CBaseWeapon__PrimaryAttack__Pre" , .Post = false );
	RegisterHam( Ham_Weapon_PrimaryAttack, WEAPON_BASE_NAME, "CBaseWeapon_PrimaryAttack_Post", .Post = true );
	RegisterHam( Ham_Item_PostFrame, WEAPON_BASE_NAME, "CBaseWeapon__PostFrame__Pre" , .Post = false );
	RegisterHam( Ham_Weapon_Reload, WEAPON_BASE_NAME, "CBaseWeapon__Reload_Pre" , .Post = false );
	RegisterHam( Ham_Weapon_Reload, WEAPON_BASE_NAME, "CBaseWeapon__Reload_Post", .Post = true );
	
	register_forward( FM_Touch , "Forward_Touch" );
	register_forward( FM_Think , "Forward_Think" );

	g_iItem = zp_register_extra_item( EXTRA_ITEM_NAME, 60, ZP_TEAM_HUMAN );
	g_iMaxPlayers = get_maxplayers( );
	g_iWeaponID = get_weaponid( WEAPON_BASE_NAME );
}

public zp_extra_item_selected( pPlayer , pItem )
{
	if( pItem == g_iItem  )
	{
		 UTIL__DropWeapons( pPlayer, DROP_PRIMARY )
		 
		 g_pveaponA[ pPlayer ]  = true;
		 
		 static pEntity;
		 pEntity = fm_give_item( pPlayer , WEAPON_BASE_NAME ); 
		 
		 if( pEntity > 0 ) cs_set_weapon_ammo( pEntity, CLIP__WEAPON );	
		 
		 cs_set_user_bpammo( pPlayer , g_iWeaponID , AMMO__WEAPON );
		 
		 UTIL__WeaponList( pPlayer,  WEAPON_LIST , 3 , AMMO__WEAPON , -1 , -1 , 0 , 4  , g_iWeaponID , 0 );
	}	
}

public weapon_hook_an( pPlayer  ) 
{
	engclient_cmd( pPlayer, WEAPON_BASE_NAME);
	return PLUGIN_HANDLED;
}

public zp_user_humanized_post( pPlayer )
{
	g_pveaponA[ pPlayer ] = false;
}

public client_disconnected( pPlayer )
{
	g_pveaponA[ pPlayer ]  = false;
}

public Forward_SetModel( pEntity, const pModel[ ] )
{
	if( !pev_valid( pEntity ) ) 
	{
		return FMRES_IGNORED;
	}	
	
	static szClassName [ 33 ]
	pev( pEntity, pev_classname, szClassName, charsmax(szClassName) );
		
	if( !equal ( szClassName, "weaponbox" ) )
	{
		return FMRES_IGNORED;
	}	
	
	static pOwner , pModel
	pModel = fm_find_ent_by_owner ( -1, WEAPON_BASE_NAME, pEntity );
	pOwner = pev ( pEntity, pev_owner );
	
	if ( g_pveaponA [ pOwner ]  && pev_valid ( pModel ) )
	{
		set_pev( pModel , pev_impulse , WEAP_KEY );
		engfunc( EngFunc_SetModel, pEntity, W_MODEL );
		
		g_pveaponA [ pOwner ]   = false;
		return FMRES_SUPERCEDE;
	}

	return FMRES_IGNORED;
}

public Forward_UpdateClientData( pPlayer , SendWeapons, CD_Handle )
{
	if ( !HoldCBaseWeapon( pPlayer ) )
	{
		return HAM_IGNORED;
	}

	static Float:fGametime;
	fGametime = get_gametime( );
	
	set_cd ( CD_Handle, CD_flNextAttack, fGametime + 0.001 );

	return FMRES_HANDLED;
}

public Forward_CmdStart( pPlayer, UC_Handle, Seed )
{
	if( !is_user_alive( pPlayer ) || !HoldCBaseWeapon( pPlayer ) )
	{
		return FMRES_IGNORED;
	}

	if( !IsValidPrivateData( pPlayer ) )
	{
                return FMRES_IGNORED;
	}
	
	static bsButtons , i_Buttons;
	bsButtons = get_uc( UC_Handle, UC_Buttons );
	i_Buttons =  pev( pPlayer, pev_oldbuttons );


	static pEntity ;pEntity = get_pdata_cbase( pPlayer , m_pActiveItem , OFFSET_LINUX );
	static Float:flNextAttack ; flNextAttack = get_pdata_float( pPlayer, m_flNextAttack, OFFSET_LINUX_WEAPONS );
	static fInReload ; fInReload = get_pdata_int( pEntity, m_fInReload, OFFSET_LINUX_WEAPONS );

	if( !IsValidPrivateData( pEntity ) || flNextAttack > 0.0 || fInReload )
	{
              return FMRES_IGNORED;
	}
	
	
	if( ( i_Buttons & IN_ATTACK ) && !( bsButtons & IN_ATTACK ) )
	{
		set_pdata_float( pPlayer , m_flNextAttack , 0.0 , OFFSET_LINUX ) 

		UTIL_SenwWeaponAnim( pPlayer , SHOOT_END ) 
	}

	return FMRES_IGNORED
}

public Forward_PlayBackEvent(flags, invoker, eventindex, Float:delay, Float:origin[3], Float:fvangles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2)
{
	return FMRES_SUPERCEDE
} 

public CBaseWeapon__AddToPlayer__Pre( pEntity , pPlayer )
{
	if( !pev_valid( pEntity ) && !is_user_connected( pPlayer ) ) 
	{
		 return HAM_IGNORED;
	}
	
	if( pev( pEntity, pev_impulse) == WEAP_KEY )
	{
		g_pveaponA[ pPlayer ]  = true;
		
		UTIL__WeaponList( pPlayer,  WEAPON_LIST , 3 , AMMO__WEAPON , -1 , -1 , 0 , 4  , g_iWeaponID , 0 );

		return HAM_HANDLED;
	}
	else
	{
		UTIL__WeaponList( pPlayer,  WEAPON_BASE_NAME , 3 , AMMO__WEAPON , -1 , -1 , 0 , 4  , g_iWeaponID , 0 )
	}	

	return HAM_IGNORED;
}

public CBaseWeapon__Deploy__Post( pEntity )
{
	if( !IsValidPrivateData( pEntity ) )
	{
                return HAM_HANDLED;
	}
	
	static pId 
	pId = get_pdata_cbase( pEntity , OFFSET_WEAPONOWNER , OFFSET_LINUX_WEAPONS );
	
	if (!g_pveaponA[pId]  )
	{
		return HAM_IGNORED;
	}	
	
	set_pev( pId, pev_viewmodel2, V_MODEL);
	set_pev( pId, pev_weaponmodel2, P_MODEL);
	
	set_pdata_float( pId, m_flNextAttack, 1.0, OFFSET_LINUX);
	set_pdata_float( pEntity, m_flTimeWeaponIdle, 1.0 , OFFSET_LINUX_WEAPONS );
	
	UTIL_SenwWeaponAnim( pId, DRAW );
	
	return HAM_IGNORED ;
}

public CBaseWeapon__PrimaryAttack__Pre(pEntity)
{
	if( !IsValidPrivateData( pEntity ) )
	{
		return HAM_IGNORED;
	}

	static 	pId;

	pId = get_pdata_cbase( pEntity , OFFSET_WEAPONOWNER , OFFSET_LINUX_WEAPONS );

	if ( !HoldCBaseWeapon( pId ) )
	{
		return HAM_IGNORED;
	}

	g_iClipAmmo[pId] = cs_get_weapon_ammo(pEntity);
	pev( pId , pev_punchangle , cl_pushangle[ pId ] );
	
	g_iForwardIndex = register_forward( FM_PlaybackEvent, "Forward_PlayBackEvent" , false )
	
	return HAM_IGNORED;
}

public CBaseWeapon_PrimaryAttack_Post( pEntity )
{
	if( !IsValidPrivateData( pEntity ) )
	{
		return HAM_IGNORED;
	}
	
	static pId ; pId  = get_pdata_cbase( pEntity, OFFSET_WEAPONOWNER, OFFSET_LINUX_WEAPONS );
	
	if ( !HoldCBaseWeapon( pId ) )
	{
		return HAM_IGNORED;
	}

	if ( !g_iClipAmmo[pId] )
	{
			return HAM_IGNORED;
	}	
		
	emit_sound( pId, CHAN_WEAPON, WEAPON_SOUND_FIRE, VOL_NORM, ATTN_NORM, 0, PITCH_NORM );
	UTIL_SenwWeaponAnim( pId, SHOOT_1 );
	
	static Float:Push[ 3 ];
	
	pev( pId, pev_punchangle, Push );
	xs_vec_sub( Push , cl_pushangle[ pId ] , Push );
		
	xs_vec_mul_scalar( Push, RECOIL , Push );
	xs_vec_add( Push, cl_pushangle[ pId ] , Push );
	set_pev( pId, pev_punchangle, Push );
	
	static Float:vf_Forward[ Coord_e ], Float:vf_vAngle[ Angle_e ];
	static Float:vf_Source [ Coord_e ]
	
	get_weapon_position( pId, vf_Source, 50.0, 4.0, -5.0 )

	global_get ( glb_v_forward, vf_Forward );
	pev ( pId, pev_v_angle, vf_vAngle );

	static Float:vf_VelocitySR[ Coord_e ]
	
	VectorScale ( vf_Forward, POISON__SPEED , vf_VelocitySR );
	Flame__Create ( vf_Source, vf_VelocitySR );
	
	set_pdata_float( pEntity, m_flNextPrimaryAttack , WEAPON__SPEED , OFFSET_LINUX_WEAPONS );
	set_pdata_float( pEntity, m_flTimeWeaponIdle, RELOAD_TIME , OFFSET_LINUX_WEAPONS );
	
	unregister_forward(FM_PlaybackEvent, g_iForwardIndex , false);
	
	return HAM_IGNORED;
}

Flame__Create ( const Float:vf_Origin[], const Float:vf_Velocity[] )
{
	static pEntity;

	if ( ( pEntity = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_sprite") ) ) )
	{
		static vf_Temp[ Angle_e ] 
		
		set_pev ( pEntity , pev_origin, vf_Origin );
		set_pev ( pEntity , pev_classname , POISON__CLASSNAME );
		
		set_pev ( pEntity, pev_movetype, MOVETYPE_FLY );
		set_pev ( pEntity, pev_solid, SOLID_SLIDEBOX   );
		set_pev ( pEntity, pev_flags, FL_FLY );
		
		engfunc ( EngFunc_VecToAngles, vf_Velocity, vf_Temp );
		set_pev ( pEntity, pev_angles, vf_Temp );
		set_pev ( pEntity, pev_scale, 0.5 )
		
		engfunc ( EngFunc_SetModel , pEntity, R_MODEL );
		engfunc ( EngFunc_SetSize  , pEntity, Float:{ 0.0, 0.0, 0.0 }, Float:{ 0.0, 0.0, 0.0 } );
		engfunc ( EngFunc_SetOrigin, pEntity, vf_Origin );
		
		set_pev ( pEntity, pev_velocity, vf_Velocity );
		set_pev ( pEntity, pev_rendermode, kRenderTransAdd );
		set_pev ( pEntity, pev_gravity, -1.0 );
		set_pev ( pEntity, pev_renderamt,   255.0 )
		
		set_pev ( pEntity , pev_nextthink, get_gametime( ) + 0.5 )
	}
}

public CBaseWeapon__PostFrame__Pre( pEntity ) 
{
	if( !IsValidPrivateData( pEntity ) )
	{
                return HAM_HANDLED;
	}

	static pId;

	pId = get_pdata_cbase( pEntity , OFFSET_WEAPONOWNER , OFFSET_LINUX_WEAPONS );

	if ( !is_user_connected( pId ) && !HoldCBaseWeapon( pId ) && !g_iMaxPlayers )
	{
		return HAM_HANDLED;
	}
	
	static fInReload ; fInReload = get_pdata_int( pEntity, 54, OFFSET_LINUX_WEAPONS );
	static Float:flNextAttack ; flNextAttack = get_pdata_float( pId, m_flNextAttack, OFFSET_LINUX_WEAPONS );
	static iClip ; iClip = get_pdata_int( pEntity, m_iClip, OFFSET_LINUX_WEAPONS );
	static iAmmoType ; iAmmoType = 376 + get_pdata_int( pEntity, 49, OFFSET_LINUX_WEAPONS );
	static iBpAmmo ; iBpAmmo  = get_pdata_int( pId, iAmmoType, OFFSET_LINUX );
	
	if ( fInReload && flNextAttack <= 1.4 )
	{
		new j = min( CLIP__WEAPON  - iClip, iBpAmmo);
	
		set_pdata_int( pEntity, m_iClip, iClip + j, OFFSET_LINUX_WEAPONS );
		set_pdata_int( pId, iAmmoType, iBpAmmo-j, OFFSET_LINUX );
		set_pdata_int( pEntity, 54, 0, OFFSET_LINUX_WEAPONS );

		fInReload = 0;
	}	 
	
	return HAM_IGNORED;
}

public CBaseWeapon__Reload_Pre(pEntity) 
{
	if( !IsValidPrivateData( pEntity ) )
	{
		return HAM_HANDLED;
	}

	static pId;

	pId = get_pdata_cbase( pEntity , OFFSET_WEAPONOWNER , OFFSET_LINUX_WEAPONS );

	if ( !is_user_connected( pId ) || !HoldCBaseWeapon( pId ) )
	{
		return HAM_IGNORED;
	}
	
	g_TmpClip[pId] = -1;
	
	static iAmmoType ; iAmmoType = 376 + get_pdata_int( pEntity, 49, OFFSET_LINUX_WEAPONS );
	static iBpAmmo ; iBpAmmo = get_pdata_int( pId, iAmmoType, OFFSET_LINUX );
	static iClip ; iClip = get_pdata_int( pEntity, m_iClip, OFFSET_LINUX );
	
	if ( iBpAmmo <= 0 || iClip >= CLIP__WEAPON )
	{
	   return HAM_SUPERCEDE;
	}  
	
	g_TmpClip[pId] = iClip;
	
	return HAM_HANDLED;
}

public CBaseWeapon__Reload_Post( pEntity ) 
{
	if( !IsValidPrivateData( pEntity ) )
	{
                return HAM_HANDLED;
	}

	static pId ; pId = get_pdata_cbase( pEntity , OFFSET_WEAPONOWNER , OFFSET_LINUX_WEAPONS );
	
	if ( !HoldCBaseWeapon( pId ) )
	{
		return HAM_IGNORED;
	}

	if (g_TmpClip[ pId ] == -1)
	{
		return HAM_IGNORED;
	}
	
	set_pdata_float( pId, m_flNextAttack, RELOAD_TIME , OFFSET_LINUX);
	set_pdata_float( pEntity, m_flTimeWeaponIdle, RELOAD_TIME , OFFSET_LINUX_WEAPONS );
	
	UTIL_SenwWeaponAnim(pId, RELOAD);

	return HAM_HANDLED;
}

public Forward_Touch( const pEntity , const i_Other )
{
	static  g_classname[ 32 ]  ; 
	pev( pEntity, pev_classname, g_classname, 31 )
	
	if( equali( g_classname, POISON__CLASSNAME ) )
	{
		static Float:flOrigin[ Coord_e ];
		pev( pEntity, pev_origin, flOrigin );
		
		set_pev(pEntity, pev_movetype, MOVETYPE_NONE)
		set_pev(pEntity, pev_solid, SOLID_NOT)	

		new pOwner = pev( pEntity, pev_owner );
		   
		static pevVictim, Float:flDistance,Float:fDamage;
						   
		pevVictim  = -1;
		while( ( pevVictim = engfunc( EngFunc_FindEntityInSphere, pevVictim, flOrigin, POISON__RADIUS) ) != 0 )
		{
			if( !is_user_alive( pevVictim ) )
					continue;
					
			if( !zp_get_user_zombie( pevVictim ) )
				continue;
				
			flDistance = fm_entity_range( pEntity, pevVictim );
			fDamage = UTIL_FloatRadius( POISON__DAMAGE, POISON__RADIUS , flDistance );
			
			if( fDamage > 0.0 )
			{
					ExecuteHamB( Ham_TakeDamage, pevVictim, pEntity, pOwner, fDamage, DMG_BURN );
			}
		}
	}
}

Float:UTIL_FloatRadius( Float:flMaxAmount, Float:flRadius, Float:flDistance )
{
        return floatsub( flMaxAmount, floatmul( floatdiv( flMaxAmount, flRadius ), flDistance ) );
}

public Forward_Think( pEntity )
{
	static  g_classname[ 32 ]
	pev( pEntity, pev_classname, g_classname, 31 )
	
	if( equali( g_classname, POISON__CLASSNAME ) )
	{
		if ( pev ( pEntity, pev_waterlevel ) > 1 )
		{
			set_pev ( pEntity, pev_flags, FL_KILLME );
		}
		
		set_pev ( pEntity, pev_nextthink, get_gametime( ) + 0.015 )
		static Float:fv_Frame, Float:fv_Scale
		
		pev ( pEntity, pev_frame, fv_Frame )
		pev ( pEntity, pev_scale, fv_Scale )
		
		#define MOVE__NONE  pev( pEntity , pev_movetype) == MOVETYPE_NONE
		if ( MOVE__NONE  )
		{
			fv_Frame += 0.2 
			
			if(fv_Scale <= 1.5)
			{
				fv_Scale += 0.1
				set_pev ( pEntity, pev_renderamt,   100.0 )
			}	
			
			if (fv_Frame > 10.0)
			{ 
				engfunc(EngFunc_RemoveEntity, pEntity)
				return 
			}
		}
		else
		{
			fv_Frame += 0.2
			
			if( fv_Frame >= 10.0)
			{
				set_pev ( pEntity, pev_movetype, MOVETYPE_NONE )
			}	
			
			if(fv_Scale <= 1.5)
			{
				fv_Scale += 0.1
				set_pev ( pEntity, pev_renderamt,   100.0 )
			}	
		}
		
		set_pev ( pEntity, pev_scale, fv_Scale )
		set_pev ( pEntity, pev_frame, fv_Frame )
	}
}

stock UTIL__DropWeapons(id, bitsDropType)
{
	static weapons[32], num, i, weaponid
	num = 0 
	get_user_weapons(id, weapons, num)
	
	for (i = 0; i < num; i++)
	{
		weaponid = weapons[i]
		
		if ((bitsDropType == DROP_PRIMARY && ((1<<weaponid) & WEAPONS_PRIMARY_BITSUM)) || (bitsDropType == DROP_SECONDARY && ((1<<weaponid) & WEAPONS_SECONDARY_BITSUM)))
		{
			static wname[32]
			get_weaponname(weaponid, wname, charsmax(wname))
			
			engclient_cmd(id, "drop", wname)
		}
	}
}

stock fm_find_ent_by_owner(entity, const classname[], owner)
{
	while ((entity = engfunc(EngFunc_FindEntityByString, entity, "classname", classname)) && pev(entity, pev_owner) != owner) { /* keep looping */ }
	return entity;
}

stock UTIL_SenwWeaponAnim(const pPlayer, const Sequence)
{
	set_pev(pPlayer, pev_weaponanim, Sequence)
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = pPlayer)
	write_byte(Sequence)
	write_byte(pev(pPlayer, pev_body))
	message_end()
}

UTIL__WeaponList( pPlayer, const szWeapon[ ], int, int2, int3, int4, int5, int6, int7, int8 )
{
	message_begin( MSG_ONE, get_user_msgid( "WeaponList" ) , _, pPlayer );
	write_string( szWeapon );
	write_byte( int );
	write_byte( int2);
	write_byte( int3 );
	write_byte( int4 );
	write_byte( int5 );
	write_byte( int6 );
	write_byte( int7 );
	write_byte( int8 );
	message_end( );
}

stock fm_give_item(id, const item[])
{
	static ent
	ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item))
	if (!pev_valid(ent)) return 0;
	
	static Float:originF[3]
	pev(id, pev_origin, originF)
	set_pev(ent, pev_origin, originF)
	set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN)
	dllfunc(DLLFunc_Spawn, ent)
	
	static save
	save = pev(ent, pev_solid)
	dllfunc(DLLFunc_Touch, ent, id)
	if (pev(ent, pev_solid) != save)
		return ent ;
	
	engfunc(EngFunc_RemoveEntity, ent)
	
	return -1;
}

stock get_weapon_position( pId, Float:fOrigin[ ], Float:add_forward, Float:add_right, Float:add_up)
{
	static Float:Angles[ Angle_e ],Float:ViewOfs[ Coord_e ], Float:vAngles[ Coord_e ]
	static Float:Forward[ Coord_e ], Float:Right[ Coord_e ], Float:Up[ Coord_e ]
	
	pev( pId, pev_v_angle, vAngles)
	pev( pId, pev_origin, fOrigin)
	pev( pId, pev_view_ofs, ViewOfs)
	xs_vec_add( fOrigin, ViewOfs, fOrigin)
	
	pev( pId, pev_angles, Angles)
	
	Angles[0] =  vAngles[0]
	
	engfunc( EngFunc_MakeVectors, Angles)
	
	global_get( glb_v_forward, Forward)
	global_get( glb_v_right, Right)
	global_get( glb_v_up,  Up)
	
	xs_vec_mul_scalar(Forward, add_forward, Forward)
	xs_vec_mul_scalar(Right, add_right, Right)
	xs_vec_mul_scalar(Up, add_up, Up)
	
	fOrigin[0] = fOrigin[0] + Forward[0] + Right[0] + Up[0]
	fOrigin[1] = fOrigin[1] + Forward[1] + Right[1] + Up[1]
	fOrigin[2] = fOrigin[2] + Forward[2] + Right[2] + Up[2]
}

stock Float:fm_entity_range(ent1, ent2) 
{
	new Float:origin1[3], Float:origin2[3];
	pev(ent1, pev_origin, origin1);
	pev(ent2, pev_origin, origin2);

	return get_distance_f(origin1, origin2);
}

PRECACHE_SOUNDS_FROM_MODEL(const szModelPath[])
{
	new iFile;
	
	if ((iFile = fopen(szModelPath, "rt")))
	{
		new szSoundPath[64];
		
		new iNumSeq, iSeqIndex;
		new iEvent, iNumEvents, iEventIndex;
		
		fseek(iFile, 164, SEEK_SET);
		fread(iFile, iNumSeq, BLOCK_INT);
		fread(iFile, iSeqIndex, BLOCK_INT);
		
		for (new k, i = 0; i < iNumSeq; i++)
		{
			fseek(iFile, iSeqIndex + 48 + 176 * i, SEEK_SET);
			fread(iFile, iNumEvents, BLOCK_INT);
			fread(iFile, iEventIndex, BLOCK_INT);
			fseek(iFile, iEventIndex + 176 * i, SEEK_SET);

			for (k = 0; k < iNumEvents; k++)
			{
				fseek(iFile, iEventIndex + 4 + 76 * k, SEEK_SET);
				fread(iFile, iEvent, BLOCK_INT);
				fseek(iFile, 4, SEEK_CUR);
				
				if (iEvent != 5004)
				{
					continue;
				}

				fread_blocks(iFile, szSoundPath, 64, BLOCK_CHAR);
				
				if (strlen(szSoundPath))
				{
					strtolower(szSoundPath);
					PRECACHE_SOUND(szSoundPath);
				}
			}
		}
	}
	
	fclose(iFile);
}
Link:
Linklerini gizle
Linki Kopyala
Başa dön
Cevapla

“Cs 1.6 Eklenti İstekleri” sayfasına dön