footnote
*	writable
**	can be null

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 old_material *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

entity_dismount	an entity dismounts another entity
Variables	entity mount as entity

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 by a player
Variables	player block *cancel

block_place	a block is placed by a player
Variables	player block hand *cancel

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

block_burn	a block is burned
Variables	block block_source *cancel

block_spread	Paper API#BlockSpreadEvent
Variables	block block_source *cancel

block_fade	Paper API#BlockFadeEvent
Variables	block *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 permission as string command_class 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

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

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 perm

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

player_jump	a player jumps
Variables	player

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

vehicle_enter	an entity enters a vehicle
Variables	vehicle entity

vehicle_exit	an living_entity exits a vehicle
Variables	vehicle living_entity

block_shear	a player uses shears on a block
Variables	player block hand *drops *cancel

bell_ring	a bell is rung
Variables	block **entity direction *cancel

spectation_start	a player starts spectating
Variables	player entity *cancel

spectation_stop	a player stops spectating
Variables	player entity *cancel

player_pickup_exp	a player picks up XP
Variables	player *cancel

elytra_boost	a player boosts using elytra
Variables	player hand firework as entity *consume as boolean *cancel

event.addMoveData	creates an area for player_move events and returns the id
Format	event.addMoveData(location1, location2, cooldown, livingtime, [uuid / uuid_string / 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 / uuid_string / 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_uuid)

ban.addIp	bans an IP from the server
Format	ban.addIp(ip, 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.removeIp	unbans an IP from the server
Format	ban.removeIp(ip)

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, side, row, text)
Arguments	row from 0 to 3 side: "FRONT"/"BACK"

block.getSign	returns the text of a sign from a specific row
Format	block.getSign(block, side, row)
Arguments	row from 0 to 3 side: "FRONT"/"BACK"

block.signSetWaxed	wax/unwax a sign
Format	block.signSetWaxed(block, boolean)

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.isOpenable	returns true if a block is openable
Format	block.isOpenable(block)

block.isDoor	returns true if a block is a door
Format	block.isDoor(block)

block.setDoorHinge	sets the door hinge of a block
Format	block.setDoorHinge(block, door_hinge_string)

block.getDoorHinge	returns the door hinge of a block as string
Format	block.getDoorHinge(block)

block.setBisectedHalf	sets the bisected half of a block
Format	block.setBisectedHalf(block, bisected_half_string)

block.getBisectedHalf	returns the bisected half of a block as string
Format	block.getBisectedHalf(block)

block.isBisected	returns true if a block is bisected
Format	block.isBisected(block)

block.setDirectionalFace	sets the directional face of a block
Format	block.setDirectionalFace(block, directional_face_string)

block.getDirectionalFace	returns the directional face of a block as string
Format	block.getDirectionalFace(block)

block.getDirectionalFaces	returns a list with directional faces as string of a block
Format	block.getDirectionalFaces(block)

block.isDirectional	returns true if a block is directional
Format	block.isDirectional(block)

block.setPersistent	sets the persistence of a block
Format	block.setPersistent(block, boolean)

block.isPersistent	returns true if a block is persistent
Format	block.isPersistent(block)

block.isLeaves	returns true if a block is a leaf
Format	block.isLeaves(block)

block.canHaveWater	returns true if a block can have water
Format	block.canHaveWater(block)

block.isWaterLogged	returns true if a block is waterlogged
Format	block.isWaterLogged(block)

block.setWaterLogged	set the waterlogged property of a block
Format	block.setWaterLogged(block, boolean)

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)

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

citizen.despawn	despawns a citizen
Format	citizen.despawn(citizen)

citizen.destroy	destroys a citizen
Format	citizen.destroy(citizen)

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

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

citizen.showNameplate	sets the nameplate visibility of a citizen
Format	citizen.showNameplate(citizen, boolean)

citizen.setEquip	equips a citizen
Format	citizen.setEquip(citizen, slot_name, itemstack)

citizen.getName	returns the name as string
Format	citizen.getName(citizen)

