hlmod.hu ::Gránát Szintrendszer

hlmod.hu https://hlmod.hu/

Gránát Szintrendszer https://hlmod.hu/viewtopic.php?f=101&t=26087	Oldal: 1 / 2

Szerző: DarkFly [2016.09.01. 16:51 ]

Hozzászólás témája: Gránát Szintrendszer

Plugin Neve:	Gránát Szintrendszer	Plugint készitette:	VodKa
Játék:	Counter-Strike	Kategória:	Szórakoztató
Eredeti link:	Megnézem	Jóváhagyó:	6almasok

[*]Gránát Szintrendszer[*]
[*]By Vodka[*]

Leírás:
A játék során megszünteti a gránát berendezését. Játémenet közben ösze hozhatunk a pluginal XP-t, és SZINT-et, Regisztrálciós rendszer használatához megadok egy, linket allúl. Használjátok egézségel. Eszt a plugint, DeathMatch módra, Ajánlom.

Modulok:

Kód: [Egész kijelölése] [Mutatás/Eltüntetés]

#include <amxmodx> 
#include <fakemeta>    
#include <fvault> 
#include <fun>
#include <cstrike

GeSHi © Codebox Plus

Cvarok:
sv_grenadegame 0/1 - 1: Kapcsolja be a játékot 0: Kapcsolja ki a játékot

Mind 1 hogy milyen, Regisztrálciós rendszert használtok hozá.
De ajánlom, Regisztrációs Rendszer

#include <amxmodx> 
#include <fakemeta>    
#if defined _file_vault_included
	#endinput
#endif

#define _file_vault_included

/**
 * FVault was created by Exolent on 8/24/08
 * This vault system uses actual files and no modules
 * It is very flexible and has many features
 * Visit this page for more information: http://forums.alliedmods.net/showthread.php?t=76453
 */

#include <amxmodx>

stock const _vault_dir[] = "addons/amxmodx/data/file_vault";
stock const _temp_vault[] = "fvault_temp.txt";

/** 
 * Retrieves a key name specified by its number
 * 
 * @param vaultname	Vault name to look in
 * @param keynum	Key number within the vault to find key name
 * @param key		String which key name will be copied to
 * @param len		Length of key name
 * @return		Returns 1 on success, 0 on failue.
 */
stock fvault_get_keyname(const vaultname[], const keynum, key[], len)
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	if( !file_exists(filename) )
	{
		return 0;
	}
	
	new vault = fopen(filename, "rt");
	
	new _data[64], _other[3];
	
	new line = -1;
	
	while( !feof(vault) )
	{
		fgets(vault, _data, sizeof(_data) - 1);
		
		if( ++line == keynum )
		{
			parse(_data, key, len, _other, sizeof(_other) - 1);
			
			fclose(vault);
			
			return 1;
		}
	}
	
	fclose(vault);
	
	return 0;
}

/** 
 * Retrieves a key number specified by its name
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key name to search for
 * @return		Returns key number on success, -1 on failure
 */
stock fvault_get_keynum(const vaultname[], const key[])
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	if( !file_exists(filename) )
	{
		return -1;
	}
	
	new vault = fopen(filename, "rt");
	
	new _data[70], _key[64], _other[3];
	
	new line = -1;
	
	while( !feof(vault) )
	{
		fgets(vault, _data, sizeof(_data) - 1);
		parse(_data, _key, sizeof(_key) - 1, _other, sizeof(_other) - 1);
		
		line++;
		
		if( equal(_key, key) )
		{
			fclose(vault);
			
			return line;
		}
	}
	
	fclose(vault);
	
	return -1;
}

/** 
 * Retrieves data specified by a key
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key name to look for the data
 * @param data		String which data will be copied to
 * @param len		Length of data
 * @param timestamp	The unix time of when the data was last set ( -1 if permanent data, 0 if old fvault version ) ( optional param )
 * @return		Returns 1 on success, 0 on failue.
 */
