Skip to content

Instantly share code, notes, and snippets.

@Glatharth

Glatharth/lua.json

Last active July 19, 2023 17:13
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save Glatharth/3b5986d44f6209821097535a74ed8a20 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save Glatharth/3b5986d44f6209821097535a74ed8a20 to your computer and use it in GitHub Desktop.
Download ZIP
Canary snippet
Raw
lua.json
{
"action:onUse": {
"prefix": "action:onUse(callback)",
"body": [
"${1:action}:onUse(${2:callback})"
],
},
"action:register": {
"prefix": "action:register()",
"body": [
"${1:action}:register(${2:})"
],
},
"action:id": {
"prefix": "action:id(ids)",
"body": [
"${1:action}:id(${2:ids})"
],
},
"action:aid": {
"prefix": "action:aid(aids)",
"body": [
"${1:action}:aid(${2:aids})"
],
},
"action:uid": {
"prefix": "action:uid(uids)",
"body": [
"${1:action}:uid(${2:uids})"
],
},
"action:allowFarUse": {
"prefix": "action:allowFarUse(bool)",
"body": [
"${1:action}:allowFarUse(${2:bool})"
],
},
"action:blockWalls": {
"prefix": "action:blockWalls(bool)",
"body": [
"${1:action}:blockWalls(${2:bool})"
],
},
"action:checkFloor": {
"prefix": "action:checkFloor(bool)",
"body": [
"${1:action}:checkFloor(${2:bool})"
],
},
"combat:setParameter": {
"prefix": "combat:setParameter(key, value)",
"body": [
"${1:combat}:setParameter(${2:key}, ${3:value})"
],
},
"combat:setFormula": {
"prefix": "combat:setFormula(type, mina, minb, maxa, maxb)",
"body": [
"${1:combat}:setFormula(${2:type}, ${3:mina}, ${4:minb}, ${5:maxa}, ${6:maxb})"
],
},
"combat:setArea": {
"prefix": "combat:setArea(area)",
"body": [
"${1:combat}:setArea(${2:area})"
],
},
"combat:addCondition": {
"prefix": "combat:addCondition(condition)",
"body": [
"${1:combat}:addCondition(${2:condition})"
],
},
"combat:setCallback": {
"prefix": "combat:setCallback(key, function)",
"body": [
"${1:combat}:setCallback(${2:key}, ${3:function})"
],
},
"combat:setOrigin": {
"prefix": "combat:setOrigin(origin)",
"body": [
"${1:combat}:setOrigin(${2:origin})"
],
},
"combat:execute": {
"prefix": "combat:execute(creature, variant)",
"body": [
"${1:combat}:execute(${2:creature}, ${3:variant})"
],
},
"condition:delete": {
"prefix": "condition:delete()",
"body": [
"${1:condition}:delete(${2:})"
],
},
"condition:getId": {
"prefix": "condition:getId()",
"body": [
"${1:condition}:getId(${2:})"
],
},
"condition:getSubId": {
"prefix": "condition:getSubId()",
"body": [
"${1:condition}:getSubId(${2:})"
],
},
"condition:getType": {
"prefix": "condition:getType()",
"body": [
"${1:condition}:getType(${2:})"
],
},
"condition:getIcons": {
"prefix": "condition:getIcons()",
"body": [
"${1:condition}:getIcons(${2:})"
],
},
"condition:getEndTime": {
"prefix": "condition:getEndTime()",
"body": [
"${1:condition}:getEndTime(${2:})"
],
},
"condition:clone": {
"prefix": "condition:clone()",
"body": [
"${1:condition}:clone(${2:})"
],
},
"condition:getTicks": {
"prefix": "condition:getTicks()",
"body": [
"${1:condition}:getTicks(${2:})"
],
},
"condition:setTicks": {
"prefix": "condition:setTicks(ticks)",
"body": [
"${1:condition}:setTicks(${2:ticks})"
],
},
"condition:setParameter": {
"prefix": "condition:setParameter(key, value)",
"body": [
"${1:condition}:setParameter(${2:key}, ${3:value})"
],
},
"condition:setFormula": {
"prefix": "condition:setFormula(mina, minb, maxa, maxb)",
"body": [
"${1:condition}:setFormula(${2:mina}, ${3:minb}, ${4:maxa}, ${5:maxb})"
],
},
"condition:setOutfit": {
"prefix": "condition:setOutfit(outfit)",
"body": [
"${1:condition}:setOutfit(${2:outfit})"
],
},
"condition:addDamage": {
"prefix": "condition:addDamage(rounds, time, value)",
"body": [
"${1:condition}:addDamage(${2:rounds}, ${3:time}, ${4:value})"
],
},
"container:getSize": {
"prefix": "container:getSize()",
"body": [
"${1:container}:getSize(${2:})"
],
},
"container:getCapacity": {
"prefix": "container:getCapacity()",
"body": [
"${1:container}:getCapacity(${2:})"
],
},
"container:getEmptySlots": {
"prefix": "container:getEmptySlots([recursive = false])",
"body": [
"${1:container}:getEmptySlots(${2:[recursive = false]})"
],
},
"container:getItemHoldingCount": {
"prefix": "container:getItemHoldingCount()",
"body": [
"${1:container}:getItemHoldingCount(${2:})"
],
},
"container:getItem": {
"prefix": "container:getItem(index)",
"body": [
"${1:container}:getItem(${2:index})"
],
},
"container:hasItem": {
"prefix": "container:hasItem(item)",
"body": [
"${1:container}:hasItem(${2:item})"
],
},
"container:addItem": {
"prefix": "container:addItem(itemId[, count/subType = 1[, index = INDEX_WHEREEVER[, flags = 0]]])",
"body": [
"${1:container}:addItem(${2:itemId[}, ${3:count/subType = 1[}, ${4:index = INDEX_WHEREEVER[}, ${5:flags = 0]]]})"
],
},
"container:addItemEx": {
"prefix": "container:addItemEx(item[, index = INDEX_WHEREEVER[, flags = 0]])",
"body": [
"${1:container}:addItemEx(${2:item[}, ${3:index = INDEX_WHEREEVER[}, ${4:flags = 0]]})"
],
},
"container:getCorpseOwner": {
"prefix": "container:getCorpseOwner()",
"body": [
"${1:container}:getCorpseOwner(${2:})"
],
},
"container:getItemCountById": {
"prefix": "container:getItemCountById(itemId[, subType = -1])",
"body": [
"${1:container}:getItemCountById(${2:itemId[}, ${3:subType = -1]})"
],
},
"container:getContentDescription": {
"prefix": "container:getContentDescription([oldProtocol])",
"body": [
"${1:container}:getContentDescription(${2:[oldProtocol]})"
],
},
"container:getItems": {
"prefix": "container:getItems([recursive = false])",
"body": [
"${1:container}:getItems(${2:[recursive = false]})"
],
},
"container:registerReward": {
"prefix": "container:registerReward()",
"body": [
"${1:container}:registerReward(${2:})"
],
},
"creatureevent:type": {
"prefix": "creatureevent:type(callback)",
"body": [
"${1:creatureevent}:type(${2:callback})"
],
},
"creatureevent:register": {
"prefix": "creatureevent:register()",
"body": [
"${1:creatureevent}:register(${2:})"
],
},
"creature:getEvents": {
"prefix": "creature:getEvents(type)",
"body": [
"${1:creature}:getEvents(${2:type})"
],
},
"creature:registerEvent": {
"prefix": "creature:registerEvent(name)",
"body": [
"${1:creature}:registerEvent(${2:name})"
],
},
"creature:unregisterEvent": {
"prefix": "creature:unregisterEvent(name)",
"body": [
"${1:creature}:unregisterEvent(${2:name})"
],
},
"creature:isRemoved": {
"prefix": "creature:isRemoved()",
"body": [
"${1:creature}:isRemoved(${2:})"
],
},
"creature:isCreature": {
"prefix": "creature:isCreature()",
"body": [
"${1:creature}:isCreature(${2:})"
],
},
"creature:isInGhostMode": {
"prefix": "creature:isInGhostMode()",
"body": [
"${1:creature}:isInGhostMode(${2:})"
],
},
"creature:isHealthHidden": {
"prefix": "creature:isHealthHidden()",
"body": [
"${1:creature}:isHealthHidden(${2:})"
],
},
"creature:canSee": {
"prefix": "creature:canSee(position)",
"body": [
"${1:creature}:canSee(${2:position})"
],
},
"creature:canSeeCreature": {
"prefix": "creature:canSeeCreature(creature)",
"body": [
"${1:creature}:canSeeCreature(${2:creature})"
],
},
"creature:getParent": {
"prefix": "creature:getParent()",
"body": [
"${1:creature}:getParent(${2:})"
],
},
"creature:getId": {
"prefix": "creature:getId()",
"body": [
"${1:creature}:getId(${2:})"
],
},
"creature:getName": {
"prefix": "creature:getName()",
"body": [
"${1:creature}:getName(${2:})"
],
},
"creature:getTypeName": {
"prefix": "creature:getTypeName()",
"body": [
"${1:creature}:getTypeName(${2:})"
],
},
"creature:getTarget": {
"prefix": "creature:getTarget()",
"body": [
"${1:creature}:getTarget(${2:})"
],
},
"creature:setTarget": {
"prefix": "creature:setTarget(target)",
"body": [
"${1:creature}:setTarget(${2:target})"
],
},
"creature:getFollowCreature": {
"prefix": "creature:getFollowCreature()",
"body": [
"${1:creature}:getFollowCreature(${2:})"
],
},
"creature:setFollowCreature": {
"prefix": "creature:setFollowCreature(followedCreature)",
"body": [
"${1:creature}:setFollowCreature(${2:followedCreature})"
],
},
"creature:getMaster": {
"prefix": "creature:getMaster()",
"body": [
"${1:creature}:getMaster(${2:})"
],
},
"creature:reload": {
"prefix": "creature:reload()",
"body": [
"${1:creature}:reload(${2:})"
],
},
"creature:setMaster": {
"prefix": "creature:setMaster(master)",
"body": [
"${1:creature}:setMaster(${2:master})"
],
},
"creature:getLight": {
"prefix": "creature:getLight()",
"body": [
"${1:creature}:getLight(${2:})"
],
},
"creature:setLight": {
"prefix": "creature:setLight(color, level)",
"body": [
"${1:creature}:setLight(${2:color}, ${3:level})"
],
},
"creature:getSpeed": {
"prefix": "creature:getSpeed()",
"body": [
"${1:creature}:getSpeed(${2:})"
],
},
"creature:setSpeed": {
"prefix": "creature:setSpeed(speed)",
"body": [
"${1:creature}:setSpeed(${2:speed})"
],
},
"creature:getBaseSpeed": {
"prefix": "creature:getBaseSpeed()",
"body": [
"${1:creature}:getBaseSpeed(${2:})"
],
},
"creature:changeSpeed": {
"prefix": "creature:changeSpeed(delta)",
"body": [
"${1:creature}:changeSpeed(${2:delta})"
],
},
"creature:setDropLoot": {
"prefix": "creature:setDropLoot(doDrop)",
"body": [
"${1:creature}:setDropLoot(${2:doDrop})"
],
},
"creature:setSkillLoss": {
"prefix": "creature:setSkillLoss(skillLoss)",
"body": [
"${1:creature}:setSkillLoss(${2:skillLoss})"
],
},
"creature:getPosition": {
"prefix": "creature:getPosition()",
"body": [
"${1:creature}:getPosition(${2:})"
],
},
"creature:getTile": {
"prefix": "creature:getTile()",
"body": [
"${1:creature}:getTile(${2:})"
],
},
"creature:getDirection": {
"prefix": "creature:getDirection()",
"body": [
"${1:creature}:getDirection(${2:})"
],
},
"creature:setDirection": {
"prefix": "creature:setDirection(direction)",
"body": [
"${1:creature}:setDirection(${2:direction})"
],
},
"creature:getHealth": {
"prefix": "creature:getHealth()",
"body": [
"${1:creature}:getHealth(${2:})"
],
},
"creature:setHealth": {
"prefix": "creature:setHealth(health)",
"body": [
"${1:creature}:setHealth(${2:health})"
],
},
"creature:addHealth": {
"prefix": "creature:addHealth(healthChange, combatType)",
"body": [
"${1:creature}:addHealth(${2:healthChange}, ${3:combatType})"
],
},
"creature:getMaxHealth": {
"prefix": "creature:getMaxHealth()",
"body": [
"${1:creature}:getMaxHealth(${2:})"
],
},
"creature:setMaxHealth": {
"prefix": "creature:setMaxHealth(maxHealth)",
"body": [
"${1:creature}:setMaxHealth(${2:maxHealth})"
],
},
"creature:setHiddenHealth": {
"prefix": "creature:setHiddenHealth(hide)",
"body": [
"${1:creature}:setHiddenHealth(${2:hide})"
],
},
"creature:isMoveLocked": {
"prefix": "creature:isMoveLocked()",
"body": [
"${1:creature}:isMoveLocked(${2:})"
],
},
"creature:setMoveLocked": {
"prefix": "creature:setMoveLocked(moveLocked)",
"body": [
"${1:creature}:setMoveLocked(${2:moveLocked})"
],
},
"creature:getSkull": {
"prefix": "creature:getSkull()",
"body": [
"${1:creature}:getSkull(${2:})"
],
},
"creature:setSkull": {
"prefix": "creature:setSkull(skull)",
"body": [
"${1:creature}:setSkull(${2:skull})"
],
},
"creature:getOutfit": {
"prefix": "creature:getOutfit()",
"body": [
"${1:creature}:getOutfit(${2:})"
],
},
"creature:setOutfit": {
"prefix": "creature:setOutfit(outfit)",
"body": [
"${1:creature}:setOutfit(${2:outfit})"
],
},
"creature:getCondition": {
"prefix": "creature:getCondition(conditionType[, conditionId = CONDITIONID_COMBAT[, subId = 0]])",
"body": [
"${1:creature}:getCondition(${2:conditionType[}, ${3:conditionId = CONDITIONID_COMBAT[}, ${4:subId = 0]]})"
],
},
"creature:addCondition": {
"prefix": "creature:addCondition(condition)",
"body": [
"${1:creature}:addCondition(${2:condition})"
],
},
"creature:removeCondition": {
"prefix": "creature:removeCondition(conditionType[, conditionId = CONDITIONID_COMBAT[, subId = 0[, force = false]]])",
"body": [
"${1:creature}:removeCondition(${2:conditionType[}, ${3:conditionId = CONDITIONID_COMBAT[}, ${4:subId = 0[}, ${5:force = false]]]})"
],
},
"creature:hasCondition": {
"prefix": "creature:hasCondition(conditionType[, subId = 0])",
"body": [
"${1:creature}:hasCondition(${2:conditionType[}, ${3:subId = 0]})"
],
},
"creature:isImmune": {
"prefix": "creature:isImmune(condition or conditionType)",
"body": [
"${1:creature}:isImmune(${2:condition or conditionType})"
],
},
"creature:remove": {
"prefix": "creature:remove([forced = true])",
"body": [
"${1:creature}:remove(${2:[forced = true]})"
],
},
"creature:teleportTo": {
"prefix": "creature:teleportTo(position[, pushMovement = false])",
"body": [
"${1:creature}:teleportTo(${2:position[}, ${3:pushMovement = false]})"
],
},
"creature:say": {
"prefix": "creature:say(text[, type = TALKTYPE_MONSTER_SAY[, ghost = false[, target = nullptr[, position]]]])",
"body": [
"${1:creature}:say(${2:text[}, ${3:type = TALKTYPE_MONSTER_SAY[}, ${4:ghost = false[}, ${5:target = nullptr[}, ${6:position]]]]})"
],
},
"creature:getDamageMap": {
"prefix": "creature:getDamageMap()",
"body": [
"${1:creature}:getDamageMap(${2:})"
],
},
"creature:getSummons": {
"prefix": "creature:getSummons()",
"body": [
"${1:creature}:getSummons(${2:})"
],
},
"creature:hasBeenSummoned": {
"prefix": "creature:hasBeenSummoned()",
"body": [
"${1:creature}:hasBeenSummoned(${2:})"
],
},
"creature:getDescription": {
"prefix": "creature:getDescription(distance)",
"body": [
"${1:creature}:getDescription(${2:distance})"
],
},
"creature:getPathTo": {
"prefix": "creature:getPathTo(pos[, minTargetDist = 0[, maxTargetDist = 1[, fullPathSearch = true[, clearSight = true[, maxSearchDist = 0]]]]])",
"body": [
"${1:creature}:getPathTo(${2:pos[}, ${3:minTargetDist = 0[}, ${4:maxTargetDist = 1[}, ${5:fullPathSearch = true[}, ${6:clearSight = true[}, ${7:maxSearchDist = 0]]]]]})"
],
},
"creature:move": {
"prefix": "creature:move(direction)",
"body": [
"${1:creature}:move(${2:direction})"
],
},
"creature:move": {
"prefix": "creature:move(tile[, flags = 0])",
"body": [
"${1:creature}:move(${2:tile[}, ${3:flags = 0]})"
],
},
"creature:getZone": {
"prefix": "creature:getZone()",
"body": [
"${1:creature}:getZone(${2:})"
],
},
"globalevent:type": {
"prefix": "globalevent:type(callback)",
"body": [
"${1:globalevent}:type(${2:callback})"
],
},
"globalevent:register": {
"prefix": "globalevent:register()",
"body": [
"${1:globalevent}:register(${2:})"
],
},
"globalevent:time": {
"prefix": "globalevent:time(time)",
"body": [
"${1:globalevent}:time(${2:time})"
],
},
"globalevent:interval": {
"prefix": "globalevent:interval(interval)",
"body": [
"${1:globalevent}:interval(${2:interval})"
],
},
"group:getId": {
"prefix": "group:getId()",
"body": [
"${1:group}:getId(${2:})"
],
},
"group:getName": {
"prefix": "group:getName()",
"body": [
"${1:group}:getName(${2:})"
],
},
"group:getFlags": {
"prefix": "group:getFlags()",
"body": [
"${1:group}:getFlags(${2:})"
],
},
"group:getAccess": {
"prefix": "group:getAccess()",
"body": [
"${1:group}:getAccess(${2:})"
],
},
"group:getMaxDepotItems": {
"prefix": "group:getMaxDepotItems()",
"body": [
"${1:group}:getMaxDepotItems(${2:})"
],
},
"group:getMaxVipEntries": {
"prefix": "group:getMaxVipEntries()",
"body": [
"${1:group}:getMaxVipEntries(${2:})"
],
},
"group:hasFlag": {
"prefix": "group:hasFlag(flag)",
"body": [
"${1:group}:hasFlag(${2:flag})"
],
},
"guild:getId": {
"prefix": "guild:getId()",
"body": [
"${1:guild}:getId(${2:})"
],
},
"guild:getName": {
"prefix": "guild:getName()",
"body": [
"${1:guild}:getName(${2:})"
],
},
"guild:getMembersOnline": {
"prefix": "guild:getMembersOnline()",
"body": [
"${1:guild}:getMembersOnline(${2:})"
],
},
"guild:getBankBalance": {
"prefix": "guild:getBankBalance()",
"body": [
"${1:guild}:getBankBalance(${2:})"
],
},
"guild:setBankBalance": {
"prefix": "guild:setBankBalance(bankBalance)",
"body": [
"${1:guild}:setBankBalance(${2:bankBalance})"
],
},
"guild:addRank": {
"prefix": "guild:addRank(id, name, level)",
"body": [
"${1:guild}:addRank(${2:id}, ${3:name}, ${4:level})"
],
},
"guild:getRankById": {
"prefix": "guild:getRankById(id)",
"body": [
"${1:guild}:getRankById(${2:id})"
],
},
"guild:getRankByLevel": {
"prefix": "guild:getRankByLevel(level)",
"body": [
"${1:guild}:getRankByLevel(${2:level})"
],
},
"guild:getMotd": {
"prefix": "guild:getMotd()",
"body": [
"${1:guild}:getMotd(${2:})"
],
},
"guild:setMotd": {
"prefix": "guild:setMotd(motd)",
"body": [
"${1:guild}:setMotd(${2:motd})"
],
},
"house:getId": {
"prefix": "house:getId()",
"body": [
"${1:house}:getId(${2:})"
],
},
"house:getName": {
"prefix": "house:getName()",
"body": [
"${1:house}:getName(${2:})"
],
},
"house:getTown": {
"prefix": "house:getTown()",
"body": [
"${1:house}:getTown(${2:})"
],
},
"house:getExitPosition": {
"prefix": "house:getExitPosition()",
"body": [
"${1:house}:getExitPosition(${2:})"
],
},
"house:getRent": {
"prefix": "house:getRent()",
"body": [
"${1:house}:getRent(${2:})"
],
},
"house:getOwnerGuid": {
"prefix": "house:getOwnerGuid()",
"body": [
"${1:house}:getOwnerGuid(${2:})"
],
},
"house:setOwnerGuid": {
"prefix": "house:setOwnerGuid(guid[, updateDatabase = true])",
"body": [
"${1:house}:setOwnerGuid(${2:guid[}, ${3:updateDatabase = true]})"
],
},
"house:startTrade": {
"prefix": "house:startTrade(player, tradePartner)",
"body": [
"${1:house}:startTrade(${2:player}, ${3:tradePartner})"
],
},
"house:getBeds": {
"prefix": "house:getBeds()",
"body": [
"${1:house}:getBeds(${2:})"
],
},
"house:getBedCount": {
"prefix": "house:getBedCount()",
"body": [
"${1:house}:getBedCount(${2:})"
],
},
"house:getDoors": {
"prefix": "house:getDoors()",
"body": [
"${1:house}:getDoors(${2:})"
],
},
"house:getDoorCount": {
"prefix": "house:getDoorCount()",
"body": [
"${1:house}:getDoorCount(${2:})"
],
},
"house:getDoorIdByPosition": {
"prefix": "house:getDoorIdByPosition(position)",
"body": [
"${1:house}:getDoorIdByPosition(${2:position})"
],
},
"house:getTiles": {
"prefix": "house:getTiles()",
"body": [
"${1:house}:getTiles(${2:})"
],
},
"house:getItems": {
"prefix": "house:getItems()",
"body": [
"${1:house}:getItems(${2:})"
],
},
"house:getTileCount": {
"prefix": "house:getTileCount()",
"body": [
"${1:house}:getTileCount(${2:})"
],
},
"house:canEditAccessList": {
"prefix": "house:canEditAccessList(listId, player)",
"body": [
"${1:house}:canEditAccessList(${2:listId}, ${3:player})"
],
},
"house:getAccessList": {
"prefix": "house:getAccessList(listId)",
"body": [
"${1:house}:getAccessList(${2:listId})"
],
},
"house:setAccessList": {
"prefix": "house:setAccessList(listId, list)",
"body": [
"${1:house}:setAccessList(${2:listId}, ${3:list})"
],
},
"house:kickPlayer": {
"prefix": "house:kickPlayer(player, targetPlayer)",
"body": [
"${1:house}:kickPlayer(${2:player}, ${3:targetPlayer})"
],
},
"house:isInvited": {
"prefix": "house:isInvited(player)",
"body": [
"${1:house}:isInvited(${2:player})"
],
},
"imbuement:getName": {
"prefix": "imbuement:getName()",
"body": [
"${1:imbuement}:getName(${2:})"
],
},
"imbuement:getId": {
"prefix": "imbuement:getId()",
"body": [
"${1:imbuement}:getId(${2:})"
],
},
"imbuement:getItems": {
"prefix": "imbuement:getItems()",
"body": [
"${1:imbuement}:getItems(${2:})"
],
},
"imbuement:getBase": {
"prefix": "imbuement:getBase()",
"body": [
"${1:imbuement}:getBase(${2:})"
],
},
"imbuement:getCategory": {
"prefix": "imbuement:getCategory()",
"body": [
"${1:imbuement}:getCategory(${2:})"
],
},
"imbuement:isPremium": {
"prefix": "imbuement:isPremium()",
"body": [
"${1:imbuement}:isPremium(${2:})"
],
},
"imbuement:getElementDamage": {
"prefix": "imbuement:getElementDamage()",
"body": [
"${1:imbuement}:getElementDamage(${2:})"
],
},
"imbuement:getCombatType": {
"prefix": "imbuement:getCombatType()",
"body": [
"${1:imbuement}:getCombatType(${2:})"
],
},
"itemClassification:addTier": {
"prefix": "itemClassification:addTier(id, gold[, core = 0])",
"body": [
"${1:itemClassification}:addTier(${2:id}, ${3:gold[}, ${4:core = 0]})"
],
},
"item:isItem": {
"prefix": "item:isItem()",
"body": [
"${1:item}:isItem(${2:})"
],
},
"item:getParent": {
"prefix": "item:getParent()",
"body": [
"${1:item}:getParent(${2:})"
],
},
"item:getTopParent": {
"prefix": "item:getTopParent()",
"body": [
"${1:item}:getTopParent(${2:})"
],
},
"item:getId": {
"prefix": "item:getId()",
"body": [
"${1:item}:getId(${2:})"
],
},
"item:clone": {
"prefix": "item:clone()",
"body": [
"${1:item}:clone(${2:})"
],
},
"item:split": {
"prefix": "item:split([count = 1])",
"body": [
"${1:item}:split(${2:[count = 1]})"
],
},
"item:remove": {
"prefix": "item:remove([count = -1])",
"body": [
"${1:item}:remove(${2:[count = -1]})"
],
},
"item:getUniqueId": {
"prefix": "item:getUniqueId()",
"body": [
"${1:item}:getUniqueId(${2:})"
],
},
"item:getActionId": {
"prefix": "item:getActionId()",
"body": [
"${1:item}:getActionId(${2:})"
],
},
"item:setActionId": {
"prefix": "item:setActionId(actionId)",
"body": [
"${1:item}:setActionId(${2:actionId})"
],
},
"item:getCount": {
"prefix": "item:getCount()",
"body": [
"${1:item}:getCount(${2:})"
],
},
"item:getCharges": {
"prefix": "item:getCharges()",
"body": [
"${1:item}:getCharges(${2:})"
],
},
"item:getFluidType": {
"prefix": "item:getFluidType()",
"body": [
"${1:item}:getFluidType(${2:})"
],
},
"item:getWeight": {
"prefix": "item:getWeight()",
"body": [
"${1:item}:getWeight(${2:})"
],
},
"item:getSubType": {
"prefix": "item:getSubType()",
"body": [
"${1:item}:getSubType(${2:})"
],
},
"item:getName": {
"prefix": "item:getName()",
"body": [
"${1:item}:getName(${2:})"
],
},
"item:getPluralName": {
"prefix": "item:getPluralName()",
"body": [
"${1:item}:getPluralName(${2:})"
],
},
"item:getArticle": {
"prefix": "item:getArticle()",
"body": [
"${1:item}:getArticle(${2:})"
],
},
"item:getPosition": {
"prefix": "item:getPosition()",
"body": [
"${1:item}:getPosition(${2:})"
],
},
"item:getTile": {
"prefix": "item:getTile()",
"body": [
"${1:item}:getTile(${2:})"
],
},
"item:hasAttribute": {
"prefix": "item:hasAttribute(key)",
"body": [
"${1:item}:hasAttribute(${2:key})"
],
},
"item:getAttribute": {
"prefix": "item:getAttribute(key)",
"body": [
"${1:item}:getAttribute(${2:key})"
],
},
"item:setAttribute": {
"prefix": "item:setAttribute(key, value)",
"body": [
"${1:item}:setAttribute(${2:key}, ${3:value})"
],
},
"item:removeAttribute": {
"prefix": "item:removeAttribute(key)",
"body": [
"${1:item}:removeAttribute(${2:key})"
],
},
"item:getCustomAttribute": {
"prefix": "item:getCustomAttribute(key)",
"body": [
"${1:item}:getCustomAttribute(${2:key})"
],
},
"item:setCustomAttribute": {
"prefix": "item:setCustomAttribute(key, value)",
"body": [
"${1:item}:setCustomAttribute(${2:key}, ${3:value})"
],
},
"item:removeCustomAttribute": {
"prefix": "item:removeCustomAttribute(key)",
"body": [
"${1:item}:removeCustomAttribute(${2:key})"
],
},
"item:serializeAttributes": {
"prefix": "item:serializeAttributes()",
"body": [
"${1:item}:serializeAttributes(${2:})"
],
},
"item:moveTo": {
"prefix": "item:moveTo(position or cylinder[, flags])",
"body": [
"${1:item}:moveTo(${2:position or cylinder[}, ${3:flags]})"
],
},
"item:transform": {
"prefix": "item:transform(itemId[, count/subType = -1])",
"body": [
"${1:item}:transform(${2:itemId[}, ${3:count/subType = -1]})"
],
},
"item:decay": {
"prefix": "item:decay(decayId)",
"body": [
"${1:item}:decay(${2:decayId})"
],
},
"item:moveToSlot": {
"prefix": "item:moveToSlot(player, slot)",
"body": [
"${1:item}:moveToSlot(${2:player}, ${3:slot})"
],
},
"item:getDescription": {
"prefix": "item:getDescription(distance)",
"body": [
"${1:item}:getDescription(${2:distance})"
],
},
"item:hasProperty": {
"prefix": "item:hasProperty(property)",
"body": [
"${1:item}:hasProperty(${2:property})"
],
},
"item:getImbuement": {
"prefix": "item:getImbuement()",
"body": [
"${1:item}:getImbuement(${2:})"
],
},
"item:getImbuementSlot": {
"prefix": "item:getImbuementSlot()",
"body": [
"${1:item}:getImbuementSlot(${2:})"
],
},
"item:setDuration": {
"prefix": "item:setDuration(minDuration, maxDuration = 0, decayTo = 0, showDuration = true)",
"body": [
"${1:item}:setDuration(${2:minDuration}, ${3:maxDuration = 0}, ${4:decayTo = 0}, ${5:showDuration = true})"
],
},
"item:isInsideDepot": {
"prefix": "item:isInsideDepot([includeInbox = false])",
"body": [
"${1:item}:isInsideDepot(${2:[includeInbox = false]})"
],
},
"item:getTier": {
"prefix": "item:getTier()",
"body": [
"${1:item}:getTier(${2:})"
],
},
"item:setTier": {
"prefix": "item:setTier(tier)",
"body": [
"${1:item}:setTier(${2:tier})"
],
},
"item:getClassification": {
"prefix": "item:getClassification()",
"body": [
"${1:item}:getClassification(${2:})"
],
},
"itemType:isCorpse": {
"prefix": "itemType:isCorpse()",
"body": [
"${1:itemType}:isCorpse(${2:})"
],
},
"itemType:isDoor": {
"prefix": "itemType:isDoor()",
"body": [
"${1:itemType}:isDoor(${2:})"
],
},
"itemType:isContainer": {
"prefix": "itemType:isContainer()",
"body": [
"${1:itemType}:isContainer(${2:})"
],
},
"itemType:isFluidContainer": {
"prefix": "itemType:isFluidContainer()",
"body": [
"${1:itemType}:isFluidContainer(${2:})"
],
},
"itemType:isMovable": {
"prefix": "itemType:isMovable()",
"body": [
"${1:itemType}:isMovable(${2:})"
],
},
"itemType:isRune": {
"prefix": "itemType:isRune()",
"body": [
"${1:itemType}:isRune(${2:})"
],
},
"itemType:isStackable": {
"prefix": "itemType:isStackable()",
"body": [
"${1:itemType}:isStackable(${2:})"
],
},
"itemType:isReadable": {
"prefix": "itemType:isReadable()",
"body": [
"${1:itemType}:isReadable(${2:})"
],
},
"itemType:isWritable": {
"prefix": "itemType:isWritable()",
"body": [
"${1:itemType}:isWritable(${2:})"
],
},
"itemType:isBlocking": {
"prefix": "itemType:isBlocking()",
"body": [
"${1:itemType}:isBlocking(${2:})"
],
},
"itemType:isGroundTile": {
"prefix": "itemType:isGroundTile()",
"body": [
"${1:itemType}:isGroundTile(${2:})"
],
},
"itemType:isMagicField": {
"prefix": "itemType:isMagicField()",
"body": [
"${1:itemType}:isMagicField(${2:})"
],
},
"itemType:isMultiUse": {
"prefix": "itemType:isMultiUse()",
"body": [
"${1:itemType}:isMultiUse(${2:})"
],
},
"itemType:isPickupable": {
"prefix": "itemType:isPickupable()",
"body": [
"${1:itemType}:isPickupable(${2:})"
],
},
"itemType:isKey": {
"prefix": "itemType:isKey()",
"body": [
"${1:itemType}:isKey(${2:})"
],
},
"itemType:isQuiver": {
"prefix": "itemType:isQuiver()",
"body": [
"${1:itemType}:isQuiver(${2:})"
],
},
"itemType:getType": {
"prefix": "itemType:getType()",
"body": [
"${1:itemType}:getType(${2:})"
],
},
"itemType:getId": {
"prefix": "itemType:getId()",
"body": [
"${1:itemType}:getId(${2:})"
],
},
"itemType:getName": {
"prefix": "itemType:getName()",
"body": [
"${1:itemType}:getName(${2:})"
],
},
"itemType:getPluralName": {
"prefix": "itemType:getPluralName()",
"body": [
"${1:itemType}:getPluralName(${2:})"
],
},
"itemType:getArticle": {
"prefix": "itemType:getArticle()",
"body": [
"${1:itemType}:getArticle(${2:})"
],
},
"itemType:getDescription": {
"prefix": "itemType:getDescription()",
"body": [
"${1:itemType}:getDescription(${2:})"
],
},
"itemType:getSlotPosition": {
"prefix": "itemType:getSlotPosition()",
"body": [
"${1:itemType}:getSlotPosition(${2:})"
],
},
"itemType:getCharges": {
"prefix": "itemType:getCharges()",
"body": [
"${1:itemType}:getCharges(${2:})"
],
},
"itemType:getFluidSource": {
"prefix": "itemType:getFluidSource()",
"body": [
"${1:itemType}:getFluidSource(${2:})"
],
},
"itemType:getCapacity": {
"prefix": "itemType:getCapacity()",
"body": [
"${1:itemType}:getCapacity(${2:})"
],
},
"itemType:getWeight": {
"prefix": "itemType:getWeight([count = 1])",
"body": [
"${1:itemType}:getWeight(${2:[count = 1]})"
],
},
"itemType:getHitChance": {
"prefix": "itemType:getHitChance()",
"body": [
"${1:itemType}:getHitChance(${2:})"
],
},
"itemType:getShootRange": {
"prefix": "itemType:getShootRange()",
"body": [
"${1:itemType}:getShootRange(${2:})"
],
},
"itemType:getAttack": {
"prefix": "itemType:getAttack()",
"body": [
"${1:itemType}:getAttack(${2:})"
],
},
"itemType:getDefense": {
"prefix": "itemType:getDefense()",
"body": [
"${1:itemType}:getDefense(${2:})"
],
},
"itemType:getExtraDefense": {
"prefix": "itemType:getExtraDefense()",
"body": [
"${1:itemType}:getExtraDefense(${2:})"
],
},
"itemType:getImbuementSlot": {
"prefix": "itemType:getImbuementSlot()",
"body": [
"${1:itemType}:getImbuementSlot(${2:})"
],
},
"itemType:getArmor": {
"prefix": "itemType:getArmor()",
"body": [
"${1:itemType}:getArmor(${2:})"
],
},
"itemType:getWeaponType": {
"prefix": "itemType:getWeaponType()",
"body": [
"${1:itemType}:getWeaponType(${2:})"
],
},
"itemType:getAmmoType": {
"prefix": "itemType:getAmmoType()",
"body": [
"${1:itemType}:getAmmoType(${2:})"
],
},
"itemType:getElementType": {
"prefix": "itemType:getElementType()",
"body": [
"${1:itemType}:getElementType(${2:})"
],
},
"itemType:getElementDamage": {
"prefix": "itemType:getElementDamage()",
"body": [
"${1:itemType}:getElementDamage(${2:})"
],
},
"itemType:getTransformEquipId": {
"prefix": "itemType:getTransformEquipId()",
"body": [
"${1:itemType}:getTransformEquipId(${2:})"
],
},
"itemType:getTransformDeEquipId": {
"prefix": "itemType:getTransformDeEquipId()",
"body": [
"${1:itemType}:getTransformDeEquipId(${2:})"
],
},
"itemType:getDestroyId": {
"prefix": "itemType:getDestroyId()",
"body": [
"${1:itemType}:getDestroyId(${2:})"
],
},
"itemType:getDecayId": {
"prefix": "itemType:getDecayId()",
"body": [
"${1:itemType}:getDecayId(${2:})"
],
},
"itemType:getRequiredLevel": {
"prefix": "itemType:getRequiredLevel()",
"body": [
"${1:itemType}:getRequiredLevel(${2:})"
],
},
"itemType:getSpeed": {
"prefix": "itemType:getSpeed()",
"body": [
"${1:itemType}:getSpeed(${2:})"
],
},
"itemType:getBaseSpeed": {
"prefix": "itemType:getBaseSpeed()",
"body": [
"${1:itemType}:getBaseSpeed(${2:})"
],
},
"itemType:getDecayTime": {
"prefix": "itemType:getDecayTime()",
"body": [
"${1:itemType}:getDecayTime(${2:})"
],
},
"itemType:getShowDuration": {
"prefix": "itemType:getShowDuration()",
"body": [
"${1:itemType}:getShowDuration(${2:})"
],
},
"itemType:getWrapableTo": {
"prefix": "itemType:getWrapableTo()",
"body": [
"${1:itemType}:getWrapableTo(${2:})"
],
},
"itemType:hasSubType": {
"prefix": "itemType:hasSubType()",
"body": [
"${1:itemType}:hasSubType(${2:})"
],
},
"itemType:getVocationString": {
"prefix": "itemType:getVocationString()",
"body": [
"${1:itemType}:getVocationString(${2:})"
],
},
"loot:delete": {
"prefix": "loot:delete()",
"body": [
"${1:loot}:delete(${2:})"
],
},
"loot:setId": {
"prefix": "loot:setId(id)",
"body": [
"${1:loot}:setId(${2:id})"
],
},
"loot:setIdFromName": {
"prefix": "loot:setIdFromName(name)",
"body": [
"${1:loot}:setIdFromName(${2:name})"
],
},
"loot:setSubType": {
"prefix": "loot:setSubType(type)",
"body": [
"${1:loot}:setSubType(${2:type})"
],
},
"loot:setChance": {
"prefix": "loot:setChance(chance)",
"body": [
"${1:loot}:setChance(${2:chance})"
],
},
"loot:setMinCount": {
"prefix": "loot:setMinCount(min)",
"body": [
"${1:loot}:setMinCount(${2:min})"
],
},
"loot:setMaxCount": {
"prefix": "loot:setMaxCount(max)",
"body": [
"${1:loot}:setMaxCount(${2:max})"
],
},
"loot:setActionId": {
"prefix": "loot:setActionId(actionid)",
"body": [
"${1:loot}:setActionId(${2:actionid})"
],
},
"loot:setText": {
"prefix": "loot:setText(text)",
"body": [
"${1:loot}:setText(${2:text})"
],
},
"loot:setNameItem": {
"prefix": "loot:setNameItem(name)",
"body": [
"${1:loot}:setNameItem(${2:name})"
],
},
"loot:setArticle": {
"prefix": "loot:setArticle(article)",
"body": [
"${1:loot}:setArticle(${2:article})"
],
},
"loot:setAttack": {
"prefix": "loot:setAttack(attack)",
"body": [
"${1:loot}:setAttack(${2:attack})"
],
},
"loot:setDefense": {
"prefix": "loot:setDefense(defense)",
"body": [
"${1:loot}:setDefense(${2:defense})"
],
},
"loot:setExtraDefense": {
"prefix": "loot:setExtraDefense(defense)",
"body": [
"${1:loot}:setExtraDefense(${2:defense})"
],
},
"loot:setArmor": {
"prefix": "loot:setArmor(armor)",
"body": [
"${1:loot}:setArmor(${2:armor})"
],
},
"loot:setShootRange": {
"prefix": "loot:setShootRange(range)",
"body": [
"${1:loot}:setShootRange(${2:range})"
],
},
"loot:setHitChance": {
"prefix": "loot:setHitChance(chance)",
"body": [
"${1:loot}:setHitChance(${2:chance})"
],
},
"loot:setUnique": {
"prefix": "loot:setUnique(bool)",
"body": [
"${1:loot}:setUnique(${2:bool})"
],
},
"loot:addChildLoot": {
"prefix": "loot:addChildLoot(loot)",
"body": [
"${1:loot}:addChildLoot(${2:loot})"
],
},
"modalWindow:getId": {
"prefix": "modalWindow:getId()",
"body": [
"${1:modalWindow}:getId(${2:})"
],
},
"modalWindow:getTitle": {
"prefix": "modalWindow:getTitle()",
"body": [
"${1:modalWindow}:getTitle(${2:})"
],
},
"modalWindow:getMessage": {
"prefix": "modalWindow:getMessage()",
"body": [
"${1:modalWindow}:getMessage(${2:})"
],
},
"modalWindow:setTitle": {
"prefix": "modalWindow:setTitle(text)",
"body": [
"${1:modalWindow}:setTitle(${2:text})"
],
},
"modalWindow:setMessage": {
"prefix": "modalWindow:setMessage(text)",
"body": [
"${1:modalWindow}:setMessage(${2:text})"
],
},
"modalWindow:getButtonCount": {
"prefix": "modalWindow:getButtonCount()",
"body": [
"${1:modalWindow}:getButtonCount(${2:})"
],
},
"modalWindow:getChoiceCount": {
"prefix": "modalWindow:getChoiceCount()",
"body": [
"${1:modalWindow}:getChoiceCount(${2:})"
],
},
"modalWindow:addButton": {
"prefix": "modalWindow:addButton(id, text)",
"body": [
"${1:modalWindow}:addButton(${2:id}, ${3:text})"
],
},
"modalWindow:addChoice": {
"prefix": "modalWindow:addChoice(id, text)",
"body": [
"${1:modalWindow}:addChoice(${2:id}, ${3:text})"
],
},
"modalWindow:getDefaultEnterButton": {
"prefix": "modalWindow:getDefaultEnterButton()",
"body": [
"${1:modalWindow}:getDefaultEnterButton(${2:})"
],
},
"modalWindow:setDefaultEnterButton": {
"prefix": "modalWindow:setDefaultEnterButton(buttonId)",
"body": [
"${1:modalWindow}:setDefaultEnterButton(${2:buttonId})"
],
},
"modalWindow:getDefaultEscapeButton": {
"prefix": "modalWindow:getDefaultEscapeButton()",
"body": [
"${1:modalWindow}:getDefaultEscapeButton(${2:})"
],
},
"modalWindow:setDefaultEscapeButton": {
"prefix": "modalWindow:setDefaultEscapeButton(buttonId)",
"body": [
"${1:modalWindow}:setDefaultEscapeButton(${2:buttonId})"
],
},
"modalWindow:hasPriority": {
"prefix": "modalWindow:hasPriority()",
"body": [
"${1:modalWindow}:hasPriority(${2:})"
],
},
"modalWindow:setPriority": {
"prefix": "modalWindow:setPriority(priority)",
"body": [
"${1:modalWindow}:setPriority(${2:priority})"
],
},
"modalWindow:sendToPlayer": {
"prefix": "modalWindow:sendToPlayer(player)",
"body": [
"${1:modalWindow}:sendToPlayer(${2:player})"
],
},
"monster:isMonster": {
"prefix": "monster:isMonster()",
"body": [
"${1:monster}:isMonster(${2:})"
],
},
"monster:getType": {
"prefix": "monster:getType()",
"body": [
"${1:monster}:getType(${2:})"
],
},
"monster:setType": {
"prefix": "monster:setType(name or raceid)",
"body": [
"${1:monster}:setType(${2:name or raceid})"
],
},
"monster:getSpawnPosition": {
"prefix": "monster:getSpawnPosition()",
"body": [
"${1:monster}:getSpawnPosition(${2:})"
],
},
"monster:isInSpawnRange": {
"prefix": "monster:isInSpawnRange([position])",
"body": [
"${1:monster}:isInSpawnRange(${2:[position]})"
],
},
"monster:isIdle": {
"prefix": "monster:isIdle()",
"body": [
"${1:monster}:isIdle(${2:})"
],
},
"monster:setIdle": {
"prefix": "monster:setIdle(idle)",
"body": [
"${1:monster}:setIdle(${2:idle})"
],
},
"monster:isTarget": {
"prefix": "monster:isTarget(creature)",
"body": [
"${1:monster}:isTarget(${2:creature})"
],
},
"monster:isOpponent": {
"prefix": "monster:isOpponent(creature)",
"body": [
"${1:monster}:isOpponent(${2:creature})"
],
},
"monster:isFriend": {
"prefix": "monster:isFriend(creature)",
"body": [
"${1:monster}:isFriend(${2:creature})"
],
},
"monster:addFriend": {
"prefix": "monster:addFriend(creature)",
"body": [
"${1:monster}:addFriend(${2:creature})"
],
},
"monster:removeFriend": {
"prefix": "monster:removeFriend(creature)",
"body": [
"${1:monster}:removeFriend(${2:creature})"
],
},
"monster:getFriendList": {
"prefix": "monster:getFriendList()",
"body": [
"${1:monster}:getFriendList(${2:})"
],
},
"monster:getFriendCount": {
"prefix": "monster:getFriendCount()",
"body": [
"${1:monster}:getFriendCount(${2:})"
],
},
"monster:addTarget": {
"prefix": "monster:addTarget(creature[, pushFront = false])",
"body": [
"${1:monster}:addTarget(${2:creature[}, ${3:pushFront = false]})"
],
},
"monster:removeTarget": {
"prefix": "monster:removeTarget(creature)",
"body": [
"${1:monster}:removeTarget(${2:creature})"
],
},
"monster:getTargetList": {
"prefix": "monster:getTargetList()",
"body": [
"${1:monster}:getTargetList(${2:})"
],
},
"monster:getTargetCount": {
"prefix": "monster:getTargetCount()",
"body": [
"${1:monster}:getTargetCount(${2:})"
],
},
"monster:changeTargetDistance": {
"prefix": "monster:changeTargetDistance(distance[, duration = 12000])",
"body": [
"${1:monster}:changeTargetDistance(${2:distance[}, ${3:duration = 12000]})"
],
},
"monster:selectTarget": {
"prefix": "monster:selectTarget(creature)",
"body": [
"${1:monster}:selectTarget(${2:creature})"
],
},
"monster:searchTarget": {
"prefix": "monster:searchTarget([searchType = TARGETSEARCH_DEFAULT])",
"body": [
"${1:monster}:searchTarget(${2:[searchType = TARGETSEARCH_DEFAULT]})"
],
},
"monster:setSpawnPosition": {
"prefix": "monster:setSpawnPosition()",
"body": [
"${1:monster}:setSpawnPosition(${2:})"
],
},
"monster:getRespawnType": {
"prefix": "monster:getRespawnType()",
"body": [
"${1:monster}:getRespawnType(${2:})"
],
},
"monster:getTimeToChangeFiendish": {
"prefix": "monster:getTimeToChangeFiendish()",
"body": [
"${1:monster}:getTimeToChangeFiendish(${2:})"
],
},
"monster:setTimeToChangeFiendish": {
"prefix": "monster:setTimeToChangeFiendish(endTime)",
"body": [
"${1:monster}:setTimeToChangeFiendish(${2:endTime})"
],
},
"monster:getMonsterForgeClassification": {
"prefix": "monster:getMonsterForgeClassification()",
"body": [
"${1:monster}:getMonsterForgeClassification(${2:})"
],
},
"monster:setMonsterForgeClassification": {
"prefix": "monster:setMonsterForgeClassification(classication)",
"body": [
"${1:monster}:setMonsterForgeClassification(${2:classication})"
],
},
"monster:getForgeStack": {
"prefix": "monster:getForgeStack()",
"body": [
"${1:monster}:getForgeStack(${2:})"
],
},
"monster:setForgeStack": {
"prefix": "monster:setForgeStack(stack)",
"body": [
"${1:monster}:setForgeStack(${2:stack})"
],
},
"monster:configureForgeSystem": {
"prefix": "monster:configureForgeSystem()",
"body": [
"${1:monster}:configureForgeSystem(${2:})"
],
},
"monster:clearFiendishStatus": {
"prefix": "monster:clearFiendishStatus()",
"body": [
"${1:monster}:clearFiendishStatus(${2:})"
],
},
"monster:isForgeable": {
"prefix": "monster:isForgeable()",
"body": [
"${1:monster}:isForgeable(${2:})"
],
},
"monster:getName": {
"prefix": "monster:getName()",
"body": [
"${1:monster}:getName(${2:})"
],
},
"monsterSpell:delete": {
"prefix": "monsterSpell:delete()",
"body": [
"${1:monsterSpell}:delete(${2:})"
],
},
"monsterSpell:setType": {
"prefix": "monsterSpell:setType(type)",
"body": [
"${1:monsterSpell}:setType(${2:type})"
],
},
"monsterSpell:setScriptName": {
"prefix": "monsterSpell:setScriptName(name)",
"body": [
"${1:monsterSpell}:setScriptName(${2:name})"
],
},
"monsterSpell:setChance": {
"prefix": "monsterSpell:setChance(chance)",
"body": [
"${1:monsterSpell}:setChance(${2:chance})"
],
},
"monsterSpell:setInterval": {
"prefix": "monsterSpell:setInterval(interval)",
"body": [
"${1:monsterSpell}:setInterval(${2:interval})"
],
},
"monsterSpell:setRange": {
"prefix": "monsterSpell:setRange(range)",
"body": [
"${1:monsterSpell}:setRange(${2:range})"
],
},
"monsterSpell:setCombatValue": {
"prefix": "monsterSpell:setCombatValue(min, max)",
"body": [
"${1:monsterSpell}:setCombatValue(${2:min}, ${3:max})"
],
},
"monsterSpell:setCombatType": {
"prefix": "monsterSpell:setCombatType(combatType_t)",
"body": [
"${1:monsterSpell}:setCombatType(${2:combatType_t})"
],
},
"monsterSpell:setAttackValue": {
"prefix": "monsterSpell:setAttackValue(attack, skill)",
"body": [
"${1:monsterSpell}:setAttackValue(${2:attack}, ${3:skill})"
],
},
"monsterSpell:setNeedTarget": {
"prefix": "monsterSpell:setNeedTarget(bool)",
"body": [
"${1:monsterSpell}:setNeedTarget(${2:bool})"
],
},
"monsterSpell:setCombatLength": {
"prefix": "monsterSpell:setCombatLength(length)",
"body": [
"${1:monsterSpell}:setCombatLength(${2:length})"
],
},
"monsterSpell:setCombatSpread": {
"prefix": "monsterSpell:setCombatSpread(spread)",
"body": [
"${1:monsterSpell}:setCombatSpread(${2:spread})"
],
},
"monsterSpell:setCombatRadius": {
"prefix": "monsterSpell:setCombatRadius(radius)",
"body": [
"${1:monsterSpell}:setCombatRadius(${2:radius})"
],
},
"monsterSpell:setConditionType": {
"prefix": "monsterSpell:setConditionType(type)",
"body": [
"${1:monsterSpell}:setConditionType(${2:type})"
],
},
"monsterSpell:setConditionDamage": {
"prefix": "monsterSpell:setConditionDamage(min, max, start)",
"body": [
"${1:monsterSpell}:setConditionDamage(${2:min}, ${3:max}, ${4:start})"
],
},
"monsterSpell:setConditionSpeedChange": {
"prefix": "monsterSpell:setConditionSpeedChange(speed)",
"body": [
"${1:monsterSpell}:setConditionSpeedChange(${2:speed})"
],
},
"monsterSpell:setConditionDuration": {
"prefix": "monsterSpell:setConditionDuration(duration)",
"body": [
"${1:monsterSpell}:setConditionDuration(${2:duration})"
],
},
"monsterSpell:setConditionTickInterval": {
"prefix": "monsterSpell:setConditionTickInterval(interval)",
"body": [
"${1:monsterSpell}:setConditionTickInterval(${2:interval})"
],
},
"monsterSpell:setCombatShootEffect": {
"prefix": "monsterSpell:setCombatShootEffect(effect)",
"body": [
"${1:monsterSpell}:setCombatShootEffect(${2:effect})"
],
},
"monsterSpell:setCombatEffect": {
"prefix": "monsterSpell:setCombatEffect(effect)",
"body": [
"${1:monsterSpell}:setCombatEffect(${2:effect})"
],
},
"monsterSpell:setOutfitMonster": {
"prefix": "monsterSpell:setOutfitMonster(effect)",
"body": [
"${1:monsterSpell}:setOutfitMonster(${2:effect})"
],
},
"monsterSpell:setOutfitItem": {
"prefix": "monsterSpell:setOutfitItem(effect)",
"body": [
"${1:monsterSpell}:setOutfitItem(${2:effect})"
],
},
"monsterType:canSpawn": {
"prefix": "monsterType:canSpawn(pos)",
"body": [
"${1:monsterType}:canSpawn(${2:pos})"
],
},
"monsterType:getCorpseId": {
"prefix": "monsterType:getCorpseId()",
"body": [
"${1:monsterType}:getCorpseId(${2:})"
],
},
"monsterType:getAttackList": {
"prefix": "monsterType:getAttackList()",
"body": [
"${1:monsterType}:getAttackList(${2:})"
],
},
"monsterType:addAttack": {
"prefix": "monsterType:addAttack(monsterspell)",
"body": [
"${1:monsterType}:addAttack(${2:monsterspell})"
],
},
"monsterType:getDefenseList": {
"prefix": "monsterType:getDefenseList()",
"body": [
"${1:monsterType}:getDefenseList(${2:})"
],
},
"monsterType:getTypeName": {
"prefix": "monsterType:getTypeName()",
"body": [
"${1:monsterType}:getTypeName(${2:})"
],
},
"monsterType:addDefense": {
"prefix": "monsterType:addDefense(monsterspell)",
"body": [
"${1:monsterType}:addDefense(${2:monsterspell})"
],
},
"monsterType:addElement": {
"prefix": "monsterType:addElement(type, percent)",
"body": [
"${1:monsterType}:addElement(${2:type}, ${3:percent})"
],
},
"monsterType:addReflect": {
"prefix": "monsterType:addReflect(type, percent)",
"body": [
"${1:monsterType}:addReflect(${2:type}, ${3:percent})"
],
},
"monsterType:addHealing": {
"prefix": "monsterType:addHealing(type, percent)",
"body": [
"${1:monsterType}:addHealing(${2:type}, ${3:percent})"
],
},
"monsterType:getElementList": {
"prefix": "monsterType:getElementList()",
"body": [
"${1:monsterType}:getElementList(${2:})"
],
},
"monsterType:addVoice": {
"prefix": "monsterType:addVoice(sentence, interval, chance, yell)",
"body": [
"${1:monsterType}:addVoice(${2:sentence}, ${3:interval}, ${4:chance}, ${5:yell})"
],
},
"monsterType:getVoices": {
"prefix": "monsterType:getVoices()",
"body": [
"${1:monsterType}:getVoices(${2:})"
],
},
"monsterType:getLoot": {
"prefix": "monsterType:getLoot()",
"body": [
"${1:monsterType}:getLoot(${2:})"
],
},
"monsterType:addLoot": {
"prefix": "monsterType:addLoot(loot)",
"body": [
"${1:monsterType}:addLoot(${2:loot})"
],
},
"monsterType:getCreatureEvents": {
"prefix": "monsterType:getCreatureEvents()",
"body": [
"${1:monsterType}:getCreatureEvents(${2:})"
],
},
"monsterType:registerEvent": {
"prefix": "monsterType:registerEvent(name)",
"body": [
"${1:monsterType}:registerEvent(${2:name})"
],
},
"monsterType:onThink": {
"prefix": "monsterType:onThink(callback)",
"body": [
"${1:monsterType}:onThink(${2:callback})"
],
},
"monsterType:onAppear": {
"prefix": "monsterType:onAppear(callback)",
"body": [
"${1:monsterType}:onAppear(${2:callback})"
],
},
"monsterType:onDisappear": {
"prefix": "monsterType:onDisappear(callback)",
"body": [
"${1:monsterType}:onDisappear(${2:callback})"
],
},
"monsterType:onMove": {
"prefix": "monsterType:onMove(callback)",
"body": [
"${1:monsterType}:onMove(${2:callback})"
],
},
"monsterType:onSay": {
"prefix": "monsterType:onSay(callback)",
"body": [
"${1:monsterType}:onSay(${2:callback})"
],
},
"monstertype:eventType": {
"prefix": "monstertype:eventType(event)",
"body": [
"${1:monstertype}:eventType(${2:event})"
],
},
"monsterType:getSummonList": {
"prefix": "monsterType:getSummonList()",
"body": [
"${1:monsterType}:getSummonList(${2:})"
],
},
"monsterType:addSummon": {
"prefix": "monsterType:addSummon(name, interval, chance[, count = 1])",
"body": [
"${1:monsterType}:addSummon(${2:name}, ${3:interval}, ${4:chance[}, ${5:count = 1]})"
],
},
"monsterType:baseSpeed": {
"prefix": "monsterType:baseSpeed()",
"body": [
"${1:monsterType}:baseSpeed(${2:})"
],
},
"monsterType:getChangeTargetChance": {
"prefix": "monsterType:getChangeTargetChance()",
"body": [
"${1:monsterType}:getChangeTargetChance(${2:})"
],
},
"monsterType:strategiesTargetNearest": {
"prefix": "monsterType:strategiesTargetNearest()",
"body": [
"${1:monsterType}:strategiesTargetNearest(${2:})"
],
},
"monsterType:strategiesTargetHealth": {
"prefix": "monsterType:strategiesTargetHealth()",
"body": [
"${1:monsterType}:strategiesTargetHealth(${2:})"
],
},
"monsterType:strategiesTargetDamage": {
"prefix": "monsterType:strategiesTargetDamage()",
"body": [
"${1:monsterType}:strategiesTargetDamage(${2:})"
],
},
"monsterType:strategiesTargetRandom": {
"prefix": "monsterType:strategiesTargetRandom()",
"body": [
"${1:monsterType}:strategiesTargetRandom(${2:})"
],
},
"monsterType:respawnTypePeriod": {
"prefix": "monsterType:respawnTypePeriod()",
"body": [
"${1:monsterType}:respawnTypePeriod(${2:})"
],
},
"monsterType:respawnTypeIsUnderground": {
"prefix": "monsterType:respawnTypeIsUnderground()",
"body": [
"${1:monsterType}:respawnTypeIsUnderground(${2:})"
],
},
"monsterType:addSound": {
"prefix": "monsterType:addSound(soundId)",
"body": [
"${1:monsterType}:addSound(${2:soundId})"
],
},
"monsterType:getSounds": {
"prefix": "monsterType:getSounds()",
"body": [
"${1:monsterType}:getSounds(${2:})"
],
},
"mount:getName": {
"prefix": "mount:getName()",
"body": [
"${1:mount}:getName(${2:})"
],
},
"mount:getId": {
"prefix": "mount:getId()",
"body": [
"${1:mount}:getId(${2:})"
],
},
"mount:getClientId": {
"prefix": "mount:getClientId()",
"body": [
"${1:mount}:getClientId(${2:})"
],
},
"mount:getSpeed": {
"prefix": "mount:getSpeed()",
"body": [
"${1:mount}:getSpeed(${2:})"
],
},
"moveevent:type": {
"prefix": "moveevent:type(callback)",
"body": [
"${1:moveevent}:type(${2:callback})"
],
},
"moveevent:register": {
"prefix": "moveevent:register()",
"body": [
"${1:moveevent}:register(${2:})"
],
},
"moveevent:slot": {
"prefix": "moveevent:slot(slot)",
"body": [
"${1:moveevent}:slot(${2:slot})"
],
},
"moveevent:level": {
"prefix": "moveevent:level(lvl)",
"body": [
"${1:moveevent}:level(${2:lvl})"
],
},
"moveevent:magicLevel": {
"prefix": "moveevent:magicLevel(lvl)",
"body": [
"${1:moveevent}:magicLevel(${2:lvl})"
],
},
"moveevent:premium": {
"prefix": "moveevent:premium(bool)",
"body": [
"${1:moveevent}:premium(${2:bool})"
],
},
"moveevent:vocation": {
"prefix": "moveevent:vocation(vocName[, showInDescription = false, lastVoc = false])",
"body": [
"${1:moveevent}:vocation(${2:vocName[}, ${3:showInDescription = false}, ${4:lastVoc = false]})"
],
},
"moveevent:id": {
"prefix": "moveevent:id(ids)",
"body": [
"${1:moveevent}:id(${2:ids})"
],
},
"moveevent:aid": {
"prefix": "moveevent:aid(ids)",
"body": [
"${1:moveevent}:aid(${2:ids})"
],
},
"moveevent:uid": {
"prefix": "moveevent:uid(ids)",
"body": [
"${1:moveevent}:uid(${2:ids})"
],
},
"moveevent:position": {
"prefix": "moveevent:position(positions)",
"body": [
"${1:moveevent}:position(${2:positions})"
],
},
"networkMessage:getByte": {
"prefix": "networkMessage:getByte()",
"body": [
"${1:networkMessage}:getByte(${2:})"
],
},
"networkMessage:getU16": {
"prefix": "networkMessage:getU16()",
"body": [
"${1:networkMessage}:getU16(${2:})"
],
},
"networkMessage:getU32": {
"prefix": "networkMessage:getU32()",
"body": [
"${1:networkMessage}:getU32(${2:})"
],
},
"networkMessage:getU64": {
"prefix": "networkMessage:getU64()",
"body": [
"${1:networkMessage}:getU64(${2:})"
],
},
"networkMessage:getString": {
"prefix": "networkMessage:getString()",
"body": [
"${1:networkMessage}:getString(${2:})"
],
},
"networkMessage:getPosition": {
"prefix": "networkMessage:getPosition()",
"body": [
"${1:networkMessage}:getPosition(${2:})"
],
},
"networkMessage:addByte": {
"prefix": "networkMessage:addByte(number)",
"body": [
"${1:networkMessage}:addByte(${2:number})"
],
},
"networkMessage:addU16": {
"prefix": "networkMessage:addU16(number)",
"body": [
"${1:networkMessage}:addU16(${2:number})"
],
},
"networkMessage:addU32": {
"prefix": "networkMessage:addU32(number)",
"body": [
"${1:networkMessage}:addU32(${2:number})"
],
},
"networkMessage:addU64": {
"prefix": "networkMessage:addU64(number)",
"body": [
"${1:networkMessage}:addU64(${2:number})"
],
},
"networkMessage:add8": {
"prefix": "networkMessage:add8(number)",
"body": [
"${1:networkMessage}:add8(${2:number})"
],
},
"networkMessage:add16": {
"prefix": "networkMessage:add16(number)",
"body": [
"${1:networkMessage}:add16(${2:number})"
],
},
"networkMessage:add32": {
"prefix": "networkMessage:add32(number)",
"body": [
"${1:networkMessage}:add32(${2:number})"
],
},
"networkMessage:add64": {
"prefix": "networkMessage:add64(number)",
"body": [
"${1:networkMessage}:add64(${2:number})"
],
},
"networkMessage:addString": {
"prefix": "networkMessage:addString(string)",
"body": [
"${1:networkMessage}:addString(${2:string})"
],
},
"networkMessage:addPosition": {
"prefix": "networkMessage:addPosition(position)",
"body": [
"${1:networkMessage}:addPosition(${2:position})"
],
},
"networkMessage:addDouble": {
"prefix": "networkMessage:addDouble(number)",
"body": [
"${1:networkMessage}:addDouble(${2:number})"
],
},
"networkMessage:addItem": {
"prefix": "networkMessage:addItem(item, player)",
"body": [
"${1:networkMessage}:addItem(${2:item}, ${3:player})"
],
},
"networkMessage:reset": {
"prefix": "networkMessage:reset()",
"body": [
"${1:networkMessage}:reset(${2:})"
],
},
"networkMessage:skipBytes": {
"prefix": "networkMessage:skipBytes(number)",
"body": [
"${1:networkMessage}:skipBytes(${2:number})"
],
},
"networkMessage:sendToPlayer": {
"prefix": "networkMessage:sendToPlayer(player)",
"body": [
"${1:networkMessage}:sendToPlayer(${2:player})"
],
},
"npc:isNpc": {
"prefix": "npc:isNpc()",
"body": [
"${1:npc}:isNpc(${2:})"
],
},
"npc:setMasterPos": {
"prefix": "npc:setMasterPos(pos)",
"body": [
"${1:npc}:setMasterPos(${2:pos})"
],
},
"npc:getCurrency": {
"prefix": "npc:getCurrency()",
"body": [
"${1:npc}:getCurrency(${2:})"
],
},
"npc:getCurrency": {
"prefix": "npc:getCurrency()",
"body": [
"${1:npc}:getCurrency(${2:})"
],
},
"npc:getSpeechBubble": {
"prefix": "npc:getSpeechBubble()",
"body": [
"${1:npc}:getSpeechBubble(${2:})"
],
},
"npc:setSpeechBubble": {
"prefix": "npc:setSpeechBubble(speechBubble)",
"body": [
"${1:npc}:setSpeechBubble(${2:speechBubble})"
],
},
"npc:getName": {
"prefix": "npc:getName()",
"body": [
"${1:npc}:getName(${2:})"
],
},
"npc:setName": {
"prefix": "npc:setName(name)",
"body": [
"${1:npc}:setName(${2:name})"
],
},
"npc:place": {
"prefix": "npc:place(position[, extended = false[, force = true]])",
"body": [
"${1:npc}:place(${2:position[}, ${3:extended = false[}, ${4:force = true]]})"
],
},
"npc:say": {
"prefix": "npc:say(text[, type = TALKTYPE_PRIVATE_NP[, ghost = false[, target = nullptr[, position]]]])",
"body": [
"${1:npc}:say(${2:text[}, ${3:type = TALKTYPE_PRIVATE_NP[}, ${4:ghost = false[}, ${5:target = nullptr[}, ${6:position]]]]})"
],
},
"npc:turnToCreature": {
"prefix": "npc:turnToCreature(creature, true)",
"body": [
"${1:npc}:turnToCreature(${2:creature}, ${3:true})"
],
},
"npc:setPlayerInteraction": {
"prefix": "npc:setPlayerInteraction(creature, topic = 0)",
"body": [
"${1:npc}:setPlayerInteraction(${2:creature}, ${3:topic = 0})"
],
},
"npc:removePlayerInteraction": {
"prefix": "npc:removePlayerInteraction()",
"body": [
"${1:npc}:removePlayerInteraction(${2:})"
],
},
"npc:isInteractingWithPlayer": {
"prefix": "npc:isInteractingWithPlayer(creature)",
"body": [
"${1:npc}:isInteractingWithPlayer(${2:creature})"
],
},
"npc:isPlayerInteractingOnTopic": {
"prefix": "npc:isPlayerInteractingOnTopic(creature, topicId = 0)",
"body": [
"${1:npc}:isPlayerInteractingOnTopic(${2:creature}, ${3:topicId = 0})"
],
},
"npc:isInTalkRange": {
"prefix": "npc:isInTalkRange()",
"body": [
"${1:npc}:isInTalkRange(${2:})"
],
},
"npc:openShopWindow": {
"prefix": "npc:openShopWindow(player)",
"body": [
"${1:npc}:openShopWindow(${2:player})"
],
},
"npc:closeShopWindow": {
"prefix": "npc:closeShopWindow(player)",
"body": [
"${1:npc}:closeShopWindow(${2:player})"
],
},
"npc:isMerchant": {
"prefix": "npc:isMerchant()",
"body": [
"${1:npc}:isMerchant(${2:})"
],
},
"npc:getShopItem": {
"prefix": "npc:getShopItem(itemId)",
"body": [
"${1:npc}:getShopItem(${2:itemId})"
],
},
"npc:move": {
"prefix": "npc:move(direction)",
"body": [
"${1:npc}:move(${2:direction})"
],
},
"npc:turn": {
"prefix": "npc:turn(direction)",
"body": [
"${1:npc}:turn(${2:direction})"
],
},
"npc:follow": {
"prefix": "npc:follow(player)",
"body": [
"${1:npc}:follow(${2:player})"
],
},
"npc:getId": {
"prefix": "npc:getId()",
"body": [
"${1:npc}:getId(${2:})"
],
},
"npc:sellItem": {
"prefix": "npc:sellItem(player, itemid, amount, <optional: default: 1> subtype, <optional: default: 0> actionid, <optional: default: false> ignoreCap, <optional: default: false> inBackpacks)",
"body": [
"${1:npc}:sellItem(${2:player}, ${3:itemid}, ${4:amount}, ${5:<optional: default: 1> subtype}, ${6:<optional: default: 0> actionid}, ${7:<optional: default: false> ignoreCap}, ${8:<optional: default: false> inBackpacks})"
],
},
"npc:getDistanceTo": {
"prefix": "npc:getDistanceTo(uid)",
"body": [
"${1:npc}:getDistanceTo(${2:uid})"
],
},
"monsterType:canSpawn": {
"prefix": "monsterType:canSpawn(pos)",
"body": [
"${1:monsterType}:canSpawn(${2:pos})"
],
},
"npcType:addShopItem": {
"prefix": "npcType:addShopItem(shop)",
"body": [
"${1:npcType}:addShopItem(${2:shop})"
],
},
"npcType:addVoice": {
"prefix": "npcType:addVoice(sentence, interval, chance, yell)",
"body": [
"${1:npcType}:addVoice(${2:sentence}, ${3:interval}, ${4:chance}, ${5:yell})"
],
},
"npcType:getVoices": {
"prefix": "npcType:getVoices()",
"body": [
"${1:npcType}:getVoices(${2:})"
],
},
"npcType:getCreatureEvents": {
"prefix": "npcType:getCreatureEvents()",
"body": [
"${1:npcType}:getCreatureEvents(${2:})"
],
},
"npcType:registerEvent": {
"prefix": "npcType:registerEvent(name)",
"body": [
"${1:npcType}:registerEvent(${2:name})"
],
},
"npcType:onThink": {
"prefix": "npcType:onThink(callback)",
"body": [
"${1:npcType}:onThink(${2:callback})"
],
},
"npcType:onAppear": {
"prefix": "npcType:onAppear(callback)",
"body": [
"${1:npcType}:onAppear(${2:callback})"
],
},
"npcType:onDisappear": {
"prefix": "npcType:onDisappear(callback)",
"body": [
"${1:npcType}:onDisappear(${2:callback})"
],
},
"npcType:onMove": {
"prefix": "npcType:onMove(callback)",
"body": [
"${1:npcType}:onMove(${2:callback})"
],
},
"npcType:onSay": {
"prefix": "npcType:onSay(callback)",
"body": [
"${1:npcType}:onSay(${2:callback})"
],
},
"npcType:onBuyItem": {
"prefix": "npcType:onBuyItem(callback)",
"body": [
"${1:npcType}:onBuyItem(${2:callback})"
],
},
"npcType:onSellItem": {
"prefix": "npcType:onSellItem(callback)",
"body": [
"${1:npcType}:onSellItem(${2:callback})"
],
},
"npcType:onCheckItem": {
"prefix": "npcType:onCheckItem(callback)",
"body": [
"${1:npcType}:onCheckItem(${2:callback})"
],
},
"npcType:eventType": {
"prefix": "npcType:eventType(event)",
"body": [
"${1:npcType}:eventType(${2:event})"
],
},
"npcType:getBaseSpeed": {
"prefix": "npcType:getBaseSpeed()",
"body": [
"${1:npcType}:getBaseSpeed(${2:})"
],
},
"npcType:respawnTypePeriod": {
"prefix": "npcType:respawnTypePeriod()",
"body": [
"${1:npcType}:respawnTypePeriod(${2:})"
],
},
"npcType:respawnTypeIsUnderground": {
"prefix": "npcType:respawnTypeIsUnderground()",
"body": [
"${1:npcType}:respawnTypeIsUnderground(${2:})"
],
},
"npcType:addSound": {
"prefix": "npcType:addSound(soundId)",
"body": [
"${1:npcType}:addSound(${2:soundId})"
],
},
"npcType:getSounds": {
"prefix": "npcType:getSounds()",
"body": [
"${1:npcType}:getSounds(${2:})"
],
},
"party:disband": {
"prefix": "party:disband()",
"body": [
"${1:party}:disband(${2:})"
],
},
"party:getLeader": {
"prefix": "party:getLeader()",
"body": [
"${1:party}:getLeader(${2:})"
],
},
"party:setLeader": {
"prefix": "party:setLeader(player)",
"body": [
"${1:party}:setLeader(${2:player})"
],
},
"party:getMembers": {
"prefix": "party:getMembers()",
"body": [
"${1:party}:getMembers(${2:})"
],
},
"party:getMemberCount": {
"prefix": "party:getMemberCount()",
"body": [
"${1:party}:getMemberCount(${2:})"
],
},
"party:getInvitees": {
"prefix": "party:getInvitees()",
"body": [
"${1:party}:getInvitees(${2:})"
],
},
"party:getInviteeCount": {
"prefix": "party:getInviteeCount()",
"body": [
"${1:party}:getInviteeCount(${2:})"
],
},
"party:addInvite": {
"prefix": "party:addInvite(player)",
"body": [
"${1:party}:addInvite(${2:player})"
],
},
"party:removeInvite": {
"prefix": "party:removeInvite(player)",
"body": [
"${1:party}:removeInvite(${2:player})"
],
},
"party:addMember": {
"prefix": "party:addMember(player)",
"body": [
"${1:party}:addMember(${2:player})"
],
},
"party:removeMember": {
"prefix": "party:removeMember(player)",
"body": [
"${1:party}:removeMember(${2:player})"
],
},
"party:isSharedExperienceActive": {
"prefix": "party:isSharedExperienceActive()",
"body": [
"${1:party}:isSharedExperienceActive(${2:})"
],
},
"party:isSharedExperienceEnabled": {
"prefix": "party:isSharedExperienceEnabled()",
"body": [
"${1:party}:isSharedExperienceEnabled(${2:})"
],
},
"party:shareExperience": {
"prefix": "party:shareExperience(experience)",
"body": [
"${1:party}:shareExperience(${2:experience})"
],
},
"party:setSharedExperience": {
"prefix": "party:setSharedExperience(active)",
"body": [
"${1:party}:setSharedExperience(${2:active})"
],
},
"player:sendInventory": {
"prefix": "player:sendInventory()",
"body": [
"${1:player}:sendInventory(${2:})"
],
},
"player:sendLootStats": {
"prefix": "player:sendLootStats(item, count)",
"body": [
"${1:player}:sendLootStats(${2:item}, ${3:count})"
],
},
"player:updateSupplyTracker": {
"prefix": "player:updateSupplyTracker(item)",
"body": [
"${1:player}:updateSupplyTracker(${2:item})"
],
},
"player:updateKillTracker": {
"prefix": "player:updateKillTracker(creature, corpse)",
"body": [
"${1:player}:updateKillTracker(${2:creature}, ${3:corpse})"
],
},
"player:resetCharmsBestiary": {
"prefix": "player:resetCharmsBestiary()",
"body": [
"${1:player}:resetCharmsBestiary(${2:})"
],
},
"player:unlockAllCharmRunes": {
"prefix": "player:unlockAllCharmRunes()",
"body": [
"${1:player}:unlockAllCharmRunes(${2:})"
],
},
"player:addCharmPoints": {
"prefix": "player:addCharmPoints()",
"body": [
"${1:player}:addCharmPoints(${2:})"
],
},
"player:isPlayer": {
"prefix": "player:isPlayer()",
"body": [
"${1:player}:isPlayer(${2:})"
],
},
"player:getGuid": {
"prefix": "player:getGuid()",
"body": [
"${1:player}:getGuid(${2:})"
],
},
"player:getIp": {
"prefix": "player:getIp()",
"body": [
"${1:player}:getIp(${2:})"
],
},
"player:getAccountId": {
"prefix": "player:getAccountId()",
"body": [
"${1:player}:getAccountId(${2:})"
],
},
"player:getLastLoginSaved": {
"prefix": "player:getLastLoginSaved()",
"body": [
"${1:player}:getLastLoginSaved(${2:})"
],
},
"player:getLastLogout": {
"prefix": "player:getLastLogout()",
"body": [
"${1:player}:getLastLogout(${2:})"
],
},
"player:getAccountType": {
"prefix": "player:getAccountType()",
"body": [
"${1:player}:getAccountType(${2:})"
],
},
"player:setAccountType": {
"prefix": "player:setAccountType(accountType)",
"body": [
"${1:player}:setAccountType(${2:accountType})"
],
},
"player:addBestiaryKill": {
"prefix": "player:addBestiaryKill(name[, amount = 1])",
"body": [
"${1:player}:addBestiaryKill(${2:name[}, ${3:amount = 1]})"
],
},
"player:isMonsterBestiaryUnlocked": {
"prefix": "player:isMonsterBestiaryUnlocked(raceId)",
"body": [
"${1:player}:isMonsterBestiaryUnlocked(${2:raceId})"
],
},
"player:getCharmMonsterType": {
"prefix": "player:getCharmMonsterType(charmRune_t)",
"body": [
"${1:player}:getCharmMonsterType(${2:charmRune_t})"
],
},
"player:removePreyStamina": {
"prefix": "player:removePreyStamina(amount)",
"body": [
"${1:player}:removePreyStamina(${2:amount})"
],
},
"player:addPreyCards": {
"prefix": "player:addPreyCards(amount)",
"body": [
"${1:player}:addPreyCards(${2:amount})"
],
},
"player:getPreyCards": {
"prefix": "player:getPreyCards()",
"body": [
"${1:player}:getPreyCards(${2:})"
],
},
"player:getPreyExperiencePercentage": {
"prefix": "player:getPreyExperiencePercentage(raceId)",
"body": [
"${1:player}:getPreyExperiencePercentage(${2:raceId})"
],
},
"player:removeTaskHuntingPoints": {
"prefix": "player:removeTaskHuntingPoints(amount)",
"body": [
"${1:player}:removeTaskHuntingPoints(${2:amount})"
],
},
"player:getTaskHuntingPoints": {
"prefix": "player:getTaskHuntingPoints()",
"body": [
"${1:player}:getTaskHuntingPoints(${2:})"
],
},
"player:addTaskHuntingPoints": {
"prefix": "player:addTaskHuntingPoints(amount)",
"body": [
"${1:player}:addTaskHuntingPoints(${2:amount})"
],
},
"player:getPreyLootPercentage": {
"prefix": "player:getPreyLootPercentage(raceid)",
"body": [
"${1:player}:getPreyLootPercentage(${2:raceid})"
],
},
"player:getCapacity": {
"prefix": "player:getCapacity()",
"body": [
"${1:player}:getCapacity(${2:})"
],
},
"player:setCapacity": {
"prefix": "player:setCapacity(capacity)",
"body": [
"${1:player}:setCapacity(${2:capacity})"
],
},
"player:setTraining": {
"prefix": "player:setTraining(value)",
"body": [
"${1:player}:setTraining(${2:value})"
],
},
"player:isTraining": {
"prefix": "player:isTraining()",
"body": [
"${1:player}:isTraining(${2:})"
],
},
"player:getFreeCapacity": {
"prefix": "player:getFreeCapacity()",
"body": [
"${1:player}:getFreeCapacity(${2:})"
],
},
"player:getKills": {
"prefix": "player:getKills()",
"body": [
"${1:player}:getKills(${2:})"
],
},
"player:setKills": {
"prefix": "player:setKills(kills)",
"body": [
"${1:player}:setKills(${2:kills})"
],
},
"player:getReward": {
"prefix": "player:getReward(rewardId[, autoCreate = false])",
"body": [
"${1:player}:getReward(${2:rewardId[}, ${3:autoCreate = false]})"
],
},
"player:removeReward": {
"prefix": "player:removeReward(rewardId)",
"body": [
"${1:player}:removeReward(${2:rewardId})"
],
},
"player:getRewardList": {
"prefix": "player:getRewardList()",
"body": [
"${1:player}:getRewardList(${2:})"
],
},
"player:setDailyReward": {
"prefix": "player:setDailyReward(value)",
"body": [
"${1:player}:setDailyReward(${2:value})"
],
},
"player:getDepotLocker": {
"prefix": "player:getDepotLocker(depotId)",
"body": [
"${1:player}:getDepotLocker(${2:depotId})"
],
},
"player:getStashCount": {
"prefix": "player:getStashCount()",
"body": [
"${1:player}:getStashCount(${2:})"
],
},
"player:getDepotChest": {
"prefix": "player:getDepotChest(depotId[, autoCreate = false])",
"body": [
"${1:player}:getDepotChest(${2:depotId[}, ${3:autoCreate = false]})"
],
},
"player:getInbox": {
"prefix": "player:getInbox()",
"body": [
"${1:player}:getInbox(${2:})"
],
},
"player:getSkullTime": {
"prefix": "player:getSkullTime()",
"body": [
"${1:player}:getSkullTime(${2:})"
],
},
"player:setSkullTime": {
"prefix": "player:setSkullTime(skullTime)",
"body": [
"${1:player}:setSkullTime(${2:skullTime})"
],
},
"player:getDeathPenalty": {
"prefix": "player:getDeathPenalty()",
"body": [
"${1:player}:getDeathPenalty(${2:})"
],
},
"player:getExperience": {
"prefix": "player:getExperience()",
"body": [
"${1:player}:getExperience(${2:})"
],
},
"player:addExperience": {
"prefix": "player:addExperience(experience[, sendText = false])",
"body": [
"${1:player}:addExperience(${2:experience[}, ${3:sendText = false]})"
],
},
"player:removeExperience": {
"prefix": "player:removeExperience(experience[, sendText = false])",
"body": [
"${1:player}:removeExperience(${2:experience[}, ${3:sendText = false]})"
],
},
"player:getLevel": {
"prefix": "player:getLevel()",
"body": [
"${1:player}:getLevel(${2:})"
],
},
"player:getMagicLevel": {
"prefix": "player:getMagicLevel()",
"body": [
"${1:player}:getMagicLevel(${2:})"
],
},
"player:getBaseMagicLevel": {
"prefix": "player:getBaseMagicLevel()",
"body": [
"${1:player}:getBaseMagicLevel(${2:})"
],
},
"player:getMana": {
"prefix": "player:getMana()",
"body": [
"${1:player}:getMana(${2:})"
],
},
"player:addMana": {
"prefix": "player:addMana(manaChange[, animationOnLoss = false])",
"body": [
"${1:player}:addMana(${2:manaChange[}, ${3:animationOnLoss = false]})"
],
},
"player:getMaxMana": {
"prefix": "player:getMaxMana()",
"body": [
"${1:player}:getMaxMana(${2:})"
],
},
"player:setMaxMana": {
"prefix": "player:setMaxMana(maxMana)",
"body": [
"${1:player}:setMaxMana(${2:maxMana})"
],
},
"player:getManaSpent": {
"prefix": "player:getManaSpent()",
"body": [
"${1:player}:getManaSpent(${2:})"
],
},
"player:addManaSpent": {
"prefix": "player:addManaSpent(amount)",
"body": [
"${1:player}:addManaSpent(${2:amount})"
],
},
"player:getBaseMaxHealth": {
"prefix": "player:getBaseMaxHealth()",
"body": [
"${1:player}:getBaseMaxHealth(${2:})"
],
},
"player:getBaseMaxMana": {
"prefix": "player:getBaseMaxMana()",
"body": [
"${1:player}:getBaseMaxMana(${2:})"
],
},
"player:getSkillLevel": {
"prefix": "player:getSkillLevel(skillType)",
"body": [
"${1:player}:getSkillLevel(${2:skillType})"
],
},
"player:getEffectiveSkillLevel": {
"prefix": "player:getEffectiveSkillLevel(skillType)",
"body": [
"${1:player}:getEffectiveSkillLevel(${2:skillType})"
],
},
"player:getSkillPercent": {
"prefix": "player:getSkillPercent(skillType)",
"body": [
"${1:player}:getSkillPercent(${2:skillType})"
],
},
"player:getSkillTries": {
"prefix": "player:getSkillTries(skillType)",
"body": [
"${1:player}:getSkillTries(${2:skillType})"
],
},
"player:addSkillTries": {
"prefix": "player:addSkillTries(skillType, tries)",
"body": [
"${1:player}:addSkillTries(${2:skillType}, ${3:tries})"
],
},
"player:setMagicLevel": {
"prefix": "player:setMagicLevel(level[, manaSpent])",
"body": [
"${1:player}:setMagicLevel(${2:level[}, ${3:manaSpent]})"
],
},
"player:setSkillLevel": {
"prefix": "player:setSkillLevel(skillType, level[, tries])",
"body": [
"${1:player}:setSkillLevel(${2:skillType}, ${3:level[}, ${4:tries]})"
],
},
"player:addOfflineTrainingTime": {
"prefix": "player:addOfflineTrainingTime(time)",
"body": [
"${1:player}:addOfflineTrainingTime(${2:time})"
],
},
"player:getOfflineTrainingTime": {
"prefix": "player:getOfflineTrainingTime()",
"body": [
"${1:player}:getOfflineTrainingTime(${2:})"
],
},
"player:removeOfflineTrainingTime": {
"prefix": "player:removeOfflineTrainingTime(time)",
"body": [
"${1:player}:removeOfflineTrainingTime(${2:time})"
],
},
"player:addOfflineTrainingTries": {
"prefix": "player:addOfflineTrainingTries(skillType, tries)",
"body": [
"${1:player}:addOfflineTrainingTries(${2:skillType}, ${3:tries})"
],
},
"player:getOfflineTrainingSkill": {
"prefix": "player:getOfflineTrainingSkill()",
"body": [
"${1:player}:getOfflineTrainingSkill(${2:})"
],
},
"player:setOfflineTrainingSkill": {
"prefix": "player:setOfflineTrainingSkill(skillId)",
"body": [
"${1:player}:setOfflineTrainingSkill(${2:skillId})"
],
},
"player:openStash": {
"prefix": "player:openStash(isNpc)",
"body": [
"${1:player}:openStash(${2:isNpc})"
],
},
"player:getItemCount": {
"prefix": "player:getItemCount(itemId[, subType = -1])",
"body": [
"${1:player}:getItemCount(${2:itemId[}, ${3:subType = -1]})"
],
},
"player:getStashItemCount": {
"prefix": "player:getStashItemCount(itemId)",
"body": [
"${1:player}:getStashItemCount(${2:itemId})"
],
},
"player:getItemById": {
"prefix": "player:getItemById(itemId, deepSearch[, subType = -1])",
"body": [
"${1:player}:getItemById(${2:itemId}, ${3:deepSearch[}, ${4:subType = -1]})"
],
},
"player:getVocation": {
"prefix": "player:getVocation()",
"body": [
"${1:player}:getVocation(${2:})"
],
},
"player:setVocation": {
"prefix": "player:setVocation(id or name or userdata)",
"body": [
"${1:player}:setVocation(${2:id or name or userdata})"
],
},
"player:getSex": {
"prefix": "player:getSex()",
"body": [
"${1:player}:getSex(${2:})"
],
},
"player:setSex": {
"prefix": "player:setSex(newSex)",
"body": [
"${1:player}:setSex(${2:newSex})"
],
},
"player:getTown": {
"prefix": "player:getTown()",
"body": [
"${1:player}:getTown(${2:})"
],
},
"player:setTown": {
"prefix": "player:setTown(town)",
"body": [
"${1:player}:setTown(${2:town})"
],
},
"player:getGuild": {
"prefix": "player:getGuild()",
"body": [
"${1:player}:getGuild(${2:})"
],
},
"player:setGuild": {
"prefix": "player:setGuild(guild)",
"body": [
"${1:player}:setGuild(${2:guild})"
],
},
"player:getGuildLevel": {
"prefix": "player:getGuildLevel()",
"body": [
"${1:player}:getGuildLevel(${2:})"
],
},
"player:setGuildLevel": {
"prefix": "player:setGuildLevel(level)",
"body": [
"${1:player}:setGuildLevel(${2:level})"
],
},
"player:getGuildNick": {
"prefix": "player:getGuildNick()",
"body": [
"${1:player}:getGuildNick(${2:})"
],
},
"player:setGuildNick": {
"prefix": "player:setGuildNick(nick)",
"body": [
"${1:player}:setGuildNick(${2:nick})"
],
},
"player:getGroup": {
"prefix": "player:getGroup()",
"body": [
"${1:player}:getGroup(${2:})"
],
},
"player:setGroup": {
"prefix": "player:setGroup(group)",
"body": [
"${1:player}:setGroup(${2:group})"
],
},
"player:setSpecialContainersAvailable": {
"prefix": "player:setSpecialContainersAvailable(stashMenu, marketMenu, depotSearchMenu)",
"body": [
"${1:player}:setSpecialContainersAvailable(${2:stashMenu}, ${3:marketMenu}, ${4:depotSearchMenu})"
],
},
"player:getStamina": {
"prefix": "player:getStamina()",
"body": [
"${1:player}:getStamina(${2:})"
],
},
"player:setStamina": {
"prefix": "player:setStamina(stamina)",
"body": [
"${1:player}:setStamina(${2:stamina})"
],
},
"player:getSoul": {
"prefix": "player:getSoul()",
"body": [
"${1:player}:getSoul(${2:})"
],
},
"player:addSoul": {
"prefix": "player:addSoul(soulChange)",
"body": [
"${1:player}:addSoul(${2:soulChange})"
],
},
"player:getMaxSoul": {
"prefix": "player:getMaxSoul()",
"body": [
"${1:player}:getMaxSoul(${2:})"
],
},
"player:getBankBalance": {
"prefix": "player:getBankBalance()",
"body": [
"${1:player}:getBankBalance(${2:})"
],
},
"player:setBankBalance": {
"prefix": "player:setBankBalance(bankBalance)",
"body": [
"${1:player}:setBankBalance(${2:bankBalance})"
],
},
"player:getStorageValue": {
"prefix": "player:getStorageValue(key)",
"body": [
"${1:player}:getStorageValue(${2:key})"
],
},
"player:setStorageValue": {
"prefix": "player:setStorageValue(key, value)",
"body": [
"${1:player}:setStorageValue(${2:key}, ${3:value})"
],
},
"player:addItem": {
"prefix": "player:addItem(itemId, count = 1, canDropOnMap = true, subType = 1, slot = CONST_SLOT_WHEREEVER, tier = 0)",
"body": [
"${1:player}:addItem(${2:itemId}, ${3:count = 1}, ${4:canDropOnMap = true}, ${5:subType = 1}, ${6:slot = CONST_SLOT_WHEREEVER}, ${7:tier = 0})"
],
},
"player:addItemEx": {
"prefix": "player:addItemEx(item[, canDropOnMap = false[, index = INDEX_WHEREEVER[, flags = 0]]])",
"body": [
"${1:player}:addItemEx(${2:item[}, ${3:canDropOnMap = false[}, ${4:index = INDEX_WHEREEVER[}, ${5:flags = 0]]]})"
],
},
"player:addItemEx": {
"prefix": "player:addItemEx(item[, canDropOnMap = true[, slot = CONST_SLOT_WHEREEVER]])",
"body": [
"${1:player}:addItemEx(${2:item[}, ${3:canDropOnMap = true[}, ${4:slot = CONST_SLOT_WHEREEVER]]})"
],
},
"player:removeStashItem": {
"prefix": "player:removeStashItem(itemId, count)",
"body": [
"${1:player}:removeStashItem(${2:itemId}, ${3:count})"
],
},
"player:removeItem": {
"prefix": "player:removeItem(itemId, count[, subType = -1[, ignoreEquipped = false]])",
"body": [
"${1:player}:removeItem(${2:itemId}, ${3:count[}, ${4:subType = -1[}, ${5:ignoreEquipped = false]]})"
],
},
"player:sendContainer": {
"prefix": "player:sendContainer(container)",
"body": [
"${1:player}:sendContainer(${2:container})"
],
},
"player:getMoney": {
"prefix": "player:getMoney()",
"body": [
"${1:player}:getMoney(${2:})"
],
},
"player:addMoney": {
"prefix": "player:addMoney(money)",
"body": [
"${1:player}:addMoney(${2:money})"
],
},
"player:removeMoney": {
"prefix": "player:removeMoney(money[, flags = 0[, useBank = true]])",
"body": [
"${1:player}:removeMoney(${2:money[}, ${3:flags = 0[}, ${4:useBank = true]]})"
],
},
"player:showTextDialog": {
"prefix": "player:showTextDialog(id or name or userdata[, text[, canWrite[, length]]])",
"body": [
"${1:player}:showTextDialog(${2:id or name or userdata[}, ${3:text[}, ${4:canWrite[}, ${5:length]]]})"
],
},
"player:sendTextMessage": {
"prefix": "player:sendTextMessage(type, text[, position, primaryValue = 0, primaryColor = TEXTCOLOR_NONE[, secondaryValue = 0, secondaryColor = TEXTCOLOR_NONE]])",
"body": [
"${1:player}:sendTextMessage(${2:type}, ${3:text[}, ${4:position}, ${5:primaryValue = 0}, ${6:primaryColor = TEXTCOLOR_NONE[}, ${7:secondaryValue = 0}, ${8:secondaryColor = TEXTCOLOR_NONE]]})"
],
},
"player:sendTextMessage": {
"prefix": "player:sendTextMessage(type, text, channelId)",
"body": [
"${1:player}:sendTextMessage(${2:type}, ${3:text}, ${4:channelId})"
],
},
"player:sendChannelMessage": {
"prefix": "player:sendChannelMessage(author, text, type, channelId)",
"body": [
"${1:player}:sendChannelMessage(${2:author}, ${3:text}, ${4:type}, ${5:channelId})"
],
},
"player:sendPrivateMessage": {
"prefix": "player:sendPrivateMessage(speaker, text[, type])",
"body": [
"${1:player}:sendPrivateMessage(${2:speaker}, ${3:text[}, ${4:type]})"
],
},
"player:channelSay": {
"prefix": "player:channelSay(speaker, type, text, channelId)",
"body": [
"${1:player}:channelSay(${2:speaker}, ${3:type}, ${4:text}, ${5:channelId})"
],
},
"player:openChannel": {
"prefix": "player:openChannel(channelId)",
"body": [
"${1:player}:openChannel(${2:channelId})"
],
},
"player:getSlotItem": {
"prefix": "player:getSlotItem(slot)",
"body": [
"${1:player}:getSlotItem(${2:slot})"
],
},
"player:getParty": {
"prefix": "player:getParty()",
"body": [
"${1:player}:getParty(${2:})"
],
},
"player:addOutfit": {
"prefix": "player:addOutfit(lookType)",
"body": [
"${1:player}:addOutfit(${2:lookType})"
],
},
"player:addOutfitAddon": {
"prefix": "player:addOutfitAddon(lookType, addon)",
"body": [
"${1:player}:addOutfitAddon(${2:lookType}, ${3:addon})"
],
},
"player:removeOutfit": {
"prefix": "player:removeOutfit(lookType)",
"body": [
"${1:player}:removeOutfit(${2:lookType})"
],
},
"player:removeOutfitAddon": {
"prefix": "player:removeOutfitAddon(lookType, addon)",
"body": [
"${1:player}:removeOutfitAddon(${2:lookType}, ${3:addon})"
],
},
"player:hasOutfit": {
"prefix": "player:hasOutfit(lookType[, addon = 0])",
"body": [
"${1:player}:hasOutfit(${2:lookType[}, ${3:addon = 0]})"
],
},
"player:sendOutfitWindow": {
"prefix": "player:sendOutfitWindow()",
"body": [
"${1:player}:sendOutfitWindow(${2:})"
],
},
"player:addMount": {
"prefix": "player:addMount(mountId or mountName)",
"body": [
"${1:player}:addMount(${2:mountId or mountName})"
],
},
"player:removeMount": {
"prefix": "player:removeMount(mountId or mountName)",
"body": [
"${1:player}:removeMount(${2:mountId or mountName})"
],
},
"player:hasMount": {
"prefix": "player:hasMount(mountId or mountName)",
"body": [
"${1:player}:hasMount(${2:mountId or mountName})"
],
},
"player:addFamiliar": {
"prefix": "player:addFamiliar(lookType)",
"body": [
"${1:player}:addFamiliar(${2:lookType})"
],
},
"player:removeFamiliar": {
"prefix": "player:removeFamiliar(lookType)",
"body": [
"${1:player}:removeFamiliar(${2:lookType})"
],
},
"player:hasFamiliar": {
"prefix": "player:hasFamiliar(lookType)",
"body": [
"${1:player}:hasFamiliar(${2:lookType})"
],
},
"player:setFamiliarLooktype": {
"prefix": "player:setFamiliarLooktype(lookType)",
"body": [
"${1:player}:setFamiliarLooktype(${2:lookType})"
],
},
"player:getFamiliarLooktype": {
"prefix": "player:getFamiliarLooktype()",
"body": [
"${1:player}:getFamiliarLooktype(${2:})"
],
},
"player:getPremiumDays": {
"prefix": "player:getPremiumDays()",
"body": [
"${1:player}:getPremiumDays(${2:})"
],
},
"player:addPremiumDays": {
"prefix": "player:addPremiumDays(days)",
"body": [
"${1:player}:addPremiumDays(${2:days})"
],
},
"player:removePremiumDays": {
"prefix": "player:removePremiumDays(days)",
"body": [
"${1:player}:removePremiumDays(${2:days})"
],
},
"player:getTibiaCoins": {
"prefix": "player:getTibiaCoins()",
"body": [
"${1:player}:getTibiaCoins(${2:})"
],
},
"player:addTibiaCoins": {
"prefix": "player:addTibiaCoins(coins)",
"body": [
"${1:player}:addTibiaCoins(${2:coins})"
],
},
"player:removeTibiaCoins": {
"prefix": "player:removeTibiaCoins(coins)",
"body": [
"${1:player}:removeTibiaCoins(${2:coins})"
],
},
"player:getTransferableCoins": {
"prefix": "player:getTransferableCoins()",
"body": [
"${1:player}:getTransferableCoins(${2:})"
],
},
"player:addTransferableCoins": {
"prefix": "player:addTransferableCoins(coins)",
"body": [
"${1:player}:addTransferableCoins(${2:coins})"
],
},
"player:removeTransferableCoins": {
"prefix": "player:removeTransferableCoins(coins)",
"body": [
"${1:player}:removeTransferableCoins(${2:coins})"
],
},
"player:hasBlessing": {
"prefix": "player:hasBlessing(blessing)",
"body": [
"${1:player}:hasBlessing(${2:blessing})"
],
},
"player:addBlessing": {
"prefix": "player:addBlessing(blessing)",
"body": [
"${1:player}:addBlessing(${2:blessing})"
],
},
"player:removeBlessing": {
"prefix": "player:removeBlessing(blessing)",
"body": [
"${1:player}:removeBlessing(${2:blessing})"
],
},
"player:getBlessingCount": {
"prefix": "player:getBlessingCount(index)",
"body": [
"${1:player}:getBlessingCount(${2:index})"
],
},
"player:canLearnSpell": {
"prefix": "player:canLearnSpell(spellName)",
"body": [
"${1:player}:canLearnSpell(${2:spellName})"
],
},
"player:learnSpell": {
"prefix": "player:learnSpell(spellName)",
"body": [
"${1:player}:learnSpell(${2:spellName})"
],
},
"player:forgetSpell": {
"prefix": "player:forgetSpell(spellName)",
"body": [
"${1:player}:forgetSpell(${2:spellName})"
],
},
"player:hasLearnedSpell": {
"prefix": "player:hasLearnedSpell(spellName)",
"body": [
"${1:player}:hasLearnedSpell(${2:spellName})"
],
},
"player:sendTutorial": {
"prefix": "player:sendTutorial(tutorialId)",
"body": [
"${1:player}:sendTutorial(${2:tutorialId})"
],
},
"player:openImbuementWindow": {
"prefix": "player:openImbuementWindow(item)",
"body": [
"${1:player}:openImbuementWindow(${2:item})"
],
},
"player:closeImbuementWindow": {
"prefix": "player:closeImbuementWindow()",
"body": [
"${1:player}:closeImbuementWindow(${2:})"
],
},
"player:addMapMark": {
"prefix": "player:addMapMark(position, type, description)",
"body": [
"${1:player}:addMapMark(${2:position}, ${3:type}, ${4:description})"
],
},
"player:save": {
"prefix": "player:save()",
"body": [
"${1:player}:save(${2:})"
],
},
"player:popupFYI": {
"prefix": "player:popupFYI(message)",
"body": [
"${1:player}:popupFYI(${2:message})"
],
},
"player:isPzLocked": {
"prefix": "player:isPzLocked()",
"body": [
"${1:player}:isPzLocked(${2:})"
],
},
"player:getClient": {
"prefix": "player:getClient()",
"body": [
"${1:player}:getClient(${2:})"
],
},
"player:getHouse": {
"prefix": "player:getHouse()",
"body": [
"${1:player}:getHouse(${2:})"
],
},
"player:sendHouseWindow": {
"prefix": "player:sendHouseWindow(house, listId)",
"body": [
"${1:player}:sendHouseWindow(${2:house}, ${3:listId})"
],
},
"player:setEditHouse": {
"prefix": "player:setEditHouse(house, listId)",
"body": [
"${1:player}:setEditHouse(${2:house}, ${3:listId})"
],
},
"player:setGhostMode": {
"prefix": "player:setGhostMode(enabled)",
"body": [
"${1:player}:setGhostMode(${2:enabled})"
],
},
"player:getContainerId": {
"prefix": "player:getContainerId(container)",
"body": [
"${1:player}:getContainerId(${2:container})"
],
},
"player:getContainerById": {
"prefix": "player:getContainerById(id)",
"body": [
"${1:player}:getContainerById(${2:id})"
],
},
"player:getContainerIndex": {
"prefix": "player:getContainerIndex(id)",
"body": [
"${1:player}:getContainerIndex(${2:id})"
],
},
"player:getInstantSpells": {
"prefix": "player:getInstantSpells()",
"body": [
"${1:player}:getInstantSpells(${2:})"
],
},
"player:canCast": {
"prefix": "player:canCast(spell)",
"body": [
"${1:player}:canCast(${2:spell})"
],
},
"player:hasChaseMode": {
"prefix": "player:hasChaseMode()",
"body": [
"${1:player}:hasChaseMode(${2:})"
],
},
"player:hasSecureMode": {
"prefix": "player:hasSecureMode()",
"body": [
"${1:player}:hasSecureMode(${2:})"
],
},
"player:getFightMode": {
"prefix": "player:getFightMode()",
"body": [
"${1:player}:getFightMode(${2:})"
],
},
"player:getBaseXpGain": {
"prefix": "player:getBaseXpGain()",
"body": [
"${1:player}:getBaseXpGain(${2:})"
],
},
"player:setBaseXpGain": {
"prefix": "player:setBaseXpGain(value)",
"body": [
"${1:player}:setBaseXpGain(${2:value})"
],
},
"player:getVoucherXpBoost": {
"prefix": "player:getVoucherXpBoost()",
"body": [
"${1:player}:getVoucherXpBoost(${2:})"
],
},
"player:setVoucherXpBoost": {
"prefix": "player:setVoucherXpBoost(value)",
"body": [
"${1:player}:setVoucherXpBoost(${2:value})"
],
},
"player:getGrindingXpBoost": {
"prefix": "player:getGrindingXpBoost()",
"body": [
"${1:player}:getGrindingXpBoost(${2:})"
],
},
"player:setGrindingXpBoost": {
"prefix": "player:setGrindingXpBoost(value)",
"body": [
"${1:player}:setGrindingXpBoost(${2:value})"
],
},
"player:getStoreXpBoost": {
"prefix": "player:getStoreXpBoost()",
"body": [
"${1:player}:getStoreXpBoost(${2:})"
],
},
"player:setStoreXpBoost": {
"prefix": "player:setStoreXpBoost(value)",
"body": [
"${1:player}:setStoreXpBoost(${2:value})"
],
},
"player:getStaminaXpBoost": {
"prefix": "player:getStaminaXpBoost()",
"body": [
"${1:player}:getStaminaXpBoost(${2:})"
],
},
"player:setStaminaXpBoost": {
"prefix": "player:setStaminaXpBoost(value)",
"body": [
"${1:player}:setStaminaXpBoost(${2:value})"
],
},
"player:setExpBoostStamina": {
"prefix": "player:setExpBoostStamina(percent)",
"body": [
"${1:player}:setExpBoostStamina(${2:percent})"
],
},
"player:getExpBoostStamina": {
"prefix": "player:getExpBoostStamina()",
"body": [
"${1:player}:getExpBoostStamina(${2:})"
],
},
"player:getIdleTime": {
"prefix": "player:getIdleTime()",
"body": [
"${1:player}:getIdleTime(${2:})"
],
},
"player:getFreeBackpackSlots": {
"prefix": "player:getFreeBackpackSlots()",
"body": [
"${1:player}:getFreeBackpackSlots(${2:})"
],
},
"player:openMarket": {
"prefix": "player:openMarket()",
"body": [
"${1:player}:openMarket(${2:})"
],
},
"player:openForge": {
"prefix": "player:openForge()",
"body": [
"${1:player}:openForge(${2:})"
],
},
"player:closeForge": {
"prefix": "player:closeForge()",
"body": [
"${1:player}:closeForge(${2:})"
],
},
"player:addForgeDusts": {
"prefix": "player:addForgeDusts(amount)",
"body": [
"${1:player}:addForgeDusts(${2:amount})"
],
},
"player:removeForgeDusts": {
"prefix": "player:removeForgeDusts(amount)",
"body": [
"${1:player}:removeForgeDusts(${2:amount})"
],
},
"player:getForgeDusts": {
"prefix": "player:getForgeDusts()",
"body": [
"${1:player}:getForgeDusts(${2:})"
],
},
"player:setForgeDusts": {
"prefix": "player:setForgeDusts()",
"body": [
"${1:player}:setForgeDusts(${2:})"
],
},
"player:addForgeDustLevel": {
"prefix": "player:addForgeDustLevel(amount)",
"body": [
"${1:player}:addForgeDustLevel(${2:amount})"
],
},
"player:removeForgeDustLevel": {
"prefix": "player:removeForgeDustLevel(amount)",
"body": [
"${1:player}:removeForgeDustLevel(${2:amount})"
],
},
"player:getForgeDustLevel": {
"prefix": "player:getForgeDustLevel()",
"body": [
"${1:player}:getForgeDustLevel(${2:})"
],
},
"player:getForgeSlivers": {
"prefix": "player:getForgeSlivers()",
"body": [
"${1:player}:getForgeSlivers(${2:})"
],
},
"player:getForgeCores": {
"prefix": "player:getForgeCores()",
"body": [
"${1:player}:getForgeCores(${2:})"
],
},
"player:setFaction": {
"prefix": "player:setFaction(factionId)",
"body": [
"${1:player}:setFaction(${2:factionId})"
],
},
"player:getFaction": {
"prefix": "player:getFaction()",
"body": [
"${1:player}:getFaction(${2:})"
],
},
"player:isUIExhausted": {
"prefix": "player:isUIExhausted()",
"body": [
"${1:player}:isUIExhausted(${2:})"
],
},
"player:updateUIExhausted": {
"prefix": "player:updateUIExhausted(exhaustionTime = 250)",
"body": [
"${1:player}:updateUIExhausted(${2:exhaustionTime = 250})"
],
},
"player:sendBosstiaryCooldownTimer": {
"prefix": "player:sendBosstiaryCooldownTimer()",
"body": [
"${1:player}:sendBosstiaryCooldownTimer(${2:})"
],
},
"player:addBosstiaryKill": {
"prefix": "player:addBosstiaryKill(name[, amount = 1])",
"body": [
"${1:player}:addBosstiaryKill(${2:name[}, ${3:amount = 1]})"
],
},
"player:setBossPoints": {
"prefix": "player:setBossPoints()",
"body": [
"${1:player}:setBossPoints(${2:})"
],
},
"player:setRemoveBossTime": {
"prefix": "player:setRemoveBossTime()",
"body": [
"${1:player}:setRemoveBossTime(${2:})"
],
},
"player:getSlotBossId": {
"prefix": "player:getSlotBossId(slotId)",
"body": [
"${1:player}:getSlotBossId(${2:slotId})"
],
},
"player:getBossBonus": {
"prefix": "player:getBossBonus(slotId)",
"body": [
"${1:player}:getBossBonus(${2:slotId})"
],
},
"player:sendSingleSoundEffect": {
"prefix": "player:sendSingleSoundEffect(soundId[, actor = true])",
"body": [
"${1:player}:sendSingleSoundEffect(${2:soundId[}, ${3:actor = true]})"
],
},
"player:sendDoubleSoundEffect": {
"prefix": "player:sendDoubleSoundEffect(mainSoundId, secondarySoundId[, actor = true])",
"body": [
"${1:player}:sendDoubleSoundEffect(${2:mainSoundId}, ${3:secondarySoundId[}, ${4:actor = true]})"
],
},
"player:getName": {
"prefix": "player:getName()",
"body": [
"${1:player}:getName(${2:})"
],
},
"player:hasGroupFlag": {
"prefix": "player:hasGroupFlag(flag)",
"body": [
"${1:player}:hasGroupFlag(${2:flag})"
],
},
"player:setGroupFlag": {
"prefix": "player:setGroupFlag(flag)",
"body": [
"${1:player}:setGroupFlag(${2:flag})"
],
},
"player:removeGroupFlag": {
"prefix": "player:removeGroupFlag(flag)",
"body": [
"${1:player}:removeGroupFlag(${2:flag})"
],
},
"player:setHazardSystemPoints": {
"prefix": "player:setHazardSystemPoints(amount)",
"body": [
"${1:player}:setHazardSystemPoints(${2:amount})"
],
},
"player:getHazardSystemPoints": {
"prefix": "player:getHazardSystemPoints()",
"body": [
"${1:player}:getHazardSystemPoints(${2:})"
],
},
"player:setLoyaltyBonus": {
"prefix": "player:setLoyaltyBonus(amount)",
"body": [
"${1:player}:setLoyaltyBonus(${2:amount})"
],
},
"player:getLoyaltyBonus": {
"prefix": "player:getLoyaltyBonus()",
"body": [
"${1:player}:getLoyaltyBonus(${2:})"
],
},
"player:getLoyaltyPoints": {
"prefix": "player:getLoyaltyPoints()",
"body": [
"${1:player}:getLoyaltyPoints(${2:})"
],
},
"player:getLoyaltyTitle": {
"prefix": "player:getLoyaltyTitle()",
"body": [
"${1:player}:getLoyaltyTitle(${2:})"
],
},
"player:setLoyaltyTitle": {
"prefix": "player:setLoyaltyTitle(name)",
"body": [
"${1:player}:setLoyaltyTitle(${2:name})"
],
},
"player:instantSkillWOD": {
"prefix": "player:instantSkillWOD(name[, value])",
"body": [
"${1:player}:instantSkillWOD(${2:name[}, ${3:value]})"
],
},
"player:upgradeSpellsWORD": {
"prefix": "player:upgradeSpellsWORD([name[, add]])",
"body": [
"${1:player}:upgradeSpellsWORD(${2:[name[}, ${3:add]]})"
],
},
"player:reloadData": {
"prefix": "player:reloadData()",
"body": [
"${1:player}:reloadData(${2:})"
],
},
"player:onThinkWheelOfDestiny": {
"prefix": "player:onThinkWheelOfDestiny([force = false])",
"body": [
"${1:player}:onThinkWheelOfDestiny(${2:[force = false]})"
],
},
"player:avatarTimer": {
"prefix": "player:avatarTimer([value])",
"body": [
"${1:player}:avatarTimer(${2:[value]})"
],
},
"player:getWheelSpellAdditionalArea": {
"prefix": "player:getWheelSpellAdditionalArea(spellname)",
"body": [
"${1:player}:getWheelSpellAdditionalArea(${2:spellname})"
],
},
"player:getWheelSpellAdditionalTarget": {
"prefix": "player:getWheelSpellAdditionalTarget(spellname)",
"body": [
"${1:player}:getWheelSpellAdditionalTarget(${2:spellname})"
],
},
"player:getWheelSpellAdditionalDuration": {
"prefix": "player:getWheelSpellAdditionalDuration(spellname)",
"body": [
"${1:player}:getWheelSpellAdditionalDuration(${2:spellname})"
],
},
"player:updateConcoction": {
"prefix": "player:updateConcoction(itemid, timeLeft)",
"body": [
"${1:player}:updateConcoction(${2:itemid}, ${3:timeLeft})"
],
},
"player:clearSpellCooldowns": {
"prefix": "player:clearSpellCooldowns()",
"body": [
"${1:player}:clearSpellCooldowns(${2:})"
],
},
"position:getDistance": {
"prefix": "position:getDistance(positionEx)",
"body": [
"${1:position}:getDistance(${2:positionEx})"
],
},
"position:getPathTo": {
"prefix": "position:getPathTo(pos[, minTargetDist = 0[, maxTargetDist = 1[, fullPathSearch = true[, clearSight = true[, maxSearchDist = 0]]]]])",
"body": [
"${1:position}:getPathTo(${2:pos[}, ${3:minTargetDist = 0[}, ${4:maxTargetDist = 1[}, ${5:fullPathSearch = true[}, ${6:clearSight = true[}, ${7:maxSearchDist = 0]]]]]})"
],
},
"position:isSightClear": {
"prefix": "position:isSightClear(positionEx[, sameFloor = true])",
"body": [
"${1:position}:isSightClear(${2:positionEx[}, ${3:sameFloor = true]})"
],
},
"position:sendMagicEffect": {
"prefix": "position:sendMagicEffect(magicEffect[, player = nullptr])",
"body": [
"${1:position}:sendMagicEffect(${2:magicEffect[}, ${3:player = nullptr]})"
],
},
"position:removeMagicEffect": {
"prefix": "position:removeMagicEffect(magicEffect[, player = nullptr])",
"body": [
"${1:position}:removeMagicEffect(${2:magicEffect[}, ${3:player = nullptr]})"
],
},
"position:sendDistanceEffect": {
"prefix": "position:sendDistanceEffect(positionEx, distanceEffect[, player = nullptr])",
"body": [
"${1:position}:sendDistanceEffect(${2:positionEx}, ${3:distanceEffect[}, ${4:player = nullptr]})"
],
},
"position:sendSingleSoundEffect": {
"prefix": "position:sendSingleSoundEffect(soundId[, actor = nullptr])",
"body": [
"${1:position}:sendSingleSoundEffect(${2:soundId[}, ${3:actor = nullptr]})"
],
},
"position:sendDoubleSoundEffect": {
"prefix": "position:sendDoubleSoundEffect(mainSoundId, secondarySoundId[, actor = nullptr])",
"body": [
"${1:position}:sendDoubleSoundEffect(${2:mainSoundId}, ${3:secondarySoundId[}, ${4:actor = nullptr]})"
],
},
"shop:delete": {
"prefix": "shop:delete()",
"body": [
"${1:shop}:delete(${2:})"
],
},
"shop:setId": {
"prefix": "shop:setId(id)",
"body": [
"${1:shop}:setId(${2:id})"
],
},
"shop:setIdFromName": {
"prefix": "shop:setIdFromName(name)",
"body": [
"${1:shop}:setIdFromName(${2:name})"
],
},
"shop:setNameItem": {
"prefix": "shop:setNameItem(name)",
"body": [
"${1:shop}:setNameItem(${2:name})"
],
},
"shop:setCount": {
"prefix": "shop:setCount(count)",
"body": [
"${1:shop}:setCount(${2:count})"
],
},
"shop:setBuyPrice": {
"prefix": "shop:setBuyPrice(price)",
"body": [
"${1:shop}:setBuyPrice(${2:price})"
],
},
"shop:setSellPrice": {
"prefix": "shop:setSellPrice(chance)",
"body": [
"${1:shop}:setSellPrice(${2:chance})"
],
},
"shop:setStorageKey": {
"prefix": "shop:setStorageKey(storage)",
"body": [
"${1:shop}:setStorageKey(${2:storage})"
],
},
"shop:setStorageValue": {
"prefix": "shop:setStorageValue(value)",
"body": [
"${1:shop}:setStorageValue(${2:value})"
],
},
"shop:addChildShop": {
"prefix": "shop:addChildShop(shop)",
"body": [
"${1:shop}:addChildShop(${2:shop})"
],
},
"spell:onCastSpell": {
"prefix": "spell:onCastSpell(callback)",
"body": [
"${1:spell}:onCastSpell(${2:callback})"
],
},
"spell:register": {
"prefix": "spell:register()",
"body": [
"${1:spell}:register(${2:})"
],
},
"spell:name": {
"prefix": "spell:name(name)",
"body": [
"${1:spell}:name(${2:name})"
],
},
"spell:id": {
"prefix": "spell:id(id)",
"body": [
"${1:spell}:id(${2:id})"
],
},
"spell:group": {
"prefix": "spell:group(primaryGroup[, secondaryGroup])",
"body": [
"${1:spell}:group(${2:primaryGroup[}, ${3:secondaryGroup]})"
],
},
"spell:cooldown": {
"prefix": "spell:cooldown(cooldown)",
"body": [
"${1:spell}:cooldown(${2:cooldown})"
],
},
"spell:groupCooldown": {
"prefix": "spell:groupCooldown(primaryGroupCd[, secondaryGroupCd])",
"body": [
"${1:spell}:groupCooldown(${2:primaryGroupCd[}, ${3:secondaryGroupCd]})"
],
},
"spell:level": {
"prefix": "spell:level(lvl)",
"body": [
"${1:spell}:level(${2:lvl})"
],
},
"spell:magicLevel": {
"prefix": "spell:magicLevel(lvl)",
"body": [
"${1:spell}:magicLevel(${2:lvl})"
],
},
"spell:mana": {
"prefix": "spell:mana(mana)",
"body": [
"${1:spell}:mana(${2:mana})"
],
},
"spell:manaPercent": {
"prefix": "spell:manaPercent(percent)",
"body": [
"${1:spell}:manaPercent(${2:percent})"
],
},
"spell:soul": {
"prefix": "spell:soul(soul)",
"body": [
"${1:spell}:soul(${2:soul})"
],
},
"spell:range": {
"prefix": "spell:range(range)",
"body": [
"${1:spell}:range(${2:range})"
],
},
"spell:isPremium": {
"prefix": "spell:isPremium(bool)",
"body": [
"${1:spell}:isPremium(${2:bool})"
],
},
"spell:isEnabled": {
"prefix": "spell:isEnabled(bool)",
"body": [
"${1:spell}:isEnabled(${2:bool})"
],
},
"spell:needTarget": {
"prefix": "spell:needTarget(bool)",
"body": [
"${1:spell}:needTarget(${2:bool})"
],
},
"spell:needWeapon": {
"prefix": "spell:needWeapon(bool)",
"body": [
"${1:spell}:needWeapon(${2:bool})"
],
},
"spell:needLearn": {
"prefix": "spell:needLearn(bool)",
"body": [
"${1:spell}:needLearn(${2:bool})"
],
},
"spell:isSelfTarget": {
"prefix": "spell:isSelfTarget(bool)",
"body": [
"${1:spell}:isSelfTarget(${2:bool})"
],
},
"spell:isBlocking": {
"prefix": "spell:isBlocking(blockingSolid, blockingCreature)",
"body": [
"${1:spell}:isBlocking(${2:blockingSolid}, ${3:blockingCreature})"
],
},
"spell:isAggressive": {
"prefix": "spell:isAggressive(bool)",
"body": [
"${1:spell}:isAggressive(${2:bool})"
],
},
"spell:allowOnSelf": {
"prefix": "spell:allowOnSelf(bool)",
"body": [
"${1:spell}:allowOnSelf(${2:bool})"
],
},
"spell:isPzLocked": {
"prefix": "spell:isPzLocked(bool)",
"body": [
"${1:spell}:isPzLocked(${2:bool})"
],
},
"spell:vocation": {
"prefix": "spell:vocation(vocation)",
"body": [
"${1:spell}:vocation(${2:vocation})"
],
},
"spell:words": {
"prefix": "spell:words(words[, separator = \"\"])",
"body": [
"${1:spell}:words(${2:words[}, ${3:separator = \"\"]})"
],
},
"spell:needDirection": {
"prefix": "spell:needDirection(bool)",
"body": [
"${1:spell}:needDirection(${2:bool})"
],
},
"spell:hasParams": {
"prefix": "spell:hasParams(bool)",
"body": [
"${1:spell}:hasParams(${2:bool})"
],
},
"spell:hasPlayerNameParam": {
"prefix": "spell:hasPlayerNameParam(bool)",
"body": [
"${1:spell}:hasPlayerNameParam(${2:bool})"
],
},
"spell:needCasterTargetOrDirection": {
"prefix": "spell:needCasterTargetOrDirection(bool)",
"body": [
"${1:spell}:needCasterTargetOrDirection(${2:bool})"
],
},
"spell:blockWalls": {
"prefix": "spell:blockWalls(bool)",
"body": [
"${1:spell}:blockWalls(${2:bool})"
],
},
"spell:runeId": {
"prefix": "spell:runeId(id)",
"body": [
"${1:spell}:runeId(${2:id})"
],
},
"spell:charges": {
"prefix": "spell:charges(charges)",
"body": [
"${1:spell}:charges(${2:charges})"
],
},
"spell:allowFarUse": {
"prefix": "spell:allowFarUse(bool)",
"body": [
"${1:spell}:allowFarUse(${2:bool})"
],
},
"spell:blockWalls": {
"prefix": "spell:blockWalls(bool)",
"body": [
"${1:spell}:blockWalls(${2:bool})"
],
},
"spell:checkFloor": {
"prefix": "spell:checkFloor(bool)",
"body": [
"${1:spell}:checkFloor(${2:bool})"
],
},
"spell:manaWOD": {
"prefix": "spell:manaWOD(grade, mana)",
"body": [
"${1:spell}:manaWOD(${2:grade}, ${3:mana})"
],
},
"spell:cooldownWOD": {
"prefix": "spell:cooldownWOD(grade, time)",
"body": [
"${1:spell}:cooldownWOD(${2:grade}, ${3:time})"
],
},
"spell:groupCooldownWOD": {
"prefix": "spell:groupCooldownWOD(grade, time)",
"body": [
"${1:spell}:groupCooldownWOD(${2:grade}, ${3:time})"
],
},
"spell:secondaryGroupCooldownWOD": {
"prefix": "spell:secondaryGroupCooldownWOD(grade, time)",
"body": [
"${1:spell}:secondaryGroupCooldownWOD(${2:grade}, ${3:time})"
],
},
"spell:increaseManaLeechWOD": {
"prefix": "spell:increaseManaLeechWOD(grade, value)",
"body": [
"${1:spell}:increaseManaLeechWOD(${2:grade}, ${3:value})"
],
},
"spell:increaselifeLeechWOD": {
"prefix": "spell:increaselifeLeechWOD(grade, value)",
"body": [
"${1:spell}:increaselifeLeechWOD(${2:grade}, ${3:value})"
],
},
"spell:increaseDamageWOD": {
"prefix": "spell:increaseDamageWOD(grade, value)",
"body": [
"${1:spell}:increaseDamageWOD(${2:grade}, ${3:value})"
],
},
"spell:increaseDamageReductionWOD": {
"prefix": "spell:increaseDamageReductionWOD(grade, value)",
"body": [
"${1:spell}:increaseDamageReductionWOD(${2:grade}, ${3:value})"
],
},
"spell:increaseHealWOD": {
"prefix": "spell:increaseHealWOD(grade, value)",
"body": [
"${1:spell}:increaseHealWOD(${2:grade}, ${3:value})"
],
},
"spell:increaseCriticalDamageWOD": {
"prefix": "spell:increaseCriticalDamageWOD(grade, value)",
"body": [
"${1:spell}:increaseCriticalDamageWOD(${2:grade}, ${3:value})"
],
},
"spell:increaseCriticalChanceWOD": {
"prefix": "spell:increaseCriticalChanceWOD(grade, value)",
"body": [
"${1:spell}:increaseCriticalChanceWOD(${2:grade}, ${3:value})"
],
},
"talkAction:onSay": {
"prefix": "talkAction:onSay(callback)",
"body": [
"${1:talkAction}:onSay(${2:callback})"
],
},
"talkAction:register": {
"prefix": "talkAction:register()",
"body": [
"${1:talkAction}:register(${2:})"
],
},
"talkAction:separator": {
"prefix": "talkAction:separator(sep)",
"body": [
"${1:talkAction}:separator(${2:sep})"
],
},
"teleport:getDestination": {
"prefix": "teleport:getDestination()",
"body": [
"${1:teleport}:getDestination(${2:})"
],
},
"teleport:setDestination": {
"prefix": "teleport:setDestination(position)",
"body": [
"${1:teleport}:setDestination(${2:position})"
],
},
"tile:getPosition": {
"prefix": "tile:getPosition()",
"body": [
"${1:tile}:getPosition(${2:})"
],
},
"tile:getGround": {
"prefix": "tile:getGround()",
"body": [
"${1:tile}:getGround(${2:})"
],
},
"tile:getThing": {
"prefix": "tile:getThing(index)",
"body": [
"${1:tile}:getThing(${2:index})"
],
},
"tile:getThingCount": {
"prefix": "tile:getThingCount()",
"body": [
"${1:tile}:getThingCount(${2:})"
],
},
"tile:getTopVisibleThing": {
"prefix": "tile:getTopVisibleThing(creature)",
"body": [
"${1:tile}:getTopVisibleThing(${2:creature})"
],
},
"tile:getTopTopItem": {
"prefix": "tile:getTopTopItem()",
"body": [
"${1:tile}:getTopTopItem(${2:})"
],
},
"tile:getTopDownItem": {
"prefix": "tile:getTopDownItem()",
"body": [
"${1:tile}:getTopDownItem(${2:})"
],
},
"tile:getFieldItem": {
"prefix": "tile:getFieldItem()",
"body": [
"${1:tile}:getFieldItem(${2:})"
],
},
"tile:getItemById": {
"prefix": "tile:getItemById(itemId[, subType = -1])",
"body": [
"${1:tile}:getItemById(${2:itemId[}, ${3:subType = -1]})"
],
},
"tile:getItemByType": {
"prefix": "tile:getItemByType(itemType)",
"body": [
"${1:tile}:getItemByType(${2:itemType})"
],
},
"tile:getItemByTopOrder": {
"prefix": "tile:getItemByTopOrder(topOrder)",
"body": [
"${1:tile}:getItemByTopOrder(${2:topOrder})"
],
},
"tile:getItemCountById": {
"prefix": "tile:getItemCountById(itemId[, subType = -1])",
"body": [
"${1:tile}:getItemCountById(${2:itemId[}, ${3:subType = -1]})"
],
},
"tile:getBottomCreature": {
"prefix": "tile:getBottomCreature()",
"body": [
"${1:tile}:getBottomCreature(${2:})"
],
},
"tile:getTopCreature": {
"prefix": "tile:getTopCreature()",
"body": [
"${1:tile}:getTopCreature(${2:})"
],
},
"tile:getBottomVisibleCreature": {
"prefix": "tile:getBottomVisibleCreature(creature)",
"body": [
"${1:tile}:getBottomVisibleCreature(${2:creature})"
],
},
"tile:getTopVisibleCreature": {
"prefix": "tile:getTopVisibleCreature(creature)",
"body": [
"${1:tile}:getTopVisibleCreature(${2:creature})"
],
},
"tile:getItems": {
"prefix": "tile:getItems()",
"body": [
"${1:tile}:getItems(${2:})"
],
},
"tile:getItemCount": {
"prefix": "tile:getItemCount()",
"body": [
"${1:tile}:getItemCount(${2:})"
],
},
"tile:getDownItemCount": {
"prefix": "tile:getDownItemCount()",
"body": [
"${1:tile}:getDownItemCount(${2:})"
],
},
"tile:getTopItemCount": {
"prefix": "tile:getTopItemCount()",
"body": [
"${1:tile}:getTopItemCount(${2:})"
],
},
"tile:getCreatures": {
"prefix": "tile:getCreatures()",
"body": [
"${1:tile}:getCreatures(${2:})"
],
},
"tile:getCreatureCount": {
"prefix": "tile:getCreatureCount()",
"body": [
"${1:tile}:getCreatureCount(${2:})"
],
},
"tile:hasProperty": {
"prefix": "tile:hasProperty(property[, item])",
"body": [
"${1:tile}:hasProperty(${2:property[}, ${3:item]})"
],
},
"tile:getThingIndex": {
"prefix": "tile:getThingIndex(thing)",
"body": [
"${1:tile}:getThingIndex(${2:thing})"
],
},
"tile:hasFlag": {
"prefix": "tile:hasFlag(flag)",
"body": [
"${1:tile}:hasFlag(${2:flag})"
],
},
"tile:queryAdd": {
"prefix": "tile:queryAdd(thing[, flags])",
"body": [
"${1:tile}:queryAdd(${2:thing[}, ${3:flags]})"
],
},
"tile:addItem": {
"prefix": "tile:addItem(itemId[, count/subType = 1[, flags = 0]])",
"body": [
"${1:tile}:addItem(${2:itemId[}, ${3:count/subType = 1[}, ${4:flags = 0]]})"
],
},
"tile:addItemEx": {
"prefix": "tile:addItemEx(item[, flags = 0])",
"body": [
"${1:tile}:addItemEx(${2:item[}, ${3:flags = 0]})"
],
},
"tile:getHouse": {
"prefix": "tile:getHouse()",
"body": [
"${1:tile}:getHouse(${2:})"
],
},
"tile:isHazard": {
"prefix": "tile:isHazard()",
"body": [
"${1:tile}:isHazard(${2:})"
],
},
"town:getId": {
"prefix": "town:getId()",
"body": [
"${1:town}:getId(${2:})"
],
},
"town:getName": {
"prefix": "town:getName()",
"body": [
"${1:town}:getName(${2:})"
],
},
"town:getTemplePosition": {
"prefix": "town:getTemplePosition()",
"body": [
"${1:town}:getTemplePosition(${2:})"
],
},
"Variant:getNumber": {
"prefix": "Variant:getNumber()",
"body": [
"${1:Variant}:getNumber(${2:})"
],
},
"Variant:getString": {
"prefix": "Variant:getString()",
"body": [
"${1:Variant}:getString(${2:})"
],
},
"Variant:getPosition": {
"prefix": "Variant:getPosition()",
"body": [
"${1:Variant}:getPosition(${2:})"
],
},
"vocation:getId": {
"prefix": "vocation:getId()",
"body": [
"${1:vocation}:getId(${2:})"
],
},
"vocation:getClientId": {
"prefix": "vocation:getClientId()",
"body": [
"${1:vocation}:getClientId(${2:})"
],
},
"vocation:getBaseId": {
"prefix": "vocation:getBaseId()",
"body": [
"${1:vocation}:getBaseId(${2:})"
],
},
"vocation:getName": {
"prefix": "vocation:getName()",
"body": [
"${1:vocation}:getName(${2:})"
],
},
"vocation:getDescription": {
"prefix": "vocation:getDescription()",
"body": [
"${1:vocation}:getDescription(${2:})"
],
},
"vocation:getRequiredSkillTries": {
"prefix": "vocation:getRequiredSkillTries(skillType, skillLevel)",
"body": [
"${1:vocation}:getRequiredSkillTries(${2:skillType}, ${3:skillLevel})"
],
},
"vocation:getRequiredManaSpent": {
"prefix": "vocation:getRequiredManaSpent(magicLevel)",
"body": [
"${1:vocation}:getRequiredManaSpent(${2:magicLevel})"
],
},
"vocation:getCapacityGain": {
"prefix": "vocation:getCapacityGain()",
"body": [
"${1:vocation}:getCapacityGain(${2:})"
],
},
"vocation:getHealthGain": {
"prefix": "vocation:getHealthGain()",
"body": [
"${1:vocation}:getHealthGain(${2:})"
],
},
"vocation:getHealthGainTicks": {
"prefix": "vocation:getHealthGainTicks()",
"body": [
"${1:vocation}:getHealthGainTicks(${2:})"
],
},
"vocation:getHealthGainAmount": {
"prefix": "vocation:getHealthGainAmount()",
"body": [
"${1:vocation}:getHealthGainAmount(${2:})"
],
},
"vocation:getManaGain": {
"prefix": "vocation:getManaGain()",
"body": [
"${1:vocation}:getManaGain(${2:})"
],
},
"vocation:getManaGainTicks": {
"prefix": "vocation:getManaGainTicks()",
"body": [
"${1:vocation}:getManaGainTicks(${2:})"
],
},
"vocation:getManaGainAmount": {
"prefix": "vocation:getManaGainAmount()",
"body": [
"${1:vocation}:getManaGainAmount(${2:})"
],
},
"vocation:getMaxSoul": {
"prefix": "vocation:getMaxSoul()",
"body": [
"${1:vocation}:getMaxSoul(${2:})"
],
},
"vocation:getSoulGainTicks": {
"prefix": "vocation:getSoulGainTicks()",
"body": [
"${1:vocation}:getSoulGainTicks(${2:})"
],
},
"vocation:getBaseAttackSpeed": {
"prefix": "vocation:getBaseAttackSpeed()",
"body": [
"${1:vocation}:getBaseAttackSpeed(${2:})"
],
},
"vocation:getAttackSpeed": {
"prefix": "vocation:getAttackSpeed()",
"body": [
"${1:vocation}:getAttackSpeed(${2:})"
],
},
"vocation:getBaseSpeed": {
"prefix": "vocation:getBaseSpeed()",
"body": [
"${1:vocation}:getBaseSpeed(${2:})"
],
},
"vocation:getDemotion": {
"prefix": "vocation:getDemotion()",
"body": [
"${1:vocation}:getDemotion(${2:})"
],
},
"vocation:getPromotion": {
"prefix": "vocation:getPromotion()",
"body": [
"${1:vocation}:getPromotion(${2:})"
],
},
"weapon:action": {
"prefix": "weapon:action(callback)",
"body": [
"${1:weapon}:action(${2:callback})"
],
},
"weapon:register": {
"prefix": "weapon:register()",
"body": [
"${1:weapon}:register(${2:})"
],
},
"weapon:onUseWeapon": {
"prefix": "weapon:onUseWeapon(callback)",
"body": [
"${1:weapon}:onUseWeapon(${2:callback})"
],
},
"weapon:wieldedUnproperly": {
"prefix": "weapon:wieldedUnproperly(bool)",
"body": [
"${1:weapon}:wieldedUnproperly(${2:bool})"
],
},
"weapon:level": {
"prefix": "weapon:level(lvl)",
"body": [
"${1:weapon}:level(${2:lvl})"
],
},
"weapon:magicLevel": {
"prefix": "weapon:magicLevel(lvl)",
"body": [
"${1:weapon}:magicLevel(${2:lvl})"
],
},
"weapon:mana": {
"prefix": "weapon:mana(mana)",
"body": [
"${1:weapon}:mana(${2:mana})"
],
},
"weapon:manaPercent": {
"prefix": "weapon:manaPercent(percent)",
"body": [
"${1:weapon}:manaPercent(${2:percent})"
],
},
"weapon:health": {
"prefix": "weapon:health(health)",
"body": [
"${1:weapon}:health(${2:health})"
],
},
"weapon:healthPercent": {
"prefix": "weapon:healthPercent(percent)",
"body": [
"${1:weapon}:healthPercent(${2:percent})"
],
},
"weapon:soul": {
"prefix": "weapon:soul(soul)",
"body": [
"${1:weapon}:soul(${2:soul})"
],
},
"weapon:breakChance": {
"prefix": "weapon:breakChance(percent)",
"body": [
"${1:weapon}:breakChance(${2:percent})"
],
},
"weapon:damage": {
"prefix": "weapon:damage(damage[min, max])",
"body": [
"${1:weapon}:damage(${2:damage[min}, ${3:max]})"
],
},
"weapon:element": {
"prefix": "weapon:element(combatType)",
"body": [
"${1:weapon}:element(${2:combatType})"
],
},
"weapon:premium": {
"prefix": "weapon:premium(bool)",
"body": [
"${1:weapon}:premium(${2:bool})"
],
},
"weapon:vocation": {
"prefix": "weapon:vocation(vocName[, showInDescription = false, lastVoc = false])",
"body": [
"${1:weapon}:vocation(${2:vocName[}, ${3:showInDescription = false}, ${4:lastVoc = false]})"
],
},
"weapon:id": {
"prefix": "weapon:id(id)",
"body": [
"${1:weapon}:id(${2:id})"
],
},
"weapon:attack": {
"prefix": "weapon:attack(atk)",
"body": [
"${1:weapon}:attack(${2:atk})"
],
},
"weapon:defense": {
"prefix": "weapon:defense(defense[, extraDefense])",
"body": [
"${1:weapon}:defense(${2:defense[}, ${3:extraDefense]})"
],
},
"weapon:range": {
"prefix": "weapon:range(range)",
"body": [
"${1:weapon}:range(${2:range})"
],
},
"weapon:charges": {
"prefix": "weapon:charges(charges[, showCharges = true])",
"body": [
"${1:weapon}:charges(${2:charges[}, ${3:showCharges = true]})"
],
},
"weapon:duration": {
"prefix": "weapon:duration(duration[, showDuration = true])",
"body": [
"${1:weapon}:duration(${2:duration[}, ${3:showDuration = true]})"
],
},
"weapon:transformEquipTo": {
"prefix": "weapon:transformEquipTo(itemid)",
"body": [
"${1:weapon}:transformEquipTo(${2:itemid})"
],
},
"weapon:transformDeEquipTo": {
"prefix": "weapon:transformDeEquipTo(itemid)",
"body": [
"${1:weapon}:transformDeEquipTo(${2:itemid})"
],
},
"weapon:shootType": {
"prefix": "weapon:shootType(type)",
"body": [
"${1:weapon}:shootType(${2:type})"
],
},
"weapon:slotType": {
"prefix": "weapon:slotType(slot)",
"body": [
"${1:weapon}:slotType(${2:slot})"
],
},
"weapon:ammoType": {
"prefix": "weapon:ammoType(type)",
"body": [
"${1:weapon}:ammoType(${2:type})"
],
},
"weapon:hitChance": {
"prefix": "weapon:hitChance(chance)",
"body": [
"${1:weapon}:hitChance(${2:chance})"
],
},
"weapon:maxHitChance": {
"prefix": "weapon:maxHitChance(max)",
"body": [
"${1:weapon}:maxHitChance(${2:max})"
],
},
"weapon:extraElement": {
"prefix": "weapon:extraElement(atk, combatType)",
"body": [
"${1:weapon}:extraElement(${2:atk}, ${3:combatType})"
],
},
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment