[Weapon] Ethereal

[Rio*]

Cum adaug acest plugin in pluginu meu de VIP..
Uite sma.

| Afiseaza codul

#include <amxmodx>
#include <hamsandwich>
#include <cstrike>
#include <amxmisc>
#include <fun>
#include <engine>
 
 
// Modifica aici pentru a seta gradul vipului
//###############################
#define ACCES_LEVEL ADMIN_LEVEL_H
//###############################
 
#define PLUGIN "VIP Furien PLUGIN"
#define VERSION "1.0"
#define AUTHOR "Raul"
 
 
new gViata, gArmura, gHE, gGodModeTime, gTeleportTime;
new gHasGodMode[32], gUsed[32];
 
new checkCount[33]
new blinkSpot[33][3]
new origBlinkSpot[33][3]
new g_lastPosition[33][3]
 
public plugin_init() {
register_plugin(PLUGIN, VERSION, AUTHOR)
gViata = register_cvar("vip_hp", "255");
gArmura = register_cvar("vip_armour", "255");
gHE = register_cvar("vip_he_nr", "3");
gGodModeTime = register_cvar("vip_god_time", "3.0");
gTeleportTime = register_cvar("vip_teleport_time", "1.0");
 
register_logevent("Inceput_runda", 2, "1=Round_Start");
RegisterHam( Ham_TraceAttack, "player", "fw_TraceAttack" );
register_clcmd("say /vipmenu", "Creare_meniu");
register_clcmd("say_team /vipmenu", "Creare_meniu");
return PLUGIN_CONTINUE
}
//----------------------------------------------------------------------------------------------
public Inceput_runda()
{
new players[32], num;
get_players(players, num, "z");
 
for(new i = 0; i < num; i++)  
{
gUsed = 0;
}
}
//----------------------------------------------------------------------------------------------
public Creare_meniu(id)
{
if( get_user_flags( id ) & ACCES_LEVEL)
{
if(gUsed[id] == 0)
{
new menu = menu_create("Alege o optiune:", "menu_handler");
menu_additem(menu, "255 HP si 255 Armour", "1", 0);
menu_additem(menu, "HE Grenades", "2", 0);
menu_additem(menu, "GodMode", "3", 0);
menu_additem(menu, "Teleport", "4", 0);
menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
 
menu_display(id, menu, 0);
}
else
client_print(id, print_chat, "Poti folosi meniul o singura data pe runda!");
}
else
client_print(id, print_chat, "Doar cei cu grad de VIP pot folosi meniul!");
}
//----------------------------------------------------------------------------------------------
public menu_handler(id, menu, item)
{
if( item == MENU_EXIT )
{
menu_destroy(menu);
return PLUGIN_HANDLED;
}
 
new data[6], szName[64];
new access, callback;
menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);
 
new key = str_to_num(data);
 
switch(key)
{
case 1:
{
client_print(id, print_chat, "Ai primit %d HP si %d Armour!", get_pcvar_num(gViata), get_pcvar_num(gArmura));
set_user_health(id, get_pcvar_num(gViata));
set_user_armor(id, get_pcvar_num(gArmura));
menu_destroy(menu);
return PLUGIN_HANDLED;
}
case 2:
{
client_print(id, print_chat, "Ai %d HE Grenades", get_pcvar_num(gHE));
cs_set_user_bpammo( id , CSW_HEGRENADE, get_pcvar_num(gHE));
menu_destroy(menu);
return PLUGIN_HANDLED;
}
case 3:
{
client_print(id, print_chat, "Ai GodMode pentru %f secunde", get_pcvar_float(gGodModeTime));
gHasGodMode[id] = 1;
set_task( get_pcvar_float(gGodModeTime), "End_God", id);
menu_destroy(menu);
return PLUGIN_HANDLED;
}
case 4:
{
client_print(id, print_chat, "Te vei teleporta în %f secunde.", get_pcvar_float(gTeleportTime));
set_task(get_pcvar_float(gTeleportTime), "Teleport_handler", id);
menu_destroy(menu);
return PLUGIN_HANDLED;
}
}
menu_destroy(menu);
return PLUGIN_HANDLED;
}
//----------------------------------------------------------------------------------------------
public fw_TraceAttack( victim, attacker, Float:damage, Float:direction[3], trace, damageBits )
{
if(gHasGodMode[victim])
return HAM_SUPERCEDE;
 
return HAM_IGNORED;
}
//----------------------------------------------------------------------------------------------
public End_God(id)
{
gHasGodMode[id] = 0;
}
//----------------------------------------------------------------------------------------------
public Teleport_handler(id)
{
get_user_origin(id,blinkSpot[id],3)
origBlinkSpot[id][0] = blinkSpot[id][0]
origBlinkSpot[id][1] = blinkSpot[id][1]
origBlinkSpot[id][2] = blinkSpot[id][2]
 
blinkSpot[id][2] += 45
set_user_origin(id,blinkSpot[id])
checkCount[id] = 1
positionChangeTimer(id)
return PLUGIN_CONTINUE
}
//----------------------------------------------------------------------------------------------
public positionChangeTimer(id)
{
if (!is_user_alive(id)) return
 
new Float:velocity[3]
get_user_origin(id, g_lastPosition[id])
 
entity_get_vector(id, EV_VEC_velocity, velocity)
if ( velocity[0] == 0.0 && velocity[1] == 0.0 && velocity[2] ) {
velocity[0] = 50.0
velocity[1] = 50.0
entity_set_vector(id, EV_VEC_velocity, velocity)
}
 
set_task(0.1,"positionChangeCheck",id)
}
//----------------------------------------------------------------------------------------------
public positionChangeCheck(id)
{
if (!is_user_alive(id)) return
 
new origin[3]
get_user_origin(id, origin)
 
if ( g_lastPosition[id][0] == origin[0] && g_lastPosition[id][1] == origin[1] && g_lastPosition[id][2] == origin[2]) {
switch(checkCount[id]) {
case 0 : blink_movecheck(id, 0, 0, 0) // Original
case 1 : blink_movecheck(id, 0, 0, 80) // Up
case 2 : blink_movecheck(id, 0, 0, -110) // Down
case 3 : blink_movecheck(id, 0, 30, 0) // Forward
case 4 : blink_movecheck(id, 0, -30, 0) // Back
case 5 : blink_movecheck(id, -30, 0, 0) // Left
case 6 : blink_movecheck(id, 30, 0, 0) // Right
case 7 : blink_movecheck(id, -30, 30, 0) // Forward-Left
case 8 : blink_movecheck(id, 30, 30, 0) // Forward-Right
case 9 : blink_movecheck(id, -30, -30, 0) // Back-Left
case 10: blink_movecheck(id, 30, -30, 0) // Back-Right
case 11: blink_movecheck(id, 0, 30, 60) // Up-Forward
case 12: blink_movecheck(id, 0, 30, -110) // Down-Forward
case 13: blink_movecheck(id, 0, -30, 60) // Up-Back
case 14: blink_movecheck(id, 0, -30, -110) // Down-Back
case 15: blink_movecheck(id, -30, 0, 60) // Up-Left
case 16: blink_movecheck(id, 30, 0, 60) // Up-Right
case 17: blink_movecheck(id, -30, 0, -110) // Down-Left
case 18: blink_movecheck(id, 30, 0, -110) // Down-Right
default: user_kill(id)
}
return
}
}
//----------------------------------------------------------------------------------------------
public blink_movecheck(id, mX, mY, mZ)
{
blinkSpot[id][0] = origBlinkSpot[id][0] + mX
blinkSpot[id][1] = origBlinkSpot[id][1] + mY
blinkSpot[id][2] = origBlinkSpot[id][2] + mZ
set_user_origin(id,blinkSpot[id])
checkCount[id]++
positionChangeTimer(id)
}
//-------------------------------------------------------------------------------------

Si sa apara doar cand scri /vipmenu doar la ct nu si la tero,sau si la tero dar sa nul poata lua