stock fvault_get_data(const vaultname[], const key[], data[], len, ×tamp=0)
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	if( !file_exists(filename) )
	{
		return 0;
	}
	
	new vault = fopen(filename, "rt");
	
	new _data[512], _key[64], _time[32];
	
	while( !feof(vault) )
	{
		fgets(vault, _data, sizeof(_data) - 1);
		parse(_data, _key, sizeof(_key) - 1);
		
		if( equal(_key, key) )
		{
			new _len = strlen(_key) + 4; // + 2 = quotes on key, + 1 = space, + 1 = first quote
			for( new i = copy(data, len, _data[_len]) - 1; i > 0; i-- )
			{
				if( data[i] == '"' ) break;
				
				if( data[i] == ' '
				&& data[i - 1] == '"' )
				{
					data[i - 1] = '^0';
					
					copy(_time, sizeof(_time) - 1, data[i + 1]);
					timestamp = str_to_num(_time);
					break;
				}
			}
			
			fclose(vault);
			
			return 1;
		}
	}
	
	fclose(vault);
	
	copy(data, len, "");
	
	return 0;
}

/** 
 * Sets data of a key with current timestamp
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key name to which data will be set
 * @param data		Data to set to key
 * @return		Does not return a value.
 */
stock fvault_set_data(const vaultname[], const key[], const data[])
{
	_fvault_set_data(vaultname, key, data, get_systime());
}

/** 
 * Sets data of a key permanently (can't be removed with fvault_prune)
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key name to which data will be set
 * @param data		Data to set to key
 * @return		Does not return a value.
 */
stock fvault_pset_data(const vaultname[], const key[], const data[])
{
	_fvault_set_data(vaultname, key, data, -1);
}

_fvault_set_data(const vaultname[], const key[], const data[], const timestamp)
{
	new file = fopen(_temp_vault, "wt");
	
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	new vault = fopen(filename, "rt");
	
	new _data[512], _key[64], _other[3];
	
	new bool:replaced = false;
	
	while( !feof(vault) )
	{
		fgets(vault, _data, sizeof(_data) - 1);
		parse(_data, _key, sizeof(_key) - 1, _other, sizeof(_other) - 1);
		
		if( equal(_key, key) && !replaced )
		{
			fprintf(file, "^"%s^" ^"%s^" %i^n", key, data, timestamp);
			
			replaced = true;
		}
		else
		{
			fputs(file, _data);
		}
	}
	
	fclose(file);
	fclose(vault);
	
	if( !replaced )
	{
		file = fopen(filename, "a+");
		fprintf(file, "^"%s^" ^"%s^" %i^n", key, data, timestamp);
		fclose(file);
		
		delete_file(_temp_vault);
	}
	else
	{
		delete_file(filename);
		
		while( !rename_file(_temp_vault, filename, 1) ) { }
	}
}

/** 
 * Removes a key from a vault
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key to remove
 * @return		No return
 */
stock fvault_remove_key(const vaultname[], const key[])
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	if( !file_exists(filename) )
	{
		return;
	}
	
	new file = fopen(_temp_vault, "wt");
	
	new vault = fopen(filename, "rt");
	
	new _data[512], _key[64], _other[3];
	new bool:found_key;
	
	while( !feof(vault) )
	{
		fgets(vault, _data, sizeof(_data) - 1);
		parse(_data, _key, sizeof(_key) - 1, _other, sizeof(_other) - 1);
		
		if( equal(_key, key) )
		{
			found_key = true;
			continue;
		}
		
		fputs(file, _data);
	}
	
	fclose(file);
	fclose(vault);
	
	if( found_key )
	{
		delete_file(filename);
		
		while( !rename_file(_temp_vault, filename, 1) ) { }
	}
	else
	{
		delete_file(_temp_vault);
	}
}

/**
 * Prunes the vault for keys that are within the given timestamps
 * 
 * @param vaultname	Vault name to look in
 * @param start		If timestamp is after this Unix Time (set -1 to prune from very start)
 * @param end		If timestamp is before this Unix Time (set -1 to prune to most time)
 * @return		Returns number of keys pruned
 */
