footnote
*	writable
**	can be null
receiver	sender (player / console) "dev" (perm "script.debug" needed) "online" "server"

entity_change_block	an entity changes a block
Variables	entity block change_data as blockdata for the new state *cancel

entity_damage	an entity gets damage
Variables	entity damage_source cause as string **damager_block **damager_entity damage raw_damage *cancel

entity_heal	an entity gets healed
Variables	entity *heal cause as string *cancel

living_death	a living_entity dies
Variables	living_entity damage_source *drops as list of itemstacks *experience *cancel

block_drop	a destroyed block drops something
Variables	player block *drops as list with ItemEntities

entity_click	an entity gets right_clicked
Variables	player entity hand *cancel

living_spawn	a living entity spawns
Variables	living_entity cause as string location *cancel

entity_spawn	an entity spawns
Variables	entity location *cancel

entity_remove	an entity is removed from a world
Variables	entity

living_tame	a living entity gets tamed
Variables	living_entity tamer *cancel

entity_mount	an entity mounts another entity
Variables	entity mount as entity *cancel

player_login	a player tries to connect to the server
Variables	player result

player_join	a player joins the server
Variables	player *message as text
Info	message = null means no message

player_quit	a player leaves the server
Variables	player *message as text
Info	message = null means no message

player_pre_respawn	a player will respawn
Variables	player
Info	devs can set the spawn-location on this event

player_post_respawn	a player has respawned
Variables	player
Info	devs can refill the inventory on this event

player_toggle_sneak	a player toggles sneak
Variables	player sneak as boolean *cancel

player_drop	a player drops an item
Variables	player item_entity *cancel

living_pickup	a living entity picks up an item
Variables	living_entity item_entity *cancel

player_move	a player moves in a before defined area
Variables	player id

block_break	a block is broken
Variables	player block *cancel

block_place	a block is placed
Variables	player block hand *cancel

block_click	a block gets clicked
Variables	player **block action as string hand *cancel

bucket_use	a bucket is filled / vacated
Variables	player block bucket as material hand *cancel

inv_click	a slot in an container gets clicked
Variables	player inv **inv_clicked inv_title as text inv_slot as double click as string action as string *cancel

snuvi_click	a slot in an custom inventory gets clicked
Variables	player inv inv_title as text inv_slot as double click as string action as string
Info	Custom inventories are not script-across.

inv_close	an inventory gets closed
Variables	player inv inv_title as text

item_consume	an item gets consumed by a player
Variables	player item *cancel

pre_craft	a player crafts an item
Variables	players as list with players *item *inv
Info	item can be set to null

craft	a player takes the result item out of craft inventory
Variables	player item *cancel

player_change_world	a player changes the world
Variables	player from world as string

player_teleport	a player teleports
Variables	player from as location to as location cause as string *cancel

fishing	a player fishes something
Variables	player **entity *experience hook as entity *cancel

command	a player uses a non custom-command
Variables	player command as string *cancel

custom_command	something uses a custom-command
Variables	sender command as string args as list string_args as list with strings only
Info	sender can be a player, console...

chat	a player writes into chat
Variables	player *message as text *cancel
Info	This event is fired asynchronous

projectile_hit	a thrown projectile hits a block or an entity
Variables	**shooter projectile **entity_hit **block_hit *cancel

arm_swing	a player makes an arm_swing (might be a leftclick into air)
Variables	player hand *cancel

human_damage	a human gets damage
Variables	human damage_source damage *cancel | true

explosion	explosions are cancelled on default
Variables	entity *fire as boolean *radius *cancel | true

missing_command	a sender uses a non-existing command
Variables	sender command

missing_perm	a sender has no permissions for a used command
Variables	sender command

player_data_tick	thrown if a timer from data.setTimer reached 0
Variables	player var

player_elytra_start	thrown if a player starts using an elytra
Variables	player

player_elytra_stop	thrown if a player stops using an elytra
Variables	player

player_item_held	a player changes their hotbar slot
Variables	player from as double to as double *cancel

player_swap_hand_items	a player swaps their items in their hands
Variables	player *cancel

world_load	a world gets loaded
Variables	world

vote	a vote gets received
Variables	from as string name as string ip as string timestamp as double

event.addMoveData	creates an area for player_move events and returns the id
Format	event.addMoveData(location1, location2, cooldown, livingtime, [uuid / string_uuid / player])
Arguments	cooldown: -1 terminated after a single trigger cooldown: > 0 clock rate in ticks, no termination livingtime: -1 area lives forever livingtime: > 0 stays amount of ticks alive uuid / string_uuid / player: event only triggers for this player
Info	on script termination this area will be removed

	removes an area for player_move events by id
Format	event.removeMoveData(id)

ban.add	bans a player from the server
Format	ban.add(player_name, reason, banner, [end_date])
Arguments	reason as string banner as string (the person who bans, write what you want) end_date as calendar object

ban.remove	unbans a player from the server
Format	ban.remove(player_name)

ban.kick	kicks a player from the server
Format	ban.kick(player, reason)
Arguments	reason as text

block.setData	set a block
Format	block.setData(block, blockdata, [boolean | false])
Arguments	boolean true places with block update

block.setMaterial	set a block
Format	block.setMaterial(block, material, [boolean | false])
Arguments	boolean true places with block update

block.clone	clone a block to a location
Format	block.clone(block, location, [boolean | false])
Arguments	boolean true places with block update

block.setSign	set text on a sign
Format	block.setSign(block, row, text)
Arguments	row from 0 to 3

block.getSign	returns the text of a sign from a specific row
Format	block.getSign(block, row)
Arguments	row from 0 to 3

block.get	returns a block
Format	block.get(location)

block.getData	returns the blockdata of a block
Format	block.getData(block)

block.getInventory	returns the inventory of a block or null if it is not a container
Format	block.getInventory(block)

