Function List (as of 3.1)

This is just the list of functions that come with YSI 3.1 inside the generic YSI.inc file.

---

y_amx

AMX_GetBaseCount(E_AMX_TABLE:table, &base, &count)

AMX_GetGlobalAddress(...)

AMX_Read(addr)

AMX_Write(addr, value)

AMX_ReadString(addr, str[], len = sizeof (str))

AMX_WriteString(addr, const str[], len = sizeof (str))

AMX_ReadArray(addr, dest[], len = sizeof (dest))

AMX_WriteArray(addr, const src[], len = sizeof (src))

AMX_GetPublicEntry(idx, &buffer, const pattern[] = "")

AMX_GetNativeEntry(idx, &buffer, const pattern[] = "")

AMX_GetLibraryEntry(idx, &buffer, const pattern[] = "")

AMX_GetPubvarEntry(idx, &buffer, const pattern[] = "")

AMX_GetTagEntry(idx, &buffer, const pattern[] = "")

AMX_GetEntry(E_AMX_TABLE:table, idx, &buffer, const pattern[] = "")

AMX_GetPublicEntryPrefix(idx, &buffer, pattern)

AMX_GetNativeEntryPrefix(idx, &buffer, pattern)

AMX_GetLibraryEntryPrefix(idx, &buffer, pattern)

AMX_GetPubvarEntryPrefix(idx, &buffer, pattern)

AMX_GetTagEntryPrefix(idx, &buffer, pattern)

AMX_GetEntryPrefix(E_AMX_TABLE:table, idx, &buffer, pattern)

AMX_GetPublicEntrySuffix(idx, &buffer, pattern)

AMX_GetNativeEntrySuffix(idx, &buffer, pattern)

AMX_GetLibraryEntrySuffix(idx, &buffer, pattern)

AMX_GetPubvarEntrySuffix(idx, &buffer, pattern)

AMX_GetTagEntrySuffix(idx, &buffer, pattern)

AMX_GetEntrySuffix(E_AMX_TABLE:table, idx, &buffer, pattern)

AMX_GetPublicName(idx, buffer[32], const pattern[] = "")

AMX_GetNativeName(idx, buffer[32], const pattern[] = "")

AMX_GetLibraryName(idx, buffer[32], const pattern[] = "")

AMX_GetPubvarName(idx, buffer[32], const pattern[] = "")

AMX_GetTagName(idx, buffer[32], const pattern[] = "")

AMX_GetName(E_AMX_TABLE:table, idx, buffer[32], const pattern[] = "")

AMX_GetPublicNamePrefix(idx, buffer[32], pattern)

AMX_GetNativeNamePrefix(idx, buffer[32], pattern)

AMX_GetLibraryNamePrefix(idx, buffer[32], pattern)

AMX_GetPubvarNamePrefix(idx, buffer[32], pattern)

AMX_GetTagNamePrefix(idx, buffer[32], pattern)

AMX_GetNamePrefix(E_AMX_TABLE:table, idx, buffer[32], pattern)

AMX_GetPublicNameSuffix(idx, buffer[32], pattern)

AMX_GetNativeNameSuffix(idx, buffer[32], pattern)

AMX_GetLibraryNameSuffix(idx, buffer[32], pattern)

AMX_GetPubvarNameSuffix(idx, buffer[32], pattern)

AMX_GetTagNameSuffix(idx, buffer[32], pattern)

AMX_GetNameSuffix(E_AMX_TABLE:table, idx, buffer[32], pattern)

AMX_GetPublicPointer(idx, &buffer, const pattern[] = "")

AMX_GetNativePointer(idx, &buffer, const pattern[] = "")

AMX_GetLibraryPointer(idx, &buffer, const pattern[] = "")

AMX_GetPubvarPointer(idx, &buffer, const pattern[] = "")

AMX_GetTagPointer(idx, &buffer, const pattern[] = "")

AMX_GetPointer(E_AMX_TABLE:table, idx, &buffer, const pattern[] = "")

AMX_GetPublicPointerPrefix(idx, &buffer, pattern)

AMX_GetNativePointerPrefix(idx, &buffer, pattern)

AMX_GetLibraryPointerPrefix(idx, &buffer, pattern)

AMX_GetPubvarPointerPrefix(idx, &buffer, pattern)

AMX_GetTagPointerPrefix(idx, &buffer, pattern)

AMX_GetPointerPrefix(E_AMX_TABLE:table, idx, &buffer, pattern)

AMX_GetPublicPointerSuffix(idx, &buffer, pattern)

AMX_GetNativePointerSuffix(idx, &buffer, pattern)

AMX_GetLibraryPointerSuffix(idx, &buffer, pattern)

AMX_GetPubvarPointerSuffix(idx, &buffer, pattern)

AMX_GetTagPointerSuffix(idx, &buffer, pattern)

AMX_GetPointerSuffix(E_AMX_TABLE:table, idx, &buffer, pattern)

AMX_GetPublicValue(idx, &buffer, const pattern[] = "")

AMX_GetNativeValue(idx, &buffer, const pattern[] = "")

AMX_GetLibraryValue(idx, &buffer, const pattern[] = "")

AMX_GetPubvarValue(idx, &buffer, const pattern[] = "")

AMX_GetTagValue(idx, &buffer, const pattern[] = "")

AMX_GetValue(E_AMX_TABLE:table, idx, &buffer, const pattern[] = "")

AMX_GetPublicValuePrefix(idx, &buffer, pattern)

AMX_GetNativeValuePrefix(idx, &buffer, pattern)

AMX_GetLibraryValuePrefix(idx, &buffer, pattern)

AMX_GetPubvarValuePrefix(idx, &buffer, pattern)

AMX_GetTagValuePrefix(idx, &buffer, pattern)

AMX_GetValuePrefix(E_AMX_TABLE:table, idx, &buffer, pattern)

AMX_GetPublicValueSuffix(idx, &buffer, pattern)

AMX_GetNativeValueSuffix(idx, &buffer, pattern)

AMX_GetLibraryValueSuffix(idx, &buffer, pattern)

AMX_GetPubvarValueSuffix(idx, &buffer, pattern)

AMX_GetTagValueSuffix(idx, &buffer, pattern)

AMX_GetValueSuffix(E_AMX_TABLE:table, idx, &buffer, pattern)

y_areas

Area_AddCube(Float:x0, Float:y0, Float:z0, Float:x1, Float:y1, Float:z1)

Area_AddBox(Float:minx, Float:miny, Float:maxx, Float:maxy)

Area_AddCircle(Float:x, Float:y, Float:r, Float:h = FLOAT_INFINITY)

Area_AddSphere(Float:x, Float:y, Float:z, Float:r)

Area_AddPoly(Float:x1, Float:y1, Float:x2, Float:y2, Float:x3, Float:y3, Float:...)

Area_Delete(area)

Area_GetPlayerArea(playerid)

Area_SetPlayer(area, playerid, bool:set)

bool:Area_GetPlayer(area, playerid)

Area_SetAllPlayers(area, bool:set)

Area_SetWorld(area, world, bool:set)

bool:Area_GetWorld(area, world)

Area_SetAllWorlds(area, bool:set)

bool:Area_IsValid(area)

bool:Area_IsEmpty(area)

y_bintree

Bintree_Generate(BinaryTree:output<>, input[][E_BINTREE_INPUT], size)

Bintree_Reset(BinaryTree:tree<>, pointer = 0)

Bintree_FindValue(BinaryTree:tree<>, value, &cont = 0, &old = 0)

Bintree_Add(BinaryTree:data<>, pointer, value, offset, maxsize = sizeof (data))

Bintree_Delete(BinaryTree:source<>, index, count)

Bintree_UpdatePointers(BinaryTree:data<>, offset, size, mod = -1)

y_bit

Bit_Set(BitArray:array<>, slot, bool:set)

Bit_SetAll(BitArray:array<>, bool:set, size = sizeof (array))

Bit_Get(BitArray:array<>, slot)

Bit_Let(BitArray:array<>, slot)

Bit_Vet(BitArray:array<>, slot)

Bit_Slot(value)

Bit_Mask(value)

Bit_GetCount(BitArray:array<>, size = sizeof (array))

Bit_Display(BitArray:array<>, size = sizeof (array))

Iterator:Bits(BitArray:array<>)

Iterator:Blanks(BitArray:array<>)

bits()

bitsof()

y_cell

Cell_ReverseBits({Float, _}:data)

Cell_ReverseNibbles({Float, _}:data)

Cell_ReverseBytes({Float, _}:data)

Cell_CountBits({Float, _}:data)

Cell_GetLowestBit({Float, _}:data)

Cell_GetLowestComponent({Float, _}:data)

y_classes

Class_Add(skin, Float:x, Float:y, Float:z, Float:a, ...)