stock fvault_prune(const vaultname[], const start=-1, const end=-1)
{
	if( start == -1 && end == -1 )
	{
		new keys = fvault_size(vaultname);
		if( keys )
		{
			fvault_clear(vaultname);
		}
		
		return keys;
	}
	
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	if( !file_exists(filename) )
	{
		return 0;
	}
	
	new file = fopen(_temp_vault, "wt");
	new vault = fopen(filename, "rt");
	
	new keys;
	
	new data[512], i, _time[32], timestamp;
	while( !feof(vault) )
	{
		fgets(vault, data, sizeof(data) - 1);
		
		if( data[0] )
		{
			_time[0] = 0;
			
			for( i = strlen(data) - 1; i >= 0; i-- )
			{
				if( data[i] == '"' ) break;
				
				if( data[i] == ' ' )
				{
					copy(_time, sizeof(_time) - 1, data[i + 1]);
					break;
				}
			}
			
			timestamp = str_to_num(_time);
			if( timestamp != -1 )
			{
				if( start == -1 && timestamp <= end
				|| end == -1 && timestamp >= start
				|| start <= timestamp <= end )
				{
					keys++;
					continue;
				}
			}
		}
		
		fputs(file, data);
	}
	
	fclose(file);
	fclose(vault);
	
	if( keys )
	{
		delete_file(filename);
		
		while( !rename_file(_temp_vault, filename, 1) ) { }
	}
	else
	{
		delete_file(_temp_vault);
	}
	
	return keys;
}

/**
 * Updates the timestamp on a key located within the vault
 * 
 * @param vaultname	Vault name to look in
 * @param key		Key to update timestamp (if it doesn't exist, a blank value will be set)
 * @param timestamp	Unix Time to set for the key (-1 for current time)
 * @return		Returns 2 on new entry, 1 on success, 0 on failure for the key having a permanent timestamp
 */
stock fvault_touch(const vaultname[], const key[], const timestamp=-1)
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	static new_time;
	if( (new_time = timestamp) == -1 )
	{
		new_time = get_systime();
	}
	
	if( !file_exists(filename) )
	{
		new vault = fopen(filename, "wt");
		fprintf(vault, "^"%s^" ^"^" %i^n", key, new_time);
		fclose(vault);
		return 2;
	}
	
	new file = fopen(_temp_vault, "wt");
	new vault = fopen(filename, "rt");
	
	new bool:updated;
	
	new data[512], _key[64], len, i, _time[32];
	while( !feof(vault) )
	{
		fgets(vault, data, sizeof(data) - 1);
		parse(data, _key, sizeof(_key) - 1);
		
		if( equal(_key, key) )
		{
			_time[0] = 0;
			
			for( i = strlen(data) - 1; i >= 0; i-- )
			{
				if( data[i] == '"' ) break;
				
				if( data[i] == ' ' )
				{
					data[i] = '^0';
					copy(_time, sizeof(_time) - 1, data[i + 1]);
					break;
				}
			}
			
			if( str_to_num(_time) == -1 )
			{
				fclose(file);
				fclose(vault);
				
				delete_file(_temp_vault);
				
				return 0;
			}
			
			fprintf(file, "%s %i^n", data, new_time);
			
			updated = true;
		}
		else
		{
			fputs(file, data);
		}
	}
	
	if( !updated )
	{
		fprintf(file, "^"%s^" ^"^" %i^n", key, new_time);
	}
	
	fclose(file);
	fclose(vault);
	
	delete_file(filename);
	
	while( !rename_file(_temp_vault, filename, 1) ) { }
	
	return (_:(!updated) + 1);
}

/** 
 * Retrieves total keys located within the vault
 * 
 * @param vaultname	Vault name to look in
 * @return		Returns amount of keys in vault
 */
stock fvault_size(const vaultname[])
{
	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	return file_exists(filename) ? file_size(filename, 1) - 1 : 0;
}

/** 
 * Clears all key entries for a vault
 * 
 * @param vaultname	Vault name to erase
 * @return		No return
 */
stock fvault_clear(const vaultname[])
{
 	new filename[128];
	_FormatVaultName(vaultname, filename, sizeof(filename) - 1);
	
	fclose(fopen(filename, "wt"));
}

