amx/include/xs.inc(119) : fatal error 110: assertion failed: 0

[CsCatalinGo]

Salut Primesc eroarea sta : amx/include/xs.inc(119) : fatal error 110: assertion failed: 0

Cand compilez asta :

Spoiler:

#include <amxmodx>
#include <cstrike>
#include <fakemeta_util>
#include <hamsandwich>
#include <zombieplague>
#include <fakemeta>
#include <nvault>
#include <dhudmessage>

#define PLUGIN "[ZBM]BuyMenu"
#define VERSION "2.0"
#define AUTHOR "Sonic Son'edit/heka/DEN67"

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)
const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE)
const ZOMBIE_ALLOWED_WEAPONS_BITSUM = (1<<CSW_KNIFE)|(1<<CSW_HEGRENADE)|(1<<CSW_FLASHBANG)|(1<<CSW_SMOKEGRENADE)|(1<<CSW_C4)

const PEV_ADDITIONAL_AMMO = pev_iuser1

const OFFSET_AWM_AMMO = 377
const OFFSET_SCOUT_AMMO = 378
const OFFSET_PARA_AMMO = 379
const OFFSET_FAMAS_AMMO = 380
const OFFSET_M3_AMMO = 381
const OFFSET_USP_AMMO = 382
const OFFSET_FIVESEVEN_AMMO = 383
const OFFSET_DEAGLE_AMMO = 384
const OFFSET_P228_AMMO = 385
const OFFSET_GLOCK_AMMO = 386
const OFFSET_FLASH_AMMO = 387
const OFFSET_HE_AMMO = 388
const OFFSET_SMOKE_AMMO = 389
const OFFSET_C4_AMMO = 390
const OFFSET_CLIPAMMO = 51
const OFFSET_TEAM = 114
const OFFSET_DEATHS = 444
const OFFSET_MONEY = 115

//wtf is unknown item ??? P228 unknown he gren xm1014 bomb mac10 aug smogegren elites fivesveen ump45 krieg500 galil famas usp glock awp mp5 m249 m3 m4a1 tmp g3sg1 flashgren deagle krieg552 ak47 ? p90
new const AMMOOFFSET[] = { -1, OFFSET_P228_AMMO, -1, OFFSET_SCOUT_AMMO, OFFSET_HE_AMMO, OFFSET_M3_AMMO, OFFSET_C4_AMMO, OFFSET_USP_AMMO, OFFSET_FAMAS_AMMO, OFFSET_SMOKE_AMMO, OFFSET_GLOCK_AMMO, OFFSET_FIVESEVEN_AMMO, OFFSET_USP_AMMO, OFFSET_FAMAS_AMMO, OFFSET_FAMAS_AMMO, OFFSET_FAMAS_AMMO,
OFFSET_USP_AMMO, OFFSET_GLOCK_AMMO, OFFSET_AWM_AMMO, OFFSET_GLOCK_AMMO, OFFSET_PARA_AMMO, OFFSET_M3_AMMO, OFFSET_FAMAS_AMMO, OFFSET_GLOCK_AMMO, OFFSET_SCOUT_AMMO, OFFSET_FLASH_AMMO, OFFSET_DEAGLE_AMMO, OFFSET_FAMAS_AMMO, OFFSET_SCOUT_AMMO, -1, OFFSET_FIVESEVEN_AMMO }

const OFFSET_LINUX = 5
const OFFSET_LINUX_WEAPONS = 4

new const sound_buyammo[] = "items/9mmclip1.wav"

new g_maxplayers

const TASK_BUYTIME_END = 100;
const TASK_RESTORE_MONEY = 200;
const TASK_KILL_ASSIST = 300;

new cvar_zp_cs_h_income_cash_rate;
new cvar_zp_cs_z_income_cash_rate;
new cvar_zp_cs_n_income_cash_rate
new cvar_zp_cs_s_income_cash_rate
new cvar_zp_cs_startmoney;
new cvar_zp_cs_restartround;
new cvar_zp_cs_moneymax;
new cvar_zp_cs_moneymax_vip;
new cvar_zp_cs_money_killbonus
new cvar_zp_cs_infectmoneybonus
new cvar_zp_cs_nemesis_canbuy
new cvar_zp_cs_survivor_canbuy

new cvar_zp_cs_money_human_win
new cvar_zp_cs_money_human_lose
new cvar_zp_cs_money_human_draw
new cvar_zp_cs_money_zombie_win
new cvar_zp_cs_money_zombie_lose
new cvar_zp_cs_money_zombie_draw
new cvar_zp_cs_zombie_nodeathscore

new Float: zp_cs_h_income_cash_rate;
new Float: zp_cs_z_income_cash_rate;
new Float: zp_cs_n_income_cash_rate
new Float: zp_cs_s_income_cash_rate
new zp_cs_moneymax;
new zp_cs_moneymax_vip;
new zp_cs_player_money[33]
new zp_cs_player_moneybonus[33]
new Float: zp_cs_damage[33][33] //[attacker][victim]

new g_MsgMoney, g_msgMoneyBlink, g_msgScoreInfo
new PlayerOldName[33][32]

new zp_cs_buymenu;
new zp_cs_submenuid[33];
new zp_cs_buymenu_pistol;
new zp_cs_buymenu_shotgun;
new zp_cs_buymenu_smgun;
new zp_cs_buymenu_rifle;
new zp_cs_buymenu_biggun;
new zp_cs_buymenu_knife;
new zp_cs_buymenu_equiph;
new zp_cs_buymenu_equipz;

new zp_cs_buymenu_ready;

new cvar_zp_cs_buymenu_pistol_name[20];
new cvar_zp_cs_buymenu_pistol_cost[20];
new cvar_zp_cs_buymenu_pistol_todo[20];
new cvar_zp_cs_buymenu_shotgun_name[20];
new cvar_zp_cs_buymenu_shotgun_cost[20];
new cvar_zp_cs_buymenu_shotgun_todo[20];
new cvar_zp_cs_buymenu_smgun_name[20];
new cvar_zp_cs_buymenu_smgun_cost[20];
new cvar_zp_cs_buymenu_smgun_todo[20];
new cvar_zp_cs_buymenu_rifle_name[20];
new cvar_zp_cs_buymenu_rifle_cost[20];
new cvar_zp_cs_buymenu_rifle_todo[20];
new cvar_zp_cs_buymenu_biggun_name[20];
new cvar_zp_cs_buymenu_biggun_cost[20];
new cvar_zp_cs_buymenu_biggun_todo[20];
new cvar_zp_cs_buymenu_equiph_name[20];
new cvar_zp_cs_buymenu_equiph_cost[20];
new cvar_zp_cs_buymenu_equiph_todo[20];
new cvar_zp_cs_buymenu_equipz_name[20];
new cvar_zp_cs_buymenu_equipz_cost[20];
new cvar_zp_cs_buymenu_equipz_todo[20];

public plugin_precache()
{
precache_sound(sound_buyammo)
}

public plugin_init()
{
register_plugin(PLUGIN,VERSION,AUTHOR)

register_dictionary("zbm_buymenu.txt")

g_MsgMoney = get_user_msgid("Money")
g_msgMoneyBlink = get_user_msgid("BlinkAcct")
g_msgScoreInfo = get_user_msgid("ScoreInfo")

register_event("HLTV", "event_round_start", "a", "1=0", "2=0")

RegisterHam(Ham_Spawn, "player", "ham_PlayerSpawn_Post", 1)
RegisterHam(Ham_TakeDamage, "player", "ham_TakeDamage")
RegisterHam(Ham_Killed, "player", "ham_PlayerKilled")

register_forward(FM_ClientConnect, "fw_ClientConnect_Post",1)
register_forward(FM_ClientDisconnect, "fw_ClientDisconnect")

register_clcmd("buy", "clcmd_zp_cs_buymenu")
register_clcmd("buyequip", "clcmd_zp_cs_buymenu")
register_clcmd("zp_cs_buymenu", "clcmd_zp_cs_buymenu")

cvar_zp_cs_h_income_cash_rate = register_cvar("zp_cs_human_income_cash_rate", "2.0")
cvar_zp_cs_z_income_cash_rate = register_cvar("zp_cs_zombie_income_cash_rate", "5.0")
cvar_zp_cs_n_income_cash_rate = register_cvar("zp_cs_nemesis_income_cash_rate", "0.5")
cvar_zp_cs_s_income_cash_rate = register_cvar("zp_cs_survivor_income_cash_rate", "0.2")
cvar_zp_cs_moneymax = register_cvar("zp_cs_moneymax", "70000")
cvar_zp_cs_moneymax_vip = register_cvar("zp_cs_moneymax_vip", "200000")
cvar_zp_cs_infectmoneybonus = register_cvar("zp_cs_infectmoneybonus", "1500")
cvar_zp_cs_money_killbonus = register_cvar("zp_cs_money_killbonus", "500")
cvar_zp_cs_startmoney = get_cvar_pointer("mp_startmoney")
cvar_zp_cs_restartround = get_cvar_pointer("sv_restartround")
cvar_zp_cs_nemesis_canbuy = register_cvar("zp_cs_nemesis_canbuy", "0")
cvar_zp_cs_survivor_canbuy = register_cvar("zp_cs_survivor_canbuy", "0")

cvar_zp_cs_money_human_win = register_cvar("zp_cs_money_human_win", "10000");
cvar_zp_cs_money_human_lose = register_cvar("zp_cs_money_human_lose", "1500");
cvar_zp_cs_money_human_draw = register_cvar("zp_cs_money_human_draw", "20000");
cvar_zp_cs_money_zombie_win = register_cvar("zp_cs_money_zombie_win", "5000");
cvar_zp_cs_money_zombie_lose = register_cvar("zp_cs_money_zombie_lose", "1500");
cvar_zp_cs_money_zombie_draw = register_cvar("zp_cs_money_zombie_draw", "-1500");
cvar_zp_cs_zombie_nodeathscore = register_cvar("zp_cs_zombie_nodeathscore", "1");

g_maxplayers = get_maxplayers()

for (new id=1;id<=g_maxplayers;id++)
{
zp_cs_player_moneybonus[id]=0;
zp_cs_player_money[id]=get_pcvar_num(cvar_zp_cs_startmoney)
}

zp_cs_buymenu_ready = false;

new strtemp[2];
new strtemp2[32];
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_pistol___name";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_pistol_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_pistol___cost";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_pistol_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_pistol___todo";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_pistol_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_shotgun___name";
if (i>8)
{
strtemp2[21]=strtemp[0];
strtemp2[22]=strtemp[1];
}
else
{
strtemp2[21]='0';
strtemp2[22]=strtemp[0];
}
cvar_zp_cs_buymenu_shotgun_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_shotgun___cost";
if (i>8)
{
strtemp2[21]=strtemp[0];
strtemp2[22]=strtemp[1];
}
else
{
strtemp2[21]='0';
strtemp2[22]=strtemp[0];
}
cvar_zp_cs_buymenu_shotgun_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_shotgun___todo";
if (i>8)
{
strtemp2[21]=strtemp[0];
strtemp2[22]=strtemp[1];
}
else
{
strtemp2[21]='0';
strtemp2[22]=strtemp[0];
}
cvar_zp_cs_buymenu_shotgun_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_smgun___name";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_smgun_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_smgun___cost";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_smgun_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_smgun___todo";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_smgun_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_rifle___name";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_rifle_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_rifle___cost";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_rifle_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_rifle___todo";
if (i>8)
{
strtemp2[19]=strtemp[0];
strtemp2[20]=strtemp[1];
}
else
{
strtemp2[19]='0';
strtemp2[20]=strtemp[0];
}
cvar_zp_cs_buymenu_rifle_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_biggun___name";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_biggun_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_biggun___cost";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_biggun_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_biggun___todo";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_biggun_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equiph___name";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equiph_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equiph___cost";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equiph_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equiph___todo";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equiph_todo[i] = register_cvar(strtemp2, "do_nothing");
}
for(new i=0;i<20;i++)
{
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equipz___name";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equipz_name[i] = register_cvar(strtemp2, "-");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equipz___cost";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equipz_cost[i] = register_cvar(strtemp2, "0");
num_to_str(i+1, strtemp, 2)
strtemp2 = "zp_cs_buymenu_equipz___todo";
if (i>8)
{
strtemp2[20]=strtemp[0];
strtemp2[21]=strtemp[1];
}
else
{
strtemp2[20]='0';
strtemp2[21]=strtemp[0];
}
cvar_zp_cs_buymenu_equipz_todo[i] = register_cvar(strtemp2, "do_nothing");
}
}

public client_authorized(id)
{
client_cmd(id, "bind b zp_cs_buymenu")
}

public plugin_natives()
{
register_native("zp_cs_get_user_money", "native_get_user_money", 1)
register_native("zp_cs_set_user_money", "native_set_user_money", 1)
}

public plugin_cfg()
{
new cfgdir[32]
get_localinfo("amxx_configsdir",cfgdir,sizeof cfgdir)
server_cmd("exec %s/zbm_buymenu.cfg", cfgdir)
build_menu;
}

public fw_ClientConnect_Post(id)
{
get_user_name(id,PlayerOldName[id],31)
if (zp_cs_player_moneybonus[id])
{
zp_cs_player_money[id]+=zp_cs_player_moneybonus[id]
zp_cs_player_moneybonus[id]=0
}
if (zp_cs_player_money[id]<get_pcvar_num(cvar_zp_cs_startmoney)) zp_cs_player_money[id]=get_pcvar_num(cvar_zp_cs_startmoney)
return FMRES_IGNORED;
}

public event_round_start(id)
{
zp_cs_buymenu_ready = false;

zp_cs_moneymax = get_pcvar_num(cvar_zp_cs_moneymax);
zp_cs_moneymax_vip = get_pcvar_num(cvar_zp_cs_moneymax_vip);
zp_cs_h_income_cash_rate = get_pcvar_float(cvar_zp_cs_h_income_cash_rate)
zp_cs_z_income_cash_rate = get_pcvar_float(cvar_zp_cs_z_income_cash_rate)
zp_cs_n_income_cash_rate = get_pcvar_float(cvar_zp_cs_n_income_cash_rate)
zp_cs_s_income_cash_rate = get_pcvar_float(cvar_zp_cs_s_income_cash_rate)

set_task(0.1, "build_menu");

set_dhudmessage(0, 255, 0, -1.0, 0.9, 2, 1.0, 4.5,0.1,0.1)
show_dhudmessage(0, "%L", LANG_PLAYER, "ZBM_NOTICE")
}

public zp_round_ended(winteam)
{
if(get_pcvar_num(cvar_zp_cs_restartround))
{
for(new id=1;id<=g_maxplayers;id++)
{
zp_cs_player_moneybonus[id] = 0
zp_cs_player_money[id]=get_pcvar_num(cvar_zp_cs_startmoney)

return PLUGIN_CONTINUE
}
}

new color[3]
for(new i=0;i<3;i++)
{
color[i] = 255*(winteam == i)
}

set_task(1.0, "round_results", winteam)

return PLUGIN_CONTINUE
}

public round_results(winteam)
{
new strtemp1[16]
new color[3]

for (new id=1;id<=g_maxplayers;id++)
{
if ((!is_user_connected(id))||(zp_get_user_survivor(id))||(zp_get_user_nemesis(id))) continue;

new MoneyBonus;
if (zp_get_user_zombie(id)||(zp_get_user_nemesis(id)))
{
if (winteam==0)
{
color[2]=255;
strtemp1="ZBM_NOONE"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_zombie_draw)
}

if (winteam==1)
{
color[1]=255;
strtemp1="ZBM_WIN"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_zombie_win)
}

if (winteam==2)
{
color[0]=255;
strtemp1="ZBM_FAIL"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_zombie_lose)
}
}
else
{
if (winteam==0)
{
color[2]=255;
strtemp1="ZBM_NOONE"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_human_draw)
}
if (winteam==1)
{
color[0]=255;
strtemp1="ZBM_FAIL"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_human_lose)
}
if (winteam==2)
{
color[1]=255;
strtemp1="ZBM_WIN"
MoneyBonus=get_pcvar_num(cvar_zp_cs_money_human_win)
}
}
zp_cs_player_moneybonus[id]+=MoneyBonus
set_dhudmessage(color[0], color[1], color[2], 0.05, 0.63, 2, 1.0, 3.5,0.05,0.05)
set_task(0.1,"update_scoreboard",id)
if (winteam) show_dhudmessage(id, "%L", LANG_PLAYER, strtemp1, MoneyBonus)
else show_dhudmessage(id, "%L", LANG_PLAYER, strtemp1, MoneyBonus)
}
}

public update_scoreboard(id)
{
message_begin(MSG_BROADCAST, g_msgScoreInfo)
write_byte(id)
write_short(pev(id, pev_frags))
write_short(get_pdata_int(id, OFFSET_DEATHS, OFFSET_LINUX))
write_short(0)
write_short(get_pdata_int(id, OFFSET_TEAM, OFFSET_LINUX))
message_end()
}

public build_menu()
{
if (zp_cs_buymenu_ready)
{
menu_destroy(zp_cs_buymenu)
menu_destroy(zp_cs_buymenu_pistol)
menu_destroy(zp_cs_buymenu_shotgun)
menu_destroy(zp_cs_buymenu_smgun)
menu_destroy(zp_cs_buymenu_rifle)
menu_destroy(zp_cs_buymenu_biggun)
menu_destroy(zp_cs_buymenu_equiph)
menu_destroy(zp_cs_buymenu_equipz)
menu_destroy(zp_cs_buymenu_knife)
}

new id

//register menus
zp_cs_buymenu = menu_create("\ySERVER: [CSO]", "zp_cs_buymenu_handle")
zp_cs_buymenu_pistol = menu_create("Pistols", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_shotgun = menu_create("Shotguns", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_smgun = menu_create("Smguns", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_rifle = menu_create("Rifles", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_biggun = menu_create("Bigguns", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_knife = menu_create("Knifes", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_equiph = menu_create("\rExtra Items (Human)", "zp_cs_subbuymenu_handle")
zp_cs_buymenu_equipz = menu_create("\rExtra Items (Zombie)", "zp_cs_subbuymenu_handle")
new callback_rifles = menu_makecallback ("call_rifles")
new strtemp0[100];
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_PISTOLS")
menu_additem(zp_cs_buymenu, strtemp0, "1", _, callback_rifles);
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_SHOTGUNS")
menu_additem(zp_cs_buymenu, strtemp0, "2", _, callback_rifles);
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_AUTO")
menu_additem(zp_cs_buymenu, strtemp0, "3", _, callback_rifles);
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_RIFLE")
menu_additem(zp_cs_buymenu, strtemp0, "4", _, callback_rifles);
formatex(strtemp0, charsmax(strtemp0), "%L^n", LANG_PLAYER, "ZBM_MAIN_MACHINE")
menu_additem(zp_cs_buymenu, strtemp0, "5", _, callback_rifles);
if(zp_get_user_survivor(id) || zp_get_user_nemesis(id))
{
formatex(strtemp0, charsmax(strtemp0), "%L^n", LANG_PLAYER, "ZBM_MAIN_EXTRA")
menu_additem(zp_cs_buymenu, strtemp0, "8", _, callback_rifles);
}
else
{
formatex(strtemp0, charsmax(strtemp0), "%L^n", LANG_PLAYER, "ZBM_MAIN_EXTRA")
menu_additem(zp_cs_buymenu, strtemp0, "8");
}
formatex(strtemp0, charsmax(strtemp0), "%L^n", LANG_PLAYER, "ZBM_MAIN_KNIFES")
menu_additem(zp_cs_buymenu, strtemp0, "7", _, callback_rifles);

formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_additem(zp_cs_buymenu, strtemp0, "0");
menu_setprop(zp_cs_buymenu, MPROP_PERPAGE, 0);
menu_setprop(zp_cs_buymenu, MPROP_NUMBER_COLOR, "\y");


new strtemp[100];
new strtemp2[100];
new strtemp3[100];
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_pistol_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_pistol_todo[i], strtemp3 , 32)

num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_pistol_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_pistol, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_pistol, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_pistol, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_pistol, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_pistol, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_shotgun_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_shotgun_todo[i], strtemp3 , 32)

num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_shotgun_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_shotgun, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_shotgun, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_shotgun, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_shotgun, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_shotgun, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_smgun_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_smgun_todo[i], strtemp3 , 32)

num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_smgun_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_smgun, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_smgun, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_smgun, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_smgun, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_smgun, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_rifle_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_rifle_todo[i], strtemp3 , 32)

num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_rifle_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_rifle, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_rifle, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_rifle, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_rifle, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_rifle, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_biggun_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_biggun_todo[i], strtemp3 , 32)

num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_biggun_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_biggun, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_biggun, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_biggun, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_biggun, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_biggun, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_equiph_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_equiph_todo[i], strtemp3 , 32)
num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_equiph_cost[i]), strtemp2, 32)

add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_equiph, strtemp, strtemp3)
}
}

menu_setprop(zp_cs_buymenu_equiph, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_equiph, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_equiph, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_equiph, MPROP_EXITNAME, strtemp0)
for(new i=0;i<20;i++)
{
get_pcvar_string(cvar_zp_cs_buymenu_equipz_name[i], strtemp , 32)
if (strtemp[0] != '-')
{
get_pcvar_string(cvar_zp_cs_buymenu_equipz_todo[i], strtemp3 , 32)
num_to_str(get_pcvar_num(cvar_zp_cs_buymenu_equipz_cost[i]), strtemp2, 32)
add(strtemp,sizeof strtemp, "\y",4)
add(strtemp,sizeof strtemp, strtemp2, sizeof strtemp2)
menu_additem(zp_cs_buymenu_equipz, strtemp, strtemp3)
}
}
menu_setprop(zp_cs_buymenu_equipz, MPROP_NUMBER_COLOR, "\y");
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_BACK")
menu_setprop(zp_cs_buymenu_equipz, MPROP_BACKNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_MORE")
menu_setprop(zp_cs_buymenu_equipz, MPROP_NEXTNAME, strtemp0)
formatex(strtemp0, charsmax(strtemp0), "%L", LANG_PLAYER, "ZBM_MAIN_EXIT")
menu_setprop(zp_cs_buymenu_equipz, MPROP_EXITNAME, strtemp0)

zp_cs_buymenu_ready=true;
}

public call_rifles(id, menu, item)
{
return (!zp_has_round_started () ) ? ITEM_ENABLED : ITEM_DISABLED
}

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)) || (dropwhat == 2 && ((1<<weaponid) & SECONDARY_WEAPONS_BIT_SUM)))
{
static wname[32], weapon_ent
get_weaponname(weaponid, wname, sizeof wname - 1)
weapon_ent = fm_find_ent_by_owner(-1, wname, id);

set_pev(weapon_ent, PEV_ADDITIONAL_AMMO, fm_get_user_bpammo(id, weaponid))

engclient_cmd(id, "drop", wname)
fm_set_user_bpammo(id, weaponid, 0)
}
}
}

stock fm_get_user_bpammo(id, weapon)
{
return get_pdata_int(id, AMMOOFFSET[weapon], OFFSET_LINUX);
}

stock fm_set_user_bpammo(id, weapon, amount)
{
set_pdata_int(id, AMMOOFFSET[weapon], amount, OFFSET_LINUX)
}

public clcmd_zp_cs_buymenu(id)
{
if (!is_user_alive(id))
return PLUGIN_HANDLED;

if ((zp_get_user_nemesis(id))&&(!get_pcvar_num(cvar_zp_cs_nemesis_canbuy)))
{
client_print(id,print_center,"%L", LANG_PLAYER, "BUYMENU_CANTBUY_NEMESIS")
return PLUGIN_HANDLED;
}
if ((zp_get_user_survivor(id))&&(!get_pcvar_num(cvar_zp_cs_survivor_canbuy)))
{
client_print(id,print_center,"%L", LANG_PLAYER, "BUYMENU_CANTBUY_SURVIVOR")
return PLUGIN_HANDLED;
}
if (zp_cs_buymenu_ready)
menu_display(id, zp_cs_buymenu)

return PLUGIN_HANDLED;
}

public zp_cs_buymenu_handle(id, menu, item)
{
new cmd[32];
new access, callback;
menu_item_getinfo(menu, item, access, cmd,2,_,_, callback);
zp_cs_submenuid[id] = str_to_num(cmd);

if (zp_cs_submenuid[id] == 0)
return PLUGIN_HANDLED;

if ((zp_get_user_zombie(id))&&(zp_cs_submenuid[id] != 8))
{
client_print(id,print_center,"%L", LANG_PLAYER, "BUYMENU_ONLY_HUMAH");
return PLUGIN_HANDLED;
}

if (zp_cs_submenuid[id] == 1)
menu_display(id, zp_cs_buymenu_pistol, 0);
if (zp_cs_submenuid[id] == 2)
menu_display(id, zp_cs_buymenu_shotgun, 0);
if (zp_cs_submenuid[id] == 3)
menu_display(id, zp_cs_buymenu_smgun, 0);
if (zp_cs_submenuid[id] == 4)
menu_display(id, zp_cs_buymenu_rifle, 0);
if (zp_cs_submenuid[id] == 5)
menu_display(id, zp_cs_buymenu_biggun, 0);
if (zp_cs_submenuid[id] == 8)
if (zp_get_user_zombie(id))
{
zp_cs_submenuid[id] = 82
menu_display(id, zp_cs_buymenu_equipz, 0);
}
else
{
zp_cs_submenuid[id] = 81
menu_display(id, zp_cs_buymenu_equiph, 0);
}
if (zp_cs_submenuid[id] == 7)
menu_display(id, zp_cs_buymenu_knife, 0);
if (zp_cs_submenuid[id] == 7)
{
client_cmd(id, "say /knife")
}

return PLUGIN_HANDLED;
}


public zp_cs_subbuymenu_handle(id, menu, item)
{
new cmd[32];
cmd [0] = '-';
new access, callback;

menu_item_getinfo(menu, item, access, cmd, charsmax(cmd),_,_, callback);

if (cmd[0]=='-') return PLUGIN_HANDLED;

new strtemp[100];
new itemcost;

if (strfind(cmd, "do_nothing") != 0)
for (new i=0;i<20;i++)
{
if (zp_cs_submenuid[id] == 1)
get_pcvar_string(cvar_zp_cs_buymenu_pistol_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 2)
get_pcvar_string(cvar_zp_cs_buymenu_shotgun_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 3)
get_pcvar_string(cvar_zp_cs_buymenu_smgun_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 4)
get_pcvar_string(cvar_zp_cs_buymenu_rifle_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 5)
get_pcvar_string(cvar_zp_cs_buymenu_biggun_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 81)
get_pcvar_string(cvar_zp_cs_buymenu_equiph_todo[i], strtemp , 32)
if (zp_cs_submenuid[id] == 82)
get_pcvar_string(cvar_zp_cs_buymenu_equipz_todo[i], strtemp , 32)

if (strfind(cmd, strtemp) == 0)
{
if (zp_cs_submenuid[id] == 1)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_pistol_cost[i])
if (zp_cs_submenuid[id] == 2)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_shotgun_cost[i])
if (zp_cs_submenuid[id] == 3)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_smgun_cost[i])
if (zp_cs_submenuid[id] == 4)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_rifle_cost[i])
if (zp_cs_submenuid[id] == 5)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_biggun_cost[i])
if (zp_cs_submenuid[id] == 81)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_equiph_cost[i])
if (zp_cs_submenuid[id] == 82)
itemcost = get_pcvar_num(cvar_zp_cs_buymenu_equipz_cost[i])

if (zp_cs_player_money[id] < itemcost) //check if player has enough money
{
message_begin(MSG_ONE_UNRELIABLE, g_msgMoneyBlink, _, id) //HUD
write_byte(5);
message_end();
client_print(id,print_center,"%L", LANG_PLAYER, "ZBM_NOT")
return PLUGIN_HANDLED;
}
else break;
}
}

if (strfind(cmd, "zp_cs_buy") == 0)
{
if ((user_has_weapon(id, CSW_HEGRENADE))&&(strfind(cmd, "zp_cs_buy_hegrenade") == 0))
{
if ((zp_get_user_zombie(id))||(zp_get_user_nemesis(id))) client_print(id,print_center,"%L", LANG_PLAYER, "BUYMENU_NOMORE_INFECTGREN")
else client_print(id,print_center,"%L", LANG_PLAYER, "ZBM_MAX_FIRE")

return PLUGIN_HANDLED;
}
if ((user_has_weapon(id, CSW_FLASHBANG))&&(strfind(cmd, "zp_cs_buy_flashbang") == 0))
{
client_print(id,print_center,"%L", LANG_PLAYER, "ZBM_MAX_FROST")

return PLUGIN_HANDLED;
}
replace(cmd,charsmax(cmd),"zp_cs_buy_","weapon_")
if ((strfind(cmd, "flashbang") == -1)&&(strfind(cmd, "hegrenade") == -1)&&(strfind(cmd, "smokegrenade") == -1))
if ((strfind(cmd, "glock18") > -1)||(strfind(cmd, "usp") > -1)||(strfind(cmd, "p228") > -1)||(strfind(cmd, "deagle") > -1)||(strfind(cmd, "elite") > -1)||(strfind(cmd, "fiveseven") > -1))
drop_weapons(id, 2);
else
drop_weapons(id, 1);

fm_give_item(id, cmd);
replace(cmd,charsmax(cmd),"weapon_","zp_cs_buy_")
}

if (strfind(cmd, "zp_cs_") != 0)
{
new temp_itemid=zp_get_extra_item_id(cmd);
if (temp_itemid>-1)
(zp_force_buy_extra_item(id,temp_itemid,1))
else
{
client_print(id, print_chat, "ERROR! ITEM %s NOT FOUND!",cmd)
}
}

if (strfind(cmd, "do_nothing") == 0) client_print(id, print_chat, "[zp_cs_buymenu]: This item does nothing.")

zp_cs_player_money[id] -= itemcost;
message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, id)
write_long(zp_cs_player_money[id]);
write_byte(1);
message_end();

return PLUGIN_HANDLED;
}

public ham_PlayerSpawn_Post(id)
{
if (!task_exists(id+TASK_RESTORE_MONEY)) set_task(0.5,"restore_player_money",id+TASK_RESTORE_MONEY)
}

public ham_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
if ((attacker<1)||(attacker>g_maxplayers)||(victim == attacker)||(!is_user_connected(attacker)))
return HAM_IGNORED;

zp_cs_damage[attacker][victim]+=damage

if (zp_get_user_survivor(attacker))
{
zp_cs_player_money[attacker] += floatround(damage*zp_cs_s_income_cash_rate);
if (zp_cs_player_money[attacker] > zp_cs_moneymax)
{
if(!(get_user_flags(attacker) & ADMIN_LEVEL_H))
{
zp_cs_player_money[attacker]=zp_cs_moneymax;
}else
if (zp_cs_player_money[attacker] > zp_cs_moneymax_vip)
{
zp_cs_player_money[attacker]=zp_cs_moneymax_vip;
}
}

message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, attacker);
write_long(zp_cs_player_money[attacker]);
write_byte(1);
message_end();
return HAM_IGNORED;
}

if (zp_get_user_zombie(attacker)||zp_get_user_nemesis(attacker))
{
if (!zp_get_user_nemesis(attacker)||zp_get_user_survivor(victim))
{
if (!zp_get_user_nemesis(attacker))
zp_cs_player_money[attacker] +=floatround(damage*zp_cs_z_income_cash_rate);
else
zp_cs_player_money[attacker] +=floatround(damage*zp_cs_n_income_cash_rate);

if (zp_cs_player_money[attacker] > zp_cs_moneymax)
{
if(!(get_user_flags(attacker) & ADMIN_LEVEL_H))
{
zp_cs_player_money[attacker]=zp_cs_moneymax;
}else
if (zp_cs_player_money[attacker] > zp_cs_moneymax_vip)
{
zp_cs_player_money[attacker]=zp_cs_moneymax_vip;
}
}

message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, attacker);
write_long(zp_cs_player_money[attacker]);
write_byte(1);
message_end();
}
return HAM_IGNORED;

}
else
{
zp_cs_player_money[attacker] += floatround(damage*zp_cs_h_income_cash_rate);

if (zp_cs_player_money[attacker] > zp_cs_moneymax)
{
if(!(get_user_flags(attacker) & ADMIN_LEVEL_H))
{
zp_cs_player_money[attacker]=zp_cs_moneymax;
}else
if (zp_cs_player_money[attacker] > zp_cs_moneymax_vip)
{
zp_cs_player_money[attacker]=zp_cs_moneymax_vip;
}
}

message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, attacker);
write_long(zp_cs_player_money[attacker]);
write_byte(1);
message_end();
return HAM_IGNORED;
}

return HAM_IGNORED;
}

public ham_PlayerKilled(victim, attacker, shouldgib)
{
if((attacker<1)||(attacker>g_maxplayers)||(attacker==victim)) return HAM_IGNORED

if (zp_get_user_zombie(attacker)&&!zp_get_user_nemesis(attacker))
{
menu_cancel(victim);
zp_cs_player_moneybonus[attacker]+=get_pcvar_num(cvar_zp_cs_infectmoneybonus)
}
else if (zp_get_user_nemesis(attacker))
{
menu_cancel(victim);
zp_cs_player_moneybonus[attacker]+=floatround(float(get_pcvar_num(cvar_zp_cs_infectmoneybonus))*zp_cs_n_income_cash_rate);
}
else if (zp_get_user_survivor(attacker))
zp_cs_player_moneybonus[attacker]+=floatround(float(get_pcvar_num(cvar_zp_cs_money_killbonus))*zp_cs_s_income_cash_rate);
else
zp_cs_player_moneybonus[attacker]+=get_pcvar_num(cvar_zp_cs_money_killbonus);

if (zp_get_user_zombie(attacker)&&!zp_get_user_nemesis(attacker))
{
if (get_pcvar_num(cvar_zp_cs_zombie_nodeathscore)) set_pdata_int(victim, OFFSET_DEATHS, get_pdata_int(victim, OFFSET_DEATHS, OFFSET_LINUX)-1, OFFSET_LINUX)
}

if(!task_exists(attacker+TASK_RESTORE_MONEY)) set_task(0.1,"restore_player_money",attacker+TASK_RESTORE_MONEY)

return HAM_IGNORED
}

public zp_user_humanized_pre(id, survivor)
{
if(survivor) menu_cancel(id)

return PLUGIN_CONTINUE
}

public zp_user_infected_post(id, infector)
{
if((infector <= g_maxplayers) && (infector > 0) && (id != infector))
{
if(!zp_get_user_nemesis(infector))
{
zp_cs_player_moneybonus[infector] += get_pcvar_num(cvar_zp_cs_infectmoneybonus)
fm_set_user_health(infector, get_user_health(infector) + 200)
}
else
zp_cs_player_moneybonus[infector]+=floatround(float(get_pcvar_num(cvar_zp_cs_infectmoneybonus))*zp_cs_n_income_cash_rate)

if(!task_exists(infector+TASK_RESTORE_MONEY)) set_task(0.1, "restore_player_money", infector+TASK_RESTORE_MONEY)
}

if((id<1)||(id>g_maxplayers)) return PLUGIN_CONTINUE

menu_cancel(id)

return PLUGIN_CONTINUE
}

public restore_player_money(id)
{
id-=TASK_RESTORE_MONEY

if(is_user_bot(id))
set_pdata_int(id,OFFSET_MONEY,16000,OFFSET_LINUX)
else
set_pdata_int(id,OFFSET_MONEY,0,OFFSET_LINUX)

message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, id)
write_long(zp_cs_player_money[id])
write_byte(1)
message_end()
zp_cs_player_money[id]+=zp_cs_player_moneybonus[id];

if (zp_cs_player_money[id] > zp_cs_moneymax)
{
if(!(get_user_flags(id) & ADMIN_LEVEL_H))
{
zp_cs_player_money[id]=zp_cs_moneymax;
}else
if (zp_cs_player_money[id] > zp_cs_moneymax_vip)
{
zp_cs_player_money[id]=zp_cs_moneymax_vip;
}
}
if (zp_cs_player_money[id] < 0) zp_cs_player_money[id]=0;
message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, id);
write_long(zp_cs_player_money[id]);
write_byte(1);
message_end();

zp_cs_player_moneybonus[id]=0;
}

public native_get_user_money(id)
{
return zp_cs_player_money[id] // return money (tERoR)
}

public native_set_user_money(id, num)
{
zp_cs_player_money[id] = num // set money (tERoR)

message_begin(MSG_ONE_UNRELIABLE, g_MsgMoney, _, id)
write_long(zp_cs_player_money[id])
write_byte(1)
message_end()
}

O rezolvare daca se poate va rog


Steam : CsCatalinGo
Casauta Vocala : CsCatalinGo

[destroi112]

din

Code:

#include <amxmodx> #include <cstrike> #include <fakemeta_util> #include <hamsandwich> #include <zombieplague> #include <fakemeta> #include <nvault> #include <dhudmessage>

in

Code:

#include <amxmodx> #include <cstrike> #include <fakemeta_util> #include <hamsandwich> #include <zombieplague> #include <fakemeta> #include <nvault> #include <dhudmessage> #include <xs>

si vezi sa iei libraria dp net si sa compilezi in pc daca nu merge pe compilator online.


Retired from Amxmodx

[CsCatalinGo]

Imi da tot acea eroare ...

Si am compilat in pc si pe amx.freakz.ro , aceeasi eraore ...

Poftim @D3luxe

Ce se afla in xs.inc :

