-- A variable can hold any data type in it. By default, a variable that has not been defined is set to nil, which is the Lua name for 'nothing'.
-- For future reference, there are 8 data types: nil, number, string, boolean, table, function, userdata, thread

var = 1 --Here, a variable has been defined and set to an integer value of 1
var2 = "Hello" --Here, a variable has been defined and set to a string value of "Hello"
var3 = function() print("Yes! Yes!") end --Yes, functions are variables, too

-- There are local and global variables. A local variable will only be addressable in the chunk it's been defined in, like thus:

local var1 = "test"
if var1 == "test" then --we check if var1 equals to the string value of "test"
	local var2 = "test indeed"
	print(var2) -> test indeed
end
print(var1) -> test
print(var2) -> nil

-- So, the var2, defined in that if chunk, will only be accessible IN that if chunk.
-- Local variables can also be defined like this, in some special cases:

local a --The local variable a now exists, but it isn't set to anything

-- Changing the value of an existing local variable does not require any prefix:

local a = 1
a = a + 1
print(a) -> 2

-- A demonstration of boolean variables --
-- A boolean variable can assume only two forms - true or false. It's a very good thing to use when you need a variable telling you if something is or is not, or other such applications. Although 1 and 0 are more understandable for some, true and false are generally better to use.
var = true
print(var) -> true
var = false
print(var) -> false
print(var.."a") -> attempt to concatenate boolean value

if var == true then print("true") end -- This can be used to check if a boolean variable is true, however a shorter variant is this:
if var then print("true") end

if var == false then print("false") end -- Shorter:
if not var then print("false") end --But beware, 'not var' will be true both if var is false and if it's nil!

----------------------

-- A string is a set of characters of some length. One of the most popular operations on a string is concatenation, i.e. appending one string to another, which is demonstrated here:

string = "Hello"
print(string) -> Hello

string2 = "there"
print(string2) -> there
-- .. concatenates (puts together) elements
print(string..string2) -> Hellothere
print(string.." "..string2) -> Hello there
print(string.."!") -> Hello!
-- In Lua, numbers can be concatenated with strings
print(string.." "..1) -> Hello 1
print(string.." 1") -> Hello 1
-- Even two numbers can be concatenated into a string; the following concatenation of two numbers will return a string:
print(1 .. 2) -> 12

---------------------------

-- A function performs actions in it and, if specified, returns a value when it finished (or failed to finish).

function test(par1)
	return par1
end

print(test(1)) -> 1

function test(par1,par2)
	return par1+par2
end

print(test(1,3)) -> 4
print(test(1,"lol")) -> attempt to perform arithmetic on string

-- In the following example, if the first parameter is a number, the function will stop and return the boolean value of 'true', and anything after that return statement will be ignored.

function test(par1)
	if type(par1)=="number" then --the type() function returns the data type of its argument in form of a string
		return true
	end
	return false
end

print(test(1)) -> true
print(test("a")) -> false

--------------------

-- Tables are storages which hold values in them.
tbl = {} --This is an empty table. The data type of the variable tbl will be table, however any index in it will be equal to nil.

tbl = {1,2,3} --This table is now not empty, and will have three indices - 1, 2, 3, each of which will have the value 1, 2, 3 respectively. Another notation:

tbl = {}
tbl[1] = 1 --Set tbl index 1 to 1
tbl[2] = 2 --Set tbl index 2 to 2
tbl[3] = 3 --Set tbl index 3 to 3

-- You can't print the table variable itself:
print(tbl) -> table: 0049A640
-- You can, however, print its indices:
print(tbl[1]) -> 1
print(tbl[2]) -> 2

-- A table's values can assume any data type.
tbl = {}
tbl[1] = 1
tbl[2] = "two"
tbl[3] = true
tbl[4] = {}
tbl[5] = function() print("test") end

-- A table can have keys, or indexes (the ones in []), of almost any data type, except for nil, like thus:
local test = function() print("test") end
tbl = {}
tbl2 = {}
tbl[1] = 1
tbl["two"] = 2
tbl[true] = 3
tbl[test] = 4
tbl[tbl2] = 5
tbl[nil] = 6 -> table index is nil

-- Side note: functions stored in tables can be accessed like so:
tbl = {}
tbl[1] = function(a1) print(a1) end
print(tbl[1](1)) -> 1

-- Side note:
tbl = {}
tbl["lol"] = "lol"
tbl["rofl"] = "rofl"
-- The following will be true:
tbl["lol"] == tbl.lol
tbl["rofl"] == tbl.rofl
-- It doesn't change anything, it just makes the code look prettier at times. It is called syntactic sugar.

-- You can also iterate through a table. The term iteration, put in simple words, is cycling through table values. There are default iterator functions called pairs and ipairs, which are used in loops. I will demonstrate:

for k,v in pairs(tbl) do
	print("["..k.."] = "..v)
end
-- The result will be three messages:
-> [1] = 1
-> [2] = 2
-> [3] = 3

-- The core difference between pairs and ipairs is that the former iterates through ALL keys, and the second only through numbered ones.
tbl = {1,2,3,["lol"] = "lol",["rofl"] = "rofl"}

for k,v in pairs(tbl) do
	print("["..k.."] = "..v)
end
-> [1] = 1
-> [2] = 2
-> [3] = 3
-> lol = lol
-> rofl = rofl

for k,v in ipairs(tbl) do
	print("["..k.."] = "..v)
end
-> [1] = 1
-> [2] = 2
-> [3] = 3

-- To get the length of a table, you can use the hash sign (#):
tbl = {1,2,3,4,5}
print(#tbl) -> 5

-- However, it does not return the absolute number of values in a table. See:
tbl = {1,2,3,4,[6]=5}
print(#tbl) -> 4

-- To get the absolute number of values, the following function can be used:

function table.count(tbl)
	local n=0
	for k,_ in pairs(tbl) do
		n=n+1
	end
	return n
end

-- You can see here that the function is, in fact, a value in the 'table' table, and without the syntactic sugar it's actually table["length"]. You can also see a vivid demonstration of how local variables, iterators and return statements are used in real functions.

-- In CS2D, hooks are events. Upon adding a hook to a function, that function will be executed every time the hook event comes to pass. For example:

function playerspawn(id)
	msg("Player "..id.." has spawned!")
end

-- That function is supposed to display the message "Player ID has spawned!" in the chat every time a player spawns. But how to achieve that? By means of hooks:

addhook("spawn","playerspawn")

-- The addhook function has three arguments: hook name, function name and priority. The list of hooks is available on cs2d.com, the function name can be anything - after all, it is you who names functions, and priority specifies the order in which functions should be executed.
-- Hooks provide values as function arguments. In this case, the spawn hook provides the player ID as argument #1. You can call that argument anything - id, ply, lolz even.
-- Another demonstration:

function killply(k,v) --k is killer, v is victim
	msg("Dayum! "..player(k,"name").." just pwned "..player(v,"name").."'s ass! Whoop whoop!")
end
addhook("kill","killply")

-- The player() function takes in two arguments: player ID and their property. In this case, the player IDs are k and v, and since we want the message to contain actual player names and not their IDs, we use the name property.