/** 
 * Retrieves a vault name specified by its number
 * 
 * @param vaultnum	Vault number to find the vault name
 * @param vaultname	String which vault name will be copied to
 * @param len		Length of vault name
 * @return		Returns 1 on success, 0 on failue.
 */
stock fvault_get_vaultname(const vaultnum, vaultname[], len)
{
	if( !dir_exists(_vault_dir) )
	{
		mkdir(_vault_dir);
		return 0;
	}
	
	new filenum;
	
	new dir = open_dir(_vault_dir, vaultname, len);
	
	do
	{
		if( equal(vaultname, ".") || equal(vaultname, "..") )
		{
			continue;
		}
		
		if( filenum == vaultnum )
		{
			close_dir(dir);
			
			replace(vaultname, len, ".txt", "");
			
			return 1;
		}
		
		++filenum;
	}
	while( next_file(dir, vaultname, len) );
	
	close_dir(dir);
	
	copy(vaultname, len, "");
	
	return 0;
}

/** 
 * Retrieves a vault number specified by its name
 * 
 * @param vaultname	Vault name to find the number
 * @return		Returns vault number on success, -1 on failure
 */
stock fvault_get_vaultnum(const vaultname[])
{
	if( !dir_exists(_vault_dir) )
	{
		mkdir(_vault_dir);
		return -1;
	}
	
	new filename[128], filenum;
	
	new dir = open_dir(_vault_dir, filename, sizeof(filename) - 1);
	
	do
	{
		if( equal(filename, ".") || equal(filename, "..") )
		{
			continue;
		}
		
		replace(filename, sizeof(filename) - 1, ".txt", "");
		
		if( equal(filename, vaultname) )
		{
			close_dir(dir);
			
			return filenum;
		}
		
		++filenum;
	}
	while( next_file(dir, filename, sizeof(filename) - 1) );
	
	close_dir(dir);
	
	copy(vaultname, len, "");
	
	return -1;
}

/** 
 * Retrieves total vaults ever created
 * 
 * @return		Returns amount of vaults
 */
stock fvault_total()
{
	if( !dir_exists(_vault_dir) )
	{
		mkdir(_vault_dir);
		return 0;
	}
	
	new vaultname[128], filename[128];
	new dir = open_dir(_vault_dir, vaultname, sizeof(vaultname) - 1);
	
	new filenum;
	do
	{
		if( equal(vaultname, ".") || equal(vaultname, "..") )
		{
			continue;
		}
		
		formatex(filename, sizeof(filename) - 1, "%s/%s", _vault_dir, vaultname);
		if( file_exists(filename) )
		{
			++filenum;
		}
	}
	while( next_file(dir, vaultname, sizeof(vaultname) - 1) );
	
	close_dir(dir);
	
	return filenum;
}

/**
 * Gets all vault keys, data, and timestamps
 * 
 * @param		vaultname - Vault name to look in
 * @param		keys - cellarray holding all of the keys
 * @param		datas - cellarray holding all of the data values
 * @param		timestamps - cellarray holding all of the timestamps
 * 
 * @return		Returns total number of entries in vault
 * 
 * @note		keys needs to be created like this: ArrayCreate(64)
 * 			datas needs to be created like this: ArrayCreate(512)
 * 			timestamps need to be created like this: ArrayCreate()
 */
stock fvault_load(const vaultname[], Array:keys=Invalid_Array, Array:datas=Invalid_Array, Array:timestamps=Invalid_Array)
{
	new filename[128];
	_FormatVaultName(vaultname, filename, 127);
	
	if( !file_exists(filename) )
	{
		return 0;
	}
	
	new vault = fopen(filename, "rt");
	
	new array_size;
	
	new filedata[1024];
	new key[64], data[512], timestamp[32];
	while( !feof(vault) )
	{
		fgets(vault, filedata, 1023);
		
		if( parse(filedata, key, 63, data, 511, timestamp, 31) < 2 )
		{
			continue;
		}
		
		if( keys != Invalid_Array )
		{
			ArrayPushString(keys, key);
		}
		if( datas != Invalid_Array )
		{
			ArrayPushString(datas, data);
		}
		if( timestamps != Invalid_Array )
		{
			ArrayPushCell(timestamps, str_to_num(timestamp));
		}
		
		array_size++;
	}
	
	fclose(vault);
	
	return array_size;
}
 