block.getType	returns the material of a block
Format	block.getType(block)

block.getLocation	returns the location of a block
Format	block.getLocation(block)

block.setOpen	set the open property for a block
Format	block.setOpen(block, boolean)

block.isOpen	returns true if the block is open
Format	block.isOpen(block)

block.getTag	returns a tag
Format	block.getTag(String tag_name)

block.hasTag	returns true if a block has a tag
Format	block.hasTag(block, tag)

block.break	breaks a block and drops the item
Format	block.break(block, [entity])

block.getEntity	return the tile entity of a block
Format	block.getEntity(block)

block.setEntity	set the tile entity for a block
Format	block.setEntity(block, entity)

databank.prepare	returns the prepared statement
Format	databank.prepare(sql-query, [boolean autoclose | true])

databank.setInt	sets an int in a statement
Format	databank.setInt(statement, index, int)

databank.setDouble	sets a double in a statement
Format	databank.setDouble(statement, index, double)

databank.setLong	sets a long in a statement
Format	databank.setLong(statement, index, long)

databank.setString	sets a string in a statement
Format	databank.setString(statement, index, string)

databank.setBool	sets a boolean in a statement
Format	databank.setBool(statement, index, boolean)

databank.getInt	returns an int from a result set
Format	databank.getInt(result-set, index)

databank.getDouble	returns a double from a result set
Format	databank.getDouble(result-set, index)

databank.getLong	returns a long from a result set
Format	databank.getLong(result-set, index)

databank.getString	returns a string from a result set
Format	databank.getString(result-set, index)

databank.getBool	returns a boolean from a result set
Format	databank.getBool(result-set, index)

databank.execute	returns a result-set after executing a reading statement
Format	databank.execute(statement)

databank.workerExecute	executes a writing statement
Format	databank.workerExecute(statement)

databank.next	returns true and jumps to the next entry if the result-set has a next entry
Format	databank.next(result-set)

databank.close	manual closing of a result-set
Format	databank.close(result-set)

config.saveAsync	saves a config asynchronous
Format	config.saveAsync(config)

gamerule.getKey	returns a gamerule_key
Format	gamerule.getKey(gamerule_string)

gamerule.getValue	return a gamerule_value from a world
Format	gamerule.getValue(world, gamerule_key)

gamerule.setBool	sets a gamerule_value
Format	gamerule.setBool(gamerule_value, boolean)

gamerule.setInt	sets a gamerule_key
Format	gamerule.setInt(gamerule_key, value)

msg	sends a message
Format	msg(receiver, text)

isPlayer	returns true if the argument is a player
Format	isPlayer(anything)

isLiving	returns true if the argument is a living entity
Format	isLiving(anything)

setMOTD	sets the message of the day in the server list
Format	setMOTD(string)

Xitem.drop	drops an itemstack at a location
Format	item.drop(location, itemstack)

Xitem.get	returns an item as object
Format	item.get(itemstack)

Xitem.getType	returns the type of an itemstack
Format	item.getType(itemstack)
Examples	"minecraft:wool" / "km:artefact"

Xitem.getAmount	returns the amount of items in an itemstack
Format	item.getAmount(itemstack)

Xitem.setAmount	sets the amount of items for an itemstack
Format	item.setAmount(itemstack, value)

Xitem.getName	returns the name of an itemstack
Format	item.getName(itemstack)

Xitem.setName	sets the name of an itemstack
Format	item.setName(itemstack, name)

Xitem.getLore	returns a list with all lores of an itemstack
Format	item.getLore(ItemStack)

Xitem.setLore	sets the lore for an itemstack with the elements in the list
Format	item.setLore(itemstack, List)

Xitem.addLore	sets the lore for an itemstack for a specific row
Format	item.addLore(itemstack, lore, row)

Xitem.addAttribute	adds an attribute to an itemstack
Format	item.addAttribute(itemstack, attribute, slot, double, operation)
Info	attributes: generic.max_health, generic.follow_range, generic.knockback_resistance, generic.movement_speed, generic.flying_speed, generic.attack_damage, generic.attack_damage, generic.attack_knockback, generic.attack_speed, generic.armor, generic.armor_toughness, generic.luck, zombie.spawn_reinforcements, horse.jump_strength slots: mainhand, offhand, head, chest, legs, feet operation: 0 (ADDITION), 1 (MULTIPLY_BASE), 2 (MULTIPLY_TOTAL)

Xitem.clearAttributes	removes all custom attributes from an itemstack
Format	item.clearAttributes(itemstack)

Xitem.hasAttributes	returns true if an itemstack has custom attributes
Format	item.hasAttributes(itemstack)

Xitem.addDefaultTags	adds the default attributes to an itemstack
Format	item.addDefaultTags(itemstack)

Xitem.hide	hides something on an itemstack and returns true on success
Format	item.hide(itemstack, name)
Info	name: "enchantments" / "attributes" / "unbreakable" / "destroys" / "placed_on" / "potion_effects"

Xitem.addPotion	unknown
Format	item.addPotion(itemstack, potion_name, duration, power)

Xitem.setCoolDown	sets the cooldown for an item-type
Format	item.setCoolDown(player, itemstack, ticks)

Xitem.clone	returns a copy of an itemstack
Format	item.clone(itemstack)

Xitem.getTag	returns a tag
Format	item.getTag(String tag_name)

Xitem.hasTag	returns true if an itemstack has a tag
Format	item.hasTag(tag, itemstack)

Xitem.hasName	returns true if the itemstack has a modified name
Format	item.hasName(itemstack)

Xitem.getFullText	returns the full text object
Format	item.getFullText(itemstack)

Xitem.isDamageable	returns true if the itemstack is damageable
Format	item.isDamageable(itemstack)

Xitem.getMaxDamage	returns the maximum damage the itemstack can get
Format	item.getMaxDamage(itemstack)

