/*
 
SDaL ANTIFAKE CS 1.6
version: 0.83
 
functions:
----------
* Storing player-data in its own Steam_ID.txt
* Displaying playerdata with their registered (fake-)names (max.5 names), when they did connect first time,
* how often they visit and their last visit on the server
* restrict playername
* createing a sdal_look.db4.txt for HLSW (www.hlsw.org)
* searching for steam_ids and returns a player_id.
* editing data of player_id
 
commands:
-----------
* admin_af: Displays a list of players on the server with their registered nicks
* admin_af_purge: Deletes old files and creates a new index.txt (DO NOT USE IN MAINTIME! It will lag the server!)
* admin_af_hlswexp: Creates a sdal_antifake.db4.txt for HLSW  (DO NOT USE IN MAINTIME! It will lag the server!)
* admin_af_restrict <playername> <[name_ID]>: restricts player to use the name with name_ID only.
* admin_af_search <part of steam_ID>: search for players with this steam id and returns the player_ID.
* admin_af_edit <player_ID> <[name_ID]>: restricts player to use the name with name_id only.
 
file-data (Steam_ID.txt):
------------
FirstConnect (Date, when file was created)
PlayerNames (max. 5 names)
iMaxConnects
LastConnect
iLastConnect_in_sec
RestriktName
 
idea:
------------
Instead of using huge parts of RAM storing a list of playernames,
only player(fake)names are stored in RAM, which are currently on the server.
Otherwise, their data is stored in their own Steam_ID.txt files.
 
Change-Log:
-----------
v.0.83
* search for Steam_ID in index.txt
* edit Player_ID which is returned by search
 
v.0.82
* restricting playername
 
v.0.81
* creates a sdal_look.db4.txt for HLSW
* added a new entry in playerfile, where admin can regulate a playername for the player.
 
v.0.8
* using a file-system to store a huge playerlist.
* files can be deleted with admin_spurge, when older than x days.(Date-LastConnect=x)
 
 
*/
 
#include <core>
#include <console>
#include <string>
#include <admin>
#include <adminlib>
 
new STRING_VERSION[MAX_DATA_LENGTH] = "04.12.03_v.0.83";
 
#define ACCESS_LOOK 	128
#define ACCESS_CONSOLE	131072
 
new g_PlayerDB[]="addons/adminmod/config/antifake/db/";
new g_Index[]="addons/adminmod/config/antifake/index.txt";
new g_HLSWtxt[]="addons/adminmod/config/antifake/sdal_antifake.db4.txt";
 
new g_AuthID[MAX_PLAYERS][MAX_AUTHID_LENGTH];
new g_FirstConnect[MAX_PLAYERS][MAX_NAME_LENGTH];
new g_Names[MAX_PLAYERS][MAX_TEXT_LENGTH];
new g_MaxConnects[MAX_PLAYERS][4];
new g_LastConnect[MAX_PLAYERS][MAX_NAME_LENGTH];
new g_RestrictName[MAX_PLAYERS][MAX_NAME_LENGTH];
new g_NewPlayer[MAX_PLAYERS];
 
new g_kill_playerdata=3;
 