Class_AddEx(Group:forgroup, Group:setgroup, skin, Float:x, Float:y, Float:z, Float:a, ...)

Class_AddForGroup(Group:group, skin, Float:x, Float:y, Float:z, Float:a, ...)

Class_AddWithGroupSet(Group:group, skin, Float:x, Float:y, Float:z, Float:a, ...)

Class_Enable(classid, bool:toggle)

Class_Delete(classid)

Class_SetPlayer(classid, playerid, bool:s)

bool:Class_GetPlayer(classid, playerid)

Class_Get(playerid)

Class_Goto(playerid, playerclass)

Class_DisableSelection(playerid)

Class_DisableReselection(playerid)

Class_EnableReselection(playerid)

Class_ForceReselection(playerid)

Class_ReturnToSelection(playerid)

y_colours

y_colors

SetColoursCanHaveSpaces(bool:set)

SetColour(const name[], color)

SetColourHash(hash, color)

GetColour(const name[], alpha = 0xAA)

GetColourStream(const str[], &idx, alpha = 0xAA)

GetColourHash(hash, alpha = 0xAA)

y_commands

Command_AddAlt(commandid, altname[])

Command_AddAltNamed(command[], altname[])

Command_SetPlayer(commandid, playerid, bool:set)

Command_SetPlayerNamed(command[], playerid, bool:set)

Command_SetDeniedReturn(bool:set)

bool:Command_GetDeniedReturn()

Command_SetIllegalReturn(bool:set)

bool:Command_GetIllegalReturn()

Command_SetUnknownReturn(bool:set)

bool:Command_GetUnknownReturn()

Command_SetDisconnectReturn(bool:set)

bool:Command_GetDisconnectReturn()

Command_GetID(command[])

bool:Command_GetPlayer(commandid, playerid)

bool:Command_GetPlayerNamed(command[], playerid)

Command_Remove(commandid)

Command_RemoveNamed(command[])

Command_ReProcess(playerid, cmdtext[], help)

Command_GetName(commandid)

Command_GetDisplay(commandid, playerid)

Command_GetDisplayNamed(command[], playerid)

Command_GetPlayerCommandCount(playerid)

Command_GetNext(index, playerid)

Command_SetProvider(p)

Command_GetProvider()

Command_SetPlayerProvider(playerid, p)

Command_GetPlayerProvider(playerid)

y_debug

P_level(str[], {Float, _}:...)

P_I(str[], {Float, _}:...)

P_W(str[], {Float, _}:...)

P_E(str[], {Float, _}:...)

P_F(str[], {Float, _}:...)

P_C(str[], {Float, _}:...)

y_dialog

Dialog_Show(playerid, style, title[], caption[], button1[], button2[] = "", dialogid = -1)

Dialog_ShowCallback(playerid, using:callback[], style, title[], caption[], button1[], button2[] = "", dialogid = -1)

Dialog_ObtainID()

Dialog_TryObtainID(id)

Dialog_Get(playerid)

Dialog_Garbage(dialogid)

Dialog_Free(dialogid)

Dialog_Set(playerid, dialogid)

Dialog_ShowCallbackData(playerid, callback[E_CALLBACK_DATA], style, title[], caption[], button1[], button2[] = "", dialogid = -1)

Dialog_Hide(playerid)

Dialog_SetCallback(dialogid, using:callback[])

Dialog_SetCallbackData(dialogid, callback[E_CALLBACK_DATA])

y_flooding

SetMaxConnections(max = -1, e_FLOOD_ACTION:action = e_FLOOD_ACTION_BLOCK)

y_groups

Group:Group_Create(name[])

Group_Destroy(Group:group)

Group_SetPlayer(Group:group, playerid, bool:s)

bool:Group_GetPlayer(Group:group, playerid)

Group_SetGroup(Group:parent, Group:child, bool:s)

Group_SetGlobalGroup(Group:child, bool:s)

Group_SetCommand(Group:group, commandid, bool:s)

Group_SetCommandDefault(Group:group, bool:s)

Group_SetGlobalCommand(commandid, bool:s)

Group_SetGlobalCommandDefault(bool:s)

Group_SetArea(Group:group, area, bool:s)

Group_SetAreaDefault(Group:group, bool:s)

Group_SetGlobalArea(area, bool:s)

Group_SetGlobalAreaDefault(bool:s)

Group_SetClass(Group:group, class, bool:s)

Group_SetClassDefault(Group:group, bool:s)

Group_SetGlobalClass(class, bool:s)