Xitem.setDamage	sets the damage of the itemstack
Format	item.setDamage(itemstack, amount)

Xitem.getDamage	returns the damage of an itemstack
Format	item.getDamage(itemstack)

Xitem.getMaxAmount	returns the maximum amount of stackable items
Format	item.getMaxAmount(itemstack)

Xitem.entity.get	returns an itemstack from an item-entity
Format	item.entity.get(item-entity)

Xitem.entity.set	sets an itemstack to an item-entity
Format	item.entity.set(item-entity, itemstack)

Xitem.entity.new	creates an item-entity from an itemstack and returns the item-entity
Format	item.entity.new(location, itemstack)

Xitem.entity.spawn	spawns an item-entity
Format	item.entity.spawn(entity)

Xitem.entity.setLifespan	sets the lifespan of an item-entity
Format	item.entity.setLifespan(item-entity, ticks)

Xenchantment.get	returns an enchantment
Format	enchantment.get(enchantment_string)
Arguments	Minecraft Wiki Verzauberungen (ID-Name verwenden)

Xenchantment.add	adds an enchantment to an itemstack
Format	enchantment.add(enchantment, itemstack, level)

Xenchantment.getLevel	returns the level of an enchantment an itemstack has
Format	enchantment.getLevel(enchantment, itemstack)

Xenchantment.readFromItem	returns a map with all enchantments from an item with the level as value
Format	enchantment.readFromItem(itemstack)

Xenchantment.writeToItem	transfers all enchantments from the map on the itemstack
Format	enchantment.writeToItem(map, itemstack)

debug.clear	clears all cached debug-messages
Format	debug.clear()

debug.getSize	returns the amount of all cached debug-messages
Format	debug.getSize()

debug.getIndex	returns the debug-message from an index
Format	debug.getIndex(index)

debug.setConsolePrint	true prints snuvi debug-messages on console (not stack traces)
Format	debug.setConsolePrint(boolean)

error.clear	clears all cached errors
Format	error.clear()

error.getSize	returns the amount of all cached errors
Format	error.getSize()

error.getIndex	returns the error from an index
Format	error.getIndex(index)

error.setConsolePrint	true prints snuvi errors on console (not stack traces)
Format	error.setConsolePrint(boolean)

loc.new	creates a location
Format	loc.new(world, x, y, z) loc.new(world, x, y, z, yaw, pitch)

loc.getX	returns the x coordinate
Format	loc.getX(location)

loc.setX	sets the x coordinate
Format	loc.setX(location, value)

loc.addX	adds the value to the x coordinate
Format	loc.addX(location, value)

loc.getBlockX	returns the x block coordinate
Format	loc.getBlockX(location)

loc.getY	returns the y coordinate
Format	loc.getY(location)

loc.setY	sets the y coordinate
Format	loc.setY(location, value)

loc.addY	adds the value to the y coordinate
Format	loc.addY(location, value)

loc.getBlockY	returns the y block coordinate
Format	loc.getBlockY(location)

loc.getZ	returns the z coordinate
Format	loc.getZ(location)

loc.setZ	sets the z coordinate
Format	loc.setZ(location, value)

loc.addZ	adds the value to the z coordinate
Format	loc.addZ(location, value)

loc.getBlockZ	returns the z block coordinate
Format	loc.getBlockZ(location)

loc.setYaw	sets the yaw of a location
Format	loc.setYaw(location, Yaw)

loc.getYaw	returns the yaw of a location
Format	loc.getYaw(location)

loc.setPitch	sets the pitch of a location
Format	loc.setPitch(location, Pitch)

loc.getPitch	returns the pitch of a location
Format	loc.getPitch(location)

loc.getWorld	returns the world of a location as object
Format	loc.getWorld(location)

loc.distance	returns the difference between two locations
Format	loc.distance(location1, location2)
Info	there is an error if the two locations have not the same world

loc.isBetween	returns true if the location is between two other locations
Format	loc.isBetween(location, location1, location2)

loc.mod	returns a modified copy of the location
Format	loc.mod(location, x, y, z)

loc.add	modifies the original location
Format	loc.add(location, x, y, z)

loc.set	modifies the original location
Format	loc.set(location, x, y, z)

loc.sort	sort in lowest and highest coordinates
Format	loc.sort(location1, location2)

loc.iterator	returns the iterator for the area
Format	loc.iterator(world, x1, y1, z1, x2, y2, z2)

loc.explode	makes an explosion at a location
Format	loc.explode(location, entity, radius, fire_bool, block_damage_bool)
Info	entity can be null

Xread.spawnMob	spawns a mob and returns the entity
Format	read.spawnMob(location, nbt-tag)

Xread.player	returns the object player
Format	read.player(playername)

Xread.item	returns an itemstack
Format	read.item(nbt-tag) read.item(item_type) read.item(item_type, item_amount) read.item(item_type, item_amount) read.item(item_type, item_amount, name) read.item(item_type, item_amount, name, lore1, lore2, ...)
Info	returns null if the item does not exist

Xread.uuid	returns a uuid
Format	read.uuid("uuid")

Xread.slot	returns a slot
Format	read.slot(slot)
Info	slot: "head" / "chest" / "legs" / "feet" / "hand" / "offhand"

string.item	returns an nbt-tag from an itemstack as string
Format	string.item(itemstack)

string.entity	returns a serialized entity
Format	string.entity(entity)

string.text	returns a text converted to a string
Format	string.text(text)

string.blockData	returns blockdata converted to a string
Format	string.blockData(blockdata)

string.blockEntity	returns a blockentity converted to a string
Format	string.blockEntity(blockentity)

text.new	returns a text
Format	text.new(string)

text.click	returns a clickable text
Format	text.click(show_text, execute_string)

text.hover	returns a hoverable text
Format	text.hover(show_text, hover_text)

text.link	returns a clickable text for links
Format	text.link(text, link_string)