public plugin_init() {
	plugin_registerinfo("SDALs ANTIFAKE Plugin","Searching for fakenames",STRING_VERSION);
	plugin_registercmd("admin_af","admin_af",ACCESS_LOOK,"admin_af: Zeigt Spieler mit Fakenamen an.");
	plugin_registercmd("admin_af_purge","admin_af_purge",ACCESS_LOOK,"admin_af_purge: Bereinigt den Datenbestand.");
	plugin_registercmd("admin_af_hlswexp","admin_af_hlswexp",ACCESS_LOOK,"admin_af_hlwsexp: Erstellt eine sdal_look.db4.txt, die dann in HLSW importiert werden kann");
	plugin_registercmd("admin_af_restrict","admin_af_restrict",ACCESS_LOOK,"admin_af_restrict <Spieler> [<Namen_IDs>]: Spielerdaten anzeigen. Wenn ID angegeben wird, darf der Spieler nur noch den Namen verwenden");
	plugin_registercmd("admin_af_search","admin_af_search",ACCESS_LOOK,"admin_af_search <Teil der Steam_ID(ohne 'STEAM_')>: Sucht nach Steam_IDs und liefert eine Spieler_ID");
	plugin_registercmd("admin_af_edit","admin_af_edit",ACCESS_LOOK,"admin_af_edit <Spieler_ID> [<Name_ID>]: Die Daten der Spieler_ID koennen nun mit dem Befehl bearbeitet werden");
	plugin_registercmd("sdal_af_enter", "enter", ACCESS_CONSOLE);
	plugin_registercmd("sdal_af_disc", "disc", ACCESS_CONSOLE);
	plugin_registercmd("sdal_af_world", "world", ACCESS_CONSOLE);
	exec( "logd_reg 51 admin_command sdal_af_enter" );
	exec( "logd_reg 52 admin_command sdal_af_disc" );
	exec( "logd_reg 62 admin_command sdal_af_world");
	return PLUGIN_CONTINUE;
}
 
public admin_af(HLCommand,HLData,HLUserName,UserIndex) {
	new Text[MAX_TEXT_LENGTH];
	new PlayerName[MAX_NAME_LENGTH];
	new Names[MAX_TEXT_LENGTH];
	new i;
	new maxplayers=maxplayercount();
	selfmessage("");
	selfmessage("*[ANTIFAKE] - STATUS*");
	selfmessage("----");
	selfmessage("* ID^tSpielername (Steam_ID)^t^t^t^tFake-Namen");
	for(i=1;i<=maxplayers;i++){
		if(playerinfo(i,PlayerName,MAX_NAME_LENGTH)){
			strcpy(Names,g_Names[i],MAX_TEXT_LENGTH);
			strsubst(Names,"®",",",MAX_TEXT_LENGTH);
			snprintf(Text,MAX_TEXT_LENGTH,"* %i. %s (%s):^t %s",i,PlayerName,g_AuthID[i],Names);
			selfmessage(Text);
			strinit(Text);
			selfmessage("-");
		}
	}
	return PLUGIN_HANDLED;
}
 
public admin_af_purge(HLCommand,HLData,HLUserName,UserIndex) {
	new FileName[MAX_TEXT_LENGTH];
	new Text[MAX_TEXT_LENGTH];
	new tempIndex[MAX_TEXT_LENGTH]="addons/adminmod/config/antifake/tempindex.txt";
	new pLastConnect[MAX_DATA_LENGTH];
	new lastConnect;
	new i;
	new iLineIndex;
	new start=systemtime();
	new end;
	new kills;
	new iDays;
	iLineIndex=filesize(g_Index);
	for(i=0;i<=iLineIndex;i++){
		readfile(g_Index,FileName,i,MAX_TEXT_LENGTH);
		if(strlen(FileName)!=0 && fileexists(FileName)){
			readfile(FileName,pLastConnect,5,MAX_DATA_LENGTH);
			lastConnect=strtonum(pLastConnect);
			iDays=(systemtime() - lastConnect) / 84600;
			if(iDays>g_kill_playerdata){
				deletefile(FileName);
				kills++;
			}else{
				writefile(tempIndex,FileName,-1);
			}
		}
	}
	resetfile(g_Index);
	iLineIndex=filesize(tempIndex);
	for(i=0;i<=iLineIndex;i++){
		readfile(tempIndex,FileName,i,MAX_TEXT_LENGTH);
		writefile(g_Index,FileName,-1);
	}
	deletefile(tempIndex);
	end=systemtime();
	snprintf(Text,MAX_TEXT_LENGTH,"[ANTIFAKE] Bereinung beendet! Dauer: %i Sek und %i Files geloescht!",end-start,kills);
	selfmessage(Text);
	log(Text);
	return PLUGIN_HANDLED;
}
 