Group_SetGlobalCalssDefault(bool:s)

Iterator:PlayerGroups(playerid)

Iterator:Group(Group:group)

Group:Group_SetBalanced(playerid, Group:...)

Group_GetColour(Group:group)

Group_GetColor(Group:group)

Group_SetColour(Group:group, colour)

Group_SetColor(Group:group, color)

bool:Group_GetGang(Group:group)

Group_SetGang(Group:group, bool:set)

Group:Group_GetID(name[])

Group_GetName(Group:group)

Group_SetName(Group:group, name[])

y_hooks

hook()

y_ini

bool:INI_ParseFile(fname[], remoteFormat[], bool:bFileFirst = false, bool:bExtra = false, extra = 0, bool:bLocal = true, bool:bPassTag = false, bool:bFilter = true, filter[] = "")

bool:INI_Load(filename[], bool:bExtra = false, extra = 0, bool:bLocal = true)

INI_Int(name[], &dest)

INI_Float(name[], &Float:dest)

INI_Hex(name[], &dest)

INI_Bin(name[], &dest)

INI_String(name[], dest[], size)

INI:INI_Open(filename[])

INI_Close(INI:file)

INI_SetTag(INI:file, tag[])

INI_DeleteTag(INI:file, tag[])

INI_WriteArray(INI:file, const name[], data[], len)

INI_RemoveEntry(INI:file, name[])

INI_WriteString(INI:file, name[], data[])

INI_WriteInt(INI:file, name[], data)

INI_WriteHex(INI:file, name[], data)

INI_WriteBin(INI:file, name[], data)

INI_WriteBool(INI:file, name[], bool:data)

INI_WriteFloat(INI:file, name[], Float:data, accuracy = 6)

y_inline

using()

inline()

Callback_Get(callback:name, result[E_CALLBACK_DATA], expect = -1)

Callback_Release(const input[E_CALLBACK_DATA])

Callback_Call(const input[E_CALLBACK_DATA], {Float, _}:...)

y_iterate

Iter_Init(Iterator:arr[]<>)

Iter_Add(Iterator:iter<>, element)

Iter_Remove(Iterator:iter<>, element)

Iter_Contains(Iterator:iter<>, element)

Iter_SafeRemove(Iterator:iter<>, element, &ret)

Iter_Random(Iterator:iter<>)

Iter_Count(Iterator:iter<>)

Iter_Clear(Iterator:iter<>)

Iter_Free(Iterator:iter<>)

foreach()

Iter_Begin(Iterator:iter<>)

Iter_End(Iterator:iter<>)

Iter_First(Iterator:iter<>)

Iter_Last(Iterator:iter<>)

Iter_Next(Iterator:iter<>, cur)

Iter_Prev(Iterator:iter<>, cur)

y_languages

Language:Langs_Add(code[], name[])

Language:Langs_SetPlayerLanguage(playerid, Language:l)

Language:Langs_GetPlayerLanguage(playerid)

Language:Langs_AddLanguage(code[], name[])

Langs_RemoveLanguage(Language:l)

Language:Langs_GetLanguage(identifier[])

Language:Langs_GetLanguageCount()

Langs_GetLanguageCodes()

Langs_GetName(Language:l)

Langs_GetCode(Language:l)

bool:Langs_IsValid(Language:l)

Language:Langs_SetPlayerCode(playerid, code[])

y_lock

y_malloc

Alloc:malloc(size)

Alloc:calloc(size)

free(Alloc:slot)

mget(Alloc:array, index)

mset(Alloc:array, index, value)

mgets(target[], length, Alloc:array, index)

msets(Alloc:array, index, const str[])

Malloc_SlotSize(Alloc:array)

Malloc_Get(Alloc:array, index)

Malloc_Set(Alloc:array, index, value)

Malloc_GetS(target[], length, Alloc:array, index)

Malloc_SetS(Alloc:array, index, const str[])

Malloc_GetA(target[], length, Alloc:array, index)

Malloc_SetA(Alloc:array, index, const arr[], len)

y_master

Master_Caller()

foreign()

global()

y_php

PHP_SendString(string:name[], string:value[], bool:priority = false)

PHP_SendFloat(string:name[], Float:value, bool:priority = false)

PHP_SendBool(string:name[], bool:value, bool:priority = false)

PHP_SendInt(string:name[], value, bool:priority = false)

phpdata()

phpfunc()

y_playerarray

PA_Init(PlayerArray:pa<>, bool:init = false, s = bits<MAX_PLAYERS>)