text.clipBoard	returns a clickable text to copy a string into the clipboard
Format	text.clipBoard(text, string)

text.merge	returns merged texts
Format	text.merge(text, ...)

plot.add	returns the created plot
Format	plot.add(location1, location2, [plot_id])

plot.remove	removes a plot from a world
Format	plot.remove(plot, world)

plot.getId	returns the plot_id
Format	plot.getId(plot)

plot.setName	sets the name of a plot
Format	plot.setName(plot, name)

plot.getName	returns the name of a plot
Format	plot.getName(plot)

plot.get	returns a list with all plots at a location
Format	plot.get(location)

plot.getMinX	returns the lowest x coordinate of a plot
Format	plot.getMinX(plot)

plot.getMinY	returns the lowest y coordinate of a plot
Format	plot.getMinY(plot)

plot.getMinZ	returns the lowest z coordinate of a plot
Format	plot.getMinZ(plot)

plot.getMaxX	returns the lowest x coordinate of a plot
Format	plot.getMaxX(plot)

plot.getMaxY	returns the lowest y coordinate of a plot
Format	plot.getMaxY(plot)

plot.getMaxZ	returns the lowest z coordinate of a plot
Format	plot.getMaxZ(plot)

plot.intersecting	returns a list with all intersecting plots
Format	plot.intersecting(world, x1, y1, z1, x2, y2, z2)

plot.setFlags	sets all flags to the boolean
Format	plot.setFlags(plot, flags, boolean)

plot.getFlags	returns all flags as double
Format	plot.getFlags(plot)

plot.hasFlags	returns true if all flags existing
Format	plot.hasFlags(plot, flags)

plot.getOwners	returns a list with all owners as uuid
Format	plot.getOwners(plot)
Info	list can be modified

plot.check	returns true if the player is owner of any plot from that location OR if any plot contains all given flags. returns empty if there is no plot
Format	plot.check(location, player, Int flags, Boolean empty)
Arguments	player can be null flags: 0 if not desired 1 PLACE_FLAG 2 BREAK_FLAG 4 BUCKET_FLAG 8 HIT_AMBIENT_FLAG 16 BLOCK_INTERACT_FLAG 32 ENTITY_INTERACT_FLAG
Examples	plot.check(loc, null, 1, false) ==> true if place_flag existing plot.check(loc, null, 2, false) ==> true if break_flag existing plot.check(loc, null, 3, false) ==> true if break_flag and place_flag existing plot.check(loc, player, 0, false) ==> true if player is owner plot.check(loc, player, 0, true) ==> true if player is owner or if there is no plot

plot.iterator	returns the iterator for the plots in a world [for a player]
Format	plot.iterator(world, [uuid])

table.new	returns a table object
Format	table.new(color, width, width, width, ...)

table.getStart	returns the head of a table
Format	table.getStart(table)

table.getMiddle	returns the middle of a table
Format	table.getMiddle(table)

table.getEnd	returns the end of a table
Format	table.getEnd(table)

table.get	returns a line of a table
Format	table.get(table, args...)

table.setSize	defines the pixel size of a character
Format	table.setSize("character", pixel_int)

table.setEmpty1	defines the 1 pixel empty character
Format	table.setEmpty1(string)

table.setEmpty2	defines the 2 pixel empty character
Format	table.setEmpty2(string)

table.setEmpty4	defines the 4 pixel empty character
Format	table.setEmpty4(string)

command.add	registers a custom command
Format	command.add(string)

command.remove	removes a custom command
Format	command.remove(string)

command.clear	removes all custom commands
Format	command.clear()

command.exists	returns true if a custom command exists
Format	command.exists(string)

command.addIgnored	ignores a (vanilla) command-help
Format	command.addIgnored(string)

command.clearIgnored	removes all ignored command-helps
Format	command.clearIgnored()

command.newHelp	returns a help-object
Format	command.newHelp(string, perm)

command.newHelpLiteral	returns a help-sub-object
Format	command.newHelpLiteral(string, [perm])

command.newHelpBool	returns a help-sub-object
Format	command.newHelpBool(string, [perm])

command.newHelpDouble	returns a help-sub-object
Format	command.newHelpDouble(string, min, max, [perm])

command.newHelpFloat	returns a help-sub-object
Format	command.newHelpFloat(string, min, max, [perm])

command.newHelpInt	returns a help-sub-object
Format	command.newHelpInt(string, min, max, [perm])

command.newHelpLong	returns a help-sub-object
Format	command.newHelpLong(string, min, max, [perm])

command.newHelpString	returns a help-sub-object
Format	command.newHelpString(string, boolean, [perm])
Arguments	boolean true means greedy

command.newHelpSpecial	returns a help-sub-object
Format	command.newHelpSpecial(type, string, [perm])
Arguments	type = "Item", "Block", "Potion", "Enchantment", "Player"

command.addHelp	registers a command-help
Format	command.addHelp(help-object)

command.addHelpChild	help-sub-object2 is added tp help-(sub-)object1 as a new argument
Format	command.addHelpChild(help-(sub-)object1, help-sub-object2)

command.addHelpAlias	help-object1 refers to help-object2
Format	command.addHelpAlias(help-object1, help-object2)

command.sendHelp	sends all registered command-helps to all players
Format	command.sendHelp([player])

command.clearHelp	removes all registered command-helps
Format	command.clearHelp()

sb.add	adds text to the scoreboard
Format	sb.add(player, unique_index, string)
Arguments	index from 1 to 99
Info	vanilla: maximum 12 rows

sb.remove	removes a row from the scoreboard
Format	sb.remove(player, unique_index)
Arguments	index as number from 1 to 99

sb.addRaw	adds text to the scoreboard
Format	sb.addRaw(player, index, unique_string)
Arguments	index from 1 to 99
Info	vanilla: maximum 12 rows