[Nubo]

'Mutat la Modificari'

[sDs|Aragon*]

Am adaugat in primul post si versiunea pentru Furien V.40 Weapons: http://www.extreamcs.com/forum/pluginur ... 82387.html

| Afiseaza codul

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//---------------------------------------| Ethereal |--------------------------------------------------------
//======================================= sDs|Aragon* =======================================================
#define weapon_ethereal		"weapon_galil"
#define CSW_ETHEREAL		CSW_GALIL
enum EtherealData {
	ETHEREAL_NAME = 0,
	ETHEREAL_TEAM,
	ETHEREAL_ACCES,
	ETHEREAL_LEVEL,
	ETHEREAL_DAMAGE,
	ETHEREAL_CLIP,
	ETHEREAL_SHOTDELAY,
	ETHEREAL_KNOCKBACK
}
new WPN_ETHEREAL[EtherealData][] = { 
	/*Name*/ "Ethereal",
	/*Team*/ "2",
	/*Acces*/ "1",
	/*Level*/ "25",
	/*Damage*/ "70",
	/*Clip*/ "40",
	/*Shot Delay*/ "0.15",
	/*KnockBack*/ "1"
},
EtherealModel_V[] = "models/Furien40/v_ethereal2.mdl",
EtherealModel_P[] = "models/Furien40/p_ethereal2.mdl",
EtherealModel_W[] = "models/Furien40/w_ethereal2.mdl",
Ethereal_WeaponList[] = "furien40_ethereal",
Ethereal_Sound[][] = {
	"weapons/ethereal_shoot1.wav",
	"weapons/ethereal_idle1.wav",
	"weapons/ethereal_reload.wav",
	"weapons/ethereal_draw.wav"
},
Ethereal_Generic[][] = {
	"sprites/furien40_ethereal.txt",
	"sprites/Furien40/ethereal.spr"
},
EtherealID, ethereal_event, ethereal_beam, ethereal_explode

Ethereal_Init() {
	EtherealID = RegisterPrimary(WPN_ETHEREAL[ETHEREAL_NAME], WPN_ETHEREAL[ETHEREAL_TEAM], WPN_ETHEREAL[ETHEREAL_ACCES], WPN_ETHEREAL[ETHEREAL_LEVEL], weapon_ethereal, CSW_ETHEREAL, Ethereal_WeaponList, WPN_ETHEREAL[ETHEREAL_CLIP])
	
	if(EtherealID) {
		register_clcmd(Ethereal_WeaponList, "Hook_Ethereal");
		
		register_event("CurWeapon", "Ethereal_ViewModel", "be", "1=1");
		register_event("WeapPickup","Ethereal_ViewModel","be", "1=19");
		
		register_forward(FM_SetModel, "Ethereal_WorldModel", 1);
		register_forward(FM_UpdateClientData, "Ethereal_UpdateClientData_Post", 1);
		register_forward(FM_PlaybackEvent, "Ethereal_PlaybackEvent");
		
		register_forward(FM_CmdStart, "Ethereal_CmdStart");	
		
		RegisterHam(Ham_Item_AddToPlayer, weapon_ethereal, "Ethereal_AddToPlayer");
		RegisterHam(Ham_Item_Deploy , weapon_ethereal, "Ethereal_Deploy_Post", 1);
		RegisterHam(Ham_Weapon_WeaponIdle, weapon_ethereal, "Ethereal_WeaponIdle")
		RegisterHam(Ham_Weapon_PrimaryAttack, weapon_ethereal, "Ethereal_PrimaryAttack");
		RegisterHam(Ham_Weapon_Reload, weapon_ethereal, "Ethereal_Reload");
		RegisterHam(Ham_Weapon_Reload, weapon_ethereal, "Ethereal_Reload_Post", 1);
		RegisterHam(Ham_Item_PostFrame, weapon_ethereal, "Ethereal_PostFrame");	
	}
}

Ethereal_Precache() {	
	register_forward(FM_PrecacheEvent, "Ethereal_PrecacheEvent_Post", 1);
	
	ethereal_beam = precache_model("sprites/Furien40/ethereal_beam.spr");
	ethereal_explode = precache_model("sprites/Furien40/ef_balrog1_blue.spr");
	
	precache_model(EtherealModel_V);
	precache_model(EtherealModel_P);
	precache_model(EtherealModel_W);
	for(new i = 0; i < sizeof(Ethereal_Sound); i++)
		engfunc(EngFunc_PrecacheSound, Ethereal_Sound);	
	for(new i = 0; i < sizeof(Ethereal_Generic); i++)
		engfunc(EngFunc_PrecacheGeneric, Ethereal_Generic);
}

Ethereal_Natives() {
	register_native("get_user_ethereal", "get_user_ethereal", 1);
	register_native("set_user_ethereal", "set_user_ethereal", 1);
	register_native("ethereal_id", "ethereal_id", 1);
}

public Ethereal_ViewModel(id) {
	if(get_user_weapon(id) == CSW_ETHEREAL && get_user_ethereal(id)) {
		new VModel[128], PModel[128];
		pev(id, pev_viewmodel2, VModel, 127),
		pev(id, pev_weaponmodel2, PModel, 127);
		
		if(!equal(VModel, EtherealModel_V))
			set_pev(id, pev_viewmodel2, EtherealModel_V);
		if(!equal(PModel, EtherealModel_P))
			set_pev(id, pev_weaponmodel2, EtherealModel_P);
	}
}

public Ethereal_WorldModel(entity, model[]) {
	if(is_valid_ent(entity)) {
		static ClassName[33];
		entity_get_string(entity, EV_SZ_classname, ClassName, charsmax(ClassName));
		
		if(equal(ClassName, "weaponbox")) {
			new Ethereal = find_ent_by_owner(-1, weapon_ethereal, entity);
			
			if(pev_valid(Ethereal) && entity_get_int(Ethereal, EV_INT_impulse) == EtherealID) {
				entity_set_model(entity, EtherealModel_W);
				entity_set_int(entity, EV_INT_impulse, str_to_num(WPN_ETHEREAL[ETHEREAL_TEAM]));
			}
		}
	}
	return FMRES_IGNORED;
}

public Ethereal_UpdateClientData_Post(id, sendweapons, cd_handle) {
	if(is_user_alive(id) && is_user_connected(id) && get_user_weapon(id) == CSW_ETHEREAL && get_user_ethereal(id))
		set_cd(cd_handle, CD_flNextAttack, halflife_time() + 0.001);
	return FMRES_IGNORED;
}

public Ethereal_PlaybackEvent(flags, invoker, eventid, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2) {
	if(is_user_connected(invoker) && eventid == ethereal_event)
		playback_event(flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2);
	return FMRES_IGNORED;
}

public Ethereal_PrecacheEvent_Post(type, const name[]) {
	if (equal("events/galil.sc", name))
		ethereal_event = get_orig_retval();
	return FMRES_IGNORED;
}

