Fala galera, hoje vim trazer pra vocês uma nova biblioteca de funções que eu venho desenvolvendo, pretendo ir atualizando esse tópico constantemente sempre adicionando funções novas e explicando a utilização delas. Algumas funções que eu coloquei aqui estão presentes na OTAL também, porém algumas eu fiz pequenas correções de forma que essa lib poderia facilmente substituir a OTAL sem grandes problemas (pelo menos se você utilizava apenas as funções básicas da otal)

Todas as funções que não tem -- nome do autor do lado dela foram feitas por mim, xWhiteWolf ou Night Wolf (NW). O restante delas são créditos dos devidos autores, apenas coloquei pois considero funções vitais no server de cada um.

Crie um arquivo em data/lib chamado 075 - White Wolf Functions.lua e coloque o seguinte código dentro:

grass = {8591, 4526, 4527, 4528, 4529, 4530, 4531, 4532, 4533, 4534, 4535, 4536, 4537, 4538, 4539, 4540, 4540, 4541, 9043, 9044, 9045, 9046, 9047, 9048, 9049, 9050, 9051, 9052, 9053, 9054, 9055, 9056, 9057, 9058}

driedgrass = {3264, 3265}

-- 1º
function isWalkable(pos, creature, proj, pz)-- by Nord
    if getTileThingByPos({x = pos.x, y = pos.y, z = pos.z, stackpos = 0}).itemid == 0 then return false end
    if getTopCreature(pos).uid > 0 and creature then return false end
    if getTileInfo(pos).protection and pz then return false, true end
    local n = not proj and 3 or 2
    for i = 0, 255 do
        pos.stackpos = i
        local tile = getTileThingByPos(pos)
        if tile.itemid ~= 0 and not isCreature(tile.uid) then
            if hasProperty(tile.uid, n) or hasProperty(tile.uid, 7) then
                return false
            end
        end
    end
    return true
end  

-- 2º
function hasGroundInDistance (uid, distance, tablegrama)
local checker = {} -- deixe assim
local pos = getThingPos(uid)
	for i = -distance, distance do
	for j = -distance, distance do
		local position = {x = pos.x + i, y = pos.y + j, z = pos.z, stackpos = 0}
		if i ~= 0 or j ~= 0 then
		local grama = getThingFromPos(position).itemid
			for k = 1, #tablegrama do
				if tablegrama[k] == grama then
				table.insert(checker, 1)
				end
			end
		end
	end
	end		
	if distance >= 1 then
		total = 0
		for x = 1, distance do
			number = x * 2 + 1
			t = (number * 2) + (2* (number-2))
			total = total + t
		end	
	end