sb.removeRaw	removes a row from the scoreboard
Format	sb.removeRaw(player, unique_string)

sb.setTitle	sets a scoreboard title
Format	sb.setTitle(player, text)

sb.clear	clears the scoreboard of a player
Format	sb.clear(player)

script.start	connects all scripts, starts them as one script and returns the script
Format	script.start(scriptpath1, scriptpath2, ...)

script.startNamed	connects all scripts, starts them as one script and returns the script
Format	script.startNamed(custom_name, scriptpath1, scriptpath2, ...)
Info	named scripts can be selected with script.get by their custom_name

script.callEvent	calls an event
Format	script.callEvent(event, [script])

title.send	shows a player a title (and subtitle if set)
Format	title.send(player, title, [subtitle], [fadeIn | 20], [stay | 60], [fadeOut | 20])

title.remove	removes the shown title
Format	title.remove(player)

perm.clear	removes all permissions from a player
Format	perm.clear(player)

perm.add	adds a permission to a player
Format	perm.add(perm, player)

perm.has	returns true if a player has the permission
Format	perm.has(perm, player)

perm.update	updates the permissions of a player
Format	perm.update(player)
Info	call this after adding all player permissions

players.toWorldList	returns a list with all players in a world
Format	players.toWorldList(World)

players.near	returns a list with all players within a radius of a location
Format	players.near(location, radius)

players.getAmount	returns the number of online players
Format	players.getAmount()

player.damageArmor	damages the armor of a player, portioned on all armor parts
Format	player.damageArmor(player, damage, damage_source)
Arguments	damage is cast to float

player.getHead	returns the head of a player as an itemstack
Format	player.getHead(uuid, name)
Arguments	uuid and(!) name of the same(!) player

player.getNearest	returns the next player to a location
Format	player.getNearest(location)
Info	searches in a radius of 10 blocks

player.setDisplayName	sets the name of a player in the tab list
Format	player.setDisplayName(player, text)

player.action	shows a message in the action bar
Format	player.action(receiver, text)

player.getTargetBlock	returns the block a player is looking at
Format	player.getTargetBlock(player, radius, [fluidmode|false])
Arguments	Vanilla default radius: 5 radius will be cast to int fluidmode: true does not ignore water

player.getName	returns the name of a player
Format	player.getName(uuid / string_uuid / player)
Info	uuid and string_uuid can return null

player.getUuid	returns the uuid of a player
Format	player.getUuid(player / player_name)
Info	player_name can return null

player.getUuidFromId	returns the uuid of a player from their id
Format	player.getUuidFromId(player_id)

player.getNameFromId	returns the name of a player from their id
Format	player.getNameFromId(player_id)

player.getId	returns the id of a player
Format	player.getId(player / uuid / string_uuid)

player.get	returns a player
Format	player.get(player / uuid / string_uuid)

player.respawn	forces the respawn of a dead player
Format	player.respawn(player)

player.setCompass	sets the target of a compass
Format	player.setCompass(player, location)

player.setHunger	sets the hunger of a player
Format	player.setHunger(player, number)
Info	Vanilla default: 0-20

player.getHunger	returns the hunger of a player
Format	player.getHunger(player)

player.setSaturation	sets the saturation of a player
Format	player.setSaturation(player, number)
Info	Vanilla default: 5, maximum: 20

player.getSaturation	returns the saturation of a player
Format	player.getSaturation(player)

player.setGamemode	set the gamemode for a player
Format	player.setGamemode(player, gamemode)
Arguments	gamemode as "SURVIVAL" / "CREATIVE" / "ADVENTURE" / "SPECTATOR"

player.isSurvival	returns true if a player is in gamemode survival
Format	player.isSurvival(player)

player.isCreative	returns true if a player is in gamemode creative
Format	player.isCreative(player)

player.isAdventure	returns true if a player is in gamemode adventure
Format	player.isAdventure(player)

player.isSpectator	returns true if a player is in gamemode spectator
Format	player.isSpectator(player)

player.hasFly	returns true if a player is allowed to fly
Format	player.hasFly(player)

player.isFlying	returns true if a player is flying
Format	player.isFlying(player)

player.setFly	set if a player is allowed to fly
Format	player.setFly(player, boolean)

player.dropInventory	drops the inventory of a player at a location
Format	player.dropInventory(player, location)

player.getItemAmount	returns the amount of an exact itemstack from a players inventory
Format	player.getItemAmount(player, itemstack)

player.damageItem	damages the item in the hand of a player
Format	player.damageItem(player, damage_amount)
Info	unbreaking (and more) is considered

player.setSpawn	sets the spawn location of a player
Format	player.setSpawn(player, location)

player.getSpawn	returns the spawn location of a player
Format	player.getSpawn(player)
Format	spawn is linked to the bed spawn, if no bed spawn exists the return value may be null

player.giveItem	gives an itemstack to a player and returns the item amount which didn't fit in a players inventory
Format	player.giveItem(player, itemstack)

player.addItem	returns 0 if the itemstack is added, otherwise the itemstack won't be added and the not fitting item amount is returned
Format	player.addItem(player, itemstack)

player.removeItem	returns 0 if the itemstack is removed, otherwise the itemstack won't be removed and the missing item amount is returned
Format	player.removeItem(player, itemstack)

player.getIP	returns the ip-address of a player as string
Format	player.getIp(player)

player.getInv	returns the (non-copy) inventory of a player
Format	player.getInv(player)

player.getEnderInv	returns the (non-copy) ender inventory of a player
Format	player.getEnderInv(player)

player.getTargetEntity	returns the targeted entity
Format	player.getTargetEntity(player, radius)
Arguments	radius will be cast to int

player.getLevel	returns the level of a player
Format	player.getLevel(player)

player.setLevel	sets the level of a player
Format	player.setLevel(player, level)
Arguments	level is cast to int

player.getExp	returns the experience of a player
Format	player.getExp(player)

player.setExp	sets the experience of a player
Format	player.setExp(player, exp)
Arguments	exp is cast to float

player.addTotalExp	modifies the experience of a player
Format	player.addTotalExp(player, exp)
Arguments	exp is cast to int

player.hide	hides a player
Format	player.hide(player)

player.show	shows a player
Format	player.show(player)

player.setFlySpeed	sets the fly speed of a player
Format	player.setFlySpeed(player, speed)
Arguments	speed is cast to float

player.setWalkSpeed	sets the walk speed of a player
Format	player.setWalkSpeed(player, speed)
Arguments	speed is cast to float

player.isSneaking	returns true if a player is sneaking
Format	player.isSneaking(player)

player.isBlocking	returns true if a player is blocking with their shield
Format	player.isBlocking(player)

player.setSlot	sets the active slot of a player
Format	player.setSlot(player, slot)
Arguments	slot from 0 to 8

inv.new	returns a new custom inventory
Format	inv.new(slotdata, title)
Arguments	slotdata as string: 0 = no slot, throws no event 1 = normal slot, throws inv_click event 2 = button slot, throws snuvi_click event
Examples	inv.new("002122000")

inv.getSize	returns the size of an inventory
Format	inv.getSize(inventory)

inv.setItem	sets an itemstack on a specific slot in an inventory
Format	inv.setItem(inventory, slotindex, itemstack)

inv.getItem	returns an itemstack from a specific slot of an inventory
Format	inv.getItem(inventory, slotindex)

inv.open	shows an inventory to a player
Format	inv.open(inventory, player)

inv.close	closes an inventory of a player
Format	inv.close(player)

inv.clear	clears an inventory
Format	inv.clear(inv)

inv.getID	returns the id of an inventory or -1 if no custom inventory
Format	inv.getID(inventory)

world.get	returns a world
Format	world.get(name)

world.getName	returns the name of a world
Format	world.getName(world)

world.getPlayers	returns a list with all players in a world
Format	world.getPlayers(world)

world.setDifficulty	sets the difficulty of a world
Format	world.setDifficulty(world, difficulty)

world.setSpawn	sets the world spawn
Format	world.setSpawn(world, location)

world.getSpawn	returns the world spawn as location
Format	world.getSpawn(world)

world.getAll	returns a list with all loaded worlds
Format	world.getAll()

world.setTime	sets the time for a world
Format	world.setTime(world, time)
Arguments	time from 0 to 24000

world.getTime	returns the time of a world
Format	world.getTime(world)

world.hasRain	returns true if it is raining in the world
Format	world.hasStorm(world)

world.hasThunder	returns true if there is thunder in the world
Format	world.hasThunder(world)

world.clearWeather	clears the weather of a world
Format	world.clearWeather(world, ticks)
Info	ticks when the next rain is allowed to start

world.setRain	sets the weather of a world to rain
Format	world.setRain(world, ticks)
Info	ticks how long the rain stays

world.setThunder	sets the weather of a world to thunder
Format	world.setThunder(world, ticks)
Info	ticks how long the thunder stays

world.getEntities	returns a list with all entities in a world
Format	world.getEntities(world)

world.load	returns the loaded world
Format	world.load(name)

world.unload	returns true if unloading a world is successful
Format	world.unload(world)

Xentity.getType	returns the type of an entity
Format	entity.getType(entity)

Xentity.setName	sets the name of an entity, true for an always visible name
Format	entity.setName(entity, name, nameVisibility|false)

Xentity.getName	returns the name of an entity
Format	entity.getName(entity)

Xentity.getLocation	returns the location of an entity
Format	entity.getLocation(entity / player)

Xentity.teleport	teleports an entity
Format	entity.teleport(entity / player, location)

Xentity.setInvulnerable	sets an entity (in)vulverable
Format	entity.setInvulnerable(entity / player, boolean)

Xentity.throw	throws an entity in relative direction to the entity
Format	entity.throw(entity / player, x, y, z)
Info	x/y/z is claimed in the interval from -3.9 to 3.9 by minecraft

Xentity.setInvisible	sets an entity (in)visible
Format	entity.setInvisible(entity / player, boolean)

Xentity.clearEffects	remove all effects from an entity
Format	entity.clearEffects(entity)

Xentity.remove	removes an entity
Format	entity.remove(entity)

Xentity.removeAll	remove specific entities from an area
Format	entity.removeAll(entity_class, location, radius)
Info	not all entity_classes are allowed (filtered and blocked)
Examples	entity.removeAll("net.minecraft.entity.passive.CowEntity", location, radius)

Xentity.setSilent	true sets an entity silent
Format	entity.setSilent(entity, boolean)

Xentity.mount	let an entity ride another entity (for any living entities)
Format	entity.mount(entity, horse_entity)

Xentity.unmount	unmounts the rider
Format	entity.unmount(entity)

Xentity.isWet	returns true if an entity is wet
Format	entity.isWet(entity)

Xentity.isBurning	returns true if an entity burns
Format	entity.isBurning(entity)

Xentity.setBurning	sets an entity on fire
Format	entity.setBurning(entity, seconds)
Info	0 seconds extinguish the entity

Xentity.setNoPickup	this arrow-entity cannot be picked up
Format	entity.setNoPickup(arrow-entity)

Xentity.get	returns the next entity to a location
Format	entity.get(location, radius, entity_class)
Examples	entity.get(location, radius, "net.minecraft.entity.passive.CowEntity")

Xentity.getItemFromFrame	returns the itemstack of an itemframe
Format	entity.getItemFromFrame(itemframe-entity)

Xentity.spawnItemFrame	sets an itemframe with an itemstack
Format	entity.spawnItemFrame(location, direction, itemstack)
Arguments	direction "north" / "east" / "south" / "west"

Xentity.spawn	spawns an entity and returns the entity
Format	entity.spawn(type, location, [daten])