citizen.lookclose	makes a citizen look at nearby players
Format	citizen.lookclose(citizen)

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

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, outsideBorder, genericKill

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.isDifficultyscaled	returns true if the damage_source will have its damageamount scaled based on the current difficulty
Format	damage.isDifficultyscaled(damage_source)

damage.isIndirect	returns true if the damage_source is indirect
Format	damage.isIndirect(damage_source)

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)

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(world, gamerule_value, boolean)

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

msg	sends a message
Format	msg(receiver, text)
Info	receiver: sender (player / console) "dev" (perm "script.debug" needed) "online" "server"

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)

isCitizen	returns true if the argument is a citizen
Format	isCitizen(anything)

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

getMOTD	returns the message of the day as text
Format	getMOTD()

stop	stops the server
Format	stop()

material.get	returns a material
Format	material.get(material_name)

material.getAll	returns an array with all materials
Format	material.getAll()

material.isItem	returns true if a material is an holdable item
Format	material.isItem(material)

material.isBlock	returns true if a material is an placeable block
Format	material.isBlock(material)

material.isSolid	returns true if a material is a block and solid (can be built upon)
Format	material.isSolid(material)

material.setCooldown	sets the cooldown of a material of a player
Format	material.setCooldown(material, player, ticks)

material.getSlot	returns the slot to use for an item attribute
Format	material.getSlot(material)

item.new	return an itemstack
Format	item.new(material, [amount | 1])

item.drop	drops an itemstack at a location and returns the item_entity
Format	item.drop(itemstack, location)

item.getType	returns the material of an itemstack
Format	item.getType(itemstack)

item.getMaxAmount	returns the maximum size of an itemstack
Format	item.getMaxAmount(itemstack)

item.getAmount	returns the size of an itemstack
Format	item.getAmount(itemstack)

item.setAmount	sets the size of an itemstack
Format	item.setAmount(itemstack, size)

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

item.getName	returns the name of an itemstack as text or null
Format	item.getName(itemstack)

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

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

item.setLore	sets the lore of an itemstack
Format	item.setLore(itemstack, list)
Arguments	list of texts

item.addAttribute	adds an attribute to an itemstack
Format	item.addAttribute(itemstack, attribute, slot, double, operation)

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

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

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

item.addFlag	adds a flag to an itemstack
Format	item.addFlag(itemstack, flag)

item.removeFlag	removes a flag from an itemstack
Format	item.removeFlag(itemstack, flag)

item.addPotion	adds a potion effect to an item
Format	item.addPotion(itemstack, potion_name, duration, power)

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

item.getTag	returns an item tag
Format	item.getTag(String tag_name)

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

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

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

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

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

item.entity.get	returns the itemstack of an item_entity
Format	item.entity.get(item_entity)

item.entity.set	sets the itemstack of an item_entity
Format	item.entity.set(item_entity, itemstack)

item.entity.setPickupDelay	sets the pickupdelay for an item_entity
Format	item.entity.setPickupDelay(item_entity, ticks)

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

enchantment.getMaxLevel	returns the maximum level of an enchantment
Format	enchantment.getMaxLevel(enchantment)

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

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

enchantment.readFromItem	returns a map with all enchantments of an itemstack
Format	enchantment.readFromItem(itemstack)
Format	enchantment as key, level as value

enchantment.writeToItem	writes 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)

debug.getIndexTime	returns the time of a debug message from an index
Format	debug.getIndexTime(index)

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)

error.getIndexTime	returns the time of an error from an index
Format	error.getIndexTime(index)

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

read.player	returns a player or null
Format	read.player(player_name)

read.item	returns an itemstack or null
Format	read.item(nbt_string)

read.uuid	returns a uuid or null
Format	read.uuid(uuid_string)

read.slot	returns a slot or null
Format	read.slot(slot_name)

read.blockData	returns blockdata or null
Format	read.blockData(blockdata_string)

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)

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, ...)

text.item	returns a hoverable itemstack text
Format	text.item(show_text, itemstack)

text.suggest	returns a clickable text for chat/command line insertion
Format	text.suggest(show_text, suggest_text)

text.color	returns rgb colored text
Format	text.color(text, red, green, blue)
Info	red green blue from 0 to 255

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])

plot.addBlock	makes a block public
Format	plot.addBlock(location)

plot.removeBlock	makes a block non-public
Format	plot.removeBlock(location)

plot.hasBlock	returns true if a block is public
Format	plot.hasBlock(location)

plot.blockIterator	returns the iterator for protected blocks in a world
Format	plot.blockIterator(world)

plot.position.getX	returns the x coordinate of a position
Format	plot.position.getX(position)

plot.position.getY	returns the y coordinate of a position
Format	plot.position.getY(position)

plot.position.getZ	returns the z coordinate of a position
Format	plot.position.getZ(position)

plot.savePlots	saves all plot changes
Format	plot.savePlots(world)

plot.saveBlocks	saves all block changes
Format	plot.saveBlocks(world)

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.newHelp	returns a help-object
Format	command.newHelp(string, perm)

command.newHelpLiteral	returns a help argument
Format	command.newHelpLiteral(string, [perm])

command.newHelpBool	returns a help argument
Format	command.newHelpBool(string, [perm])

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

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

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

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

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

command.newHelpSpecial	returns a help argument
Format	command.newHelpSpecial(type, string, [perm])
Arguments	type = "Item", "Particle", "Potion", "Sound", "Enchantment", "Player"

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

command.addHelpArgument	adds a help argument to a help
Format	command.addHelpArgument(help, helpArgument)

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.remove	removes a permission from a player
Format	perm.remove(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.toList	returns a list with all players in a world
Format	players.toList(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.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)
Info	receiver: sender (player / console) "dev" (perm "script.debug" needed) "online" "server"

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 / uuid_string / player)
Info	uuid and uuid_string 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 / uuid_string)

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

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 did not fit in a players inventory
Format	player.giveItem(player, itemstack)

player.addItem	returns 0 if the itemstack is added, otherwise the itemstack will not 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 will not 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.getTargetCitizen	returns the targeted citizen
Format	player.getTargetCitizen(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 from another player
Format	player.hide(player, player_to_hide)

player.show	shows a player or another player
Format	player.show(player, player_to_show)

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.isSprinting	returns true if the player is sprinting
Format	player.isSprinting(player)

player.setSprinting	sets weather the player is sprinting or not
Format	player.setSprinting(player)

player.setSneaking	sets weather the player is sneaking or not
Format	player.setSneaking(player)

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

player.resetSleep	resets the time since last rest
Format	player.resetSleep(player)

player.getSpectatorTarget	gets the Targetentity the player is spectating
Format	player.getSpectatorTarget(player)

player.setSpectatorTarget	sets the Targetentity the player is spectating, set entity to null to reset.
Format	player.getSpectatorTarget(player, entity)

player.getLastDeathLocation	gets the players last death location
Format	player.getLastDeathLocation(player)

player.showElderGuardian	if silent is true, the elder guardian animation if hidden
Format	player.showElderGuardian(player, silent)

player.setExpCooldown	Sets the player's cooldown between picking up experience orbs.
Format	player.setExpCooldown(player, ticks)

player.sendHurtAnimation	Fakes incoming damage, yaw from 0-270. 0 = straight, 90 = right
Format	player.sendHurtAnimation(player, yaw)

player.lookat	sets the player to look at an entity, LookAnchor = "EYES"/"FEET"
Format	player.lookat(player, entity, playerLookAnchor, entityLookAnchor)

player.getPing	returns the ping of a player
Format	player.getPing(player)

player.setPlayerListHeader	sets the TablistHeader for the receiver
Format	player.setPlayerListHeader(receiver, text)

player.setPlayerListFooter	sets the TablistFooter for the receiver
Format	player.setPlayerListFooter(receiver, text)

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)

inv.closeAll()	closes all custom inventories of all players
Format	inv.closeAll()

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(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)

world.getLoadedChunks	returns an array with all loaded chunks
Format	world.getLoadedChunks(world)

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

world.getChunkX	returns the x chunk coordinate
Format	world.getChunkX(chunk)

world.getChunkZ	returns the x chunk coordinate
Format	world.getChunkZ(chunk)

world.isForceLoadedChunk	returns true if a chunk is forced to be loaded
Format	world.isForceLoadedChunk(chunk)

entity.getUuid	returns the uuid of an entity
Format	entity.getUuid(entity)

entity.getType	returns the type of an entity as string
Format	entity.getType(entity)

entity.setName	sets the name of an entity
Format	entity.setName(entity, text, [nameVisibility | false])
Info	nameVisibility true means an always visible name)

entity.getName	returns the name of an entity as text
Format	entity.getName(entity)

entity.getLocation	returns the location of an entity
Format	entity.getLocation(entity)

entity.teleport	teleports an entity
Format	entity.teleport(entity, location)

entity.setInvulnerable	sets an entity (in)vulnerable
Format	entity.setInvulnerable(entity, boolean)

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

entity.removeAll	remove specific entities from an area
Format	entity.removeAll(entity_class, location, radius)

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

entity.mount	lets an entity ride another entity
Format	entity.mount(entity, mount_entity)

entity.unmount	unmounts an entity
Format	entity.unmount(entity)

entity.getMount	returns the mount of an entity
Format	entity.getMount(entity)

entity.getPassengers	returns a list of passengers of an entity
Format	entity.getPassengers(entity)

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

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

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

entity.setNoPickup	sets an arrow_entity not pickupable
Format	entity.setNoPickup(arrow_entity)

entity.get	returns the next entity to a location or null
Format	entity.get(location, radius, entity_class)

entity.spawn	spawns an entity and returns it
Format	entity.spawn(location, type)

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

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

entity.getPotionType	returns the itemstack of a thrown potion
Format	entity.getPotionType(potion_entity)

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

entity.getLook	returns the look direction as array
Format	entity.getLook(entity)

entity.setLook	sets the look of an entity
Format	entity.setLook(entity, x, y, z)

entity.getMotion	returns the motion as array
Format	entity.getMotion(entity)

entity.setMotion	sets the motion of an entity
Format	entity.setMotion(entity, x, y, z)
Info	x/y/z is clamped in the interval from -3.9 to 3.9 by Minecraft

entity.frame.spawn	spawns an itemframe with an itemstack
Format	entity.frame.spawn(location, block_face, itemstack)

entity.frame.getItem	returns the itemstack of an itemframe
Format	entity.frame.getItem(entity_frame)

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

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

entity.frame.setFixed	sets the fixed tag for an itemframe
Format	entity.frame.setFixed(entity_frame, boolean)

entity.frame.setFacing	sets the facing for an itemframe
Format	entity.frame.setFacing(entity_frame, block_face)

entity.spawnSeat	returns an itemframe (as a seat to mount another entity)
Format	entity.spawnSeat(location)

rabbit.spawnKillerBunny	spawns a killer bunny and returns it
Format	rabbit.spawnKillerBunny(location)

creeper.explode	lets a creeper explode
Format	creeper.explode(entity)

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

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

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

pet.setTamed	sets tame state for a tameable entity
Format	pet.setTamed(tameable_entity, boolean, [owner])
Example	pet.setTamed(horse, true) pet.setTamed(horse, false) pet.setTamed(horse, true, player) pet.setTamed(horse, false, player)

pet.getOwner	returns the owner of a pet
Format	pet.getOwner(tameable_entity)

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

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

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

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

living.setEquip	sets the equipment of a living entity
Format	living.setEquip(living_entity, slot, itemstack)

living.getEquip	returns the equipment of a living_entity
Format	living.getEquip(living_entity, slot)

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

living.setAi	sets if the AI of an entity is active
Format	living.setAi(living_entity, boolean)

generic living commands	commands for living properties
Format	living.get...(living_entity) living.set...(living_entity, value) living.reset...(living_entity)
Properties	attributes without "GENERIC." and "_"

living.shootProjectile	returns the shooten entity
Format	living.shootProjectile(living_entity, entity_class)