Spoiler:

/* XS Library
* for AMX and AMXX
*
* Copyright (C) 2004 Pavol "PM" Marko
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
* Version 0.1
*
*
* MACROS THAT YOU CAN DEFINE BEFORE INCLUDING XS.INC:
* XS_FLEQ_TOLERANCE:
* Tolerance that is used for XS_FLEQ float nearly-equal comparisions
* DEFAULT: 0.000005
* XS_DEBUG
* Turn debug logging on
* DEFAULT: 0
* XS_LOGBUFFER_SIZE
* Buffer size for logging
* DEFAULT: 512
* XS_TASK_MAXPARAMS
* Maximal parameter count for managed tasks
* DEFAULT: 8
* XS_TASK_MAXPARAMSIZE
* Maximal size of string parameter for tasks
* Has to be power of 2 and has to be >= 8
* DEFAULT: 512
* XS_TASK_MANAGEDIDS
* Number of managed IDs for tasks.
* DEFAULT: 2048
* XS_REPLACEBUF_SIZE
* DEFAULT: 3072
*
*
* NOTES:
* On AMX, VexdUM is required for some math functions
*
* xs__ / XS__ (2 underscores) stuff is meant to be intern
*
* untested: never tested
* half-tested: succesfully used in other applications; not extensively tested in xs though
* tested: fully tested
*
* If you have any useful functions / ideas for functions, please tell me.
*/

#if defined _xs_included
#endinput
#endif
#define _xs_included

// **** CONFIG CHECK

#if !defined XS_FLEQ_TOLERANCE
#define XS_FLEQ_TOLERANCE 0.000005
#endif

#if !defined XS_DEBUG
#define XS_DEBUG 0
#endif

#if !defined XS_LOGBUFFER_SIZE
#define XS_LOGBUFFER_SIZE 512
#endif

#if !defined XS_TASK_MAXPARAMS
#define XS_TASK_MAXPARAMS 8
#endif

#if !defined XS_TASK_MAXPARAMSIZE
#define XS_TASK_MAXPARAMSIZE 512
#endif

#if !defined XS_TASK_MANAGEDIDS
#define XS_TASK_MANAGEDIDS 2048
#endif

#if !defined XS_REPLACEBUF_SIZE
#define XS_REPLACEBUF_SIZE 3072
#endif

// **** Detect platform
#define XS_AMX 0
#define XS_AMXX 1

#if defined _amxmodx_included
#define XS_PLATFORM XS_AMXX
#endif

#if defined _amxmod_included && !defined _amxmodx_included
#define XS_PLATFORM XS_AMX
#endif

#if !defined XS_PLATFORM
// Could not detect platform.
// Make sure you include amxmodx.inc or amxmod.inc before including xs.inc
#assert 0
#endinput
#endif

// Turn on for release
#define XS__LIBRELEASE 1

#if XS__LIBRELEASE
#define XS_LIBFUNC_ATTRIB stock
#else
#define XS_LIBFUNC_ATTRIB
#endif
#if XS__LIBRELEASE
#define XS_LIBVAR_ATTRIB stock
#else
#define XS_LIBVAR_ATTRIB new
#endif


/****** DEBUGGING / LOGING FUNCTIONS ******/
enum xs_logtypes
{
xs_debug,
xs_message,
xs_warning,
xs_error,
xs_fatalerror,
xs__assertionfailed,

// must come last
xs_logtypes_count
}

XS_LIBVAR_ATTRIB const xs__logtypenames[xs_logtypes_count][] = {"DEBUG", "", "WARNING", "ERROR", "FATAL ERROR", "DEBUG ASSERTION FAILED"};

// tested
XS_LIBFUNC_ATTRIB xs_log(xs_logtypes:logtype, {Float,_}:...)
{
// WARNING: Don't try to use assert in here; it uses this func

// Don't log debug if not in debug mode
#if !XS_DEBUG
if (logtype == xs_debug)
return;
#endif

new buffer[XS_LOGBUFFER_SIZE+1];
buffer[XS_LOGBUFFER_SIZE]=0;
format_args(buffer, XS_LOGBUFFER_SIZE, 1 /* go from SECOND argument*/);
new bool:addLogTypeName = strlen(xs__logtypenames[logtype]) ? true : false;

#if XS_PLATFORM == XS_AMX
new plugname[32];
new dummy[1];
get_plugin(-1, plugname, 31, dummy, 0, dummy, 0, dummy, 0, dummy, 0, dummy[0]);
// log into HL Logs
log_message("[AMX][%s]: %s%s%s", plugname, addLogTypeName ? xs__logtypenames[logtype] : "",
addLogTypeName ? ": " : "", buffer);
#else // assume AMXX

// Use AMXX's logging system
log_amx("%s%s%s", addLogTypeName ? xs__logtypenames[logtype] : "",
addLogTypeName ? ": " : "", buffer);
#endif
}

// Assertion
// tested
XS_LIBFUNC_ATTRIB xs_assertfunc({Float,_}:exp, const desc[])
{
// Check exp
if (exp)
return 1; // ok

// not ok

// print info
xs_log(xs__assertionfailed, "%s", desc);

return 0;
}
#define xs_assert(%1,%2) if (!xs_assertfunc(%1,%2)) xs__global_null /= xs__global_null


// Assertion; only in debug mode
// untested; logical flow says it should work
#if XS_DEBUG
#define xs_assert_dbg(%1,%2) if (!xs_assertfunc(%1,%2)) xs__global_null /= xs__global_null
#else
#define xs_assert_dbg(%1,%2)
#endif

new xs__global_null = 0;

/****** MATH FUNCTIONS ******/

/****** BASIC STUFF ******/

#if XS_PLATFORM == XS_AMX
enum anglemode
{
radian = 0,
degrees,
grades
}
#endif

// Returns -1 if num is negative, 0 if num is 0, 1 if num is positive
// tested
XS_LIBFUNC_ATTRIB xs_sign(num)
{
return (num < 0) ? -1 : ((num == 0) ? 0 : 1);
}

// Returns -1 if num is negative, 0 if num is 0, 1 if num is positive
// tested
XS_LIBFUNC_ATTRIB xs_fsign(Float:num)
{
return (num < 0.0) ? -1 : ((num == 0.0) ? 0 : 1);
}

// Returns absolute value
// tested
XS_LIBFUNC_ATTRIB xs_abs(num)
{
return (num < 0) ? -num : num;
}

// is power of 2? (== can be expressed as 1<<i)
// tested
XS_LIBFUNC_ATTRIB xs_is_2power(x)
{
return (x!=0) && ((x&(x-1))==0);
}

// degrees to radians
// tested
XS_LIBFUNC_ATTRIB Float:xs_deg2rad(Float:x)
{
return x * 0.017453292519943;
}

// tested
XS_LIBFUNC_ATTRIB Float:xs_rad2deg(Float:x)
{
return x * 57.29577951308232;
}

// untested, should work though
XS_LIBFUNC_ATTRIB Float:xs_gra2rad(Float:x)
{
return x * 0.015707963267948;
}

// untested, should work though
XS_LIBFUNC_ATTRIB Float:xs_rad2gra(Float:x)
{
return x * 63.66197723675813;
}

// Only works when there is no whitespace between %1, the comma and %2...
// tested
#define XS_FLEQ(%1,%2) (((%1) <= ((%2) + XS_FLEQ_TOLERANCE)) && ((%1) >= ((%2) - XS_FLEQ_TOLERANCE)))

// 1/sqrt
// tested
XS_LIBFUNC_ATTRIB Float:xs_rsqrt(Float:x)
{
#if XS_PLATFORM == XS_AMX
// store half
new Float:xhalf = x * 0.5;

// compute initial guess
new i = _;
i = 0x5f375a84 - (i >> 1);
x = Float:i;

// refine 3 times
x = x * (1.5 - xhalf * x * x);
x = x * (1.5 - xhalf * x * x);
x = x * (1.5 - xhalf * x * x);

return x;
#else
return 1.0 / floatsqroot(x);
#endif
}

// sqrt
// tested
XS_LIBFUNC_ATTRIB Float:xs_sqrt(Float:x)
{
#if XS_PLATFORM == XS_AMX
// 1.0 / rsqrt should still be faster than loop-using-approximation-methods
return 1.0 / xs_rsqrt(x);
#else
return floatsqroot(x);
#endif
}

// These functions generate errors if you use the macros with wrong parameter count.
stock Float:xs_fabs(Float:pa)
{
#pragma unused pa
new rawr = you_need_one_param_for_fabs;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_asin(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_asin;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_sin(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_sin;
#pragma unused rawr
}
stock Float:xs_acos(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_acos;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_cos(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_cos;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_atan(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_atan;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_atan2(Float:pa,Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_atan2;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}
stock Float:xs_tan(Float:pa, Float:pb)
{
#pragma unused pa,pb
new rawr = you_need_two_params_for_tan;
rawr = warning_below_shows_line_number;
#pragma unused rawr
}

#if XS_PLATFORM == XS_AMX
#pragma semicolon 0
#include <VexdUM>
#pragma semicolon 1
// We need stocks to provide radian / degrees / grades functionality

XS_LIBFUNC_ATTRIB Float:xs__2rad(Float:x, anglemode:mod)
{
switch (mod)
{
case radian:
return x;
case degrees:
return xs_deg2rad(x);
case grades:
return xs_gra2rad(x);
default:
xs_assert(0, "xs_asin, xs_sin, xs_acos, xs_cos, xs_atan, xs_atan2 or xs_tan called with invalid mod param");
}

return 0.0; // compiler warning
}

#define xs_fabs(%1) fabs(%1)
#define xs_asin(%1,%2) asin(xs__2rad(%1, %2))
#define xs_sin(%1,%2) sin(xs__2rad(%1, %2))
#define xs_acos(%1,%2) acos(xs__2rad(%1, %2))
#define xs_cos(%1,%2) cos(xs__2rad(%1, %2))
#define xs_atan(%1,%2) atan(xs__2rad(%1, %2))
#define xs_atan2(%1,%2) atan2(xs__2rad(%1, %2))
#define xs_tan(%1,%2) tan(xs__2rad(%1, %2))
#else
#define xs_fabs(%1) floatabs(%1)
#define xs_asin(%1,%2) floatasin(%1, %2)
#define xs_sin(%1,%2) floatsin(%1, %2)
#define xs_acos(%1,%2) floatacos(%1, %2)
#define xs_cos(%1,%2) floatcos(%1, %2)
#define xs_atan(%1,%2) floatatan(%1, %2)
#define xs_atan2(%1,%2) floatatan2(%1, %2)
#define xs_tan(%1,%2) floattan(%1, %2)
#endif

/****** RANDOM NUMBERS ******/
// This routine comes from the book "Inner Loops" by Rick Booth, Addison-Wesley
// (ISBN 0-201-47960-5). This is a "multiplicative congruential random number
// generator" that has been extended to 31-bits

XS_LIBVAR_ATTRIB xs__internalseed=0x546875;

#define XS__IL_RMULT 1103515245

// tested
XS_LIBFUNC_ATTRIB xs_seed(seed)
{
xs__internalseed = seed;
}

// tested
XS_LIBFUNC_ATTRIB xs_irand()
{
new lo, hi, ll, lh, hh, hl;
new result;

lo = xs__internalseed & 0xffff;
hi = xs__internalseed >> 16;
xs__internalseed = xs__internalseed * XS__IL_RMULT + 12345;
ll = lo * (XS__IL_RMULT & 0xffff);
lh = lo * (XS__IL_RMULT >> 16 );
hl = hi * (XS__IL_RMULT & 0xffff);
hh = hi * (XS__IL_RMULT >> 16 );
result = xs_abs(((ll + 12345) >> 16) + lh + hl + (hh << 16));
return result;
}

// tested
XS_LIBFUNC_ATTRIB Float:xs_frand()
{
return float(xs_irand()) / float(xs_get_maxnum()); // -1/2 should be the biggest possible positive number
}

// tested
XS_LIBFUNC_ATTRIB xs_irand_range(pmin, pmax)
{
xs_assert_dbg(pmax - pmin >= 0, "xs_irand_range: pmin > pmax");
new i = pmin + floatround(xs_frand() * float(pmax - pmin));
if (i > pmax)
i = pmax;
return i;
}

/****** VECTORS & PLANES ******/

// *** vectors

// Set vec components to values
// tested
XS_LIBFUNC_ATTRIB xs_vec_set(Float:vec[], Float:x, Float:y, Float:z)
{
vec[0] = x;
vec[1] = y;
vec[2] = z;
}

// Add vec
// tested
XS_LIBFUNC_ATTRIB xs_vec_add(const Float:in1[], const Float:in2[], Float:out[])
{
out[0] = in1[0] + in2[0];
out[1] = in1[1] + in2[1];
out[2] = in1[2] + in2[2];
}

// Subtract vec
// untested, but should work
XS_LIBFUNC_ATTRIB xs_vec_sub(const Float:in1[], const Float:in2[], Float:out[])
{
out[0] = in1[0] - in2[0];
out[1] = in1[1] - in2[1];
out[2] = in1[2] - in2[2];
}

// Are vectors equal?
// untested, but should work
XS_LIBFUNC_ATTRIB bool:xs_vec_equal(const Float:vec1[], const Float:vec2[])
{
return (vec1[0] == vec2[0]) && (vec1[1] == vec2[1]) && (vec1[2] == vec2[2]);
}

// Are vectors nearly equal?
// tested
XS_LIBFUNC_ATTRIB bool:xs_vec_nearlyequal(const Float:vec1[], const Float:vec2[])
{
return XS_FLEQ(vec1[0], vec2[0]) && XS_FLEQ(vec1[1], vec2[1]) && XS_FLEQ(vec1[2], vec2[2]);
}

// multiply vector by scalar
// tested
XS_LIBFUNC_ATTRIB xs_vec_mul_scalar(const Float:vec[], Float:scalar, Float:out[])
{
out[0] = vec[0] * scalar;
out[1] = vec[1] * scalar;
out[2] = vec[2] * scalar;
}

// divide vector by scalar
// untested, but should work
XS_LIBFUNC_ATTRIB xs_vec_div_scalar(const Float:vec[], Float:scalar, Float:out[])
{
new Float:__tmp = 1.0 / scalar;
out[0] = vec[0] * __tmp;
out[1] = vec[1] * __tmp;
out[2] = vec[2] * __tmp;
}

// Compute vector length
// tested
XS_LIBFUNC_ATTRIB Float:xs_vec_len(const Float:vec[])
{
return xs_sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
}

// Normalize vec
// tested
XS_LIBFUNC_ATTRIB xs_vec_normalize(const Float:vec[], Float:out[])
{
new Float:invlen = xs_rsqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
out[0] = vec[0] * invlen;
out[1] = vec[1] * invlen;
out[2] = vec[2] * invlen;
}

// Store the cross product of vec1 and vec2 in out
// tested
XS_LIBFUNC_ATTRIB xs_vec_cross(const Float:vec1[], const Float:vec2[], Float:out[])
{
out[0] = vec1[1]*vec2[2] - vec1[2]*vec2[1];
out[1] = vec1[2]*vec2[0] - vec1[0]*vec2[2];
out[2] = vec1[0]*vec2[1] - vec1[1]*vec2[0];
}

// Compute vec1 dot vec2
// tested
XS_LIBFUNC_ATTRIB Float:xs_vec_dot(const Float:vec1[], const Float:vec2[])
{
return vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2];
}

// Negate vec into out
// untested, but should work
XS_LIBFUNC_ATTRIB xs_vec_neg(const Float:vec[], Float:out[])
{
out[0] = -vec[0];
out[1] = -vec[1];
out[2] = -vec[2];
}

// Copy vec
// untested, but should work
XS_LIBFUNC_ATTRIB xs_vec_copy(const Float:vecIn[], Float:vecOut[])
{
vecOut[0] = vecIn[0];
vecOut[1] = vecIn[1];
vecOut[2] = vecIn[2];
}

// Compute angle between vec1 and vec2
// tested
XS_LIBFUNC_ATTRIB Float:xs_vec_angle(const Float:vec1[], const Float:vec2[])
{
return xs_rad2deg(xs_acos(xs_vec_dot(vec1, vec2), radian));
}

// Reflect vec about normal
// untested
XS_LIBFUNC_ATTRIB xs_vec_reflect(const Float:vec[], const Float:normal[], Float:out[])
{
// normalize(vec) - (normal * 2.0 * (tmp . normal)) * length(vec)

new Float:tmp1[3];
xs_vec_normalize(vec, tmp1);

// tmp1 - (normal * 2.0 * (tmp . normal)) * length(vec)

new Float:tmp2[3];
xs_vec_mul_scalar(normal, 2.0, tmp2);
xs_vec_mul_scalar(tmp2, xs_vec_dot(tmp1, normal), tmp2);

// tmp1 - tmp2 * length(vec)
xs_vec_mul_scalar(tmp2, xs_vec_len(vec), tmp2);

// tmp1 - tmp2
xs_vec_sub(tmp1, tmp2, out);
}

// Turn a 3D vector into a 2D vector
XS_LIBFUNC_ATTRIB xs_vec_make2d(const Float:vec[3], Float:out[2])
{
out[0] = vec[0];
out[1] = vec[1];
}

// *** planes

// normal
#define XS_PLANE_A 0
#define XS_PLANE_B 1
#define XS_PLANE_C 2
// plane shift distance
#define XS_PLANE_D 3


// Set a plane to specific values
// tested
XS_LIBFUNC_ATTRIB xs_plane_set(Float:plane[], Float:a, Float:b, Float:c, Float:d)
{
plane[XS_PLANE_A] = a;
plane[XS_PLANE_B] = b;
plane[XS_PLANE_C] = c;
plane[XS_PLANE_D] = d;
}

// Construct a plane out of 3 points
// tested
XS_LIBFUNC_ATTRIB xs_plane_3p(Float:plane[], const Float:p1[], const Float:p2[], const Float:p3[])
{
new Float:normalA[3], Float:normalB[3];

// normalA = Normalize(p3 - p1);
normalA[0] = p3[0] - p1[0];
normalA[1] = p3[1] - p1[1];
normalA[2] = p3[2] - p1[2];
xs_vec_normalize(normalA, normalA);

// normalB = Normalize(p3 - p2);
normalB[0] = p3[0] - p2[0];
normalB[1] = p3[1] - p2[1];
normalB[2] = p3[2] - p2[2];
xs_vec_normalize(normalB, normalB);

// plane normal = Normalize(normalA cross normalB)
xs_vec_cross(normalA, normalB, plane);
xs_vec_normalize(plane, plane);

// plane shift distance = (-p1) dot plane normal
new Float:__tmp[3];
xs_vec_neg(plane, __tmp);
plane[XS_PLANE_D] = xs_vec_dot(__tmp, p1);

}

// untested, but should work
XS_LIBFUNC_ATTRIB bool:xs_plane_equal(const Float:plane1[], const Float:plane2[])
{
if ( (plane1[0] == plane2[0]) &&
(plane1[1] == plane2[1]) &&
(plane1[2] == plane2[2]) &&
(plane1[3] == plane2[3]))
return true;
return false;
}

// untested, but should work
XS_LIBFUNC_ATTRIB bool:xs_plane_nearlyequal(const Float:plane1[], const Float:plane2[])
{
if ( XS_FLEQ(plane1[0], plane2[0]) &&
XS_FLEQ(plane1[1], plane2[1]) &&
XS_FLEQ(plane1[2], plane2[2]) &&
XS_FLEQ(plane1[3], plane2[3]))
return true;
return false;
}

// Compute distance between plane and point
// tested
XS_LIBFUNC_ATTRIB Float:xs_plane_dst2point(const Float:plane[], const Float:point[])
{
// return normal dot point + D
return xs_vec_dot(plane, point) + plane[XS_PLANE_D];
}

// Checks whether plane intersects with the ray starting and rayStart and going to rayDir direction.
// If yes, returns true and sets out to the intersection point
// Otherwise, returns false
// tested
XS_LIBFUNC_ATTRIB bool:xs_plane_rayintersect(const Float:plane[], const Float:rayStart[], const Float:rayDir[], Float:out[])
{
new Float:a = xs_vec_dot(plane, rayDir);

if (a == 0.0)
return false; // ray is parallel to plane

// if (distance plane<->(rayStart + rayDir) > distance plane<->rayStart) and both have the same sign, the ray
// goes away from the plane
new Float:rsplusrd[3];
xs_vec_add(rayStart, rayDir, rsplusrd);
new Float:dst1 = xs_plane_dst2point(plane, rsplusrd);
new Float:dst2 = xs_plane_dst2point(plane, rayStart);
if (xs_fabs(dst1) > xs_fabs(dst2) && xs_fsign(dst1) == xs_fsign(dst2))
return false;


// out = rayStart - rayDir * ((distance plane<->rayStart) / a)
new Float:__tmp[3];
xs_vec_mul_scalar(rayDir, xs_plane_dst2point(plane, rayStart) / a, __tmp);
// out = rayStart - tmp
xs_vec_sub(rayStart, __tmp, out);

return true;
}

// Is point on plane?
// tested
XS_LIBFUNC_ATTRIB bool:xs_point_onplane(const Float:plane[], const Float:point[])
{
return XS_FLEQ(xs_plane_dst2point(plane, point), 0.0);
}

// Project point on plane
// tested
XS_LIBFUNC_ATTRIB xs_projpoint_onplane(const Float:plane[], const Float:point[], Float:out[])
{
new Float:__tmp[3];
// out = point - (plane normal * distance point<->plane)
xs_vec_copy(plane, __tmp);
xs_vec_mul_scalar(__tmp, xs_plane_dst2point(plane, point), __tmp);
xs_vec_sub(point, __tmp, out);
}

// Copy plane
// untested, but should work
XS_LIBFUNC_ATTRIB xs_plane_copy(const Float:planeIn[], Float:planeOut[])
{
planeOut[0] = planeIn[0];
planeOut[1] = planeIn[1];
planeOut[2] = planeIn[2];
planeOut[3] = planeIn[3];
}

/****** HL ENGINE SPECIFIC STUFF ******/
// Compute forward, right and up vector from angles
// half-tested

// angle indexes
#define XS_PITCH 0 // up / down
#define XS_YAW 1 // left / right
#define XS_ROLL 2 // fall over

XS_LIBFUNC_ATTRIB xs_anglevectors(const Float:angles[3], Float:fwd[3], Float:right[3], Float:up[3])
{
// sin (s) and cos (c) for yaw (y), pitch (p) and roll (r)
new Float:sr, Float:sp, Float:sy, Float:cr, Float:cp, Float:cy;

sy = xs_sin(angles[XS_YAW], degrees);
cy = xs_cos(angles[XS_YAW], degrees);
sp = xs_sin(angles[XS_PITCH], degrees);
cp = xs_cos(angles[XS_PITCH], degrees);
sr = xs_sin(angles[XS_ROLL], degrees);
cr = xs_cos(angles[XS_ROLL], degrees);

fwd[0] = cp*cy;
fwd[1] = cp*sy;
fwd[2] = -sp;

right[0] = (-1*sr*sp*cy + -1*cr*-sy);
right[1] = (-1*sr*sp*sy + -1*cr*cy);
right[2] = -1*sr*cp;

up[0] = (cr*sp*cy + -sr*-sy);
up[1] = (cr*sp*sy + -sr*cy);
up[2] = cr*cp;
}
/****** STRING FUNCS *******/

// tested
XS_LIBFUNC_ATTRIB xs_strchr(const str[], chr)
{
for (new i = 0; str[i] != 0; ++i)
{
if (str[i] == chr)
return i;
}
return -1;
}

// by JGHG, adapted
// removes charstotrim number of charactes from stringtotrim's
// - beginning if fromleft is true
// - end if fromleft is false
// tested
XS_LIBFUNC_ATTRIB xs_strtrim(stringtotrim[], charstotrim, bool:fromleft = true)
{
if (charstotrim <= 0)
return;

if (fromleft)
{
new maxlen = strlen(stringtotrim);
if (charstotrim > maxlen)
charstotrim = maxlen;

// In format, input and output regions can overlap
format(stringtotrim, maxlen, "%s", stringtotrim[charstotrim]);
}
else
{
new maxlen = strlen(stringtotrim) - charstotrim;
if (maxlen < 0)
maxlen = 0;

// In format, input and output regions can overlap
format(stringtotrim, maxlen, "%s", stringtotrim);
}
}

// by xeroblood, adapted
// copies characters from oldmsg to newmsg, starting at start and ending at end (_includes_ end).
// terminates newmsg with 0
// if outlen is positive, it specifies the maximal number of characters to be copied.
// otherwise, assumes that newmsg is at least end-start+1 characters long.
// tested
XS_LIBFUNC_ATTRIB xs_strmid(const oldmsg[], newmsg[], start, end, outlen=-1)
{
new len = strlen(oldmsg);

if(start < 0)
start = 0;

++end; // Include end

if(end <= start || end > len)
end = len;

new j = 0, i = start;
for(; (i < end) && (outlen--)
newmsg[j++] = oldmsg[i++];

newmsg[j] = 0;
}

// by xeroblood, adapted
// maxelems: maximal number of elements in output, elemsize: maximal size of one element
// tested
XS_LIBFUNC_ATTRIB xs_explode(const input[], output[][], delimiter, maxelems, elemsize)
{
new nIdx = 0;
new nLen = 0;

new copied = 0;
while(nLen < strlen(input) && nIdx < maxelems)
{
copied = copyc(output[nIdx++], elemsize, input[nLen], delimiter);
if (copied == elemsize)
{
// maybe it got force-stopped because of maxsize
// so check whether we have to skip something
if (input[nLen + copied] != delimiter && input[nLen + copied] != 0)
{
new found = xs_strchr(input[nLen + copied], delimiter);
if (found == -1)
break;
copied += found;
}
}

nLen += copied + 1; // +1: skip delimiter
}
return nIdx;
}

// returns number of cells written.
XS_LIBFUNC_ATTRIB xs_implode(output[], outsize, delimiter, const input[][], elemsnum)
{
new pos = 0;
new copied;
for (new i = 0; i < elemsnum; ++i)
{
copied = copy(output[pos], outsize - pos, input[i]);
pos += copied;
if (pos >= outsize)
return outsize;
// append delimiter
output[pos] = delimiter;
++pos;
// last check
if (pos >= outsize)
return outsize;
}

output[--pos] = 0; // The last char would be delimiter, so skip it.
return pos;
}


XS_LIBVAR_ATTRIB xs__replace_buf[XS_REPLACEBUF_SIZE];
// Replace all occurencies of what in text with with
// Returns number of (also partially if trimmed by len) replaced items.
XS_LIBFUNC_ATTRIB xs_replace(text[], len, const what[], const with[])
{
new occur = 0;
new i = 0;
new bufPos = 0;
new replaceLen = strlen(with);
new whatLen = strlen(what);
for (; text[i]; ++i)
{
if (text[i] == what[0])
{
new posInWhat=0;
new j;
for (j = i; j-i < replaceLen && text[j]; ++j, ++posInWhat)
{
if (text[j] != what[posInWhat])
break;
}
if (whatLen == posInWhat)
{
for (new i2 = 0; i2 < replaceLen && bufPos < XS_REPLACEBUF_SIZE; ++i2)
xs__replace_buf[bufPos++] = with[i2];
i = j - 1;
++occur;
if (bufPos >= XS_REPLACEBUF_SIZE)
return occur;
continue;
}
}
if (bufPos >= XS_REPLACEBUF_SIZE)
return occur;
xs__replace_buf[bufPos++] = text[i];
}
xs__replace_buf[bufPos] = 0;
copy(text, len, xs__replace_buf);
return occur;
}

// replaces all occurencies of what in text with with
// Returns number of replaced items.
XS_LIBFUNC_ATTRIB xs_replace_char(text[], len, what, with)
{
// let the xs_replace function do the work
new arr[4];
arr[0] = what;
arr[1] = 0;
arr[2] = with;
arr[3] = 0;

return xs_replace(text, len, arr[0], arr[2]);
}

#if XS_PLATFORM == XS_AMX
// message_begin checking for AMX
xs__hook_message_begin(dest, msg_type, origin[3]={0,0,0}, player = 0)
{
xs_assert(xs_is_msg_valid(msg_type), "message_begin called with bogus message type");
return message_begin(dest, msg_type, origin, player);
}

#define message_begin xs__hook_message_begin
#endif
/****** MISC FUNCS *******/
// sets namestr to name of the command identified by cid
// half-tested
XS_LIBFUNC_ATTRIB xs_concmd_name(cid, namestr[], namelen)
{
new dummy1;
new dummy2[1];
get_concmd(cid, namestr, namelen, dummy1, dummy2, 0, 0);
}

// Checks whether there are at least num free visible slots
// half-tested
XS_LIBFUNC_ATTRIB bool:xs_freevisibleslots(num)
{
new maxplayers = get_cvar_num("sv_visiblemaxplayers");
if (maxplayers <= 0)
maxplayers = get_maxplayers();

return (get_playersnum(1) <= maxplayers-num) ? true : false;
}

// Returns biggest possible positive number
XS_LIBVAR_ATTRIB xs__maxnum = 0;
// tested
XS_LIBFUNC_ATTRIB xs_get_maxnum()
{
if (!xs__maxnum)
{
// build it
xs__maxnum = ((1 << (cellbits - 2)) - 1 ) | (1 << (cellbits - 2));
/*
new bits = get_cellsize() * 8 - 1;
for (new i = 0; i < bits; ++i)
xs__maxnum |= 1 << i;
*/
}
return xs__maxnum;
}

// tested
XS_LIBFUNC_ATTRIB xs_get_minnum()
{
return xs_get_maxnum() + 1;
}


// *** The following two functions were created by Damaged Soul.

// Max messages reserved by engine (DO NOT MODIFY)
#define XS__MAX_ENGINE_MESSAGES 63
// Max possible messages for mod, is 255 really the limit?
#define XS__MAX_POSSIBLE_MESSAGES 255

// Returns max number of messages for mod
XS_LIBFUNC_ATTRIB xs_get_maxmessages()
{
new name[2];

for (new i = XS__MAX_ENGINE_MESSAGES + 1; i <= XS__MAX_POSSIBLE_MESSAGES; i++)
if (!get_user_msgname(i, name, 1))
return i - 1;

return XS__MAX_POSSIBLE_MESSAGES;
}

// Returns true if msgid is a valid message
XS_LIBFUNC_ATTRIB bool:xs_is_msg_valid(msgid)
{
new name[2];
new retval = get_user_msgname(msgid, name, 1);

if (msgid < 1 || (msgid > XS__MAX_ENGINE_MESSAGES && !retval))
return false;

return true;
}

/****** MANAGED TASKS ******/

// ***** managed task ids
XS_LIBFUNC_ATTRIB xs_find_freetaskid()
{
for (new i = 1; i <= XS_TASK_MANAGEDIDS; ++i)
{
if (!task_exists(i))
return i;
}
return -1;
}

// ***** managed tasks
enum xs_paramtypes
{
xs_invalid = 0,
xs_int,
xs_float,
xs_string
}

// new task
XS_LIBVAR_ATTRIB xs__TaskParam[ 1 + // number of parameters
XS_TASK_MAXPARAMS + // parameter types
(XS_TASK_MAXPARAMSIZE char) * XS_TASK_MAXPARAMS]; // space for len + value

XS_LIBVAR_ATTRIB Float:xs__TaskInterval = 0.0;
XS_LIBVAR_ATTRIB xs__TaskFlags[5];
XS_LIBVAR_ATTRIB xs__TaskFunc[48];
XS_LIBVAR_ATTRIB xs__TaskId;
XS_LIBVAR_ATTRIB xs__TaskRepeat;

#define xs__TaskParamCount xs__TaskParam[0]
#define xs__TaskParamType[%1] xs__TaskParam[1 + %1]

#define xs__TaskParamValue[%1] xs__TaskParam[1 + XS_TASK_MAXPARAMS + (%1 * (XS_TASK_MAXPARAMSIZE char))]


// incoming task
XS_LIBVAR_ATTRIB xs__ITaskParam[ 1 + // number of parameters
XS_TASK_MAXPARAMS + // parameter types
(XS_TASK_MAXPARAMSIZE char) * XS_TASK_MAXPARAMS]; // space for len + value
XS_LIBVAR_ATTRIB xs__ITaskId;

#define xs__ITaskParamCount xs__ITaskParam[0]
#define xs__ITaskParamType[%1] xs__ITaskParam[1 + %1]

#define xs__ITaskParamValue[%1] xs__ITaskParam[1 + XS_TASK_MAXPARAMS + (%1 * (XS_TASK_MAXPARAMSIZE char))]

// tested
XS_LIBFUNC_ATTRIB xs_task_begin(Float:interval, const func[], id = 0, const flags[] = "", repeat = 0)
{
xs_assert(xs__TaskInterval == 0.0, "New xs_task_begin called before xs_task_end");

xs__TaskInterval = interval;
if (xs__TaskInterval < 0.1)
xs__TaskInterval = 0.1;

copy(xs__TaskFunc, 47, func);
xs__TaskId = id;
copy(xs__TaskFlags, 4, flags);
xs__TaskRepeat = repeat;

xs__TaskParamCount = 0;
}

// tested
XS_LIBFUNC_ATTRIB xs_task_pushint(value, bool:__isfl=false /*internal use only*/)
{
xs_assert(xs__TaskInterval, "xs_task_push* called without xs_task_begin");
if (xs__TaskParamCount >= XS_TASK_MAXPARAMS)
return 0;

xs__TaskParamType[xs__TaskParamCount] = __isfl ? xs_float : xs_int;
xs__TaskParamValue[xs__TaskParamCount] = value;

++xs__TaskParamCount;
return 1;
}

// tested
XS_LIBFUNC_ATTRIB xs_task_pushfl(Float:value)
{
return xs_task_pushint(_:value, true);
}

// tested
XS_LIBFUNC_ATTRIB xs_task_pushstr(const value[])
{
xs_assert(xs__TaskInterval, "xs_task_push* called without xs_task_begin");
if (xs__TaskParamCount >= XS_TASK_MAXPARAMS)
return 0;

xs__TaskParamType[xs__TaskParamCount] = xs_string;
strpack(xs__TaskParamValue[xs__TaskParamCount], value);
++xs__TaskParamCount;
return 1;
}

// tested
XS_LIBFUNC_ATTRIB xs_task_end()
{
xs_assert(xs__TaskInterval, "xs_task_end called without xs_task_begin");

// find a task id if needed
if (xs__TaskId == -1)
{
xs__TaskId = xs_find_freetaskid();
if (xs__TaskId == -1)
{
// not found
xs__TaskInterval = 0.0;
return -1;
}
}

set_task(xs__TaskInterval, xs__TaskFunc, xs__TaskId, xs__TaskParam,
1 + xs__TaskParamCount * (XS_TASK_MAXPARAMSIZE char), xs__TaskFlags, xs__TaskRepeat);

xs__TaskInterval = 0.0;

return xs__TaskId;
}


// tested
#define XS_MAKE_TASKFUNC(%1) public %1(const _xs__taskparam[], _xs__taskid) if(xs__task_setup(_xs__taskparam, _xs__taskid))

// tested
XS_LIBFUNC_ATTRIB xs__task_setup(const param[], taskid)
{
xs__ITaskId = taskid;
new len = 1 + param[0] * (XS_TASK_MAXPARAMSIZE char);
for (new i = 0; i < len; ++i)
xs__ITaskParam[i] = param[i];
return 1;
}

// tested
XS_LIBFUNC_ATTRIB xs_task_readid()
{
return xs__ITaskId;
}

// tested
XS_LIBFUNC_ATTRIB xs_task_paramcount()
{
return xs__ITaskParamCount;
}

// tested
XS_LIBFUNC_ATTRIB xs_paramtypes:xs_task_paramtype(paramid)
{
if (paramid < 0 || paramid >= xs__ITaskParamCount)
return xs_invalid;

return xs_paramtypes:xs__ITaskParamType[paramid];
}

// tested
XS_LIBFUNC_ATTRIB xs_task_paramint(paramid)
{
if (paramid < 0 || paramid >= xs__ITaskParamCount)
return 0;
if (xs__ITaskParamType[paramid] != _:xs_int)
return 0;

return xs__ITaskParamValue[paramid];
}

// tested
XS_LIBFUNC_ATTRIB Float:xs_task_paramfl(paramid)
{
if (paramid < 0 || paramid >= xs__ITaskParamCount)
return 0.0;
if (xs__ITaskParamType[paramid] != _:xs_float)
return 0.0;

return Float:xs__ITaskParamValue[paramid];
}

// tested
XS_LIBFUNC_ATTRIB xs_task_paramstr(paramid, out[], maxlen)
{
#pragma unused maxlen

if (paramid < 0 || paramid >= xs__ITaskParamCount)
return 0;
if (xs__ITaskParamType[paramid] != _:xs_string)
return 0;

strunpack(out, xs__ITaskParamValue[paramid]);
return 1;
}

Steam : CsCatalinGo
Casauta Vocala : CsCatalinGo

[destroi112]

Nu am ce face cu inc-ul , e problema de la tine mie mi-a dat 1 eroare da am rezolvat-o , uite aici pluginul.sma ,amx si inc-ul(cel mai probabil nu il ai bun)
http://www.fileshare.ro/e3172273124


Retired from Amxmodx

[CsCatalinGo]

Rezolvat , mersi frumos !


Steam : CsCatalinGo
Casauta Vocala : CsCatalinGo