Xentity.getEnchantmentModifier	returns the summarized enchantment modificator of the armor for the damagesource
Format	entity.getEnchantmentModifier(entity, damagesource)

Xentity.setGravity	toggles the gravity of an entity
Format	entity.setGravity(entity, boolean)

Xentity.setPickupDelay	unknown
Format	entity.setPickupDelay(item-entity, ticks)

Xentity.setGrowingAge	sets the growing age of an entity
Format	entity.setGrowingAge(entity, age_int)

Xentity.getEffectAmplifier	returns the amplifier (effect level), 0 if not existing
Format	entity.hasEffect(entity / player, effect)
Arguments	String effect

Xentity.addEffect	adds an effect to an entity
Format	entity.addEffect(entity / player, effect, ticks, amplifier, [particle|true])
Arguments	String effect / number ticks (infinite: 32760) / number amplifier (1 means potion-level 1)

Xentity.getPotionType	returns the type of a potion
Format	entity.getPotionType(potion-entity)

Xentity.near	returns a list with all entities within a location / a radius of an entity
Format	entity.near(location / entity, radius)

Xentity.getLook	returns an array with vectors
Format	entity.getLook(entity / player)
Examples	array[0] = x array[1] = y array[2] = z

Xentity.getMotion	returns an array with vectors
Format	entity.getMotion(entity)

Xentity.addTag	adds a tag to an entity
Format	entity.addTag(entity, tag as string)

Xentity.removeTag	removes a tag from an entity
Format	entity.removeTag(entity, tag as string)

Xentity.clearTag	removes all tags from an entity
Format	entity.clearTag(entity)

Xentity.hasTag	returns true if an entity has a tag
Format	entity.hasTag(entity, tag as string)
Info	default entity-tags: no_tick, mod_spawned

entity.frame.hide	hides an item frame
Format	entity.frame.hide(entity_frame)

entity.frame.show	shows an item frame
Format	entity.frame.show(entity_frame)

entity.frame.setFixed	sets the fix tag for an item frame
Format	entity.frame.setFixed(entity_frame, boolean)

Xcreeper.explode	let a creeper explode
Format	creeper.explode(entity)

Xsheep.isSheared	returns true if a sheep is sheared
Format	sheep.isSheared(entity)

Xsheep.getColor(entity)	returns the color of a sheep
Format	sheep.getColor(entity)

Xpet.isTamed	returns true if a pet is tamed
Format	pet.isTamed(tamable_entity)

Xpet.setTamed	set tame state for a tamable entity
Format	pet.setTamed(tamable_entity, boolean, [owner])
Example	pet.setTamed(horse, true) pet.setTamed(horse, false) pet.setTamed(horse, true, owner) pet.setTamed(horse, false, owner)

Xpet.getOwner	returns the owner's uuid from an pet
Format	pet.getOwner(tamable_entity)

Xliving.setHealth	sets the health points for a living entity
Format	living.setHealth(living_entity, amount)

Xliving.getHealth	returns the health points from a living entity
Format	living.getHealth(living_entity)

Xliving.damage	damages a living entity
Format	living.damage(living_entity, damage_amount, [damagesource])
Info	triggers events on the next server tick

Xliving.heal	heals a living entity
Format	living.heal(living_entity, heal_amount)
Info	triggers events on the next server tick

Xliving.setEquip	set the equipment of a living entity
Format	living.setEquip(living_entity, bodypart, itemstack)
Info	bodypart: "head" / "chest" / "legs" / "feet" / "hand" / "offhand"

Xliving.getEquip	returns the equipment of a living_entity
Format	living.getEquip(living_entity, bodypart)
Arguments	bodypart: "head" / "chest" / "legs" / "feet" / "hand" / "offhand"

Xliving.near	returns a list with all living entities within a location / a radius of an entity
Format	living.near(location / entity, radius)

Xliving.removeAi	removes the AI of an entity
Format	living.removeAi(living_entity)

X	commands for living properties
Format	living.get...(living_entity) living.getBase...(living_entity) living.set..(living_entity, value) living.setPersistent...(living_entity, value)
Properties	...maxHealth ...AttackKnockback ...AttackDamage ...AttackSpeed ...FollowRange ...Luck ...Armor ...ArmorThoughness ...MovementSpeed ...FlyingSpeed ...KnockbackResistance

Xliving.shootProjectile	returns the shooten entity. A projectile is shooten into viewing direction of the player
Format	living.shootProjectile(living_entity, String entity_class, Number power, [data])
Arguments	data: always null, except for arrows and potions use itemstacks entity_classes: me.km.entities.EntityItemProjectile net.minecraft.entity.projectile.SnowballEntity net.minecraft.entity.projectile.EggEntity net.minecraft.entity.item.EnderPearlEntity net.minecraft.entity.projectile.PotionEntity net.minecraft.entity.item.ExpBottleEntity net.minecraft.entity.projectile.ArrowEntity net.minecraft.entity.projectile.TippedArrowEntity net.minecraft.entity.projectile.SpectralArrowEntity net.minecraft.entity.projectile.ArrowEntity net.minecraft.entity.projectile.SmallFireballEntity net.minecraft.entity.projectile.WitherSkullEntity net.minecraft.entity.projectile.DragonFireballEntity net.minecraft.entity.projectile.FireballEntity

Xliving.isBlocking	returns true if an entity is blocking (e.g. activated shield)
Format	living.isBlocking(entity)

particle.get	returns a particle
Format	particle.get(name)

particle.getAll	returns an array of all particles
Format	particle.getAll()

particle.spawn	spawns a particle
Format	particle.spawn(location, particle, [count | 1], [speed | 0.0], [offX | 0.0], [offY | 0.0], [offZ | 0.0])