stock _FormatVaultName(const vaultname[], filename[], len)
{
	static const invalid_chars[][] =
	{
		"/", "\", "*", ":", "?", "^"", "<", ">", "|"
	};
	
	static tempvault[128], i;
	copy(tempvault, sizeof(tempvault) - 1, vaultname);
	
	for( i = 0; i < sizeof(invalid_chars); i++ )
	{
		replace_all(tempvault, sizeof(tempvault) - 1, invalid_chars[i], "");
	}
	
	if( !dir_exists(_vault_dir) )
	{
		mkdir(_vault_dir);
	}
	
	formatex(filename, len, "%s/%s.txt", _vault_dir, tempvault);
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1033\\ f0\\ fs16 \n\\ par }
*/
 
#include <fun>
#include <cstrike>
///Fordította DarkFly
new SZ_Password[ 192 ] 
new SZ_Password_T[ 33 ][ 192 ]

new Registrado[ 33 ] 
new BadPassword[ 33 ]

new const Vault[] = "GrenadeGame_Datos"

new gCvarPluginToggle  
new cvar_active

new g_PlayerXP[33]; 
new g_PlayerLevel[33];

new gBuyCommands[][] = {
    "usp", "glock", "deagle", "p228", "elites", "fn57", "m3", "xm1014", "mp5", "tmp", "p90", "mac10", "ump45", "ak47",   
    "galil", "famas", "sg552", "m4a1", "aug", "scout", "awp", "g3sg1", "sg550", "m249", "vest", "vesthelm", "flash", "hegren",  
    "sgren", "defuser", "nvgs", "shield", "primammo", "secammo", "km45", "9x19mm", "nighthawk", "228compact", "12gauge",  
    "autoshotgun", "smg", "mp", "c90", "cv47", "defender", "clarion", "krieg552", "bullpup", "magnum", "d3au1", "krieg550",  
    "buyammo1", "buyammo2"  
}

#define NUM_OF_LEVELS 10

new const LEVELS[NUM_OF_LEVELS] = { 
    100,  
    200,  
    400,  
    800, 
    1600, 
    3200, 
    6400, 
    12800, 
    25600, 
    51200
}

new const szHealth[] = {
    105, 110, 115, 120, 125, 130, 135, 140, 145, 150 
}
new const szVelocity[] = {
    252, 254, 256, 260, 263, 267, 271, 275, 279, 284 
}

new gmsgStatusText;

#define PLUGIN    "Grenade"  
#define AUTHOR    "VodKa"  
#define VERSION    "1.2"

/* Register mod by Kiske */

public plugin_init()  
{  
    register_forward( FM_ClientUserInfoChanged, "FWClientUserInfoChanged" ) 
    register_event("CurWeapon" , "Event_CurWeapon" , "be" , "1=1" );  
    gCvarPluginToggle = register_cvar("amx_block_buy", "1")  
    cvar_active = register_cvar("amx_grenade",  "1")  
    register_plugin(PLUGIN, VERSION, AUTHOR)   
    register_logevent("Ham_PlayerSpawn", 2, "1=Round_Start"); 
    register_clcmd( "say /registrarse", "CMDRegistrarse" ) 
    register_clcmd( "IntroducirContrasenia", "CMDIntroducirContrasenia" ) 
    register_cvar("sv_grenadegame", "1") 
    register_event("DeathMsg", "DeathMsg", "a") 
    register_cvar("XP_per_kill", "20") 
    register_event("ResetHUD", "ResetHud", "b") 
    gmsgStatusText = get_user_msgid("StatusText") 
    register_event("Niveles", "Event_Niveles", "be", "1=1"); 
    
    for (new i = 0; i < sizeof (gBuyCommands); i++)  
        register_clcmd(gBuyCommands[i], "BlockBuyCommands")  
}