living.setInvisible	sets a living_entity (in)visible
Format	living.setInvisible(living_entity, boolean)

living.addEffect	adds an effect to a living_entity
Format	living.addEffect(living_entity, effect, ticks, amplifier, [particle | true])
Arguments	amplifier 0 means potion level 1

living.clearEffects	removes all effects from a living entity
Format	living.clearEffects(living_entity)

living.getEffectAmplifier	returns the amplifier (effect level), -1 if not existing
Format	living.getEffectAmplifier(entity, effect)

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])

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(bossbar, string)

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

whitelist.enable	enables the whitelist
Format	whitelist.enable()

whitelist.disable	disables the whitelist
Format	whitelist.disable()

whitelist.add	adds a player to the whitelist
Format	whitelist.add(uuid / uuid_string / player)

whitelist.remove	removes a player from the whitelist
Format	whitelist.remove(uuid / uuid_string / player)

whitelist.clear	clears the whitelist
Format	whitelist.clear()

as.getBodyPose	returns the body pose of an armor stand
Format	as.getBodyPose(armor_stand)

as.getHeadPose	returns the head pose of an armor stand
Format	as.getHeadPose(armor_stand)

as.getLeftArmPose	returns the left arm pose of an armor stand
Format	as.getLeftArmPose(armor_stand)

as.getRightArmPose	returns the right arm pose of an armor stand
Format	as.getRightArmPose(armor_stand)

as.getLeftLegPose	returns the left leg pose of an armor stand
Format	as.getLeftLegPose(armor_stand)

as.getRightLegPose	returns the right leg pose of an armor stand
Format	as.getRightLegPose(armor_stand)

as.hasArms	returns true if an armor stand has arms
Format	as.hasArms(armor_stand)

as.hasBasePlate	returns true if an armor stand has a base plate
Format	as.hasBasePlate(armor_stand)

as.isMarker	returns true if an armor stand is a marker
Format	as.isMarker(armor_stand)

as.isSmall	returns true if an armor stand is small
Format	as.isSmall(armor_stand)

as.setArms	sets that an armor stand can have arms
Format	as.setArms(armor_stand, boolean)

as.setBasePlate	sets that an armor stand can have a base plate
Format	as.setBasePlate(armor_stand, boolean)

as.setMarker	sets that an armor stand can be a marker
Format	as.setMarker(armor_stand, boolean)

as.setSmall	sets that an armor stand is small
Format	as.setSmall(armor_stand, boolean)

as.canMove	sets that an armor stand can move
Format	as.canMove(armor_stand, boolean)

as.canTick	sets that an armor stand can tick
Format	as.canTick(armor_stand, boolean)

as.setBodyPose	sets the body pose of an armor stand
Format	as.setBodyPose(armor_stand, euler_angle)

as.setHeadPose	sets the head pose of an armor stand
Format	as.setHeadPose(armor_stand, euler_angle)

as.setLeftArmPose	sets the left arm pose of an armor stand
Format	as.setLeftArmPose(armor_stand, euler_angle)

as.setRightArmPose	sets the right arm pose of an armor stand
Format	as.setRightArmPose(armor_stand, euler_angle)

as.setLeftLegPose	sets the left leg pose of an armor stand
Format	as.setLeftLegPose(armor_stand, euler_angle)

as.setRightLegPose	sets the right leg pose of an armor stand
Format	as.setRightLegPose(armor_stand, euler_angle)

euler.new	returns a new created euler angle
Format	euler.new(x, y, z)

euler.getX	returns the x angle of an euler angle
Format	euler.getX(euler_angle)

euler.getY	returns the y angle of an euler angle
Format	euler.getY(euler_angle)

euler.getZ	returns the z angle of an euler angle
Format	euler.getZ(euler_angle)

euler.setX	sets the x angle of an euler angle
Format	euler.setX(euler_angle, value)

euler.setY	sets the y angle of an euler angle
Format	euler.setY(euler_angle, value)

euler.setZ	sets the z angle of an euler angle
Format	euler.setZ(euler_angle, value)