particle.spawnPlayer	spawns a particle
Format	particle.spawnPlayer(location, particle, player, [count | 1], [speed | 0.0], [offX | 0.0], [offY | 0.0], [offZ | 0.0])

sound.get	returns a sound
Format	sound.get(name)

sound.getCategory	returns a sound category
Format	sound.getCategory(name)

sound.spawn	plays a sound
Format	sound.spawn(location, sound, sound_category, [volume | 1.0], [pitch | random from 0.9 to 1.0])

sound.spawnForPlayer	plays a sound for a player
Format	sound.spawnForPlayer(player, sound, sound_category, [volume | 1.0], [pitch | random from 0.9 to 1.0])

human.spawn	returns the spawned human
Format	human.spawn(location, name)

human.setSkin	sets the skin of a human
Format	human.setSkin(human, texture_value, texture_signature)

human.setName	sets the name of a human
Format	human.setName(human, name)

damage.get	returns a damage_source
Format	damage.get(damage_name)
Arguments	damage_name: inFire, lightningBolt, onFire, lava, hotFloor, inWall, cramming, drown, starve, cactus, fall, flyIntoWall, outOfWorld, generic, magic, wither, anvil, fallingBlock, dragonBreath, dryout, sweetBerryBush, freeze, fallingStalactite, stalagmite

damage.getType	returns the type of a damage_source as string
Format	damage.getType(damage_source)

damage.getImmediateSource	returns the direct damager entity of a damage_source
Format	damage.getImmediateSource(damage_source)

damage.getTrueSource	returns the indirect damager entity of a damage_source
Format	damage.getTrueSource(damage_source)

damage.isCreativePlayer	returns true if the damage_source can damage an creative player
Format	damage.isCreativePlayer(damage_source)

damage.isAbsolute	returns true if the damage ignores modifications by potion effects or enchantments
Format	damage.isAbsolute(damage_source)

damage.isDifficultyscaled	returns true if the damage_source will have its damageamount scaled based on the current difficulty
Format	damage.isDifficultyscaled(damage_source)

damage.isExplosion	returns true if the damage is explosion based
Format	damage.isExplosion(damage_source)

damage.isFire	returns true if the damage is fire based
Format	damage.isFire(damage_source)

damage.isMagic	returns true if the damage is magic based
Format	damage.isMagic(damage_source)

damage.isProjectile	returns true if the damage is projectile based
Format	damage.isProjectile(damage_source)

damage.isUnblockable	returns true if the damage cannot be blocked by armor
Format	damage.isUnblockable(damage_source)

damage.isFall	returns true if the damage is fall based
Format	damage.isFall(damage_source)

damage.isDamagingHelmet	returns true if the damage is damaging helmet based
Format	damage.isDamagingHelmet(damage_source)

damage.isSweep	returns true if the damage is sweep based
Format	damage.isSweep(damage_source)

damage.sting	returns a sting damage_source
Format	damage.sting(living_entity)

damage.mobAttack	returns a mob attack damage_source
Format	damage.mobAttack(living_entity)

damage.indirect	returns a indirect damage_source
Format	damage.indirect(entity, living_entity)

damage.playerAttack	returns a player attack damage_source
Format	damage.playerAttack(player)

damage.arrow	returns a arrow damage_source
Format	damage.arrow(arrow, entity)

damage.trident	returns a trident damage_source
Format	damage.trident(entity1, entity2)

damage.firework	returns a firework damage_source
Format	damage.firework(firework, entity)

damage.fireball	returns a fireball damage_source
Format	damage.fireball(large_fireball, entity)

damage.witherSkull	returns a wither skull damage_source
Format	damage.witherSkull(wither_skull, entity)

damage.projectile	returns a projectile damage_source
Format	damage.projectile(entity1, entity2)

damage.indirectMagic	returns a indirect magic damage_source
Format	damage.indirectMagic(entity1, entity2)

damage.thorns	returns a thorns damage_source
Format	damage.thorns(entity)

damage.explosion	returns a explosion damage_source
Format	damage.explosion(living_entity)

damage.explosionBed	returns a explosion bed damage_source
Format	damage.explosionBed()

data.set	sets data for a player (script-across)
Format	data.set(player, key, value)

data.get	returns data from a player (script-across)
Format	data.get(player, key)

data.setTimer	sets timed data for a player (script-across)
Format	data.setTimer(player, key, ticks)
Arguments	set ticks to -1 to delete the timer when the timer expires the event player_data_tick is thrown

data.getTimer	returns the remaining ticks of timed data (script-across)
Format	data.getTimer(player, key)

data.clear	deletes all data from a player (script-across)
Format	data.clear(player)

Xshop.new	returns a new shop
Format	shop.new()

Xshop.addOffer	adds an offer to a shop
Format	shop.addOffer(shop, buy_item, sell_item, max_uses)

Xshop.addDoubleOffer	adds a double offer to a shop
Format	shop.addDoubleOffer(shop, buy_item_1, buy_item_2, sell_item, max_uses)

Xshop.open	shows a shop to a player
Format	shop.open(shop, player, shop_name)

boss.create	returns a bossbar
Format	boss.create(title, color, barstyle)
Arguments	title as string color as string barstyle as string

boss.addPlayer	add a player to the bossbar
Format	boss.addPlayer(bossbar, player)

boss.removePlayer	remove a player from the bossbar
Format	boss.removePlayer(bossbar, player)

boss.removeAll	remove all players from the bossbar
Format	boss.removeAll(bossbar)

boss.addFlag	adds a flag to the bossbar
Format	boss.addFlag(bossbar, flag)
Arguments	flag as string

boss.removeFlag	removes a flag from the bossbar
Format	boss.removeFlag(bossbar, flag)
Arguments	flag as string

boss.setTitle	sets the title for the bossbar
Format	boss.setTitle(string)

boss.setProgress	sets the progress of the bossbar
Format	boss.setProgress(double)
Arguments	double from 0 to 1