public DeathMsg() 
{     
    if (!get_cvar_num("sv_grenadegame")) 
        return; 
    
    new attacker = read_data(1) 
    new victim = read_data(2)
    
    if(g_PlayerLevel[attacker] == NUM_OF_LEVELS) 
        return; 
    
    g_PlayerXP[attacker] += get_cvar_num("XP_per_kill") 
    
    if(g_PlayerXP[attacker] >= LEVELS[g_PlayerLevel[attacker]]) 
    { 
        ++g_PlayerLevel[attacker]; 
        
        client_print(attacker, _:print_chat, "[Grenade_Game] Gratulálunk szintet léptél %i!", g_PlayerLevel[attacker]) 
    } 
    ShowHUD(attacker); 
    
    respawn_player(victim) 
    give_item(victim, "weapon_hegrenade")  
    give_item(victim, "weapon_flashbang") 
}

ShowHUD(id) {
    new HUD[51] 
    format(HUD, 50, "[Grenade_Game] Szint: %i XP: %i", g_PlayerLevel[id], g_PlayerXP[id]) 
    
    message_begin(MSG_ONE, gmsgStatusText, {0,0,0}, id) 
    write_byte(0) 
    write_string(HUD) 
    message_end() 
}

public client_connect(id) 
{ 
    g_PlayerXP[id] = 0; 
    g_PlayerLevel[id] = 0; 
}

public Event_Niveles(id) 
{ 
    set_pev(id, pev_health, szHealth[g_PlayerLevel[id]]);
    set_pev(id, pev_velocity, szVelocity[g_PlayerLevel[id]]);
}

public client_disconnect(id) 
    Save(id)

public client_putinserver(id) 
{ 
    Registrado[id] = 0 
    BadPassword[id] = 0 
    Load(id) 
}

public CMDRegistrarse(id) 
{ 
    if( Registrado[id] || BadPassword[id] ) 
        return PLUGIN_HANDLED; 
    
    client_cmd( id, "messagemode IntroducirContrasenia" ) 
    
    return PLUGIN_CONTINUE; 
}

public CMDIntroducirContrasenia(id) 
{ 
    read_args( SZ_Password, 191 )  
    remove_quotes( SZ_Password )  
    trim( SZ_Password )  
    
    if( equal( SZ_Password, "" ) || contain( SZ_Password, " ") != -1)  
        return PLUGIN_HANDLED; 
    else  
    { 
        client_cmd(id, "setinfo _pass ^"%s^"", SZ_Password )  
        Registrado[id] = 1        
        
        static SZ_Name[ 32 ], SZ_Data[ 512 ] 
        get_user_name(id, SZ_Name, 31 )        
        
        formatex( SZ_Data, charsmax( SZ_Data ), "%s %d", SZ_Password, cs_get_user_money(id) )           
        
        fvault_set_data( Vault, SZ_Name, SZ_Data ) 
        
        SZ_Password_T[id] = SZ_Password 
        
        return PLUGIN_HANDLED; 
    } 
    
    return PLUGIN_CONTINUE; 
}

public Save(id) 
{ 
    if( !Registrado[id] || BadPassword[id] )  
        return PLUGIN_HANDLED; 
    
    static SZ_Data[ 512 ], SZ_Name[ 32 ] 
    
    formatex( SZ_Data, charsmax( SZ_Data ), "%s %d", SZ_Password_T[id], cs_get_user_money(id) ) 
    get_user_name(id, SZ_Name, 31 ) 
    
    fvault_set_data( Vault, SZ_Name, SZ_Data ) 
    
    return PLUGIN_CONTINUE; 
}

public Load(id) 
{ 
    static SZ_Data[ 512 ], SZ_Name[ 32 ], SETINFO_Password[ 191 ], VAULT_Password[ 191 ], Dinero[ 11 ]
    
    get_user_name(id, SZ_Name, 31 )
    get_user_info(id, "_pass", SETINFO_Password, 190 )
    
    if( !fvault_get_data( Vault, SZ_Name, SZ_Data, charsmax( SZ_Data ) ) ) 
        return 0;
    
    Registrado[id] = 1 
    
    parse( SZ_Data, VAULT_Password, 190, Dinero, 10 )  
    
    if( equal( SETINFO_Password, VAULT_Password ) )  
    { 
        SZ_Password_T[id] = SETINFO_Password 
        
        cs_set_user_money(id, str_to_num( Dinero ) ) 
        
        return 2; 
    } 
    else  
    { 
        BadPassword[id] = 1 
        set_hudmessage(255, 0, 0, -1.0, 0.15, 1, 6.0, 14.0) 
        show_hudmessage(id, "Helytelen jelszó, próbálja újra"); 
    } 
    
    return 1; 
}