public admin_af_hlswexp(HLCommand,HLData,HLUserName,UserIndex) {
	new Text[MAX_TEXT_LENGTH];
	new FileName[MAX_TEXT_LENGTH];
	new Names[5][MAX_NAME_LENGTH];
	new STEAM_ID[MAX_TEXT_LENGTH];
	new Data[MAX_DATA_LENGTH];
	new ST[MAX_DATA_LENGTH];
	new start=systemtime();
	new end;
	new i;
	new iLineIndex;
	new k;
 
	servertime(ST, MAX_DATA_LENGTH, "%d.%m.%y-%H:%M:%S");
 
	resetfile(g_HLSWtxt);
	snprintf(Text,MAX_TEXT_LENGTH,"// HLSW WONID database text file created by sdal_antifake");
	writefile(g_HLSWtxt,Text,-1);
	snprintf(Text,MAX_TEXT_LENGTH,"// %s",ST);
	writefile(g_HLSWtxt,Text,-1);
	writefile(g_HLSWtxt,"",-1);
	writefile(g_HLSWtxt,"Version: 1",-1);
	writefile(g_HLSWtxt,"",-1);
	iLineIndex=filesize(g_Index);
 
	for(i=0;i<=iLineIndex;i++){
		readfile(g_Index,FileName,i,MAX_TEXT_LENGTH);
		if(fileexists(FileName)){
			strcpy(STEAM_ID,FileName,MAX_TEXT_LENGTH);
			subst_filename(STEAM_ID);
			snprintf(Text,MAX_TEXT_LENGTH,"STEAM:^t%s",STEAM_ID);
			writefile(g_HLSWtxt,Text,-1);
			snprintf(Text,MAX_TEXT_LENGTH,"Type:^t^"Auto Added^"");
			writefile(g_HLSWtxt,Text,-1);
			snprintf(Text,MAX_TEXT_LENGTH,"Banned:^t0");
			writefile(g_HLSWtxt,Text,-1);
			readfile(FileName,Data,2,MAX_TEXT_LENGTH);
			if(strlen(Data)!=0){
				strsplit(Data,"®",Names[0],MAX_NAME_LENGTH,Names[1],MAX_NAME_LENGTH,Names[2],MAX_NAME_LENGTH,
					Names[3],MAX_NAME_LENGTH,Names[4],MAX_NAME_LENGTH);					
				snprintf(Text,MAX_TEXT_LENGTH,"Names:^t");
				for(k=0;k<5;k++){
					if(strlen(Names[k])!=0){
						snprintf(Text,MAX_TEXT_LENGTH,"%s^"%s^" ",Text,Names[k]);
						strinit(Names[k]);
					}else{
						break;
					}
				}
				writefile(g_HLSWtxt,Text,-1);
			}
			strinit(Data);
			readfile(FileName,Data,6,MAX_TEXT_LENGTH);
			if(strlen(Data)!=0){
				snprintf(Text,MAX_TEXT_LENGTH,"Comment:^t^"%s^"",Data);
				writefile(g_HLSWtxt,Text,-1);
			}
			writefile(g_HLSWtxt,"",-1);
		}
		strinit(Data);
		strinit(Text);
		strinit(STEAM_ID);
	}
	end=systemtime();
	snprintf(Text,MAX_TEXT_LENGTH,"[ANTIFAKE] HLSW Import Datei erstellt! Dauer: %i Sek",end-start);
	selfmessage(Text);
	return PLUGIN_HANDLED;
}
 
 
public admin_af_restrict(HLCommand,HLData,HLUserName,UserIndex) {
	new Data[MAX_DATA_LENGTH];
	new Text[MAX_DATA_LENGTH];
	new ID[3];
	new Target[MAX_NAME_LENGTH];
	new Player[MAX_NAME_LENGTH];
	new AuthID[MAX_AUTHID_LENGTH];
	new Names[5][MAX_NAME_LENGTH];
	new pUserIndex;
	new iID;
	new i;
	new a;
 
	convert_string(HLData, Data, MAX_DATA_LENGTH);
 
	strbreak(Data,Target,ID,MAX_DATA_LENGTH);
 
	if(strlen(Target)!=0){
		if (check_user(Target)==1) {
			get_username(Target,Player,MAX_NAME_LENGTH);
			get_userAuthID(Player,AuthID);
			get_userindex(Player,pUserIndex);
			selfmessage("");
			selfmessage("* [ANTIFAKE]- RESTRICT");
			selfmessage("----");
			snprintf(Text,MAX_TEXT_LENGTH,"Spieler: %s (%s)",Player,AuthID);
			selfmessage(Text);
			selfmessage("----");
			snprintf(Text,MAX_TEXT_LENGTH,"* Erste Mal registriert: %s",g_FirstConnect[pUserIndex]);
			selfmessage(Text);
			snprintf(Text,MAX_TEXT_LENGTH,"* Letzter Besuch: %s",g_LastConnect[pUserIndex]);
			selfmessage(Text);
			snprintf(Text,MAX_TEXT_LENGTH,"* Anzahl der Besuche: %s mal",g_MaxConnects[pUserIndex]);
			selfmessage(Text);
			snprintf(Text,MAX_TEXT_LENGTH,"* Bisher benutzte Spielernamen:");
			selfmessage(Text);
			strsplit(g_Names[pUserIndex],"®",Names[0],MAX_NAME_LENGTH,Names[1],MAX_NAME_LENGTH,Names[2],MAX_NAME_LENGTH,
					Names[3],MAX_NAME_LENGTH,Names[4],MAX_NAME_LENGTH);					
			for(i=0;i<5;i++){
				if(strlen(Names[i])!=0){
					strinit(Text);
					snprintf(Text,MAX_TEXT_LENGTH,"* - %i. %s",i,Names[i]);
					selfmessage(Text);
					a++;
				}else{
					break;
				}
			}
			a=a-1;
			if(strlen(ID)!=0){
				if(check_immunity(Player)==1){
					snprintf(Text, MAX_TEXT_LENGTH, "* Sorry. Du kannst den Namen von '%s' nicht festlegen!", Player);
					selfmessage(Text);
				}else{
					iID=strtonum(ID);
					if(iID<=a){
						strcpy(g_RestrictName[pUserIndex],Names[iID],MAX_NAME_LENGTH);
						snprintf(Text,MAX_TEXT_LENGTH,"name ^"%s^"",g_RestrictName[pUserIndex]);
						execclient(Player,Text);
						write_filedata(pUserIndex);
					}else{
						strcpy(g_RestrictName[pUserIndex],"",MAX_NAME_LENGTH);
						selfmessage("* Namensrestriktion des Spielers wurde aufgehoben!");
						write_filedata(pUserIndex);
					}
				}
			}
			snprintf(Text,MAX_TEXT_LENGTH,"* Darf nur Spielernamen benutzen: ^"%s^"",g_RestrictName[pUserIndex]);
			selfmessage(Text);
			return PLUGIN_HANDLED;
		}
	}		
	selfmessage("[ANTIFAKE] Spieler wurde nicht eindeutig identifiziert.");
	return PLUGIN_HANDLED;
}
 