return (#checker == total and true or false)
end

-- 3º
function checkGroundInDistance (uid, distance, tablegrama)
local checker = {} -- deixe assim
local pos = getThingPos(uid)
	for i = -distance, distance do
	for j = -distance, distance do
		local position = {x = pos.x + i, y = pos.y + j, z = pos.z, stackpos = 0}
		if i ~= 0 or j ~= 0 then
		local grama = getThingFromPos(position).itemid
			for k = 1, #tablegrama do
				if tablegrama[k] == grama then
				table.insert(checker, position)
				end
			end
		end
	end
	end		
return checker
end

-- 4º
function spinRotate(uid, spins, delay)
doCreatureSetNoMove(uid, true)
look = getCreatureLookDirection(uid)
	for i = 1, (4* spins) + 1 do		
		addEvent(function()
			if isPlayer(uid) then
				if i <= (4 * spins) then
					look = look < 3 and look + 1 or 0
					doCreatureSetLookDirection(uid, look)
				else
					doCreatureSetNoMove(uid, false)
				end
			end
		end, delay * i)	
	end
return true
end

-- 5º
function getPositionsByDirection(uid)
pos = getCreaturePosition(uid)
positionsByDirection = {
[0] = {
[1] = {x = pos.x + 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[2] = {x = pos.x + 1, y = pos.y, z = pos.z, stackpos = 0},
[3] = {x = pos.x + 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[4] = {x = pos.x, y = pos.y + 1, z = pos.z, stackpos = 0},
[5] = {x = pos.x - 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[6] = {x = pos.x - 1, y = pos.y, z = pos.z, stackpos = 0},
[7] = {x = pos.x - 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[8] = {x = pos.x, y = pos.y - 1, z = pos.z, stackpos = 0},
[9] = {x = pos.x, y = pos.y, z = pos.z, stackpos = 0}
},
[1] = {
[1] = {x = pos.x + 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[2] = {x = pos.x, y = pos.y + 1, z = pos.z, stackpos = 0},
[3] = {x = pos.x - 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[4] = {x = pos.x - 1, y = pos.y, z = pos.z, stackpos = 0},
[5] = {x = pos.x - 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[6] = {x = pos.x, y = pos.y - 1, z = pos.z, stackpos = 0},
[7] = {x = pos.x + 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[8] = {x = pos.x + 1, y = pos.y, z = pos.z, stackpos = 0},
[9] = {x = pos.x, y = pos.y, z = pos.z, stackpos = 0}
},
[2] = {
[1] = {x = pos.x - 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[2] = {x = pos.x - 1, y = pos.y, z = pos.z, stackpos = 0},
[3] = {x = pos.x - 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[4] = {x = pos.x, y = pos.y - 1, z = pos.z, stackpos = 0},
[5] = {x = pos.x + 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[6] = {x = pos.x + 1, y = pos.y, z = pos.z, stackpos = 0},
[7] = {x = pos.x + 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[8] = {x = pos.x, y = pos.y + 1, z = pos.z, stackpos = 0},
[9] = {x = pos.x, y = pos.y, z = pos.z, stackpos = 0}
},
[3] = {
[1] = {x = pos.x - 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[2] = {x = pos.x, y = pos.y - 1, z = pos.z, stackpos = 0},
[3] = {x = pos.x + 1, y = pos.y - 1, z = pos.z, stackpos = 0},
[4] = {x = pos.x + 1, y = pos.y, z = pos.z, stackpos = 0},
[5] = {x = pos.x + 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[6] = {x = pos.x, y = pos.y + 1, z = pos.z, stackpos = 0},
[7] = {x = pos.x - 1, y = pos.y + 1, z = pos.z, stackpos = 0},
[8] = {x = pos.x - 1, y = pos.y, z = pos.z, stackpos = 0},
[9] = {x = pos.x, y = pos.y, z = pos.z, stackpos = 0}
}
}
return positionsByDirection[getCreatureLookDirection(uid)]
end

-- 6º
function checkGroundInArray(array, tablegrama)
local checker = {} -- deixe assim
for i = 1, #array do
	local grama = getThingFromPos(array[i]).itemid
			for k = 1, #tablegrama do
				if tablegrama[k] == grama then
				table.insert(checker, array[i])
				end
			end
		end
return checker
end

-- 7º
function creatureGoToPos(uid, position, delay) 
	if not isOnSameFloor(getCreaturePosition(uid), position) then
		return isPlayer(uid) and doPlayerSendCancel(uid, "You are not in the same floor of destination.") or false
	end	
	local interPos, k = 0, 0	
	local range = getDistanceBetween(getCreaturePosition(uid), position)	
	while k < range and (getCreaturePosition(uid).x ~= position.x or getCreaturePosition(uid).y ~= position.y) do	
		k = k + 1
		addEvent(function()
			if isCreature(uid) then
				local fromPos = fromPos or getCreaturePosition(uid)
				dir = getDirectionTo(fromPos, position)
				toPos = getPosByDir(fromPos, dir)
				toPos.stackpos = STACKPOS_TOP_MOVEABLE_ITEM_OR_CREATURE
				if isWalkable(toPos, false, false, false) then
					doTeleportThing(uid, toPos)
					fromPos = toPos
				else			
					for i = 1, #getPositionsByDirection(uid) do
						interPos = interPos ~= 0 and interPos or getCreaturePosition(uid)
						if isWalkable(getPositionsByDirection(uid)[i], false, false, false) and getDistanceBetween(getPositionsByDirection(uid)[i], position) <= getDistanceBetween(interPos, position) then
							interPos = getPositionsByDirection(uid)[i]						
						end
					end
					doTeleportThing(uid, interPos)
					fromPos = interPos
				end
			end
		end, delay * k)	
	end	
	addEvent(function()
		if isPlayer(uid) then
			local pos = getCreaturePosition(uid)
			if pos.x == position.x and pos.y == position.y and pos.z == position.z then
				doPlayerSendTextMessage(uid, MESSAGE_STATUS_CONSOLE_BLUE, "You just arrived your destination.")
				doCreatureSetLookDirection(uid, 2)
			end
		end
	end, (delay * k) + 100)	
return k
end

-- 8º
function isOnSameFloor(fromPos, toPos)
return fromPos.z == toPos.z and true or false
end

-- 9º
function isEven(arg)
return arg % 2 == 0 and true or false
end

-- 10º
function getDistanceRadius(fromPos, toPos)
	if not isOnSameFloor(fromPos, toPos) then
	return false
	end
local distance = getDistanceBetween(fromPos, toPos)
return isEven(distance) and (distance/2) or math.floor(distance/2) + 1
end

-- 11º
function walkForward(uid)
local dir = getCreatureLookDirection(uid)
local pos = getCreaturePosition(uid)
local newPos = getPosByDir(pos, dir)
return doTeleportThing(uid, newPos)
end

-- 12º
function getMiddlePos(fromPos, toPos)
	if not isOnSameFloor(fromPos, toPos) then
	return false
	end
local middle = {x = 0, y = 0, z = 0}	
middle.x = isEven(fromPos.x + toPos.x) and (fromPos.x + toPos.x)/2 or math.floor((fromPos.x + toPos.x)/2) + 1
middle.y = isEven(fromPos.y + toPos.y) and (fromPos.y + toPos.y)/2 or math.floor((fromPos.y + toPos.y)/2) + 1
middle.z = fromPos.z or toPos.z
return middle
end

-- 13º
function Taunt(uid, target, delay, times) 
	local interPos, k = 0, 0		
	doCreatureSetNoMove(target, true)
	doSendMagicEffect(getCreaturePosition(target), 36)	
	while k < times do	
		k = k + 1				
		addEvent(function()
			if isCreature(uid) and isCreature(target) then
				if not isOnSameFloor(getCreaturePosition(uid), getCreaturePosition(target)) then
					return isPlayer(uid) and doPlayerSendCancel(uid, "You are not in the same floor of target.") or false
				end
				local range = getDistanceBetween(getCreaturePosition(uid), getCreaturePosition(target))
				local fromPos = fromPos or getCreaturePosition(target)
				doSendMagicEffect(getCreaturePosition(target), 13)
				dir = getDirectionTo(fromPos, getCreaturePosition(uid))
				toPos = getPosByDir(fromPos, dir)
				toPos.stackpos = STACKPOS_TOP_MOVEABLE_ITEM_OR_CREATURE				
					if range <= 1 then
						return false
					end				
				if isWalkable(toPos, false, true, true) then
					doTeleportThing(target, toPos)
					fromPos = toPos
				else			
					for i = 1, #getPositionsByDirection(target) do
						interPos = interPos ~= 0 and interPos or getCreaturePosition(target)
						if isWalkable(getPositionsByDirection(target)[i], false, true, true) and getDistanceBetween(getPositionsByDirection(target)[i], getCreaturePosition(uid)) <= getDistanceBetween(interPos, getCreaturePosition(uid)) then
							interPos = getPositionsByDirection(target)[i]						
						end
					end
					doTeleportThing(target, interPos)
					fromPos = interPos
				end
			end
		end, delay * k)	
	end		
	addEvent(function()
		if isCreature(target) then
			doCreatureSetNoMove(target, false)
		end
		if isMonster(target) then
			doMonsterSetTarget(target, uid)
		end
	end, (delay * k) + 100)		
return true
end

-- 14º
function getFloorsBetweenPos(fromPos, toPos)
return math.abs(fromPos.z - toPos.z)
end

-- 15º
function getLowestFloor(fromPos, toPos)
return fromPos.z > toPos.z and toPos.z or fromPos.z
end

-- 16º
function getAllPlayersInArea(fromPos, toPos)
local players = {}	
local andares = getFloorsBetweenPos(fromPos, toPos)
	for index, creature in ipairs(getPlayersOnline()) do
		local z = getLowestFloor(fromPos, toPos)
		local frompos = {x = fromPos.x, y = fromPos.y, z = fromPos.z}
		local topos = {x = toPos.x, y = toPos.y, z = toPos.z}		
		for i = 0, andares do
			z = z or 0
			frompos.z = z + i
			topos.z = z + i	
			if isInArea(getThingPos(creature), frompos, topos) then
				table.insert(players, creature)
			end
		end
	end
return players
end

-- 17º
function clearArea(middlePos, rangex, rangey, mob, player)
	for i = -rangex, rangex do
	for j = -rangey, rangey do
		pos = {x = middlePos.x + i, y = middlePos.y + j, z = middlePos.z}
		creature = getTopCreature(pos).uid		
		if isMonster(creature) and mob then
			doSendMagicEffect(getThingPos(creature), 14)
			addEvent(doCreateMonster, 1000, getCreatureName(creature), pos)
			doRemoveCreature(creature)
		end
		if isPlayer(creature) and player then
			doSendMagicEffect(getThingPos(creature), 14)
			doTeleportThing(creature, getTownTemplePosition(getPlayerTown(creature)))
		end
	end
	end
return true
end

-- 18º
function addQuery(table, name, tipo, default)
if type(table) ~= 'string' and type(name) ~= "string" and (type(tipo) ~= "string") then
		return nil, error('Voce presisa inserir um valor do tipo string.')
end
tipo = string.upper(tipo)
db.executeQuery("ALTER TABLE `"..table.."` ADD `"..name.."` "..tipo.." NOT NULL DEFAULT "..default..";")
end

-- 19º
function loopEffect(uid, effect, tempo)
		local effectPositions = getPositionsByDirection(uid)
		doSendDistanceShoot(effectPositions[math.random(#effectPositions)], effectPositions[math.random(#effectPositions)], effect)
		addEvent(function()
		   if isCreature(uid) then
			  loopEffect(uid, effect, tempo)
		   end
		end, 1000 * tempo)
return true
end

-- 20º
function getDistanceToMiddle(fromPos, toPos)
local middlePos = getMiddlePos(fromPos, toPos)
local pos = {
x = math.max(math.abs(middlePos.x - fromPos.x), math.abs(middlePos.x - toPos.x)),
y = math.max(math.abs(middlePos.y - fromPos.y), math.abs(middlePos.y - toPos.y)),
z = middlePos.z
}
return pos
end

-- 21º
function pairsByKeys(t, f) -- Lua.org
    local a = {}
    for n in pairs(t) do table.insert(a, n) end
    table.sort(a, f)
    local i = 0      -- iterator variable
local iter = function ()   -- iterator function
    i = i + 1
    if a[i] == nil then return nil
		else return a[i], t[a[i]]
		end
    end
return iter
end
	
-- 22º
function table.max(t)
	local a = {}
    for n in pairs(t) do table.insert(a, n) end
    table.sort(a, function(a, b) return a > b end)
return a[1]
end

-- 23º
function table.min(t)
	local a = {}
    for n in pairs(t) do table.insert(a, n) end
    table.sort(a, f)
return a[1]
end

-- 24º
function doKillCreature(uid)-- by Shawak
	return doCreatureAddHealth(uid, -getCreatureHealth(uid))
end

-- 25º
function isHandItem(uid) -- NW based on Mock
uid = uid or 0
    if isInArray({1,2,3,4,5,6}, getItemWeaponType(uid)) then
        return true
    end
return false
end

-- 26º
function isWearing(uid)
uid = uid or 0
	for i = 1, 10 do         
		if isInArray({uid}, getPlayerSlotItem(uid, i).uid) then
		return true
		end
	end
    return false
end

-- 27º
function getItemDodgePercent(itemuid)
	return getItemAttribute(itemuid, "dodgePercent") or 0
end

-- 28º
function setItemDodgePercent(uid, percent)
doItemSetAttribute(uid, "description", "[Dodge: "..percent.."%]")
doItemSetAttribute(uid, "dodgePercent", percent)
end

-- 29ª
function tableToString(tb) -- by Mock
	if type(tb) ~= "table" then
		return nil, error("bad argument #1 to 'saveTable' (table expected, got "..type(tb)..")", 2)
	end
	local str = "{"
	for k,d in pairs(tb) do
		if type(k) == 'string' then
			if type(d) == 'string' then
				str = str..""..k.."='"..d.."',"
			elseif type(d) == 'number' or type(d) == 'boolean' then
				str = str..""..k.."="..tostring(d)..","
			elseif type(d) == 'table' then
				str = str..'{'
				for e,f in pairs(d) do
					if type(e) == 'string' then
						if type(f) == 'string' then
							str = str..""..e.."='"..f.."',"
						elseif type(f) == 'number' or type(e) == 'boolean' then
							str = str..""..e.."="..tostring(f)..","
						elseif type(f) == 'table' then
							str = str..""..e.."="..tableToString(f)..","
						end
					elseif type(e) == 'number' then
						if type(f) == 'string' then
							str = str.."["..e.."]='"..f.."',"
						elseif type(f) == 'number' or type(f) == 'boolean' then
							str = str.."["..e.."]="..tostring(f)..","
						elseif type(f) == 'table' then
							str = str.."["..e.."]="..tableToString(f)..","
						end
					end
				end
				str = str..'},'
			end
		elseif type(k) == 'number' then
			if type(d) == 'string' then
				str = str.."["..k.."]='"..d.."',"
			elseif type(d) == 'number' or type(d) == 'boolean' then
				str = str.."["..k.."]="..tostring(d)..","
			elseif type(d) == 'table' then
				str = str..'{'
				for e,f in pairs(d) do
					if type(e) == 'string' then
						if type(f) == 'string' then
							str = str..""..e.."='"..f.."',"
						elseif type(f) == 'number' or type(e) == 'boolean' then
							str = str..""..e.."="..tostring(f)..","
						elseif type(f) == 'table' then
							str = str..""..e.."="..tableToString(f)..","
						end
					elseif type(e) == 'number' then
						if type(f) == 'string' then
							str = str.."["..e.."]='"..f.."',"
						elseif type(f) == 'number' or type(f) == 'boolean' then
							str = str.."["..e.."]="..tostring(f)..","
						elseif type(f) == 'table' then
							str = str.."["..e.."]="..tableToString(f)..","
						end
					end
				end
				str = str..'},'
			end
		end
	end
	local str = str.."}"
	if string.sub(str,string.len(str)-2,string.len(str)-2) == "," then
		str = string.sub(str,0,string.len(str)-3).."}"
	end
	return str
end
table.tostring = tableToString

-- 30º
function saveTable(table,name)-- by Mock
	if type(table) ~= "table" then
		return nil, error("bad argument #1 to 'saveTable' (table expected, got "..type(table)..")", 2)
	end
	if type(name) ~= 'string' then
		error('Voce presisa inserir um valor do tipo string')
	end
	local file = io.open('data/storage/'..name..'.tbl','r')
	if file == nil then
		local file = io.open('data/storage/'..name..'.tbl','w')
		file:write(tableToString(table))
		file:close()
	else
		file:close()
		local file = io.open('data/storage/'..name..'.tbl','w')
		file:write("")
		file:close()
		local file = io.open('data/storage/'..name..'.tbl','w')
		file:write(tableToString(table))
		file:close()
	end
end

-- 31º
function loadTable(name)-- by Mock
	if type(name) ~= 'string' and type(name) ~= "number" then
		return nil, error('Voce presisa inserir um valor do tipo string ou number.')
	end
	if io.open('data/storage/'..name..'.tbl','r') == nil then
		return nil
	end
	local file = io.open('data/storage/'..name..'.tbl','r')
	local f ,err = loadstring("return "..file:read())
	if err then
		return nil, error('Error in file "data/storage/'..name..'.tbl". Data lost.')
	end
	file:close()
	return f()
end

-- 32º
function getWeapon(uid)
	teste = getPlayerSlotItem(uid, CONST_SLOT_RIGHT)
	if teste.itemid > 0 then
		if not isThatWeapon(teste.uid) then
			teste = getPlayerSlotItem(uid, CONST_SLOT_LEFT)
		end
	else
		teste = getPlayerSlotItem(uid, CONST_SLOT_LEFT)
	end

	if teste.itemid > 0 then
		if not isThatWeapon(teste.uid) then
			teste = false
		end
	else
		teste = false
	end
return teste
end

-- 33º
function getItemLevel(uid, maxlevel)
	level = 0
	local name = getItemName(uid)
	
	for i = 1, maxlevel do
		if string.find(tostring(name),"+".. i .."") then
			level = i
			end
		end
return level
end

-- 34º
function getMirroredPos(uid, target, radius)
	n = radius or 1
	local pos = getCreaturePosition(uid)
	local middlePos = getCreaturePosition(target)
	local vPos = {x = pos.x - middlePos.x, y = pos.y - middlePos.y, z = 0}	
	for i, k in pairs (vPos) do
		if math.abs(k) > n and i == "x" then
			vPos.x = k >= 0 and n or -n
		elseif math.abs(k) > n and i == "y" then
			vPos.y = k >= 0 and n or -n
		end
	end
	local finalPos = {x = middlePos.x - vPos.x, y = middlePos.y - vPos.y, z = pos.z}
	b = 0
	while not isWalkable(finalPos, true, true, true) and b < radius do
	b = b + 1
	if b == radius then
		finalPos = pos
	    break
	end
	n = n - 1
		for i, k in pairs (vPos) do		
			if math.abs(k) > n and i == "x" then
				vPos.x = k >= 0 and n or -n
			elseif math.abs(k) > n and i == "y" then
				vPos.y = k >= 0 and n or -n
			end
		end
	finalPos = {x = middlePos.x - vPos.x, y = middlePos.y - vPos.y, z = pos.z}
	end
return finalPos
end

-- 35º
function outfitOnWalk(uid, key, id, tempo, lastPos)
	if getPlayerStorageValue(uid, key) - os.time() >= 0 then
		lastPos = lastPos or getCreaturePosition(uid)
		if getCreaturePosition(uid).x ~= lastPos.x or getCreaturePosition(uid).y ~= lastPos.y or getCreaturePosition(uid).z ~= lastPos.z  then
			lastPos = getCreaturePosition(uid)
			local atual = getCreatureOutfit(uid)
			atual.lookType = id
			doSetCreatureOutfit(uid, atual, tempo)
		end
	addEvent(function()
		if isCreature(uid) then
			outfitOnWalk(uid, key, id, tempo, lastPos)
		end
	end, tempo) 
	end
return true
end

-- 36º
function onCastChannel(uid, target, delay, effect, key)
local str = {"Casting:\n[", "   ", "   ", "   ", "   ", "   ", "   ", "   ", "   ", "   ", "   ", "]"}
local pos = getCreaturePosition(uid)
effect = effect or 255
key = key or 88888
delay = delay or 200
setPlayerStorageValue(uid, key, 0)
for i = 2, 11 do
addEvent(function()
	if isCreature(uid) and getCreaturePosition(uid).x == pos.x and getCreaturePosition(uid).y == pos.y and (getCreatureTarget(uid) == target or not target) then
		if str[i-1] ~= "   " then		
			str[i] = "@"
			local msg = ""
			for _, k in pairs(str) do
			msg = msg.."".. k ..""
			end
			if isEven(i) then
				doSendMagicEffect(getCreaturePosition(uid), effect)
			end
			setPlayerStorageValue(uid, key, i)
			doPlayerSendTextMessage(uid, 25, msg)
		end
	end
end, delay * (i - 1))
end
return delay * (#str - 1)
end

-- 37º
function doBlast(uid, target, delay, effectx, effectz, percent, min, max, type, hits, fromPos, n)
	if fromPos ~= nil and (fromPos.x ~= getCreaturePosition(target).x or fromPos.y ~= getCreaturePosition(target).y) then
		doSendDistanceShoot(fromPos, getCreaturePosition(target), effectx)
		fromPos = (fromPos.x ~= getCreaturePosition(target).x or fromPos.y ~= getCreaturePosition(target).y) and getCreaturePosition(target) or nil
	else
		fromPos = getCreaturePosition(target)
	end	
doTargetCombatHealth(uid, target, type, -min, -max, effectz)
n = n or 1
if math.random(1, 10) <= (percent/10) then
	possible = {}
	for j = -3, 3 do
	for k = -3, 3 do
		middlePos = {x = getCreaturePosition(target).x + j, y = getCreaturePosition(target).y + k, z = getCreaturePosition(target).z, stackpos = 253}
		if isWalkable(middlePos, false, true, true) then
			creature = getTopCreature(middlePos).uid		
			if creature > 0 then
				table.insert(possible, creature)
			end
		end
	end
	end		
	target = #possible > 0 and possible[math.random(#possible)] or target
end		
if n < hits then
	addEvent(function()
	if isCreature(uid) and isCreature(target) then
		doBlast(uid, target, delay, effectx, effectz, percent, min, max, type, hits, fromPos, (n + 1))
	end
	end, delay)
end
return true
end

-- 38º
function doShowTimeByPos(uid, pos, duration, type)
type = type or 20
	for i = 0, (duration - 1) do
	addEvent(function()
		if isCreature(uid) then
			doCreatureSay(uid, tostring(duration - i), type, false, 0, pos)
		end
	end, i * 1000)
	end
return true
end


-- functions of TFS Compiled (removed from OTAL)
function setItemName(uid,name)
 return doItemSetAttribute(uid,'name',name)
end

function setItemArmor(uid,name)
 return doItemSetAttribute(uid,'armor',name)
end

function setItemDefense(uid,name)
 return doItemSetAttribute(uid,'defense',name)
end

function setItemAttack(uid,name)
 return doItemSetAttribute(uid,'attack',name)
end

function getItemAttack(uid)
   return getItemAttribute(uid,'attack')
end

function getItemDefense(uid)
   return getItemAttribute(uid,'defense')
end

function getItemArmor(uid)
   if type(uid) == 'number' then
      return getItemAttribute(uid,'armor')
   else
      return getItemInfo(uid.itemid).armor
   end
end
 

 

Agora eu vou explicar oque cada função faz porque de nada adianta lançar uma lib e não explicar oque ela faz não é mesmo? hahaha
Obs inicial: quando uma função tiver em seus parametros um [] significa que oque está dentro do colchetes não é um parâmetro obrigatório.

1º-- isWalkable(pos[, creature[, proj[, pz]]])
Oque faz: Verifica se uma posição é andável tomando como base 3 coisas: Se há criatura na pos, se há alguma sinalização de bloqueio de projétil ou bloqueio de caminho no item que está nessa posição ou se o chão daquela posição é do tipo pz
Como utilizar: isWalkable(posição que irá analisar, true/false, true/false, true/false) para decidir se quer verificar cada uma das coisas. No caso de você não indicar os parametros eles terão valor false.
xemplo: isWalkable(pos) é a mesma coisa que isWalkable(pos, false, false, false) e irá retornar verdadeiro se a posição for andável ou falso se não for.

2º-- hasGroundInDistance(uid, distance, tablegrama)
Oque faz: Verifica se todos sqms ao redor de uma criatura em  'distance' sqms são feitos de grounds que estejam na tablegrama
Como utilizar: hasGroundInDistance(cid, 1, {8591, 4526, 4527}) irá verificar se nas posições ao redor do player todos os ids de piso são um desses da tabela: ou 8591, 4526 ou 4527 e irá retornar verdadeiro, do contrário irá retornar falso

3º-- checkGroundInDistance(uid, distance, tablegrama)
Oque faz: Semelhante a anterior só que dessa vez irá retornar uma tabela com todas as posições que possuam ground com mesmo id dos inseridos em tablegrama.
Como utilizar: checkGroundInDistance(cid, 2, {8591, 4526, 4527}) irá retornar todas as posições partindo da posição do player com 2 sqms de distancia:

x x x x x
x x x x x
x x p x x
x x x x x
x x x x x

se o itemid do ground em x for igual a um dos ids colocados em tablegrama irá retornar essa posição dentro de uma tabela/vetor.

4º-- spinRotate(uid, spins, delay)
Oque faz: Faz uma criatura girar (alterar gradativamente a direção que ela está olhando) 'spins' vezes em 'delay' tempo
Como utilizar: spinRotate(cid, 2, 150) irá fazer o player dar 2 voltas completas com intervalo de 150 milisegundos pra cada virada que ele der.
Irá retornar verdadeiro caso a volta seja completa.

5º-- getPositionsByDirection(uid)
Oque faz: Retorna uma tabela de posições ao redor do player com base na direção que o player está olhando, fiz essa função inicialmente para servidores alternativos mas ela acabou se tornando útil em outros scripts mais complexos.
Ela sempre começa a contagem a partir da diagonal mais próxima no sentido horário a partir da posição que o player está olhando.
Exemplo: Se o player está olhando para /\ as posições contadas serão na ordem:

7 8 1
6 p 2
5 4 3

Como utilizar: getPositionsByDirection(cid) e irá retornar uma tabela com as posições em ordem 1, 2, 3, 4, 5, 6, 7, 8 e por ultimo a posição do player.

6º-- checkGroundInArray(array, tablegrama)
Oque faz: Checa todos os pisos num array de posições para ver se há algum id semelhante aos que estão colocados em tablegrama, caso haja irá adicionar essa posição num vetor e por fim retorna o vetor de posições.
Como utilizar: checkGroundInArray(getPositionsByDirection(cid), {8591, 4526, 4527}) irá primeiramente criar um vetor de posições através da função getPositionsByDirection(cid) e em seguida irá verificar quais dessas posições possuem os ids dos pisos como sendo 8591 ou 4526 ou 4527, e irá retornar as posições que possuem num vetor.

7º-- creatureGoToPos(uid, position, delay)
Oque faz: Faz uma criatura andar até uma posição dando passos com intervalo como sendo delay. Essa função ainda está em desenvolvimento mas já resolve problemas simples, sugiro que não use para coisas muito elaboradas pois ela ainda é incapaz de atravessar obstáculos com mais de 2 sqms de distancia. 
Como utilizar: creatureGoToPos(cid, {x = 160, y = 54, z = 7}, 150) irá fazer o player ir até a posição do templo (no meu server é 160, 54, 7) dando 1 passo a cada 150 milisegundos (acredite isso é bem rapido). Caso tenha algum obstáculo no caminho a função desvia desse obstaculo mas para obstáculos grandes com ordem de dimensão maior que 2 ela ainda não é capaz então só a utilize para caminhos curtos ou lugares abertos.
Retorna o número de passos que deu até chegar na posição final.

8º-- isOnSameFloor (fromPos, toPos)
Oque faz: verifica se duas posições estão no mesmo andar.
Como utilizar: isOnSameFloor({x = 160, y = 54, z = 7}, {x = 125, y = 64, z = 7}) irá retornar true, caso o z seja diferente irá retornar false.

9º-- isEven(arg)
Oque faz: verifica se um número é par
Como utilizar: isEven(10) irá retornar true pois 10 é par, isEven(50 - 1) irá retornar false pois 50-1 é igual a 49, que é ímpar.

10º-- getDistanceRadius(fromPos, toPos)
Oque faz: Pega o raio mínimo de distancia necessário para se executar uma checagem e alcançar duas posições.
Como utilizar: getDistanceRadius({x = 125, y = 54, z = 7}, {x = 125, y = 64, z = 7}) irá retornar 5 pois se eu estiver na posição do meio das duas, com 5 sqm eu consigo chegar da posição do meio até qualquer uma das duas

11º-- walkForward(uid)
Oque faz: faz uma criatura andar pra frente.
Como utilizar: walkForward(cid)

12º-- getMiddlePos(fromPos, toPos)
Oque faz: Pega a posição do meio entre duas posições contanto que elas estejam no mesmo andar.
Como utilizar getMiddlePos({x = 125, y = 54, z = 7}, {x = 125, y = 64, z = 7}) irá retornar a posição {x = 125, y = 59, z = 7} que é a posição do meio entre as duas.

13º-- Taunt(uid, target, delay, times)
Oque faz: provoca um target obrigando ele a ir em sua direção enlouquecidamente
Como utilizar: Taunt(cid, target, 150, 5) irá fazer o target correr até o cid dando 1 passo a cada 150 milisegundos num total de 5 passos ou até chegar no player.

14º-- getFloorsBetweenPos(fromPos, toPos)
Oque faz: Pega todos os andares entre duas posições.
Como utilizar: getFloorsBetweenPos({x = 125, y = 54, z = 4}, {x = 125, y = 64, z = 7}) irá retornar 3 pois é a diferença entre os dois z's

15º-- getLowestFloor(fromPos, toPos)
Oque faz: Retorna o menor andar entre duas posições
Como utilizar: getLowestFloor({x = 125, y = 54, z = 4}, {x = 125, y = 64, z = 7}) irá retornar 4 pois é o menor z dentre as posições.

16º-- getAllPlayersInArea(fromPos, toPos)
Oque faz: Pega todos os players entre duas áreas, se as áreas estiverem em andares diferentes ele checa todos os andares intermediários também.
Como utilizar: getAllPlayersInArea({x = 125, y = 54, z = 4}, {x = 125, y = 64, z = 7}) irá retornar todos os players que estão entre os 10 sqms de distancia das posições (y = 54, 55, 56.. 63, 64) em todos os andares (z = 4, 5, 6, 7) e retorna uma tabela com todos os players que estão dentro desse range.

17º-- clearArea(middlePos, rangex, rangey, mob, player)
Oque faz: limpa uma área de quest/evento se baseando nos parametros. middlePos é a posição do meio a qual você vai partir, rangex e rangey é quantos sqms a partir da posição do meio você irá checar e mob e player você coloca true/false para escolher se quer limpar a area de monstros e ou de players.
Como utilizar: clearArea({x = 125, y = 54, z = 7}, 2, 1, false, true) irá analisar a seguinte posição:

x x x x x
x x p x x
x x x x x

Como vcs podem ver, p é a posição, 2 é o numero de sqms de distancia no eixo x e 1 é o numero de sqms de distancia no eixo y. Se houver qualquer player nessa área ele irá ser enviado para o templo. Agora se você colocar true para mobs ele irá remover os monstros e recriá-los com a vida cheia nas exatas posições em que estavam os que foram removidos.

18º-- addQuery(table, name, tipo, default)
Oque faz: cria uma variável rapidamente na database;
Como utilizar: addQuery("players", "testinho", "integer", 0) irá criar na tabela players uma variavel chamada testinho que irá guardar uma informação do tipo INTEGER (numero inteiro) e com valor padrão sendo 0.

19º-- loopEffect(uid, effect, tempo)
Oque faz: cria efeitos infinitos no player de distancias ao redor da posição dele. Obs: o tempo é em segundos e os efeitos são somente os de distancia.
Como utilizar: loopEffect(cid, 18, 0.3) irá iniciar um efeito em loop da shuriken vermelha (efeito 18) a cada 0.3 segundos (300 milisegundos).

20º-- getDistanceToMiddle(fromPos, toPos)
Oque faz: retorna um vetor de posições com os valores máximos de distancia entre cada x e y  até a posição intermediária
Como utilizar: getDistanceToMiddle({x = 125, y = 54, z = 7}, {x = 125, y = 64, z = 7}) você vai ter uma posição do meio como sendo {x = 125, y = 59, z = 7}  e a função irá retornar {x = 0, y = 5, z = 7} pois as duas posições tem x idêntico à posição do meio e a diferença delas para o y do meio é 5. O z é meramente ilustrativo nessa função pois a middlePos não existe caso não sejam no mesmo andar então não teria porque executá-la para achar o z.

21º-- pairsByKeys(t, f)
Oque faz: Organiza uma tabela t se baseando na função de organização em f. O padrão de f é a < b, ou seja, organizar de forma crescente.
Como utilizar:

lines = {
c = 10,
a = 24,
b = 48,
}

for name, line in pairsByKeys(lines) do
print(name, line)
end

vai printar:

a 24
b 48
c 10

Perceba que com essa função eu organizei uma tabela que contém seus indexes em força de string em ordem crescente (ordem alfabética)

se eu tivesse utilizado f do parametro como sendo function(a, b) return a > b end da seguinte forma:

for name, line in pairsByKeys(lines, function(a, b) return a > b end) do
print(name, line)
end

eu iria obter no print:

c 10
b 48
a 24

22º-- table.max(t)
Oque faz: retorna o maior index possível de uma tabela

23º-- table.min(t)
Oque faz: retorna o menor index possível de uma tabela

24º-- doKillCreature(uid)
Oque faz: mata uma criatura
Como utilizar: doKillCreature(cid) irá matar o player.

25º-- isHandItem(uid)
Oque faz: Verifica se o item em uid é um item de mão
Como utilizar: isHandItem(getPlayerSlotItem(cid, 6).uid) vai retornar true se o item no slot 6 for um item de mão (shield ou qualquer arma) e false se não for.

26º-- isWearing(uid)
Oque faz: Verifica se o item em uid é um item que está sendo utilizado pelo player no momento
Como utilizar: isWearing(item.uid) vai retornar true se o item utilizado na action estiver no corpo do player e falso se não estiver.

27º-- getItemDodgePercent(itemuid)
Oque faz: Verifica se o item em uid possui um atributo chamado dodge (Função do Dodge System por Item)
A utilização é semelhante dos dois exemplos acima.

28º-- setItemDodgePercent(uid, percent)
Oque faz: Seta uma % de dodge no item em uid (Função do Dodge System por Item)
Como utilizar: setItemDodgePercent(item.uid, 45) irá adicionar 45% de atributo Dodge no item em uid.

29º-- tableToString(tb)
Oque faz: transforma uma tabela em string, também pode ser usada a função table.tostring(tb) e retorna a string.
Como utilizar: local tabela = {arroz, feijao, pao, frango, leite, ovos}
se eu der um tableToString(tabela) eu irei obter a seguinte string:
"{[1] = arroz, [2] = feijao, [3] = pao, [4] = frango, [5]= leite, [6] = ovos,}"

30º-- saveTable(table, name)
Oque faz: Salva uma tabela em data/storage, o conteúdo da tabela fica num documento com nome igual a "name".
Como utilizar: Ainda com base na tabela acima utilize saveTable(tabela, "lista de compras") e você vai ter em data/storage um documento com extensão .tbl chamado "lista de compras" e dentro com a string da tabela que foi mostrada acima.

31º-- loadTable(name)
Oque faz: Carrega uma tabela que foi salva anteriormente
Como utilizar: loadTable("lista de compras") vai me retornar a tabela que foi salva.

32º-- getWeapon(uid)
Oque faz: retorna a arma que o player está utilizando, muito útil para scripts que alteram a arma como o meu experience system.
Como utilizar: getWeapon(cid) irá retornar o item arma ou false caso ele não esteja utilizando nenhuma arma. Para fazer edições você só precisa usar getWeapon(cid).uid e você terá o uid pra utilizar em qualquer função que utilize .uid. Se preferir tb pode usar getWeapon(cid).itemid para pegar o id do item que é a arma e criar scripts legais.

33º-- getItemLevel(uid, maxlevel)
Oque faz: retorna o level de um item atraves da checagem se há algum +level no nome.
Como utilizar: use getItemLevel(getWeapon(cid).uid, 12) que ele irá fazer uma checagem na arma de 1 até 12 para verificar se há +1, +2, .., + 11, +12 no nome do item.

34º-- getMirroredPos(uid, target, radius)
Oque faz: retorna a posição espelhada entre o cid e o target tendo radius como valor máximo.
Como utilizar: getMirroredPos(cid, getCreatureTarget(cid), 2) vai funcionar assim:
p, s, s, t, s, y, x;
Se considerarmos p a posição do player e t a posição do target a posição espelhada (considere t como sendo o espelho) seria a x, porém x está a 3 sqm de distancia do target e o radius é 2 então a posição que irá ser retornada na função será y.

35º-- outfitOnWalk(uid, key, id, tempo, lastPos)
Oque faz: Ativa uma condition nova que irá modificar seu outfit sempre que vc andar, caso vc pare ele irá retornar ao outfit anterior. Os parametros são o uid da criatura que terá a condition ativada, uma key de storage qualquer, um id de lookType da outfit, o tempo em milisegundos pra se modificar o outfit e uma ultima posição como base pro inicio do script (recomenda-se usar nil no parametro lastPos pra melhor uso do script)
Como usar: outfitOnWalk(cid, 13842, 153, 150, nil) irá fazer o player mudar pro outfit de lookType 153 chegando de 150 em 150 milisegundos para ver se ele ainda está na mesma posição anterior. O tempo que irá durar é salvo no storage 13842.
Exemplo:

setPlayerStorageValue(cid, 13842, os.time() + 25) --- irá adicionar 25 segundos de carga na condition
outfitOnWalk(cid, 13842, 153, 150, nil) -- irá iniciar a condition.

36º-- onCastChannel(uid[, target[, delay[, effect[, key]]]])
Oque faz: Começa um cast de spell do tipo Channelling, carregando uma barra (é a função principal do cast system). Ao mover-se ou retirar target/trocar target o carregamento da spell será cancelado. Retorna o tempo final de execução da spell que será utilizado no addEvent pra soltar a magia no final do channelling.
Como usar: Todos os parametros com excessão do cid são opcionais, se colocado um target a função irá continuamente checar se o target atual do player tem o mesmo uid do target colocado e cancelará o channelling caso não. Delay é o tempo para cada etapa de checagem (200 é o padrão), effect é o efeito que sairá a cada duas checagens (só nas pares) e key é um id de storage pra salvar algumas informações da função.
onCastChannel(cid, getCreatureTarget(cid), 200, 36, 61728) irá iniciar um processo de casting do cid em cima do target dele com cada etapa em 200 milisegundos (são 10 etapas então a spell associada será castada através desse sistema após 2 segundos), 36 é o efeito que ficará saindo enquanto o player está carregando e 61728 é o storage associado à esse cast. Essa função pode ser usada para adicionar uma espécie de "carregamento" envolvendo outras funções e principalmente spells.

37º-- doBlast(uid, target, delay, effectx, effectz, percent, min, max, type, hits[, fromPos[, n]])
Oque faz: inicia um combat do tipo blast, a spell bate no target e ricocheteia entre os outros monstros/players ao redor dele.
Como usar: uid é o id de quem ataca, target é o primeiro alvo, delay é o tempo pra escolher outro target, effectx é o efeito de distancia que irá ter ao trocar de target, effectz é o efeito que sairá quando o oponente for hitado, percent é a porcentagem de ricochetear e ir para outro inimigo perto, min é o minimo que tira (colocar um valor positivo para tirar dano), max é o maximo de dano que irá tirar (colocar um valor positivo pra tirar dano), type é o tipo de combate seguindo a tabela do constant.lua, hits é a quantidade de hits que irá dar, fromPos é a posição inicial e não é obrigatório colocar pois ele irá considerar a posição do player de qualquer forma, n é a contagem de quantos hits já foram dados então sempre coloque 1 ou nil pois sendo nil/false ele irá considerar 1 de qualquer forma.
doBlast(cid, getCreatureTarget(cid), 300, 35, 11, 100, 50, 100, 2, 20, getCreaturePosition(cid), nil)
irá produzir o mesmo resultado da spell desse tópico aqui

38º-- doShowTimeByPos(uid, pos, duration, type)

Oque faz: Faz uma contagem regressiva em determinada posição de duration até 1. O texto é pela função doCreatureSay e o type segue a tabela do constant.lua

TALKTYPE_FIRST = 1
TALKTYPE_WHISPER = 2
TALKTYPE_YELL = 3
TALKTYPE_PRIVATE_PN = 4
TALKTYPE_PRIVATE_NP = 5
TALKTYPE_PRIVATE = 6
TALKTYPE_CHANNEL_Y = 7
TALKTYPE_CHANNEL_W = 8
TALKTYPE_RVR_CHANNEL = 9
TALKTYPE_RVR_ANSWER = 10
TALKTYPE_RVR_CONTINUE = 11
TALKTYPE_BROADCAST = 12
TALKTYPE_CHANNEL_RN = 13
TALKTYPE_PRIVATE_RED = 14
TALKTYPE_CHANNEL_O = 15
TALKTYPE_CHANNEL_RA = 17
TALKTYPE_MONSTER = 19
TALKTYPE_MONSTER_YELL = 20 

Como usar: doShowTimeByPos(cid, getCreaturePosition(cid), 20, 20)
Irá fazer uma contagem regressiva na posição que o player se encontra começando de 20 e mandando a mensagem na mesma cor da fala dos monstros.
Essa função é bem útil em actions/spells para fazer contagem de tempo em runas como a magic wall e ver quanto tempo falta pra magic wall sumir)

 

Obs: Espero que ajude bastante pessoas a entender sobre funções, eu utilizei cid como o principal uid das funções nos exemplos mas você pode muito bem utilizar outros uids, fica a critério seu.

Qualquer dúvida comentem abaixo que eu vou tentar ajudar da melhor maneira.
Ahhh, isso daí foi testado em 8.54 mas deve funcionar em quase todas as versões que tenham as funções básicas do TFS. 

EDIT: Pessoal, agora é sério, essa lib tem fácil umas 600 linhas, das quais umas 500 eu devo ter codado sozinho (na mão, linha por linha). Eu tive todo o trabalho de testar cada uma delas e oque eu peço é o mínimo de gratidão e respeito. Se eu te ajudei clique em Gostei, se você tiver alguma dúvida eu to me colocando a disposição de responder qualquer coisa relacionada ao tópico, mesmo que você não saiba nem oque é uma lib apenas venha aqui e escreva sua dúvida.

EDIT 2: Duas novas funções adicionas, espero que gostem!

EDIT 3: Três novas funções adicionadas juntamente com suas respectivas explicações.

Editado Dezembro 10, 2014 10 anos por xWhiteWolf (veja o histórico de edições)

Muito foda *-*

Muito bom, um projeto no github do TK seria ótimo para quem quiser ajudar ... 

Sou contra github (sério), se alguém quiser contribuir é só me procurar PM que a gente conversa (se já tiver um trabalho pronto, ótimo, vem falar cmg que eu adiciono na lib juntamente com as explicações). GitHub acaba transformando oque era pra ser um artesanato de código em algo sem valor.

Perfeito! Otimo trabalho.