function say_commands(id,txt)

	if parse_word(txt,1) == "!map" and check_admin(id) == 1 then
		parse('sv_map '..parse_word(txt,2))
		if parse_word(txt,1) == "!map" and check_admin(id) == 0 then msg2(id,"©255040000Access Denied. This is admin command") return(1) end
	end

end

function parse_word(line,wordnr)
local var={}
local index=1
	for i in string.gmatch(line, "%S+") do
		var[index]=i
		index=index+1
	end
return (var[wordnr]) end

function check_admin(id)

	local file = io.open("sys/ranks/admins.txt", "rb")
	if not file then msg('©255100100Internal error: Could not read "sys/ranks/admins.txt"') return 0 end
	local con = file:read("*all")
	file:flush()
	file:close()

	local admin_list = word_split(con,'-')
	local steamid = player(id,'steamid')
	if steamid ~= 0 then
		for i in pairs(admin_list) do
			if admin_list[i] == steamid then
				return 1
			end
		end	
	end
return 0
end

if !FileExist("sys/ranks/admins.txt")
FileAppend,76561198193930577, sys/ranks/admins.txt
if !FileExist("sys/ranks/areports.txt")
FileAppend, , sys/ranks/areports.txt
if !FileExist("sys/ranks/amembers.txt")
FileAppend, , sys/ranks/amembers.txt
if !FileExist("sys/ranks/standings.txt")
FileAppend, , sys/ranks/standings.txt
if !FileExist("sys/ranks/history.txt")
FileAppend, , sys/ranks/history.txt

--------------------
---Functions List---
--------------------
; lines(filepath)
; K_Factor(rank)
; ELO(w,l,report)
; ReadInput(report)
; ExtractNumbers(report)
; FindUSGN(usgn,filepath,nr)
; GetName(line)
; Extract_Players_Match(match_report,match_data) 1
; Extract_Players_Standings(filepath)            2
; Calculate_Players_Standings()                  3
; ReplaceLine(line,calc_report,filepath)
; SortFileRating(standings)
; CheckErrors(filepath) checks reports.txt and compares it with standings to see if there are any errors.
; UpdateHistory(filepath)
; Add_Newbie(report)
-------------------------------
-------report examples---------
-------------------------------
;match_report=Red team-Blue Team-4-0-222-4-0-0-111-2-0-2-333-1-2-3-444-1-2-3-555-1-2-3-666-1-2-3-777-1-2-3-888-1-2-3-999-1-2-3-100-1-2-3
;match_report=Red team-Blue Team-4-0-222-4-0-0-111-2-0-2-333-1-2-3-444-1-2-3-555-1-2-3-666-1-2-3-777
;match_report=Red team-Blue Team-4-0-222-4-0-0-111-2-0-2-333-1-2-3-444-1-2-3-555-1-2-3-666-1-2-3-777
-------------------------------------
----------Initial Setup--------------
-------------------------------------
CheckErrors("sys/ranks/standings.txt")
assist_impact:=1
kpd_impact:=2
-------------------------------------
-------Start Adding Reports----------
-------------------------------------
loop % lines("sys/ranks/areports.txt") ;add_report loop start
{
FileReadLine, match_report, sys/ranks/areports.txt, %A_Index%
Match_Data:=ReadInput(match_report)
	if(Match_Data[1]="A")
	{
	Add_Newbie(match_report)
	continue
	}
		if(Match_Data[1]="P")
		{
		penalty(match_report)
		continue
		}
Match_Data:=""
temp:=ReadInput(match_report)
total_players:=(temp.MaxIndex()-4)/4

temp:=""
team_game_bonus:=total_players*2
	if (total_players=2)
	team_game_bonus:=0
Match_Data:=ReadInput(match_report)

Extract_Players_Match(match_report,Match_Data)
Extract_Players_Standings("sys/ranks/standings.txt")
Calculate_Players_Standings()
	loop % total_players/2
	{
	linenrW:=FindUSGN(calculated_winner%a_index%[4],"sys/ranks/standings.txt",3)
	linenrL:=FindUSGN(calculated_looser%a_index%[4],"sys/ranks/standings.txt",3)
	ReplaceLine(linenrW[2],calculated_winner%a_index%[2],"sys/ranks/standings.txt")
	ReplaceLine(linenrL[2],calculated_looser%a_index%[2],"sys/ranks/standings.txt")
	}
SortFileRating("sys/ranks/standings.txt")
		loop % total_players/2
		{
		calculated_winner%a_index%:=""
		calculated_looser%a_index%:=""
		}
}
UpdateHistory("sys/ranks/areports.txt")
UpdateMembers("sys/ranks/standings.txt")
FileDelete, sys/ranks/areports.txt
FileAppend, %var%, sys/ranks/areports.txt
exitapp


--------------------
-----Functions------
--------------------
penalty(report) {

data:=ReadInput(report)
msgbox % data[2]
find_player:=FindUSGN(data[2],"sys/ranks/standings.txt",3)
standings_player:=ReadInput(find_player[1])

if(standings_player[1]<1700)
standings_player[1]:=standings_player[1]-100
if(standings_player[1]>1699)
standings_player[1]:=standings_player[1]-50

finished_report:=standings_player[1] "-" standings_player[2] "-" standings_player[3] "-" standings_player[4] "-" standings_player[5] "-" standings_player[6] "-" standings_player[7] "-" standings_player[8] "-" standings_player[9]

ReplaceLine(find_player[2],finished_report,"sys/ranks/standings.txt")
SortFileRating("sys/ranks/standings.txt")

return
}

Add_Newbie(report) {
data:=ReadInput(report)
nr:=1
Name:=data[2]
USGN:=data[3]
Info:=1500 "-" Name "-" USGN "-" 0 "-" 0 "-" 0 "-" 0 "-" 0 "-" 0
FileAppend, %Info%`n, sys/ranks/standings.txt
SortFileRating("sys/ranks/standings.txt")
return
}

UpdateMembers(filepath) {
all:=[]
FileDelete, sys/ranks/amembers.txt
	loop % lines(filepath)
	{
	FileReadLine, line, %filepath%, %A_Index%
	all%a_index%:=ReadInput(line)
	}
		loop % lines(filepath)
		{
		var:=all%a_index%[3] " " all%a_index%[1]
		FileAppend, %var%`n, sys/ranks/amembers.txt
		}
return
}

UpdateHistory(filepath) {
global
historylines:=lines(filepath)
loop % historylines
{
FileReadLine, his, %filepath%, %A_Index%
FileAppend, %his%`n, sys/ranks/history.txt
}
return
}

e_performance(var1,var2) {
QA:=10**(var1/400)
QB:=10**(var2/400)
EA:=QA/(QA+QB)
return, EA
}

CheckErrors(filepath) {
global
loop % lines("sys/ranks/areports.txt")
{
	FileReadLine, error_check, sys/ranks/areports.txt, %A_Index%
	debugger:=ReadInput(error_check)
	in:=0

	if(debugger[1]="A")
	{
	continue
	}

	if(debugger[1]="P")
	{
	continue
	}

	if (debugger.MaxIndex() < 12)
	{
	FileDelete, sys/ranks/areports.txt
	FileAppend, , sys/ranks/areports.txt
	exitapp
	}

}

if (lines("sys/ranks/areports.txt") <1)
exitapp

return
}


Calculate_Players_Standings() {
global
winner_team_rating:=0
looser_team_rating:=0
loop % total_players/2
winner_team_rating:=winner_team_rating+standings_winner%a_index%[3]
winner_team_rating:=winner_team_rating/(total_players/2)
loop % total_players/2
looser_team_rating:=looser_team_rating+standings_looser%a_index%[3]
looser_team_rating:=looser_team_rating/(total_players/2)
loop % total_players/2 ;performance
{
calculated_winner%a_index%:=[]
calculated_looser%a_index%:=[]
winner_kills:=match_winner%a_index%[2]
winner_deaths:=match_winner%a_index%[3]
winner_assists:=match_winner%a_index%[4]
looser_kills:=match_looser%a_index%[2]
looser_deaths:=match_looser%a_index%[3]
looser_assists:=match_looser%a_index%[4]
	if (winner_kills=0)
	winner_kills:=1
	if (winner_deaths=0)
	winner_deaths:=1
	if (winner_assists=0)
	winner_assists:=1
	if (looser_kills=0)
	looser_kills:=1
	if (looser_deaths=0)
	looser_deaths:=1
	if (looser_assists=0)
	looser_assists:=1
calculated_winner%a_index%[1]:=winner_kills+(winner_assists*assist_impact)+winner_kills/winner_deaths*kpd_impact
calculated_looser%a_index%[1]:=looser_kills+(looser_assists*assist_impact)+looser_kills/looser_deaths*kpd_impact
}
winner_team_performance:=0
looser_team_performance:=0
loop % total_players/2
winner_team_performance:=winner_team_performance+calculated_winner%a_index%[1]
loop % total_players/2
looser_team_performance:=looser_team_performance+calculated_looser%a_index%[1]

loop % total_players/2 ;rating
{
calculated_winner%a_index%[3]:=ceil(standings_winner%a_index%[3]+(K_Factor(standings_winner%a_index%[3])*(1-e_performance(standings_winner%a_index%[3],looser_team_rating)))+team_game_bonus*(calculated_winner%a_index%[1]/winner_team_performance))
calculated_looser%a_index%[3]:=floor(standings_looser%a_index%[3]+(K_Factor(standings_looser%a_index%[3])*(0-e_performance(standings_looser%a_index%[3],winner_team_rating)))+team_game_bonus*(calculated_looser%a_index%[1]/looser_team_performance))
	if (standings_looser%a_index%[3] > 1699)
	{
		if (standings_looser%a_index%[3] - calculated_looser%a_index%[3] > 32)
		{
		calculated_looser%a_index%[3]:= standings_looser%a_index%[3] - 32
		}
	}
	if (calculated_looser%a_index%[3] < 1000)
	calculated_looser%a_index%[3]:= 1000
	if (calculated_winner%a_index%[3] < 1000)
	calculated_winner%a_index%[3]:= 1000
}
loop % total_players/2 ;usgn
{
calculated_winner%a_index%[4]:=standings_winner%a_index%[5]
calculated_looser%a_index%[4]:=standings_looser%a_index%[5]
}
loop % total_players/2 ;kills
{
calculated_winner%a_index%[5]:=match_winner%a_index%[2]+standings_winner%a_index%[6]+match_winner%a_index%[4]
calculated_looser%a_index%[5]:=match_looser%a_index%[2]+standings_looser%a_index%[6]+match_looser%a_index%[4]
}
loop % total_players/2 ;deaths
{
calculated_winner%a_index%[6]:=match_winner%a_index%[3]+standings_winner%a_index%[7]
calculated_looser%a_index%[6]:=match_looser%a_index%[3]+standings_looser%a_index%[7]
}
loop % total_players/2 ;won
{
calculated_winner%a_index%[7]:=1+standings_winner%a_index%[8]
calculated_looser%a_index%[7]:=0+standings_looser%a_index%[8]
}
loop % total_players/2 ;lost
{
calculated_winner%a_index%[8]:=0+standings_winner%a_index%[9]
calculated_looser%a_index%[8]:=1+standings_looser%a_index%[9]
}
loop % total_players/2 ;kpd
{
winner_kills:=calculated_winner%a_index%[5]
winner_deaths:=calculated_winner%a_index%[6]
looser_kills:=calculated_looser%a_index%[5]
looser_deaths:=calculated_looser%a_index%[6]
	if (winner_kills=0)
	winner_kills:=1
	if (winner_deaths=0)
	winner_deaths:=1
	if (looser_kills=0)
	looser_kills:=1
	if (looser_deaths=0)
	looser_deaths:=1
calculated_winner%a_index%[9]:=winner_kills/winner_deaths
calculated_looser%a_index%[9]:=looser_kills/looser_deaths
SetFormat, float, 0.2
calculated_winner%a_index%[9] += 0 
SetFormat, float, 0.2
calculated_looser%a_index%[9] += 0 
}
loop % total_players/2 ;win%
{
	if (calculated_winner%a_index%[7]>0)&&(calculated_winner%a_index%[8]>0)
	calculated_winner%a_index%[10]:=calculated_winner%a_index%[7]*100/(calculated_winner%a_index%[8]+calculated_winner%a_index%[7])
	if (calculated_looser%a_index%[7]>0)&&(calculated_looser%a_index%[8]>0)
	calculated_looser%a_index%[10]:=calculated_looser%a_index%[7]*100/(calculated_looser%a_index%[8]+calculated_looser%a_index%[7])
	if (calculated_winner%a_index%[7]>0)&&(calculated_winner%a_index%[8]=0)
	calculated_winner%a_index%[10]:=100.00
	if (calculated_looser%a_index%[7]>0)&&(calculated_looser%a_index%[8]=0)
	calculated_looser%a_index%[10]:=100.00
	if (calculated_winner%a_index%[7]=0)
	calculated_winner%a_index%[10]:=0
	if (calculated_looser%a_index%[7]=0)
	calculated_looser%a_index%[10]:=0
	SetFormat, float, 0.2
	calculated_winner%a_index%[10] += 0 
	SetFormat, float, 0.2
	calculated_looser%a_index%[10] += 0 
}

; producing finished lines ready for copying to standings textfile

loop % total_players/2 ;win%
{
calculated_winner%a_index%[2]:=calculated_winner%a_index%[3] "-" standings_winner%a_index%[4] "-" calculated_winner%a_index%[4] "-" calculated_winner%a_index%[5] "-" calculated_winner%a_index%[6] "-" calculated_winner%a_index%[7] "-" calculated_winner%a_index%[8] "-" calculated_winner%a_index%[9] "-" calculated_winner%a_index%[10]
calculated_looser%a_index%[2]:=calculated_looser%a_index%[3] "-" standings_looser%a_index%[4] "-" calculated_looser%a_index%[4] "-" calculated_looser%a_index%[5] "-" calculated_looser%a_index%[6] "-" calculated_looser%a_index%[7] "-" calculated_looser%a_index%[8] "-" calculated_looser%a_index%[9] "-" calculated_looser%a_index%[10]
}
return
}

K_Factor(rank) {
K:=24
if (rank<=1600)&&(rank>=1000)
{
K:=64
return, K
}
	if (rank>1600)&&(rank<=2000)
	{
	K:=32
	return, K
	}
		if (rank>2000)
		{
		K:=24
		return, K
		}
return, K
}

Extract_Players_Standings(filepath) {
global
	loop % total_players/2
	{
	standings_winner%a_index%:=FindUSGN(match_winner%a_index%[1],filepath,3)
	extracted_numbers:=ReadInput(standings_winner%a_index%[1])
	outer_loop_index:=a_index
		loop % 9
		standings_winner%outer_loop_index%[a_index+2]:=extracted_numbers[a_index]
	}
			loop % total_players/2
			{
			standings_looser%a_index%:=FindUSGN(match_looser%a_index%[1],filepath,3)
			extracted_numbers:=ReadInput(standings_looser%a_index%[1])
			outer_loop_index:=a_index
				loop % 9
				standings_looser%outer_loop_index%[a_index+2]:=extracted_numbers[a_index]
			}
return
}

lines(filepath) {
	Loop,
	{
	FileReadLine, lines, %filepath%, %A_Index%
			if ErrorLevel
			{
			lines:=A_Index-1
			break
			}
	}
return, lines
}

ExtractNumbers(report) {
array:=[]
lastnumber:=0
test:=1
loop parse, report
{
	if A_LoopField is Number
	{
		if (A_Index=1)
		{
		data.=A_LoopField
		lastnumber:=1
		continue
		}
			if (lastnumber=2)
			{
			data.=temp
			data.=A_LoopField
			lastnumber:=1
			temp:=""
			continue
			}
			if (lastnumber=1)
			{
			data.=A_LoopField
			lastnumber:=1
			continue
			}
				else
				{
				data.=A_LoopField
				lastnumber:=1
				continue
				}
	}

if (A_LoopField=".")&&(lastnumber=1)
{
temp:=A_LoopField
lastnumber:=2
continue
}
	if (lastnumber=2)
	{	
	temp:=""
	array[test]:=data
	data:=""
	test:=test+1
	lastnumber:=0
	continue
	}
		if (lastnumber=1)
		{
		array[test]:=data
		data:=""
		test:=test+1
		lastnumber:=0
		continue
		}
}
if (lastnumber=1)
array[test]:=data
return, array
}

Extract_Players_Match(match_report,match_data) {
global
player_data_count:=4
loop % total_players/2
{
match_winner%a_index%:=[]
winner_index:=a_index
	loop,4
	match_winner%winner_index%[a_index]:=match_data[a_index+player_data_count]
player_data_count:=player_data_count+4
}
loop % total_players/2
{
match_looser%a_index%:=[]
looser_index:=a_index
	loop,4
	match_looser%looser_index%[a_index]:=match_data[a_index+player_data_count]
player_data_count:=player_data_count+4
}
player_data_count:="", winner_index:="", looser_index:=""
return
}

ReadInput(report) {
array:=[]
loop, parse, report, `-
array[A_Index]:=A_LoopField
return, array
}

FindUSGN(usgn,filepath,nr) {
array:=[]
	loop % lines(filepath)
	{
	FileReadLine, reading, %filepath%, %A_Index%
	number:=ReadInput(reading)
		if (number[nr]=usgn)
		{
		array[1]:=reading
		array[2]:=a_index
		found:=1
		break
		}
	number:={}
	}
if (found="")
{
exitapp
}
return, array
}

GetName(line) {
	loop parse, line
	{
		if (A_Index<6)
		continue
			if (A_LoopField="(")
			break
	Name.=A_LoopField
	}
foundname:=Name
return, foundname
}

ReplaceLine(line,calc_report,filepath) {
	Loop % line-1
	{
	FileReadLine, read, %filepath%, %A_Index%
	FileAppend, %read%`n, sys/ranks/temp.txt
	}
FileAppend, %calc_report%`n, sys/ranks/temp.txt
	Loop % lines(filepath)-line
	{
	remains:=A_Index+line
	FileReadLine, read, %filepath%, %remains%
	FileAppend, %read%`n, sys/ranks/temp.txt
	}
FileCopy, sys/ranks/temp.txt, %filepath%, 1
FileDelete, sys/ranks/temp.txt
return
}

SortFileRating(standings) {
playerstats:=[]
finished:=[]
line:=[]
rating:=[]
lines:=lines(standings)
Loop % lines
{
line[A_Index]:=A_Index   ;lines list
FileReadLine, reading, %standings%, %A_Index%
playerstats[A_Index]:=reading
extracted:=ReadInput(reading)
rating[A_Index]:=extracted[1] ;ratings list
}
	loop % lines
	str.=rating[A_Index] "?" line[A_Index] "`n" 
sort, str, N, R
str:=rtrim(str, "`n")
		loop parse, str, `n
		{
		StringSplit, PL, A_LoopField, ?
		finished[A_Index] := PL2
		}

				loop % lines(standings)
				{
				copy:=playerstats[finished[A_Index]]
				FileAppend, %copy%`n, sys/ranks/temp.txt
				}

FileCopy, sys/ranks/temp.txt, %standings%, 1
FileDelete, sys/ranks/temp.txt
return
}