public admin_af_search(HLCommand,HLData,HLUserName,UserIndex) {
	new Data[MAX_DATA_LENGTH];
	new Text[MAX_DATA_LENGTH];
	new FileName[MAX_TEXT_LENGTH];
	new i;
	new iLineIndex;
	new x;
	convert_string(HLData,Data,MAX_DATA_LENGTH);
 
	iLineIndex=filesize(g_Index);
	selfmessage("");
	selfmessage("* [ANTIFAKE] - SEARCH");
	snprintf(Text,MAX_TEXT_LENGTH,"* Es sind z.Z. %i Steam_IDs gespeichert!",iLineIndex);
	selfmessage(Text);
	selfmessage("* ID^t^tSTEAM_ID");
	for(i=0;i<=iLineIndex;i++){
		readfile(g_Index,FileName,i,MAX_TEXT_LENGTH);
		subst_filename(FileName);
		if(strstrx(FileName,Data)!=-1){
			snprintf(Text,MAX_TEXT_LENGTH,"* %i.^t%s",i,FileName);
			selfmessage(Text);
			strinit(Text);
			x++;
		}
		if(x==10){
			selfmessage("* Suche nach 10 Treffern abgebrochen! Suchkriterium besser spezifizieren!");
			break;
		}
	}
	selfmessage("* Suche beendet!");
	return PLUGIN_HANDLED;
}
 
public admin_af_edit(HLCommand,HLData,HLUserName,UserIndex) {
	new Data[MAX_DATA_LENGTH];
	new Text[MAX_DATA_LENGTH];
	new FileName[MAX_TEXT_LENGTH];
	new STEAM_ID[MAX_TEXT_LENGTH];
	new Names[5][MAX_NAME_LENGTH];
	new RestrictName[MAX_NAME_LENGTH];
	new NameID[3];
	new iNameID;
	new Line[10];
	new iLine;
	new i;
	new a;
 
	convert_string(HLData,Data,MAX_DATA_LENGTH);
	strbreak(Data,Line,NameID,MAX_DATA_LENGTH);
 
	iLine=strtonum(Line);
	readfile(g_Index,FileName,iLine,MAX_TEXT_LENGTH);
 
	if(fileexists(FileName)){
		selfmessage("");
		selfmessage("* [ANTIFAKE] - EDIT");
		snprintf(Text,MAX_TEXT_LENGTH,"* Daten von Spieler %i:",iLine);
		selfmessage(Text);
		strcpy(STEAM_ID,FileName,MAX_TEXT_LENGTH);
		subst_filename(STEAM_ID);
		selfmessage("----");
		snprintf(Text,MAX_TEXT_LENGTH,"STEAM-ID: %s",STEAM_ID);
		selfmessage(Text);
		selfmessage("----");
		readfile(FileName,Data,1,MAX_DATA_LENGTH);
		snprintf(Text,MAX_TEXT_LENGTH,"* Erste Mal registriert: %s",Data);
		selfmessage(Text);
		readfile(FileName,Data,4,MAX_DATA_LENGTH);
		snprintf(Text,MAX_TEXT_LENGTH,"* Letzter Besuch: %s",Data);
		selfmessage(Text);
		readfile(FileName,Data,3,MAX_DATA_LENGTH);
		snprintf(Text,MAX_TEXT_LENGTH,"* Anzahl der Besuche: %s mal",Data);
		selfmessage(Text);
		readfile(FileName,Data,2,MAX_DATA_LENGTH);
		snprintf(Text,MAX_TEXT_LENGTH,"* Bisher benutzte Spielernamen:");
		selfmessage(Text);
		strsplit(Data,"®",Names[0],MAX_NAME_LENGTH,Names[1],MAX_NAME_LENGTH,Names[2],MAX_NAME_LENGTH,
				Names[3],MAX_NAME_LENGTH,Names[4],MAX_NAME_LENGTH);					
		for(i=0;i<5;i++){
			if(strlen(Names[i])!=0){
				strinit(Text);
				snprintf(Text,MAX_TEXT_LENGTH,"* - %i. %s",i,Names[i]);
				selfmessage(Text);
				a++;
			}else{
				break;
			}
		}
		a=a-1;
		if(strlen(NameID)!=0){
			iNameID=strtonum(NameID);
			if(iNameID<=a){
				writefile(FileName,Names[iNameID],6);
				strcpy(RestrictName,Names[iNameID],MAX_NAME_LENGTH);
			}else{
				writefile(FileName,"",6);
				strcpy(RestrictName,"",MAX_NAME_LENGTH);
				selfmessage("* Namensrestriktion des Spielers wurde aufgehoben!");
			}
		}else{
			readfile(FileName,RestrictName,6,MAX_DATA_LENGTH);
		}		
		snprintf(Text,MAX_TEXT_LENGTH,"* Darf nur Spielernamen benutzen: ^"%s^"",RestrictName);
		selfmessage(Text);
	}else{
		selfmessage("[ANTIFAKE] Konnte Datei nicht finden!");
	}
	return PLUGIN_HANDLED;
}
 
/*Logd-Enter Funktion*/
public enter(HLCommand,HLUserIndex){
	new strUserIndex[MAX_NAME_LENGTH];
	new Player[MAX_NAME_LENGTH];
	new AuthID[MAX_AUTHID_LENGTH];
	new UserIndex;
	convert_string(HLUserIndex, strUserIndex, MAX_NAME_LENGTH);
	UserIndex=strtonum(strUserIndex);
	playerinfo(UserIndex,Player,MAX_NAME_LENGTH,_,_,_,_,AuthID);
	load_filedata(Player,AuthID,UserIndex);
	return PLUGIN_CONTINUE; 
}
 
/*Logd-Disconnect Funktion*/
public disc(HLCommand,HLUserIndex){
	new strUserIndex[MAX_NAME_LENGTH];
	new UserIndex;
	convert_string(HLUserIndex, strUserIndex, MAX_NAME_LENGTH);
	UserIndex=strtonum(strUserIndex);
	write_filedata(UserIndex);
	reset_arry(UserIndex);
	return PLUGIN_CONTINUE; 
}
 
/*Logd-World Funktion*/
public world(HLCommand,HLData){
	new Data[MAX_DATA_LENGTH];
	new Player[MAX_NAME_LENGTH];
	new maxplayers=maxplayercount();
	new i;
 
	convert_string(HLData, Data, MAX_DATA_LENGTH);
	if(Data[6]=='S'){
		for(i=1;i<=maxplayers;i++){
			if(playerinfo(i,Player,MAX_NAME_LENGTH)){
				if(strlen(g_RestrictName[i])!=0){
					if(strcmp(Player,g_RestrictName[i])!=0){
						messageex(Player,"[ANTIFAKE] Du darfst Deinen Namen nicht aendern!",print_chat);
						execclient(Player,"name x");
 
					}
				}
			}
		}
	}					
	return PLUGIN_CONTINUE; 
}
 