PA_FastInit(PlayerArray:pa<>)

PA_Set(PlayerArray:pa<>, slot, bool:set)

PA_Let(PlayerArray:pa<>, slot)

PA_Vet(PlayerArray:pa<>, slot)

PA_Get(PlayerArray:pa<>, slot)

PA_GetCount(PlayerArray:pa<>)

Iterator:PA(PlayerArray:pa<>)

y_playerset

Iterator:PS(@PlayerSet:iter)

y_remote

remotefunc()

broadcastfunc()

localfunc()

targetfunc()

y_scriptinit

y_stringhash

YHash(const str[], bool:sensitive = true, e_HASH_TYPE:type = hash_bernstein, len = -1, pack = false)

y_svar

svar()

y_td

Style:TD_Create(Float:x = 0.0, Float:y = 0.0, Float:letterX = 0.48, Float:letterY = 1.12, Float:textX = 1280.0, Float:textY = 1280.0, colour = 0xE1E1E1FF, boxColour = 0x80808080, bgColour = 0x000000FF, shadow = 2, outline = 0, align = _:td_align_none, font = 1, bool:proportional = false, bool:box = false, time = 0, name[] = "\1")

TD_Delete(Style:styleId)

Text:TD_Display(text[], Style:id, Float:x = NAN, Float:y = NAN)

TD_Destroy(Text:textDraw)

TD_TextPosition(Text:textID, Float:x, Float:y)

TD_TextXPos(Text:textID, Float:x)

TD_TextYPos(Text:textID, Float:y)

TD_SetString(Text:td, text[])

TD_ShowForPlayer(playerid, Text:textDraw)

TD_HideForPlayer(playerid, Text:textDraw)

TD_ShowForAll(Text:textDraw)

TD_HideForAll(Text:textDraw)

Text:TD_DisplayForPlayer(playerid, text[], Style:id, Float:x = NAN, Float:y = NAN)

Text:TD_DisplayForAll(text[], Style:id, Float:x = NAN, Float:y = NAN)

TD_StylePosition(Style:styleID, Float:x, Float:y)

TD_StyleXPos(Style:styleID, Float:x)

TD_StyleYPos(Style:styleID, Float:y)

TD_LetterSize(Style:styleID, Float:x, Float:y)

TD_LetterX(Style:styleID, Float:x)

TD_LetterY(Style:styleID, Float:y)

TD_TextSize(Style:styleID, Float:x, Float:y)

TD_TextX(Style:styleID, Float:x)

TD_TextY(Style:styleID, Float:y)

TD_Alignment(Style:styleID, alignment = _:td_align_none)

TD_Colour(Style:styleID, colour)

TD_Color(Style:styleID, color)

TD_UseBox(Style:styleID, bool:use)

TD_BoxColour(Style:styleID, colour)

TD_BoxColor(Style:styleID, color)

TD_SetShadow(Style:styleID, size)

TD_SetOutline(Style:styleID, size)

TD_BackgroundColour(Style:styleID, colour)

TD_BackgroundColor(Style:styleID, color)

TD_Font(Style:styleID, font)

TD_SetProportional(Style:styleID, bool:set)

TD_SetTime(Style:styleID, time, bool:existing = false)

TD_Morph(Text:textDraw, Style:style, time, delay = 0)

TD_Link(Text:base, Text:other)

TD_Unlink(Text:td)

Style:TD_GetDisplayStyle(Text:td)

Text:TD_DisplayHashed(text[], hash, Float:x = NAN, Float:y = NAN)

Text:TD_DisplayHashedForPlayer(playerid, text[], hash, Float:x = NAN, Float:y = NAN)

Text:TD_DisplayHashedForAll(text[], hash, Float:x = NAN, Float:y = NAN)

Text:TD_DisplayNamed(text[], style[], Float:x = NAN, Float:y = NAN)

Text:TD_DisplayNamedForPlayer(playerid, text[], style[], Float:x = NAN, Float:y = NAN)

Text:TD_DisplayNamedForAll(text[], style[], Float:x = NAN, Float:y = NAN)

TD_Garbage(Text:textDraw)

TD_Parse(filename[])

Style:TD_GetNamed(name[])

Style:TD_GetID(hash)

Style:TD_Clone(Style:styleID, name[] = "\1")

TD_GetStyleData(Style:styleID, ret[E_TD_DATA])

TD_Name(Style:styleID, name[])

y_testing

Testing_RunAll()