public Ethereal_CmdStart(id, uc_handle, seed) {
	if(is_user_alive(id) && is_user_connected(id)) {
		new Ethereal = fm_find_ent_by_owner(-1, weapon_ethereal, id);	
		
		if(pev_valid(Ethereal) && get_user_weapon(id) == CSW_ETHEREAL && entity_get_int(Ethereal, EV_INT_impulse) == EtherealID) {
			new CurButton = get_uc(uc_handle, UC_Buttons);
			
			if(CurButton & IN_ATTACK) {				
				if(pev_valid(Ethereal) && cs_get_weapon_ammo(Ethereal) > 0 && !get_pdata_int(Ethereal, 54, 4) && get_pdata_float(id, 83, 5) <= 0.0) {
					set_weapon_anim(id, random_num(3,5));
					emit_sound(id, CHAN_WEAPON,Ethereal_Sound[0], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
					
					Ethereal_Fire(id);
					
					cs_set_weapon_ammo(Ethereal, cs_get_weapon_ammo(Ethereal) - 1);
					
					if(cs_get_weapon_ammo(Ethereal) > 0 && !get_pdata_int(Ethereal, 54, 4) && get_pdata_float(id, 83, 5) <= 0.0) {
						set_pdata_float(id, 83, str_to_float(WPN_ETHEREAL[ETHEREAL_SHOTDELAY]), 5);
						set_pdata_float(Ethereal, 48, 1.0, 4)
					}
				}
				CurButton &= ~IN_ATTACK;
				set_uc(uc_handle, UC_Buttons, CurButton);
			}
		}
	}
	return FMRES_IGNORED;
}

public Ethereal_AddToPlayer(Weapon, id) {
	if(pev_valid(Weapon) && is_user_alive(id) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID)
		WeaponList(id, CSW_ETHEREAL, Ethereal_WeaponList, 0)
	else if(pev_valid(Weapon) && is_user_alive(id) && entity_get_int(id, EV_INT_impulse) == EtherealID)
		ColorChat(id, "!t[!g%s!t]!g Damage:!t %s!g Clip:!t %s!g Shot Delay:!t %s!g KnockBack:!t %s", WPN_ETHEREAL[ETHEREAL_NAME], WPN_ETHEREAL[ETHEREAL_DAMAGE], WPN_ETHEREAL[ETHEREAL_CLIP], WPN_ETHEREAL[ETHEREAL_SHOTDELAY], WPN_ETHEREAL[ETHEREAL_KNOCKBACK])
	return HAM_IGNORED;
}

public Ethereal_Deploy_Post(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID) {
			set_pev(Owner, pev_viewmodel2, EtherealModel_V);
			set_pev(Owner, pev_weaponmodel2, EtherealModel_P);
			set_weapon_anim(Owner, 2)
			
			set_pdata_float(Owner, 83, 1.3, 5);
			set_pdata_float(Weapon, 48, 1.3, 4)
		}
	}
	return HAM_IGNORED;
}

public Ethereal_WeaponIdle(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID && get_pdata_float(Weapon, 48, 4) <= 0.1)  {
			set_pdata_float(Weapon, 48, 10.0, 4)
			set_weapon_anim(Owner, 0)
			return HAM_SUPERCEDE;
		}
	}
	return HAM_IGNORED;
}

public Ethereal_PrimaryAttack(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID)
			return HAM_SUPERCEDE;
	}
	return HAM_IGNORED;
}

public Ethereal_Reload(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID) {		
			if(cs_get_user_bpammo(Owner, CSW_ETHEREAL) <= 0 || get_pdata_int(Weapon, 51, 4) >= str_to_num(WPN_ETHEREAL[ETHEREAL_CLIP]))
				return HAM_SUPERCEDE;
		}
	}
	return HAM_IGNORED;
}

public Ethereal_Reload_Post(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID) {			
			if(cs_get_user_bpammo(Owner, CSW_ETHEREAL) <= 0 || get_pdata_int(Weapon, 51, 4) >= str_to_num(WPN_ETHEREAL[ETHEREAL_CLIP]))
				return HAM_SUPERCEDE;
			set_pdata_float(Weapon, 48, 3.0, 4);
			set_pdata_float(Owner, 83, 3.0, 5);
			set_pdata_int(Weapon, 54, 1, 4);
			set_weapon_anim(Owner, 1)
		}
	}
	return HAM_IGNORED;
}

public Ethereal_PostFrame(Weapon) {
	if(pev_valid(Weapon)) {
		new Owner = get_pdata_cbase(Weapon, 41, 4);
		
		if(is_user_alive(Owner) && entity_get_int(Weapon, EV_INT_impulse) == EtherealID && get_pdata_int(Weapon, 54, 4) && get_pdata_float(Owner, 83, 5) <= 0.0) {
			new Temp = min(str_to_num(WPN_ETHEREAL[ETHEREAL_CLIP]) - get_pdata_int(Weapon, 51, 4), cs_get_user_bpammo(Owner, CSW_ETHEREAL));
			
			set_pdata_int(Weapon, 51, get_pdata_int(Weapon, 51, 4) + Temp, 4);
			cs_set_user_bpammo(Owner, CSW_ETHEREAL, cs_get_user_bpammo(Owner, CSW_ETHEREAL) - Temp);		
			set_pdata_int(Weapon, 54, 0, 4);
		}
	}
	return HAM_IGNORED;
}