public plugin_info(HLOldName,HLNewName,UserIndex) {
	new NewName[MAX_NAME_LENGTH];
	new OldName[MAX_NAME_LENGTH];
	new ReName[MAX_TEXT_LENGTH];
	new icharcount;
 
	convert_string(HLNewName, NewName, MAX_NAME_LENGTH);
	convert_string(HLOldName, OldName, MAX_NAME_LENGTH);
 
	if(strlen(g_RestrictName[UserIndex])!=0){
		if(strcmp(NewName,g_RestrictName[UserIndex])!=0){
			messageex(OldName,"[ANTIFAKE] Du darfst Deinen Namen nicht aendern!",print_chat);
			snprintf(ReName,MAX_TEXT_LENGTH,"name ^"%s^"",g_RestrictName[UserIndex]);
			execclient(OldName,ReName);
			return PLUGIN_CONTINUE;
		}
	}
	if(strstrx(g_Names[UserIndex], NewName)==-1){
		icharcount=strcount(g_Names[UserIndex],'®');
		if(icharcount<5){
			snprintf(g_Names[UserIndex],MAX_TEXT_LENGTH,"%s®%s",g_Names[UserIndex],NewName);
		}
	}
	return PLUGIN_CONTINUE;
}
 
 
load_filedata(Player[],AuthID[],UserIndex){
	new ST[MAX_DATA_LENGTH];
	new File[MAX_DATA_LENGTH];
	new ReName[MAX_TEXT_LENGTH];
	new icharcount;
	new iConnect;
 
	servertime(ST, MAX_DATA_LENGTH, "%d.%m.%y-%H:%M:%S");
 
	strcpy(g_AuthID[UserIndex],AuthID,MAX_AUTHID_LENGTH);
 
	strsubst(AuthID, ":", "-",MAX_AUTHID_LENGTH);
	snprintf(File,MAX_DATA_LENGTH,"%s%s.txt",g_PlayerDB,AuthID);
 
	if(fileexists(File)){
		readfile(File,g_FirstConnect[UserIndex],1,MAX_NAME_LENGTH);
		readfile(File,g_Names[UserIndex],2,MAX_TEXT_LENGTH);
		if(strstrx(g_Names[UserIndex], Player)==-1){
			icharcount=strcount(g_Names[UserIndex],'®');
			if(icharcount<5){
				snprintf(g_Names[UserIndex],MAX_TEXT_LENGTH,"%s®%s",g_Names[UserIndex],Player);
			}
		}
		readfile(File,g_MaxConnects[UserIndex],3,4);
		iConnect=strtonum(g_MaxConnects[UserIndex]);
		iConnect++;
		numtostr(iConnect,g_MaxConnects[UserIndex]);
		readfile(File,g_LastConnect[UserIndex],4,MAX_NAME_LENGTH);
		readfile(File,g_RestrictName[UserIndex],6,MAX_NAME_LENGTH);
		if(strlen(g_RestrictName[UserIndex])!=0){
			if(strcmp(Player,g_RestrictName[UserIndex])!=0){
				snprintf(ReName,MAX_TEXT_LENGTH,"name %s",g_RestrictName[UserIndex]);
				messageex(Player,"[ANTIFAKE] Du musst unter Deinem registrierten Namen spielen!",print_chat);
				execclient(Player,ReName);
			}
		}
	}else{
		strcpy(g_FirstConnect[UserIndex],ST,MAX_NAME_LENGTH);
		strcpy(g_Names[UserIndex],Player,MAX_NAME_LENGTH);
		strcpy(g_MaxConnects[UserIndex],"1",4);
		strcpy(g_LastConnect[UserIndex],ST,4);
		g_NewPlayer[UserIndex]=1;
	}
}
 
subst_filename(Name[]){
	strsubst(Name,g_PlayerDB,"",MAX_TEXT_LENGTH);
	strsubst(Name, "-", ":",MAX_TEXT_LENGTH);
	strsubst(Name, ".txt", "",MAX_TEXT_LENGTH);
}
 
write_filedata(UserIndex){
	new ST[MAX_DATA_LENGTH];
	new File[MAX_DATA_LENGTH];
	new LastCon[MAX_DATA_LENGTH];
	new lastcon;
	servertime(ST, MAX_DATA_LENGTH, "%d.%m.%y-%H:%M:%S");
	lastcon=systemtime();
	set_vaultnumdata("LOOK_TIMESTAMP",lastcon);
	strsubst(g_AuthID[UserIndex], ":", "-",MAX_AUTHID_LENGTH);
	snprintf(File,MAX_DATA_LENGTH,"%s%s.txt",g_PlayerDB,g_AuthID[UserIndex]);
	if(g_NewPlayer[UserIndex]==1){
		writefile(g_Index,File,-1);
	}
	writefile(File,g_FirstConnect[UserIndex],1);
	writefile(File,g_Names[UserIndex],2);
	writefile(File,g_MaxConnects[UserIndex],3);
	writefile(File,ST,4);
	get_vaultdata("LOOK_TIMESTAMP",LastCon,MAX_DATA_LENGTH);
	writefile(File,LastCon,5);
	writefile(File,g_RestrictName[UserIndex],6);
}
 
reset_arry(UserIndex){
	g_AuthID[UserIndex][0]=0;
	g_FirstConnect[UserIndex][0]=0;
	g_Names[UserIndex][0]=0;
	g_MaxConnects[UserIndex][0]=0;
	g_NewPlayer[UserIndex]=0;
	g_RestrictName[UserIndex][0]=0;
	g_LastConnect[UserIndex][0]=0;
}