public FWClientUserInfoChanged(id, Buffer ) 
{ 
    if( !is_user_connected(id) ) 
        return FMRES_IGNORED; 
    
    static NickName[32], NickOld[32]; get_user_name(id, NickOld, 31 ) 
    engfunc( EngFunc_InfoKeyValue, Buffer, "name", NickName, 31 )  
    
    if( equal( NickName, NickOld ) ) 
        return FMRES_IGNORED; 
    
    engfunc( EngFunc_SetClientKeyValue,id, Buffer, "name", NickOld )  
    
    client_cmd(id, "name ^"%s^"; setinfo name ^"%s^"", NickOld, NickOld ) 
    
    return FMRES_SUPERCEDE; 
}

public BlockBuyCommands(id)  
{  
    if (!get_pcvar_num(gCvarPluginToggle))  
        return PLUGIN_CONTINUE;  
    
    return PLUGIN_HANDLED;  
}

public Ham_PlayerSpawn(id)  
{  
    new players[32], num
    get_players(players, num, "a")
    
    for( --num; num >= 0; num-- ) /* By ConnorMcLeod */
    {
        fm_strip_user_weapons(players[num])
    }   
}

public Event_CurWeapon( id )  
{  
    if(get_pcvar_num(cvar_active))  
    {  
        new he = read_data(2)  
        
        if(he == CSW_HEGRENADE && is_user_alive(id))  
            
        return PLUGIN_CONTINUE  
        
        else  
        {  
            set_task(0.1, "he", id)  
        }  
    }  
    else  
    {  
        return PLUGIN_CONTINUE;  
    }  
    return PLUGIN_HANDLED;  
}

public he(id)  
    give_item(id,"weapon_hegrenade")

fm_strip_user_weapons( id ) {
    new iEnt = engfunc( EngFunc_CreateNamedEntity, engfunc( EngFunc_AllocString, "player_weaponstrip" ) );
    
    if( !pev_valid( iEnt ) )
        return 0;
    
    dllfunc( DLLFunc_Spawn, iEnt );
    dllfunc( DLLFunc_Use, iEnt, id );
    engfunc( EngFunc_RemoveEntity, iEnt );
    
    return 1;
}

/* By GHW_Chronic  */

public respawn_player(id)
{
    if(is_user_connected(id))
    {
        set_pev(id,pev_deadflag,DEAD_RESPAWNABLE);
        set_pev(id, pev_iuser1, 0);
        dllfunc(DLLFunc_Think,id)
        
        engfunc(EngFunc_SetOrigin,id,Float:{-4800.0,-4800.0,-4800.0})
        
        set_task(0.5,"spawnagain",id)
    }
}

public spawnagain(id)
{
    if(is_user_connected(id))
    {
        spawn(id)
        dllfunc(DLLFunc_Spawn,id)
    }
}

/* XP Mod edit by VodKa' */
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang11274\\ f0\\ fs16 \n\\ par }
*/

SMA	Letöltés \| Megtekintés
AMXX	Átalakítás AMXX-re*
*A fordítás a aghl.ru oldalon történik.

Szerző:	Pista. [2016.09.01. 16:55 ]
Hozzászólás témája:	Re: Grenade
Kép, leírás, kéne még bővíteni. (Csak úgy le írtam) Én nem nagyon értem ezt A játék során megszünteti a gránát berendezését. Játémenet közben ösze hozhatunk a pluginal XP-t, és SZINT-et