public Ethereal_Fire(id) {	
	static Victim, Body, EndOrigin[3], BeamOrigin[3];
	get_user_origin(id, BeamOrigin, 3) ;
	get_user_origin(id, EndOrigin, 3);
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(TE_BEAMENTPOINT);
	write_short(id | 0x1000);
	write_coord(BeamOrigin[0]);	// Start X
	write_coord(BeamOrigin[1]);	// Start Y
	write_coord(BeamOrigin[2]);	// Start Z
	write_short(ethereal_beam);	// Sprite
	write_byte(1);      		// Start frame				
	write_byte(2);     		// Frame rate					
	write_byte(1);			// Life
	write_byte(20);   		// Line width				
	write_byte(0);    		// Noise
	write_byte(0); 			// Red
	write_byte(100);		// Green
	write_byte(200);		// Blue
	write_byte(255);     		// Brightness					
	write_byte(25);      		// Scroll speed					
	message_end();
	
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
	write_byte(TE_EXPLOSION);
	write_coord(EndOrigin[0]);
	write_coord(EndOrigin[1]);
	write_coord(EndOrigin[2]);
	write_short(ethereal_explode);
	write_byte(2);
	write_byte(10);
	write_byte(TE_EXPLFLAG_NOSOUND);
	message_end();
	
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_WORLDDECAL)
	write_coord(EndOrigin[0])
	write_coord(EndOrigin[1])
	write_coord(EndOrigin[2])
	write_byte(41)
	message_end()
	
	
	get_user_aiming(id, Victim, Body, 999999);
	static ClassName[32];
	pev(Victim, pev_classname, ClassName, charsmax(ClassName));
	
	if(equal(ClassName, "player") && is_user_connected(Victim) && is_user_alive(Victim)) {
		if(!fm_get_user_godmode(Victim) && get_user_team(Victim) != get_user_team(id) && Victim != id) {
			new Float:Damage = float(get_damage_body(Body, str_to_float(WPN_ETHEREAL[ETHEREAL_DAMAGE])));
			new Float:Origin[3];
			pev(id, pev_origin, Origin);
			
			make_blood(Victim, floatround(Damage))
			make_knockback(Victim, Origin, str_to_float(WPN_ETHEREAL[ETHEREAL_KNOCKBACK])*Damage);
			
			if(get_user_health(Victim) > Damage)
				ExecuteHam(Ham_TakeDamage, Victim, id, id, Damage, DMG_ENERGYBEAM);
			else 
				death_message(id, Victim, "ethereal");
		}
	}
	else if(is_valid_ent(Victim) && equal(ClassName, "func_breakable")) {		
		if(entity_get_float(Victim, EV_FL_health) <= str_to_float(WPN_ETHEREAL[ETHEREAL_DAMAGE]))
			force_use(id, Victim);
	}
}

public Hook_Ethereal(id) {
	engclient_cmd(id, weapon_ethereal);
	return PLUGIN_HANDLED
}

public get_user_ethereal(id)
	return get_weapon(id, weapon_ethereal, CSW_ETHEREAL, EtherealID)

public set_user_ethereal(id)
	set_weapons(id, EtherealID)

public ethereal_id()
	return EtherealID

[Cosmin]

ce cauta aici :O ,mutat in categoria corespunzatoare.

[COMAN001]

O poti face pentru mod respawn.. ?

[COMAN001]

upppppp cand dau /respawn se pune gail... si se duce skinul

[dinilimandro]

mercy de arma ! imi zice cineva si mie cum o bag la shop alaturi de celelalte arme?