y_text

Text_Send(@PlayerSet:players, message[], {Float, _}:...)

Text_MessageBox(@PlayerSet:players, using:callback[], title[], text[], button1[], button2[], {Float, _}:...)

Text_InputBox(@PlayerSet:players, using:callback[], title[], text[], button1[], button2[], {Float, _}:...)

Text_ListBox(@PlayerSet:players, using:callback[], title[], text[], button1[], button2[], {Float, _}:...)

Text_PasswordBox(@PlayerSet:players, using:callback[], title[], text[], button1[], button2[], {Float, _}:...)

Text_DialogBox(@PlayerSet:players, style, using:callback[], title[], text[], button1[], button2[], {Float, _}:...)

y_timers

stop()

defer()

repeat()

timer()

task()

ptask()

pause()

resume()

y_users

Language:Player_GetPreloadLanguage(playerid)

Player_IsRegistered(playerid)

bool:Player_IsLoggedIn(playerid)

Player_GetYID(playerid)

Player_RemoveEntry(name[])

Player_WriteString(name[], data[])

Player_WriteArray(const name[], data[], len)

Player_WriteInt(name[], data)

Player_WriteHex(name[], data)

Player_WriteBin(name[], data)

Player_WriteBool(name[], bool:data)

Player_WriteFloat(name[], Float:data, accuracy = 6)

Player_SetTag(tag[])

Player_DeleteTag(tag[])

Player_TryLogin(playerid, password[])

Player_ForceLogin(playerid)

Player_TryRegister(playerid, password[])

Player_ChangePassword(playerid, password[])

Player_TryGroup(playerid, other[], password[])

Player_ForceGroup(playerid, other[])

Player_Reload(playerid)

Player_SetPreload(playerid, data[E_USER_PRELOAD])

Player_Preload(name[], ret[E_USER_PRELOAD])

y_utils

ceildiv(num, denom)

floordiv(num, denom)

isnull(str[])

isodd(num)

iseven(num)

strcpy(dest[], src[], maxlength = sizeof (dest))

StripNL(str[])

endofline(line[], pos)

chrfind(needle, haystack[], start = 0)

chrfindp(needle, haystack[], start = 0)

bernstein(string[])

ishex(str[])

unpack(const str[])

GetIP(playerid)

getstring(addr)

getstringarg(addr)

isnumeric(str[])

hexstr(string[])

bool:boolstr(string[])

binstr(string[])

memset(dest[], size = sizeof (dest), val = 0, blocksize = 8)

ReturnPlayerName(playerid)

ftouch(const filename[])

y_uvar

uvar()

y_va

va_printf(fmat[], va_start)

va_format(out[], size, fmat[], va_start)

va_strlen(arg)

va_getstring(dest[], arg, len = sizeof (dest))

y_writemem

WriteMem(addr, value)

y_xml

XML:XML_New()

XML_Destroy(XML:rule)

XML_AddHandler(XML:rule, trigger[], function[])

XML_RemoveHandler(XML:rule, trigger[])

XML_Parse(XML:rule, filename[])

XML_GetKeyValue(key[], value[])

XMLEntry:XML_AddParameter(XMLEntry:parent, tag[], value[] = "")

XMLEntry:XML_AddItem(tag[], name[] = "", XMLEntry:parent = XMLEntry:cellmax)

XMLEntry:XML_CreateEntry(tag[], name[] = "", XMLEntry:parent = XMLEntry:cellmax)

XMLEntry:XML_AddSubEntry(tag[], name[] = "", XMLEntry:parent = XMLEntry:cellmax)

XML_WriteItem(filename[], XMLEntry:item, bool:bIncludeXML = true, bool:bFavourShort = false)

XML_WriteEntry(filename[], XMLEntry:item, bool:bIncludeXML = true, bool:bFavourShort = false)

y_zonepulse

GangZonePulse(@PlayerSet:players, zone, from, to, time, delay = ZONE_PULSE_STAGE_TIME, time2 = -1, delay2 = -1)

GangZonePulseForPlayer(playerid, zone, from, to, time, delay = ZONE_PULSE_STAGE_TIME, time2 = -1, delay2 = -1)

GangZonePulseForAll(zone, from, to, time, delay = ZONE_PULSE_STAGE_TIME, time2 = -1, delay2 = -1)

GangZoneStopPulse(@PlayerSet:players, zone)

GangZoneStopPulseForPlayer(playerid, zone)

GangZoneStopPulseForAll(zone)