Szerző:	DarkFly [2016.09.01. 16:56 ]
Hozzászólás témája:	Re: Grenade
Tessék néz utána! nem feleslegesen pótoltam, az eredeti linket... https://forums.alliedmods.net/showthread.php?t=194709

Szerző:	theglorious [2016.09.01. 17:41 ]
Hozzászólás témája:	Re: Grenade
Idézet: AMX Mod X Compiler 1.8.3-manual Copyright (c) 1997-2006 ITB CompuPhase Copyright (c) 2004-2013 AMX Mod X Team Modified for http://www.Freakz.ro / amx.freakz.ro Header size: 1624 bytes Code size: 10492 bytes Data size: 40712 bytes Stack/heap size: 16384 bytes; estimated max. usage=1778 cells (7112 bytes) Total requirements: 69212 bytes Done. Ez nem kell... A fordítás meg egy

Szerző:	6almasok [2016.09.01. 18:40 ]
Hozzászólás témája:	Re: Grenade
Elvileg az oldal az aghl.ru compilerét használja de érdekes módon ott átfordul itt meg nem. Amúgy a plugin működő képesnek tűnik és a setinfo-s jelszózás... Viszont a pluginnak adhatlán egy normális nevet (pl Gránát Mod vagy Gránát Szintrendszer stb.) illetve egy normálist leírást.

Szerző:	voga955 [2016.09.01. 19:15 ]
Hozzászólás témája:	Re: Grenade
theglorious írta: A fordítás meg egy Ezt adom én is!

Szerző:	DarkFly [2016.09.01. 21:59 ]
Hozzászólás témája:	Re: Grenade
theglorious írta: Idézet: AMX Mod X Compiler 1.8.3-manual Copyright (c) 1997-2006 ITB CompuPhase Copyright (c) 2004-2013 AMX Mod X Team Modified for http://www.Freakz.ro / amx.freakz.ro Header size: 1624 bytes Code size: 10492 bytes Data size: 40712 bytes Stack/heap size: 16384 bytes; estimated max. usage=1778 cells (7112 bytes) Total requirements: 69212 bytes Done. Ez nem kell... A fordítás meg egy AMX Mod X Compiler 1.8.3-manual Copyright (c) 1997-2006 ITB CompuPhase Copyright (c) 2004-2013 AMX Mod X Team Modified for http://www.Freakz.ro / amx.freakz.ro Header size: 1624 bytes Code size: 10492 bytes Data size: 40712 bytes Stack/heap size: 16384 bytes; estimated max. usage=1778 cells (7112 bytes) Total requirements: 69212 bytes Done. Frisítve.

Szerző:	voga955 [2016.09.02. 18:35 ]
Hozzászólás témája:	Re: Gránát Szintrendszer
Ez még mindig hiányzik: Kód: [Egész kijelölése] [Mutatás/Eltüntetés] `register_cvar("XP_per_kill", "20")` GeSHi © Codebox Plus Ezt még írd be leírásba amúgy gondolom mennyi XP-t adjon ölésekért a cvar jelentése

Szerző:	DarkFly [2016.09.02. 20:13 ]
Hozzászólás témája:	Re: Gránát Szintrendszer
voga955 írta: Ez még mindig hiányzik: Kód: [Egész kijelölése] [Mutatás/Eltüntetés] `register_cvar("XP_per_kill", "20")` GeSHi © Codebox Plus Ezt még írd be leírásba amúgy gondolom mennyi XP-t adjon ölésekért a cvar jelentése Hogyan? xD

Szerző:	voga955 [2016.09.02. 20:22 ]
Hozzászólás témája:	Re: Gránát Szintrendszer
Elkezdi hogyan... Könnyen és egyszerűen gondolom te most arra gondoltál ,hogy a pluginba kell írni valamit hát nem hanem csak a leírást kéne szerkeszteni. + cvar Cvarok: sv_grenadegame 0/1 - 1: Kapcsolja be a játékot 0: Kapcsolja ki a játékot XP_per_kill 20 - Állítható az ölésekért kapható XP-k száma

Oldal: 1 / 2	Minden időpont UTC+02:00 időzóna szerinti
Powered by phpBB® Forum Software © phpBB Limited https://www.phpbb.com/