paper-snuvi-scripts/utils/u_general.txt

function calcLeftShift(bit) { //Deprecated, kaje soll << einbauen
	a = 1;
	a <<= bit;
	return a;
}

function sb.getSpacer() {
	return("§0------------------");
}

function isString(anything) {
	return string.class(anything) == "String";
}

function isBlock(anything) {
	return string.class(anything) == "CraftBlock";
}

function getServerConfig() {
	return getScriptVar("server_config");
}

function snuvi.debug(string) {
	msg.string("dev", string.concat("[§eDebug§r] ", string));
}

function perm.no(perm, player) {
	msg.prefix(player, "§6Perms", string.concat("You have no permission for §c", perm, "§r."));
}

function checkIfEverOnline(player_name) {
	if(player.getUuid(player_name) == null) {
		return false;
	}
	return true;
}

function isOnline(player_name) {
	if(read.player(player_name) == null) {
		return false;
	}
	return true;
}

function list.copy(list) {
	list_new = list.new();
	iter = iterator(list);
	while(hasNext(iter)) {
		list.add(list_new, next(iter));
	}
	return list_new;
}

function list.transfer(from_list, to_list) {
	iter = iterator(from_list);
	while(hasNext(iter)) {
		list.add(to_list, next(iter));
	}
}

function array.sort(my_array, ascending) {
	size = array.getSize(my_array);
	if(ascending) {
		for(i = 0; i < size - 1; i++) {
			for(j = i + 1; j < size; j++) {
				if(my_array[j] < my_array[i]) {
					temp = my_array[i];
					my_array[i] = my_array[j];
					my_array[j] = temp;
				}
			}
		}
	} else {
		for(i = 0; i < size - 1; i++) {
			for(j = i + 1; j < size; j++) {
				if(my_array[j] > my_array[i]) {
					temp = my_array[i];
					my_array[i] = my_array[j];
					my_array[j] = temp;
				}
			}
		}
	}
	return my_array;
}

function array.contains(array, element) {
	for(i = 0; i < array.getSize(array); i++) {
		if(array[i] == element) {
			return true;
		}
	}
	return false;
}

function array.getIndexOf(array, element) {
	for(i = 0; i < array.getSize(array); i++) {
		if(array[i] == element) {
			return i;
		}
	}
	return -1;
}

function map.sort(map, ascending) {
	size = map.getSize(map);
	my_array = array.new(size, 2);
	//Map in Array umwandeln
	i = 0;
	iter = map.iterator(map);
	while(hasNext(iter)) {
		element = next(iter);
		key = map.getKey(element);
		value = map.getValue(element);
		my_array[i, 0] = key;
		my_array[i, 1] = value;
		i++;
	}
	//Array sortieren
	if(ascending) {
		for(i = 0; i < size - 1; i++) {
			for(j = i + 1; j < size; j++) {
				if(my_array[j, 1] < my_array[i, 1]) {
					g = my_array[i, 0];
					h = my_array[i, 1];
					my_array[i, 0] = my_array[j, 0];
					my_array[i, 1] = my_array[j, 1];
					my_array[j, 0] = g;
					my_array[j, 1] = h;
				}
			}
		}
	} else {
		for(i = 0; i < size - 1; i++) {
			for(j = i + 1; j < size; j++) {
				if(my_array[j, 1] > my_array[i, 1]) {
					g = my_array[i, 0];
					h = my_array[i, 1];
					my_array[i, 0] = my_array[j, 0];
					my_array[i, 1] = my_array[j, 1];
					my_array[j, 0] = g;
					my_array[j, 1] = h;
				}
			}
		}
	}
	return my_array;
}

function getDirection(yaw) {
	while(yaw < 0) {
		yaw += 360;
	}
	while(yaw >= 360) {
		yaw -= 360;
	}
	if(yaw > 60 && yaw < 120) {
		direction = "west";
	} elseif(yaw > 150 && yaw < 210) {
		direction = "north";
	} elseif(yaw > 240 && yaw < 300) {
		direction = "east";
	} elseif(yaw > 330 || yaw < 30) {
		direction = "south";
	} else {
		return null;
	}
	return direction;
}

function getDirectionExact(yaw) {
	while(yaw < 0) {
		yaw += 360;
	}
	while(yaw >= 360) {
		yaw -= 360;
	}
	if(yaw > 67.5 && yaw <= 112.5) {
		direction = "West";
	} elseif(yaw > 112.5 && yaw <= 157.5) {
		direction = "North-West";
	} elseif(yaw > 157.5 && yaw <= 202.5) {
		direction = "North";
	} elseif(yaw > 202.5 && yaw <= 247.5) {
		direction = "North-East";
	} elseif(yaw > 247.5 && yaw <= 292.5) {
		direction = "East";
	} elseif(yaw > 292.5 && yaw <= 337.5) {
		direction = "South-East";
	}elseif(yaw > 337.5 || yaw <= 22.5) {
		direction = "South";
	} elseif(yaw > 22.5 && yaw <= 67.5) {
		direction = "South-West";
	}else {
		return null;
	}
	return direction;
}

function correctTimeFormat(textnumber) {
	if(string.length(textnumber) == 1) {
		textnumber = string.concat("0", textnumber);
	}
	return textnumber;
}

function player.giveSingleItem(player, item) {
	amount = inv.getItemAmount(player.getInv(player), item.getType(item));
	if(amount == 0) {
		player.safeGiveItem(player, item);
	}
}

function player.splitGiveItem(player, item, safe_give) {
	amount = item.getAmount(item);
	max_amount = item.getMaxAmount(item);
	max_item = item.clone(item);
	item.setAmount(max_item, max_amount);
	while(amount > max_amount) {
		if(safe_give) {
			player.safeGiveItem(player, max_item);
		} else {
			player.giveItem(player, max_item);
		}
		amount -= max_amount;
	}
	item.setAmount(item, amount);
	if(safe_give) {
		player.safeGiveItem(player, item);
	} else {
		player.safeGiveItem(player, item);
	}
}

function player.safeGiveItem(player, item) {
	rest_amount = player.giveItem(player, item);
	if(rest_amount > 0) {
		item.setAmount(item, rest_amount);
		item.drop(item, entity.getLocation(player));
	}
}

function block.setIfAir(block, type) {
	if(block.isAir(block)) {
		block.setMaterial(block, material.get(type));
		return true;
	}
	return false;
}

//Gesamte Spielzeit eines Spielers inkl. der Online-Spielzeit
function playtime.getPlayerTotal(player_or_id) {
	player_id = player.getValidId(player_or_id);
	minutes = playtime.getPlayerOnlineMinutes(player_id);
	stmt = databank.prepare("SELECT SUM(leave_time - join_time) FROM playtime WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		minutes += databank.getLong(result, 1) / 1000 / 60;
	}
	databank.close(result);
	databank.close(stmt);
	return minutes;
}

//Spielzeit eines Online-Spielers
function playtime.getPlayerOnlineMinutes(player_id) {
	stmt = databank.prepare("SELECT join_time FROM playtime WHERE player_id = ? AND leave_time IS NULL;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		minutes = (time.getMillis() - databank.getLong(result, 1)) / 1000 / 60;
	} else {
		minutes = 0;
	}
	databank.close(result);
	databank.close(stmt);
	return minutes;
}

function grow(center_loc, radius) {
	crops_tag = block.getTag("minecraft:crops");
	for(x = radius * -1; x <= radius; x++) {
		for(z = radius * -1; z <= radius; z++) {
			for(y = radius * -1; y <= radius; y++) {
				length = math.hypot(x, math.hypot(y, z));
				if(length <= radius) {
					block = block.get(loc.mod(center_loc, x, y, z));
					if(block.hasTag(block, crops_tag)) {
						if(block.isType(block, "minecraft:beetroots")) {
							block.setData(block, read.blockData(string.replace(string.blockData(block.getData(block)), "age=.", "age=3")));
						} else {
							block.setData(block, read.blockData(string.replace(string.blockData(block.getData(block)), "age=.", "age=7")));
						}
					}
				}
			}
		}
	}
}

function getBlockLocation(location) {
	world = loc.getWorld(location);
	bx = loc.getBlockX(location);
	by = loc.getBlockY(location);
	bz = loc.getBlockZ(location);
	return loc.new(world, bx, by, bz);
}

function time.getDateString(time) {
	calendar = time.new(time);
	day = time.getStringFromNumber(time.getDay(calendar));
	month = time.getStringFromNumber(time.getMonth(calendar));
	year = string.number(time.getYear(calendar));
	return string.concat(day, ".", month, ".", year);
}

function time.getCal(year, month, day, hour, minute, second) {
	second = time.getStringFromNumber(second);
	minute = time.getStringFromNumber(minute);
	hour = time.getStringFromNumber(hour);
	day = time.getStringFromNumber(day);
	month = time.getStringFromNumber(month);
	year = string.number(year);
	return time.parse("yyyyMMddHHmmss", string.concat(year, month, day, hour, minute, second));
}

function time.getStringFromNumber(number) {
	if(number > 9) {
		return string.number(number);
	}
	return string.concat("0", string.number(number));
}

function time.getClockString(time) { //s
	return string.concat(string.number(math.roundDown(time / 60)), " min ", string.number(math.round(time % 60)), " s");
}

function time.getString(millis) {
	calendar = time.new(millis);
	day = time.getStringFromNumber(time.getDay(calendar));
	month = time.getStringFromNumber(time.getMonth(calendar));
	year = time.getYear(calendar);
	hour = time.getStringFromNumber(time.getHour(calendar));
	minute = time.getStringFromNumber(time.getMinute(calendar));
	timestring = string.concat(day, ".", month, ".", string.number(year), " ", hour, ":", minute);
	return timestring;
}

function isFollowingDay(timestamp_1, timestamp_2) {
	cal_1 = time.new(timestamp_1);
	time.nextDay(cal_1);
	mid_1 = time.from(cal_1);
	diff = timestamp_2 - mid_1;
	return diff > 0 && diff < 86400000;
}

function isSameDay(timestamp_1, timestamp_2) {
	cal_1 = time.new(timestamp_1);
	cal_2 = time.new(timestamp_2);
	time.nextDay(cal_1);
	time.nextDay(cal_2);
	mid_1 = time.from(cal_1);
	mid_2 = time.from(cal_2);
	return mid_1 == mid_2;
}

function player.hasMinigame(player) {
	id_set = player.getMinigameIds(player);
	if(set.getSize(id_set) > 0)  {
		return true;
	}
	return false;
}

function player.getMinigameIds(player) {
	set = data.get(player, "minigames_set");
	if(set == null) {
		set = set.new();
		data.set(player, "minigames_set", set);
	}
	return set;
}

function player.resetMinigames(player) {
	id_set = player.getMinigameIds(player);
	set.clear(id_set);
}

function tjr.getWholeModule(player_or_id) {
	return ranking.getPoints("tjrranks", player_or_id);
}

function tjr.getWholeTime(player_or_id) {
	return ranking.getSecPoints("tjrranks", player_or_id);
}

function ranking.getPoints(rankingtable, player_or_id) {
	player_id = player.getValidId(player_or_id);
	stmt = databank.prepare(string.concat("SELECT points FROM ", rankingtable, " WHERE player_id = ?;"));
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		points = databank.getInt(result, 1);
	} else {
		points = 0;
	}
	databank.close(result);
	databank.close(stmt);
	return points;
}

function ranking.getSecPoints(rankingtable, player_or_id) {
	player_id = player.getValidId(player_or_id);
	stmt = databank.prepare(string.concat("SELECT sec_points FROM ", rankingtable, " WHERE player_id = ?;"));
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		sec_points = databank.getInt(result, 1);
	} else {
		sec_points = 0;
	}
	databank.close(result);
	databank.close(stmt);
	return sec_points;
}

function registerNewbie(id, time) {
	stmt = databank.prepare("INSERT INTO newbies (player_id, time) VALUES(?,?);");
	databank.setInt(stmt, 1, id);
	databank.setLong(stmt, 2, time);
	databank.workerExecute(stmt);
}

//--------------------------------------------------
//ModTimer-Utils
//--------------------------------------------------

function modTimer.scriptCallEvent(event, script) {
	modTimer(-20);
	if(script == null) {
		script.callEvent(event);
		return;
	}
	script.callEvent(event, script);
}

function modTimer.entityTeleport(entity, location) {
	modTimer(-15);
	entity.teleport(entity, location);
}

//--------------------------------------------------
//World-Utils
//--------------------------------------------------

function read.location(string) {
	a = string.split(":", string);
	w = world.get(a[0]);
	x = read.number(a[1]);
	y = read.number(a[2]);
	z = read.number(a[3]);
	if(array.getSize(a) > 4) {
		yaw = read.number(a[4]);
		pitch = read.number(a[5]);
	} else {
		yaw = 0;
		pitch = 0;
	}
	return loc.new(w, x, y, z, yaw, pitch);
}

function string.location(location) {
	w = world.getName(loc.getWorld(location));
	x = loc.getX(location);
	y = loc.getY(location);
	z = loc.getZ(location);
	yaw = loc.getYaw(location);
	pitch = loc.getPitch(location);
	return string.concat(w, ":", x, ":", y, ":", z, ":", yaw, ":", pitch);
}

function world.getServerSpawn() {
	return read.location(config.getString(getServerConfig(), "serverspawn", "world:0:0:0"));
}

function world.getGamesSpawn() {
	return read.location(config.getString(getServerConfig(), "gamesspawn", "world:0:0:0"));
}

function world.getCreativeSpawn() {
	return read.location(config.getString(getServerConfig(), "creativespawn", "world:0:0:0"));
}

function world.getOverWorld() {
	return world.get("world");
}

function world.getTheEnd() {
	return world.get("world_the_end");
}

function world.getTheNether() {
	return world.get("world_nether");
}

function world.getGames() {
	return world.get("games");
}

function world.getCreative() {
	return world.get("creative");
}

function world.isCreativeName(world_name) {
	return world_name == "creative";
}

function world.isGamesName(world_name) {
	return world_name == "games";
}

function world.isOverworld(world_name) {
	return world_name == "world";
}

function world.isSurvName(world_name) {
	if(world_name == "world") {
		return true;
	} elseif(world_name == "world_the_end") {
		return true;
	} elseif(world_name == "world_nether") {
		return true;
	}
	return false;
}

function world.canUsePlots(world) {
	world_name = world.getName(world);
	if(world.isSurvName(world_name)) {
		return true;
	}
	if(world.isCreativeName(world_name)) {
		return true;
	}
	return false;
}

function world.addTimedStatus(world, index, time, message) {
	return;
	world_name = world.getName(world);
	if(world.isSurvName(world_name)) {
		worldlist = world.getPlayers(world.getOverWorld());
		for(i = 0; i < list.getSize(worldlist); i++) {
			status.addTimed(list.getIndex(worldlist, i), index, time, message);
		}
		worldlist = world.getPlayers(world.getTheEnd());
		for(i = 0; i < list.getSize(worldlist); i++) {
			status.addTimed(list.getIndex(worldlist, i), index, time, message);
		}
		worldlist = world.getPlayers(world.getTheNether());
		for(i = 0; i < list.getSize(worldlist); i++) {
			status.addTimed(list.getIndex(worldlist, i), index, time, message);
		}
		return;
	}
	worldlist = world.getPlayers(world);
	for(i = 0; i < list.getSize(worldlist); i++) {
		status.addTimed(list.getIndex(worldlist, i), index, time, message);
	}
}

function world.giveItem(world, item) {
	world_list = woorld.getPlayers(world);
	iter = iterator(world_list);
	while(hasNext(iter)) {
		player.safeGiveItem(next(iter), item);
	}
}

//--------------------------------------------------
//Inv-Utils
//--------------------------------------------------

function player.checkForWorldChange(player, location) {
	from_world = loc.getWorld(entity.getLocation(player));
	to_world = loc.getWorld(location);
	//Wenn ignore aktiviert --> kein Wechsel
	if(player.hasInvIgnore(player)) {
		return false;
	}
	from_world_name = world.getName(from_world);
	to_world_name = world.getName(to_world);
	//Wenn in selber Welt --> kein Wechsel
	if(from_world == to_world) {
		return false;
	}
	//Wenn beide Welten in derselben Liste sind --> kein Wechsel
	if(world.isSurvName(from_world_name) && world.isSurvName(to_world_name)) {
		return false;
	}
	return true;
}

function player.changeInv(player, from_world, to_world) {
	from_world_name = world.getName(from_world);
	to_world_name = world.getName(to_world);
	//Inventory
	inv.saveForPlayer(player, player, from_world);
	inv.loadFromPlayer(player, player, to_world);
	if(perm.has("isTeam", player)) {
		if(perm.has("isSupporter", player) && !perm.has("isAdmin", player) && !perm.has("isMod", player)) {
			player.changeGamemode(player, to_world_name);
		}
	} else {
		player.changeGamemode(player, to_world_name);
	}
	if(world.isSurvName(to_world_name)) {
		if(player.hasFly(player)) {
			scheduler.addFly(5, player, true);
		}
	}
}

function player.changeGamemode(player, to_world_name) {
	if(!player.isSpectator(player)) {
		if(to_world_name == "creative") {
			if(perm.has("creative.gm1", player)) {
				gm = "CREATIVE";
			} else {
				gm = "ADVENTURE";
				scheduler.addFly(5, player, true);
			}
		} else {
			gm = "SURVIVAL";
		}
		player.setGamemode(player, gm);
		duration = data.getTimer(player, "fly");
		if(world.isSurvName(to_world_name) && duration > 0) {
			scheduler.addFly(5, player, true);
		}
	}
}

function inv.backup(p_or_id) {
	player_id = player.getValidId(p_or_id);
	from_file = file.new(string.concat("scripts/configs/inv_data/survival/", player_id, ".snuvic"));
	if(!file.exists(from_file)) {
		return;
	}
	
	dir = file.new(string.concat("scripts/configs/inv_data/backup/", player_id));
	if(!file.exists(dir)) {
		file.createFolder(dir);
	}
	
	f_map = map.new();
	file_list = file.getList(dir);
	iter = iterator(file_list);
	while(hasNext(iter)) {
		f = next(iter);
		f_name = file.getName(f);
		split_array = string.split("_", f_name);
		number = read.number(split_array[1]);
		a = array.new(2);
		a[0] = f;
		a[1] = split_array[2];
		map.add(f_map, number, a);
	}
	
	number_of_backups = 10;
	for(i = number_of_backups; i > 0; i--) {
		a = map.get(f_map, i);
		if(a == null) {
			continue;
		}
		f = a[0];
		timestamp = a[1];
		if(i == number_of_backups) {
			file.delete(f);
			continue;
		}
		new_f_name = string.concat("backup_", string.number(i + 1), "_", timestamp);
		file.rename(f, file.new(string.concat("scripts/configs/inv_data/backup/", player_id, "/", new_f_name)));
	}
	
	cal = time.new(time.getMillis());
	year = string.number(time.getYear(cal));
	month = string.number(time.getMonth(cal));
	day = string.number(time.getDay(cal));
	hour = string.number(time.getHour(cal));
	min = string.number(time.getMinute(cal));
	sec = string.number(time.getSecond(cal));
	new_f = file.new(string.concat(dir, "/backup_", string.number(1), "_", year, "-", month, "-", day, "-", hour, "-", min, "-", sec));
	f_list = file.read(from_file);
	file.write(new_f, f_list);
}

function inv.saveForPlayer(sec_player, for_player_or_id, world) {
	if(isPlayer(for_player_or_id)) {
		for_player_or_id = player.getId(for_player_or_id);
	}
	world_name = world.getName(world);
	if(world.isSurvName(world_name)) {
		inv.backup(for_player_or_id);
		pfad = "scripts/configs/inv_data/survival";
	} else {
		pfad = string.concat("scripts/configs/inv_data/", world_name);
	}
	config = config.new(pfad, for_player_or_id);
	
	//Allgemeine Daten
	if(for_player_or_id == player.getId(sec_player)) {
		config.set(config, "health", living.getHealth(sec_player));
		config.set(config, "hunger", player.getHunger(sec_player));
		config.set(config, "saturation", player.getSaturation(sec_player));
		config.set(config, "xp", player.getExp(sec_player));
		config.set(config, "lvl", player.getLevel(sec_player));
	}
	
	//Inventare
	inv = player.getInv(sec_player);
	for(i = 0; i < 36; i++) {
		item_string = string.item(inv.getItem(inv, i));
		config.set(config, string.concat("slot-", i), item_string);
	}
	ender_inv = player.getEnderInv(sec_player);
	for(i = 0; i < 27; i++) {
		item_string = string.item(inv.getItem(ender_inv, i));
		config.set(config, string.concat("eslot-", i), item_string);
	}
	config.set(config, "offhand", string.item(living.getOffHand(sec_player)));
	config.set(config, "head", string.item(living.getEquip(sec_player, read.slot("HEAD"))));
	config.set(config, "chest", string.item(living.getEquip(sec_player, read.slot("CHEST"))));
	config.set(config, "legs", string.item(living.getEquip(sec_player, read.slot("LEGS"))));
	config.set(config, "feet", string.item(living.getEquip(sec_player, read.slot("FEET"))));
	config.saveAsync(config);
}

function inv.loadFromPlayer(sec_player, from_player_or_id, world) {
	if(isPlayer(from_player_or_id)) {
		from_player_or_id = player.getId(from_player_or_id);
	}
	world_name = world.getName(world);
	if(world.isSurvName(world_name)) {
		pfad = "scripts/configs/inv_data/survival";
	} else {
		pfad = string.concat("scripts/configs/inv_data/", world_name);
	}
	config = config.new(pfad, from_player_or_id);
	if(config.exists(config)) {
		config.load(config);
	}
	
	//Allgemeine Daten
	if(from_player_or_id == player.getId(sec_player)) {
		health = config.getDouble(config, "health", 20);
		if(health > 20) {
			health = 20;
		}
		living.setHealth(sec_player, health);
		player.setHunger(sec_player, config.getDouble(config, "hunger", 20));
		player.setSaturation(sec_player, config.getDouble(config, "saturation", 5));
		player.setExp(sec_player, config.getDouble(config, "xp", 0));
		player.setLevel(sec_player, config.getDouble(config, "lvl", 0));
	}
	
	//Inventare
	air_string = item.getAirString();
	for(i = 0; i <= 35; i++) {
		item_string = config.getString(config, string.concat("slot-", i), air_string);
		item = read.item(item_string);
		if(item != null) {
			inv = player.getInv(sec_player);
			inv.setItem(inv, i, item);
		}
	}
	for(i = 0; i < 27; i++) {
		item_string = config.getString(config, string.concat("eslot-", i), air_string);
		item = read.item(item_string);
		if(item != null) {
			ender_inv = player.getEnderInv(sec_player);
			inv.setItem(ender_inv, i, item);
		}
	}
	living.setEquip(sec_player, read.slot("OFF_HAND"), read.item(config.getString(config, "offhand", air_string)));
	living.setEquip(sec_player, read.slot("HEAD"), read.item(config.getString(config, "head", air_string)));
	living.setEquip(sec_player, read.slot("CHEST"), read.item(config.getString(config, "chest", air_string)));
	living.setEquip(sec_player, read.slot("LEGS"), read.item(config.getString(config, "legs", air_string)));
	living.setEquip(sec_player, read.slot("FEET"), read.item(config.getString(config, "feet", air_string)));
}

function inv.getItemAmount(inv, wusi) {
	//wusi: item_stack or item_type or item_tag
	c = 0;
	if(isMaterial(wusi)) {
		for(i = 0; i < inv.getSize(inv); i++) {
			item = inv.getItem(inv, i);
			if(item == null) {
				continue;
			}
			if(item.getType(item) == wusi) {
				c += item.getAmount(item);
			}
		}
	} elseif(isItemstack(wusi)) {
		for(i = 0; i < inv.getSize(inv); i++) {
			item = inv.getItem(inv, i);
			if(item == null) {
				continue;
			}
			if(isSameItem(item, wusi)) {
				c += item.getAmount(item);
			}
		}
	} else {
		for(i = 0; i < inv.getSize(inv); i++) {
			item = inv.getItem(inv, i);
			if(item == null) {
				continue;
			}
			if(item.hasTag(item, wusi)) {
				c += item.getAmount(item);
			}
		}
	}
	return c;
}

function inv.addItem(inv, itemstack) {
	//adds an item and returns the amount which could not be added
	amount_to_add = item.getAmount(itemstack);
	for(i = 0; i < inv.getSize(inv); i++) {
		item = inv.getItem(inv, i);
		if(item == null) {
			space = item.getMaxAmount(itemstack);
			item = item.clone(itemstack);
			if(space <= amount_to_add) {
				item.setAmount(item, space);
				inv.setItem(inv, i, item);
				amount_to_add -= space;
				if(amount_to_add == 0) {
					break;
				}
			} else {
				item.setAmount(item, amount_to_add);
				inv.setItem(inv, i, item);
				amount_to_add = 0;
				break;
			}
		}
		elseif(isSameItem(item, itemstack)) {
			a = item.getAmount(item);
			max_a = item.getMaxAmount(item);
			space = max_a - a;
			if(space > 0) {
				if(space <= amount_to_add) {
					item.setAmount(item, max_a);
					amount_to_add -= space;
					if(amount_to_add == 0) {
						break;
					}
				} else {
					item.setAmount(item, a + amount_to_add);
					amount_to_add = 0;
					break;
				}
			}
		}
	}
	return amount_to_add;
}

function inv.removeItem(inv, itemstack) {
	//removes items and returns the amount which could not be removed
	amount_to_remove = item.getAmount(itemstack);
	for(i = 0; i < inv.getSize(inv); i++) {
		item = inv.getItem(inv, i);
		if(item == null) {
			continue;
		}
		if(isSameItem(item, itemstack)) {
			a = item.getAmount(item);
			if(a <= amount_to_remove) {
				inv.setItem(inv, i, null);
				amount_to_remove -= a;
				if(amount_to_remove == 0) {
					break;
				}
			} else {
				item.setAmount(item, a - amount_to_remove);
				amount_to_remove = 0;
				break;
			}
		}
	}
	return amount_to_remove;
}

function inv.removeItem2(inv, wusi, amount_to_remove) {
	//wusi: item_type or item_tag
	//removes items and returns the amount which could not be removed
	if(isMaterial(wusi)) {
		for(i = 0; i < inv.getSize(inv); i++) {
			item = inv.getItem(inv, i);
			if(item == null) {
				continue;
			}
			if(item.getType(item) == wusi) {
				a = item.getAmount(item);
				if(a <= amount_to_remove) {
					inv.setItem(inv, i, null);
					amount_to_remove -= a;
					if(amount_to_remove == 0) {
						break;
					}
				} else {
					item.setAmount(item, a - amount_to_remove);
					amount_to_remove = 0;
					break;
				}
			}
		}
	} else {
		for(i = 0; i < inv.getSize(inv); i++) {
			item = inv.getItem(inv, i);
			if(item == null) {
				continue;
			}
			if(item.hasTag(item, wusi)) {
				a = item.getAmount(item);
				if(a <= amount_to_remove) {
					inv.setItem(inv, i, null);
					amount_to_remove -= a;
					if(amount_to_remove == 0) {
						break;
					}
				} else {
					item.setAmount(item, a - amount_to_remove);
					amount_to_remove = 0;
					break;
				}
			}
		}
	}
	return c;
}

//--------------------------------------------------
//Text-Utils
//--------------------------------------------------

function text.getClickText(show_text, execute_string) {
	return text.click(show_text, execute_string);
}

function text.getHoverText(show_text, execute_string) {
	return text.hover(show_text, text.new(execute_string));
}

//--------------------------------------------------
//String-Utils
//--------------------------------------------------

function string.getHoverText(show_string, execute_string) {
	return text.hover(text.new(show_string), text.new(execute_string));
}

function string.getClipBoardText(show_string, copy_string) {
	return text.clipBoard(text.new(show_string), copy_string);
}


function string.getInterpretedText(string) {
	start_index = string.indexOf(string, "%link", 0);
	if(start_index == -1) {
		return text.new(string);
	}
	start_text = text.new(string.subString(string, 0, start_index));
	show_index = start_index + 6;
	link_index = string.indexOf(string, " ", show_index) + 1;
	show_string = string.subString(string, show_index, link_index - 1);
	end_index = string.indexOf(string, " ", link_index) + 1;
	link_string = string.subString(string, link_index, end_index - 1);
	rest_string = string.subString(string, end_index, string.length(string));
	return text.merge(start_text, string.getLinkText(show_string, link_string), text.new(rest_string));
}

function string.getPrefix(string) {
	return string.concat("§r[", string, "§r]");
}

function string.removeFormat(string) {
	return string.replace(string, "§.", "");
}

function string.getLinkText(show_string, link_string) {
	return text.link(text.new(show_string), link_string);
}

function string.getClickText(show_string, execute_string) {
	return text.click(text.new(show_string), execute_string);
}

function string.getSpacer() {
	return("§0-------------------------------------------------");
}

function string.concatList(list, connector, from_index, to_index) {
	for(i = from_index; i <= to_index; i++) {
		element = list.getIndex(list, i);
		if(i == from_index) {
			string = element;
		} else {
			string = string.concat(string, connector, element);
		}
	}
	return string;
}

function string.onlyLetters(string) {
	a_code = string.charcode("a", 0);
	z_code = string.charcode("z", 0);
	oe_code = string.charcode("ö", 0);
	ae_code = string.charcode("ä", 0);
	ue_code = string.charcode("ü", 0);
	cap_a_code = string.charcode("A", 0);
	cap_z_code = string.charcode("Z", 0);
	cap_oe_code = string.charcode("Ö", 0);
	cap_ae_code = string.charcode("Ä", 0);
	cap_ue_code = string.charcode("Ü", 0);
	
	for(i = 0; i < string.length(string); i++) {
		char_code = string.charcode(string, i);
	}
	if(char_code >= a_code && char_code <= z_code) {
		return true;
	}
	if(char_code >= cap_a_code && char_code <= cap_z_code) {
		return true;
	}
	if(char_code == ae_code || char_code == cap_ae_code) {
		return true;
	}
	if(char_code == oe_code || char_code == cap_oe_code) {
		return true;
	}
	if(char_code == ue_code || char_code == cap_ue_code) {
		return true;
	}
	return false;
}

function string.upperFirstLetter(string) {
	length = string.length(string);
	first_letter = string.subString(string, 0, 1);
	rest = string.substring(string, 1, length);
	return string.concat(string.toUpperCase(first_letter), rest);
}

function string.getTextWithLink(string) {
	if(string.contains(string, "https://")) {
		https_index = string.indexOf(string, "https://", 0);
		space_index = string.indexOf(string, " ", https_index);
		length = string.length(string);
		if(https_index == 0) {
			msg_before = "";
		} else {
			msg_before = string.subString(string, 0, https_index);
		}
		if(space_index == -1) {
			string_link = string.subString(string, https_index, length);
			msg_after = "";
		} else {
			string_link = string.subString(string, https_index, space_index);
			msg_after = string.subString(string, space_index, length);
		}
		text_link = string.getLinkText(string_link, string_link);
		return text.merge(text.new(msg_before), text_link, text.new(msg_after));
	}
	return text.new(string);
}

function string.intelligentSplit(string) {
	list = list.new();
	from_index = 0;
	to_index = 0;
	split_after = 25;
	split_index = split_after;
	whole_length = string.length(string);
	
	while(true) {
		to_index = string.indexOf(string, " ", split_index);
		if(to_index == -1) {
			sub_string = string.subString(string, from_index, string.length(string));
			list.add(list, text.new(sub_string));
			break;
		}
		sub_string = string.subString(string, from_index, to_index);
		list.add(list, text.new(sub_string));
		from_index = to_index + 1;
		split_index += split_after;
	}
	
	return list;
}

//--------------------------------------------------
//Quest-Utils
//--------------------------------------------------

function quest.display(player, quest_name, stage, all_stages) {
	sb.add(player, 10, string.concat("§dQuest: ", quest_name, " [", string.number(stage), "/", string.number(all_stages), "]"));
}

function quest.removeDisplay(player) {
	sb.remove(player, 10);
}

function quest.getIds() {
	return getScriptVar("quest_ids");
}

function quest.addPlayer(script, player) {
	quest_ids = quest.getIds();
	map.add(quest_ids, player.getUuid(player), script.getId(script));
}

function quest.removePlayer(player) {
	quest_ids = quest.getIds();
	map.remove(quest_ids, player.getUuid(player));
}

function player.hasQuest(player) {
	quest_ids = quest.getIds();
	return map.contains(quest_ids, player.getUuid(player));
}

function quest.getFromPlayer(player) {
	quest_ids = quest.getIds();
	return map.get(quest_ids, player.getUuid(player));
}

function player.isQuester(player, script) {
	if(player == null) {
		return false;
	}
	if(script == null) {
		return false;
	}
	script_id = script.getId(script);
	quest_ids = quest.getIds();
	return map.get(quest_ids, player.getUuid(player)) == script_id;
}

function quest.getCounter(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "quests_solved", 0);
}

function quest.setCounter(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "quests_solved", amount);
	config.saveAsync(config);
}

function quest.addCounter(player, amount) {
	config = playerdata.getSurvival(player);
	new_amount = config.getDouble(config, "quests_solved", 0) + amount;
	config.set(config, "quests_solved", new_amount);
	config.saveAsync(config);
	if(new_amount == 500) {
		offerRank(player, "rank.altruist");
		perm.addGroupToPlayer(player.getId(player), 17);
		waitfor(20);
	} elseif(new_amount == 50) {
		offerRank(player, "rank.friend");
	} elseif(new_amount == 15) {
		offerRank(player, "rank.volunteer");
	}
}

function quest.finish(script, player) {
	sound = sound.get("ENTITY_EXPERIENCE_ORB_PICKUP");
	category = sound.getCategory("MASTER");
	sound.spawnForPlayer(player, sound, category);
	quest.addCounter(player, 1);
	quest.term(script, player);
}

function quest.finishReward(script, player, reward) {
	msg.string(player, string.concat("§dQuest finished. §rReward: ", money.getString(reward)));
	money.addBoost(player, reward);
	sound = sound.get("ENTITY_EXPERIENCE_ORB_PICKUP");
	category = sound.getCategory("MASTER");
	sound.spawnForPlayer(player, sound, category);
	quest.addCounter(player, 1);
	quest.term(script, player);
}

function quest.term(script, player) {
	quest.removeDisplay(player);
	quest.removePlayer(player);
	script.term(script);
}

function script.isActiveName(script_name) {
	script = script.get(script_name);
	if(script == null) {
		return false;
	}
	return true;
}

//--------------------------------------------------
//Slot-Utils
//--------------------------------------------------

function slot.getHand() {
	return read.slot("HAND");
}

function slot.getOffHand() {
	return read.slot("OFF_HAND");
}

function slot.getHead() {
	return read.slot("HEAD");
}

function slot.getChest() {
	return read.slot("CHEST");
}

function slot.getLegs() {
	return read.slot("LEGS");
}

function slot.getFeet() {
	return read.slot("FEET");
}

function slot.isHand(slot) {
	return slot == slot.getHand();
}

function slot.isOffHand(slot) {
	return slot == slot.getOffHand();
}

function slot.isHead(slot) {
	return slot == slot.getHead();
}

function slot.isChest(slot) {
	return slot == slot.getChest();
}

function slot.isLegs(slot) {
	return slot == slot.getLegs();
}

function slot.isFeet(slot) {
	return slot == slot.getFeet();
}

//--------------------------------------------------
//Player-Data-Utils
//--------------------------------------------------

function player.teleport(player, location, setBackPos) {
	player_uuid = player.getUuid(player);
	if(player.isOnAdventure(player)) {
		msg.string(player, "[§5Adventure§r] Teleport blocked. ", string.getClickText("[§5Cancel Adventure?§r]", string.concat("/stopadventure ", player)));
		return false;
	}
	if(player.hasMinigame(player)) {
		return false;
	}
	passengers = entity.getPassengers(player);
	iter = iterator(passengers);
	while(hasNext(iter)) {
		entity.unmount(next(iter));
	}
	if(setBackPos) {
		player.setBackPos(player);
	}
	player_loc = entity.getLocation(player);
	from_world = loc.getWorld(player_loc);
	from_world_name = world.getName(from_world);
	to_world = loc.getWorld(location);
	to_world_name = world.getName(to_world);
	world_change = player.checkForWorldChange(player, location);
	if(world_change) {
		//Inventory
		player.changeInv(player, from_world, to_world);
		living.clearEffects(player);
		//Party
		if(player.isInParty(player) && player.isPartyLeader(player)) {
			party_id = player.getPartyId(player);
			party_list = party.getList(party_id);
			iter = iterator(party_list);
			while(hasNext(iter)) {
				p = player.get(next(iter));
				if(player_uuid == player.getUuid(p)) {
					continue;
				}
				p_name = player.getName(p);
				if(!loc.isSameWorld(player_loc, entity.getLocation(p))) {
					msg.prefix(player, "§5Party", string.concat(p_name, "§c is in another world."));
					continue;
				}
				if(player.hasMinigame(p)) {
					msg.prefix(player, "§5Party", string.concat(p_name, "§c is in a game."));
					continue;
				}
				if(player.hasQuest(p)) {
					msg.prefix(player, "§5Party", string.concat(p_name, "§c is doing a quest."));
					continue;
				}
				if(player.isOnAdventure(p)) {
					msg.prefix(player, "§5Party", string.concat(p_name, "§c is on an adventure."));
					continue;
				}
				if(player.isAfk(p)) {
					msg.prefix(player, "§5Party", string.concat(p_name, "§c is afk."));
					continue;
				}
				player.teleport(p, location, setBackPos);
			}
		}
		//Quests
		script_id = quest.getFromPlayer(player);
		if(script_id != null) {
			script = script.getFromId(script_id);
			if(script != null) {
				setScriptVar("player", player);
				script.callEvent("quest_term", script);
				quest.term(script, player);
				msg.prefix(player, "§dQuest", "Quest termed.");
			}
		}
	}
	modTimer(-50);
	entity.teleport(player, location);
	player.setHeadName(player);
	
	if(world.isGamesName(to_world_name)) {
		player.clearInventory(player);
		inv = player.getInv(player);
		inv.setItem(inv, 0, item.create("COMPASS", 1, null, null));
	}
	player.setTabName(player);
	return true;
}

function playerdata.getSurvival(player_or_id) {
	player_id = player.getValidId(player_or_id);
	if(player_id == null) {
		snuvi.debug(string.concat("invalid player_id ", player_id, " on playerdata.getSurvival"));
		return;
	}
	map = getScriptVar("survival_data");
	config = map.get(map, player_id);
	if(config == null) {
		playerdata.load(player_id, map, "survival_data");
		config = map.get(map, player_id);
	}
	return config;
}

function playerdata.getGames(player_or_id) {
	player_id = player.getValidId(player_or_id);
	if(player_id == null) {
		snuvi.debug(string.concat("invalid player_id ", player_id, " on playerdata.getGames"));
		return;
	}
	map = getScriptVar("games_data");
	config = map.get(map, player_id);
	if(config == null) {
		playerdata.load(player_id, map, "games_data");
		config = map.get(map, player_id);
	}
	return config;
}

function playerdata.load(player_or_id, map, name) {
	player_id = player.getValidId(player_or_id);
	if(player_id == null) {
		snuvi.debug(string.concat("invalid player_id ", player_id, " on playerdata.load"));
		return;
	}
	config = map.get(map, player_id);
	if(config == null) {
		config = config.new(string.concat("scripts/configs/player_data/", name), player_id);
		if(config.exists(config)) {
			config.load(config);
		}
		map.add(map, player_id, config);
	}
}

function player.getValidId(player_or_id) {
	if(isPlayer(player_or_id)) {
		return player.getId(player_or_id);
	}
	if(isDouble(player_or_id)) {
		if(player.getNameFromId(player_or_id) != null) {
			return player_or_id;
		}
	}
	return null;
}

function player.getValid(player_or_id) {
	if(isPlayer(player_or_id)) {
		return player_or_id;
	}
	player = player.get(player.getUuidFromId(player_or_id));
	if(player == null) {
		return null;
	}
	return player;
}

//--------------------------------------------------
//Msg-Utils
//--------------------------------------------------

function getMessage(text_or_string) {
	if(isString(text_or_string)) {
		message = getMessageFromString(text_or_string);
	} else {
		message = text_or_string;
	}
	return message;
}

function getMessageFromString(string) {
	string = string.replace(string, "&", "§");
	message = string.getTextWithLink(string);
	return message;
}

function msg.action(receiver, text_or_string) {
	player.action(receiver, getMessage(text_or_string));
}

function msg.string(receiver, string) {
	msg(receiver, text.new(string));
}

function msg.prefix(receiver, prefix, text_or_string) {
	msg(receiver, text.merge(text.new(string.concat(string.getPrefix(prefix), " ")), getMessage(text_or_string)));
}

function msg.online(prefix, text_or_string) {
	msg.prefix("online", prefix, text_or_string);
}

function msg.quest(player, speaker, line_now, line_max, string) {
	msg.string(player, string.concat("[§b", string.number(line_now), "§r/§b", string.number(line_max), "§r] §a", speaker, " §r| ", string.concat("§e", string)));
}

function msg.chat(player, text_or_string) {
	nickname = player.getNickName(player);
	rank = getRank(player);
	colorcode = string.subString(rank, 0, 2);
	if(player.isLive(player)) {
		live_tag = "§dLive §f| ";
	} else {
		live_tag = "";
	}
	online_list = players.toList();
	iter = iterator(online_list);
	while(hasNext(iter)) {
		p = next(iter);
		if(player.hasMinigame(p) && player.isMuted(p)) {
			continue;
		}
		msg(p, text.merge(text.new("<"), text.new(live_tag), string.getHoverText(string.concat(colorcode, nickname), rank), text.new("§r> §r"), getMessage(text_or_string)));
	}
}

function msg.send(from_player, to_name, prefix, string_message, send_mail) {
	p = read.player(to_name);
	if(p == null) {
		if(send_mail) {
			mail.send(player.getName(from_player), to_name, string_message);
		}
	} else {
		msg.prefix(p, prefix, string_message);
	}
}

function msg.team(from, text_or_string) {
	if(isString(from)) {
		from_name = from;
	} else {
		from_name = player.getName(from);
	}
	pre_text = text.new(string.concat("§c", from_name, "§r: "));
	message = getMessage(text_or_string);
	online_list = players.toList();
	iter = iterator(online_list);
	while(hasNext(iter)) {
		p = next(iter);
		if(perm.has("isTeam", p)) {
			if(player.isLive(p)) {
				msg.prefix(p, "§4Team", text.merge(pre_text, text.hover(text.new("§7§oHidden"), message)));
			} else {
				msg.prefix(p, "§4Team", text.merge(pre_text, message));
			}
		}
	}
	msg.prefix("SERVER", "§4Team", text.merge(pre_text, message));
}

function msg.radius(prefix, text_or_string, location, radius) {
	list = players.near(location, radius);
	iter = iterator(list);
	while(hasNext(iter)) {
		msg.prefix(next(iter), prefix, text_or_string);
	}
}

function msg.world(world, text_or_string) {
	if(world == null) {
		return;
	}
	world_list = world.getPlayers(world);
	iter = iterator(world_list);
	while(hasNext(iter)) {
		msg(next(iter), getMessage(text_or_string));
	}
}

function msg.survival(text_or_string) {
	msg.world(world.getOverWorld(), text_or_string);
	msg.world(world.getTheEnd(), text_or_string);
	msg.world(world.getTheNether(), text_or_string);
}

function msg.creative(text_or_string) {
	msg.world(world.getCreative(), text_or_string);
}

function msg.games(text_or_string) {
	msg.world(world.getGames(), text_or_string);
}

//--------------------------------------------------
//Material-Utils
//--------------------------------------------------

function isMaterial(anything) {
	return string.class(anything) == "Material";
}

function material.getAir() {
	return material.get("AIR");
}

function material.equals(type, type_string) {
	return type == material.get(type_string);
}

//--------------------------------------------------
//Item-Utils
//--------------------------------------------------

function item.isType(item, type_string) {
	return item.getType(item) == material.get(type_string);
}

function isSameItem(itemstack_1, itemstack_2) {
	itemstack_1 = item.clone(itemstack_1);
	itemstack_2 = item.clone(itemstack_2);
	item.setAmount(itemstack_1, 1);
	item.setAmount(itemstack_2, 1);
	return itemstack_1 == itemstack_2;
}

function isItemstack(anything) {
	type = string.class(anything);
	return type == "ItemStack" || type == "CraftItemStack";
}

function item.isAir(itemstack) {
	if(itemstack == null) {
		return true;
	}
	return item.getType(itemstack) == material.getAir();
}

function item.custom.isType(item, custom) {
	return item.getCustom(item) == custom;
}

function item.custom.create(type, amount, name, wusi) {
	//wusi: lore_list or lore_string
	item = item.custom.new(item.custom.get(type), amount);
	if(name != null) {
		item.setName(item, text.new(name));
	}
	if(wusi != null) {
		if(isString(wusi)) {
			lore_list = list.new();
			list.add(lore_list, text.new(wusi));
			item.setLore(item, lore_list);
		} else {
			item.setLore(item, wusi);
		}
	}
	return item;
}

function item.create(type, amount, name, wusi) {
	//wusi: lore_list or lore_string
	item = item.new(material.get(type), amount);
	if(name != null) {
		item.setName(item, text.new(name));
	}
	if(wusi != null) {
		if(isString(wusi)) {
			lore_list = list.new();
			list.add(lore_list, text.new(wusi));
			item.setLore(item, lore_list);
		} else {
			item.setLore(item, wusi);
		}
	}
	return item;
}

function item.createLore(string) {
	lore = list.new();
	list.add(lore, text.new(string));
	return lore;
}

function item.addLore(item, string) {
	lore = item.getLore(item);
	if(lore == null) {
		lore = list.new();
	}
	list.add(lore, text.new(string));
	item.setLore(item, lore);
}

function item.getAir() {
	return item.new(material.get("AIR"));
}

function item.getAirString() {
	return "{id:\"minecraft:air\",Count:1b}";
}

function item.isAmber(item) {
	return item.custom.get("AMBER") == item.getCustom(item);
}

function item.isSapphire(item) {
	return item.custom.get("SAPPHIRE") == item.getCustom(item);
}

function item.isRuby(item) {
	return item.custom.get("RUBY") == item.getCustom(item);
}

function item.getAmber() {
	return item.custom.new(item.custom.get("AMBER"));
}

function item.getSapphire() {
	return item.custom.new(item.custom.get("SAPPHIRE"));
}

function item.getRuby() {
	return item.custom.new(item.custom.get("RUBY"));
}

function item.isDigit(item) {
	c = item.getCustom(item);
	set = getScriptVar("digits");
	return set.contains(set, c);
}

function drops.containsMaterial(drops_list, material) {
	for(i = 0; i < list.getSize(drops_list); i++) {
		item_entity = list.getIndex(drops_list, i);
		item = item.entity.get(item_entity);
		item_type = item.getType(item);
		if(item_type == material) {
			return true;
		}
	}
	return false;
}

//--------------------------------------------------
//Entity-Utils
//--------------------------------------------------

function entity.isArmorstand(entity) {
	if(entity == null) {
		return false;
	}
	return entity.getType(entity) == "armor_stand";
}

//--------------------------------------------------
//Player-Utils
//--------------------------------------------------

function player.hasBypass(player) {
	return perm.has("plot.bypass", player);
}

function player.clearInventory(player) {
	inv = player.getInv(player);
	inv.clear(inv);
}

function player.toggleFly(player) {
	new_state = !player.hasFly(player);
	player.setFly(player, new_state);
	return new_state;
}

function player.canTeleport(player) {
	if(player.hasMinigame(player)) {
		return false;
	}
	if(player.isOnAdventure(player)) {
		return false;
	}
	return true;
}

function player.hasClearInventory(player) {
	air = item.getAir();
	inv = player.getInv(player);
	for(slot = 0; slot < 36; slot++) {
		if(item.getType(inv.getItem(inv, slot)) != air) {
			return false;
		}
	}
	if(item.getType(living.getEquip(player, read.slot("HEAD"))) != air) {
		return false;
	}
	if(item.getType(living.getEquip(player, read.slot("CHEST"))) != air) {
		return false;
	}
	if(item.getType(living.getEquip(player, read.slot("LEGS"))) != air) {
		return false;
	}
	if(item.getType(living.getEquip(player, read.slot("FEET"))) != air) {
		return false;
	}
	if(item.getType(living.getOffHand(player)) != air) {
		return false;
	}
	return true;
}

function player.getJoinMessage(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	temp = config.getString(config, "message.join", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function player.setJoinMessage(player_or_id, message) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "message.join", message);
	config.saveAsync(config);
}

function player.getLeaveMessage(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	temp = config.getString(config, "message.leave", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function player.setLeaveMessage(player_or_id, message) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "message.leave", message);
	config.saveAsync(config);
}

function player.getDeathMessage(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	temp = config.getString(config, "message.death", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function player.setDeathMessage(player_or_id, message) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "message.death", message);
	config.saveAsync(config);
}

function player.usesCustomMessage(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "message.use", true);
}

function player.activateCustomMessage(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "message.use", boolean);
	config.saveAsync(config);
}

function player.setLoggedIp(player_or_id, ip) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "ip", ip);
	config.saveAsync(config);
}

function player.getLoggedIp(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getString(config, "ip", "-");
}

function player.resetDeathLoc(player) {
	config = playerdata.getSurvival(player);
	config.set(config, "deathloc", "null");
	config.saveAsync(config);
}

function player.setDeathLoc(player) {
	config = playerdata.getSurvival(player);
	config.set(config, "deathloc", string.location(entity.getLocation(player)));
	config.saveAsync(config);
}

function player.getDeathLoc(player) {
	config = playerdata.getSurvival(player);
	loc = config.getString(config, "deathloc", "null");
	if(loc == "null") {
		return null;
	}
	return read.location(loc);
}

function player.isLive(player) {
	player_uuid = player.getUuid(player);
	live_set = getScriptVar("live_set");
	return set.contains(live_set, player_uuid);
}

function player.setLive(player, boolean) {
	player_uuid = player.getUuid(player);
	live_set = getScriptVar("live_set");
	if(boolean) {
		set.add(live_set, player_uuid);
	} else {
		set.remove(live_set, player_uuid);
	}
}

function player.getFullName(player) {
	nickname = player.getNickname(player);
	if(player.isNicked(player)) {
		full_name = string.concat("[§3User§r] ", nickname);
	} else {
		full_name = string.concat("[", getRank(player), "§r] ", nickname);
	}
	return full_name;
}

function player.setTabName(player) {
	nickname = player.getNickname(player);
	rank = getRank(player);
	if(string.startswith(rank, "§", 0)) {
		colorcode = string.subString(rank, 0, 2);
		tab_name = string.concat(colorcode, nickname);
	} else {
		tab_name = nickname;
	}
	if(player.isAfk(player)) {
		tab_name = string.concat(tab_name, " §5§o[Afk]");
	}
	if(player.isLive(player)) {
		tab_name = string.concat(tab_name, " §f[§dLive§f]");
	}
	player.setDisplayName(player, text.new(tab_name));
}

function player.removeItemNbt(player, itemstack) { //Might be deprecated
	//Make a copy
	item_type = item.getType(itemstack);
	amount = item.getAmount(itemstack);
	my_item = item.new(item_type, amount);
	//Loop the inventory
	inv = player.getInv(player);
	for(slot = 0; slot < inv.getSize(inv); slot++) {
		item = inv.getItem(inv, slot);
		if(item == null) {
			continue;
		}
		if(item.getType(item) == item_type) {
			diff = amount - item.getAmount(item);
			if(diff > 0) {
				amount = diff;
				item.setAmount(item, 0);
			} else {
				item.setAmount(item, math.abs(diff));
				air = item.getAir();
				item.setAmount(air, 0);
				return air;
			}
		}
	}
	item.setAmount(my_item, amount);
	return my_item;
}

function player.removeItemTag(player, tag, amount) {
	air = item.getAir();
	inv = player.getInv(player);
	for(slot = 0; slot < inv.getSize(inv); slot++) {
		item = inv.getItem(inv, slot);
		if(item == null) {
			continue;
		}
		if(item.hasTag(item, tag)) {
			diff = amount - item.getAmount(item);
			if(diff > 0) {
				item.setAmount(item, 0);
				amount = diff;
			} else {
				item.setAmount(item, math.abs(diff));
				amount = 0;
				break;
			}
		}
	}
	item.setAmount(air, amount);
	return air;
}

function player.setSpeed(player, speed) {
	speed = 4/5/9 * speed + 1/9;
	player.setWalkSpeed(player, speed);
	player.setFlySpeed(player, speed / 2);
}

function player.hasBigPlotCreated(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "plot.big", false);
}

function player.setBigPlotCreated(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "plot.big", boolean);
	config.saveAsync(config);
}

function player.hasPlotRaised(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "plot.raised", false);
}

function player.setPlotRaised(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "plot.raised", boolean);
	config.saveAsync(config);
}

function player.usedHisFreePlot(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "plot.usedFree", false);
}

function player.setUsedFreePlot(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "plot.usedFree", boolean);
	config.saveAsync(config);
}

function player.activateSitting(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "sitting", boolean);
	config.saveAsync(config);
}

function player.hasSittingActivated(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "sitting", true);
}

function player.acceptTpaRequests(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "tptoggle", boolean);
	config.saveAsync(config);
}

function player.doesAcceptTpaRequests(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "tptoggle", true);
}

function player.getBackPos(player) {
	config = playerdata.getSurvival(player);
	location = config.getString(config, "backpos", "null");
	if(location == "null") {
		return null;
	}
	return read.location(location);
}

function player.setBackPos(player) {
	config = playerdata.getSurvival(player);
	config.set(config, "backpos", string.location(entity.getLocation(player)));
	config.saveAsync(config);
}

function player.setBackPosLoc(player, location) {
	config = playerdata.getSurvival(player);
	config.set(config, "backpos", string.location(location));
	config.saveAsync(config);
}

function player.clearBackPos(player) {
	config = playerdata.getSurvival(player);
	config.set(config, "backpos", "null");
	config.saveAsync(config);
}

function entity.getFromDamageSource(damage_source) {
	entity = damage.getImmediateSource(damage_source);
	if(entity == null) {
		return damage.getTrueSource(damage_source);
	}
	return entity;
}

function player.getFromDamageSource(damage_source) {
	entity = damage.getImmediateSource(damage_source);
	if(isPlayer(entity)) {
		return entity;
	}
	entity = damage.getTrueSource(damage_source);
	if(isPlayer(entity)) {
		return entity;
	}
	return null;
}

function player.getJoins(player_or_id) {
	if(isPlayer(player_or_id)) {
		player_id = player.getId(player_or_id);
	} else {
		player_id = player_or_id;
	}
	stmt = databank.prepare("SELECT COUNT(join_time) FROM playtime WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		amount = databank.getLong(result, 1);
	}
	databank.close(result);
	databank.close(stmt);
	return amount;
}

function player.getTotalPlaytime(player_or_id) {
	if(isPlayer(player_or_id)) {
		player_id = player.getId(player_or_id);
	} else {
		player_id = player_or_id;
	}
	//Online seit
	since_minutes = 0;
	if(isOnline(player.getNameFromId(player_id))) {
		stmt = databank.prepare("SELECT join_time FROM playtime WHERE player_id = ? AND leave_time IS NULL;");
		databank.setInt(stmt, 1, player_id);
		result = databank.execute(stmt);
		while(databank.next(result)) {
			since_minutes = (time.getMillis() - databank.getLong(result, 1)) / 1000 / 60;
		}
		databank.close(result);
		databank.close(stmt);
	}
	//Spielzeit gesamt
	stmt2 = databank.prepare("SELECT SUM(leave_time - join_time) FROM playtime WHERE player_id = ?;");
	databank.setInt(stmt2, 1, player_id);
	result = databank.execute(stmt2);
	while(databank.next(result)) {
		minutes = databank.getLong(result, 1) / 1000 / 60 + since_minutes;
	}
	databank.close(result);
	databank.close(stmt2);
	return minutes;
}

function player.hasInvIgnore(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "invignore", false);
}

function player.invIgnore(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "invignore", boolean);
	config.saveAsync(config);
}

function player.getClanId(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "clan_id", -1);
}

function player.setClanId(player_or_id, clan_id) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "clan_id", clan_id);
	config.saveAsync(config);
}

function player.getClanRole(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	temp = config.getString(config, "clan_role", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function player.setClanRole(player_or_id, clan_id) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "clan_role", clan_id);
	config.saveAsync(config);
}

function player.isInClan(player_or_id) {
	return player.getClanId(player_or_id) >= 0;
}

function player.isClanLeader(player_or_id) {
	return player.getClanRole(player_or_id) == "leader";
}

function player.isClanMod(player_or_id) {
	return player.getClanRole(player_or_id) == "mod";
}

function player.isClanMember(player_or_id) {
	return player.getClanRole(player_or_id) == "member";
}

function player.isSameClan(player_or_id_1, player_or_id_2) {
	id_1 = player.getClanId(player_or_id_1);
	id_2 = player.getClanId(player_or_id_2);
	if(id_1 < 0 || id_2 < 0) {
		return false;
	}
	return id_1 == id_2;
}

function player.setHeadName(player) {
	nickname = player.getNickname(player);
	clan_string = "";
	if(player.isInClan(player)) {
		clan_id = player.getClanId(player);
		clan_string = string.concat(" [§6", clan.getTag(clan_id), "§r]");
	}
	live_string = "";
	if(player.isLive(player)) {
		live_string = "§f[§dLive§f] ";
	}
	entity.setName(player, text.new(string.concat(live_string, nickname, clan_string)));
}

function player.setAIChallengeAmounts(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "cha.ai.amount", amount);
	config.saveAsync(config);
}

function player.getAIhallengeAmounts(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "cha.ai.amount", 0);
}

function player.setAEChallengeAmounts(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "cha.ae.amount", amount);
	config.saveAsync(config);
}

function player.getAEChallengeAmounts(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "cha.ae.amount", 0);
}

function player.setADTChallengeAmounts(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "cha.dtype.amount", amount);
	config.saveAsync(config);
}

function player.getADTChallengeAmounts(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "cha.dtype.amount", 0);
}

function player.setAdventureAmounts(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "adventures", amount);
	config.saveAsync(config);
}

function player.getAdventureAmounts(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "adventures", 0);
}

function player.isOnAdventure(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "onadventure", false);
}

function player.setAdventure(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "onadventure", boolean);
	config.saveAsync(config);
}

function player.getAdventureStart(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	location = config.getString(config, "adventureloc", "null");
	if(location == "null") {
		return world.getServerSpawn();
	}
	return read.location(location);
}

function player.setAdventureStart(player_or_id, location) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "adventureloc", string.location(location));
	config.saveAsync(config);
}

function player.isMuted(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "muted", false);
}

function player.mute(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "muted", boolean);
	config.saveAsync(config);
}

function player.isGameMuted(player_or_id) {
	config = playerdata.getGames(player_or_id);
	return config.getBool(config, "game_muted", false);
}

function player.gameMute(player_or_id, boolean) {
	config = playerdata.getGames(player_or_id);
	config.set(config, "game_muted", boolean);
	config.saveAsync(config);
}

function player.getSilentJoin(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "silentjoin", false);
}

function player.setSilentJoin(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "silentjoin", boolean);
	config.saveAsync(config);
}

function player.getAutoCloseDoor(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "door_auto_close", true);
}

function player.setAutoCloseDoor(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "door_auto_close", boolean);
	config.saveAsync(config);
}

function player.getNoPetDamage(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "pet_damage", true);
}

function player.setNoPetDamage(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "pet_damage", boolean);
	config.saveAsync(config);
}

function player.getTipLoop(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "tip_loop", true);
}

function player.setTipLoop(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "tip_loop", boolean);
	config.saveAsync(config);
}

function player.setVoteStreak(player_or_id, millis) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "votestreak", millis);
	config.saveAsync(config);
}

function player.getVoteStreak(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "votestreak", 0);
}

function player.setLastVoteTime(player_or_id, millis) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "lastvotetime", millis);
	config.saveAsync(config);
}

function player.getLastVoteTime(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "lastvotetime", 0);
}

function player.setVotePoints(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "votepoints", amount);
	config.saveAsync(config);
}

function player.getVotePoints(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "votepoints", 0);
}

function player.addVotePoints(player_or_id, amount) {
	config = playerdata.getSurvival(player_or_id);
	points = config.getDouble(config, "votepoints", 0) + amount;
	config.set(config, "votepoints", points);
	config.saveAsync(config);
}

function player.isFirstJoin(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "firstjoin", true);
}

function player.setFirstJoin(player_or_id, boolean) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "firstjoin", !boolean);
	config.saveAsync(config);
}

function player.getShowcoords(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "showcoords", true);
}

function player.setShowcoords(player_or_id, bool) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "showcoords", bool);
	config.saveAsync(config);
}

function player.getFirstJoin(player_or_id) {
	if(isPlayer(player_or_id)) {
		player_id = player.getId(player_or_id);
	} else {
		player_id = player_or_id;
	}
	stmt = databank.prepare("SELECT MIN(join_time) FROM playtime WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		time = databank.getLong(result, 1);
	}
	databank.close(result);
	databank.close(stmt);
	return time;
}

function player.getLastJoin(player_or_id) {
	if(isPlayer(player_or_id)) {
		player_id = player.getId(player_or_id);
	} else {
		player_id = player_or_id;
	}
	stmt = databank.prepare("SELECT MAX(join_time) FROM playtime WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		time = databank.getLong(result, 1);
	}
	databank.close(result);
	databank.close(stmt);
	return time;
}

function player.blockCommands(player) {
	list = getScriptVar("block_commands_list");
	list.add(list, player.getUuid(player));
}

function player.unblockCommands(player) {
	list = getScriptVar("block_commands_list");
	player_uuid = player.getUuid(player);
	while(list.contains(list, player_uuid)) {
		list.remove(list, player_uuid);
	}
}

function player.isCommandBlocked(player) {
	list = getScriptVar("block_commands_list");
	return list.contains(list, player.getUuid(player));
}

function player.checkHandForType(player, item_type) {
	return item.getType(living.getHand(player)) == item_type;
}

function player.checkHandsForItem(player, item_or_type) {
	if(string.class(item_or_type) != "String") {
		item_or_type = item.getType(item_or_type);
	}
	hand = living.getHand(player);
	if(item.getType(hand) == item_or_type) {
		return true;
	}
	offhand = living.getOffHand(player);
	return item.getType(offhand) == item_or_type;
}

function player.checkHandsForTag(player, tag) {
	hand = living.getHand(player);
	if(item.hasTag(hand, tag)) {
		return true;
	}
	offhand = living.getOffHand(player);
	return item.hasTag(offhand, tag);
}

function player.hideOnline(player) {
	list = players.toList();
	iter = iterator(list);
	while(hasNext(iter)) {
		p = next(iter);
		player.hide(p, player);
	}
}

function player.showOnline(player) {
	list = players.toList();
	iter = iterator(list);
	while(hasNext(iter)) {
		p = next(iter);
		player.show(p, player);
	}
}

//--------------------------------------------------
//Chestshop-Utils
//--------------------------------------------------

function shop.getOwner(sign_block) {
	owner_id = read.number(sign.getString(sign_block, 3));
	if(owner_id == null) {
		return null;
	}
	return owner_id;
}

function shop.isOwner(player, sign_block) {
	if(player.hasBypass(player)) {
		return true;
	}
	owner_id = shop.getOwner(sign_block);
	if(owner_id == null) {
		return false;
	}
	owner_name = player.getNameFromId(owner_id);
	if(owner_name == null) {
		return false;
	}
	return owner_id == player.getId(player);
}

//--------------------------------------------------
//Block-Utils
//--------------------------------------------------

function block.isChest(block) {
	return block.isType(block, "minecraft:chest");
}

function block.isWallSign(block) {
	if(block == null) {
		return false;
	}
	return block.hasTag(block, block.getTag("minecraft:wall_signs"));
}

function sign.getString(block, row) {
	return string.text(block.getSign(block, row));
}

function sign.setString(block, row, string) {
	block.setSign(block, row, text.new(string));
}

function block.isType(block, type_string) {
	return block.getType(block) == material.get(type_string);
}

function block.isAir(block) {
	type = block.getType(block);
	return type == material.getAir() || type == material.get("CAVE_AIR");
}

function block.mod(block, x, y, z) {
	return block.get(loc.mod(block.getLocation(block), x, y, z));
}

function block.gotWater(block) {
	if(block.canHaveWater(block)) {
		return block.isWaterlogged(block);
	}
	return false;
}

//--------------------------------------------------
//Money-Utils
//--------------------------------------------------

function hasEnoughMoney(player_or_id, price) {
	return money.get(player_or_id) >= price;
}

function money.get(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getDouble(config, "money", 0);
}

function money.set(player_or_id, money) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "money", money);
	config.saveAsync(config);
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	money.display(player, money);
}

function money.getBoostFactor() {
	return getScriptVar("money_factor");
}

function money.setBoostFactor(factor) {
	setScriptVar("money_factor", factor);
}

function money.addBoost(player_or_id, money) {
	money *= money.getBoostFactor();
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	if(money.getBoostFactor() > 1) {
		money.popUp(player, money, true);
	}
	money.add(player, money);
}


function money.add(player_or_id, money) {
	if(money == 0) {
		return;
	}
	config = playerdata.getSurvival(player_or_id);
	new_money = config.getDouble(config, "money", 0) + money;
	config.set(config, "money", new_money);
	config.saveAsync(config);
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	money.display(player, new_money);
	money.popUp(player, money, false);
}

function money.sub(player_or_id, money) {
	if(money == 0) {
		return;
	}
	config = playerdata.getSurvival(player_or_id);
	new_money = config.getDouble(config, "money", 0) - money;
	config.set(config, "money", new_money);
	config.saveAsync(config);
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	money.display(player, new_money);
	money.popUp(player, money * -1, false);
}

function money.subWithoutPopUp(player_or_id, money) {
	if(money == 0) {
		return;
	}
	config = playerdata.getSurvival(player_or_id);
	new_money = config.getDouble(config, "money", 0) - money;
	config.set(config, "money", new_money);
	config.saveAsync(config);
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	money.display(player, new_money);
}

function money.popUp(player, money, boosted) {
	if($boost_blocker == null) {
		$boost_blocker = false;
	}
	if($boost_blocker) {
		$boost_blocker = false;
		return;
	}
	if(money == 0) {
		return;
	}
	if(money > 0) {
		pre = "+";
	}
	if(money < 0) {
		pre = "-";
		money *= -1;
	}
	if(boosted) {
		$boost_blocker = true;
		post = " §6§k#§rBoosted§6§k#";
	} else {
		post = "";
	}
	//player.action(player, string.concat(pre, "§6", string.number(money), " §rsnuvi", post));
	player.action(player, text.new(string.concat(pre, " ", money.getString(money), " ", post)));
}

function money.display(player, money)  {
	a = money.split(money);
	gold = string.number(a[0]);
	silver = string.number(a[1]);
	copper = string.number(a[2]);
	sb.add(player, 1, string.concat(icon.getGoldCoin(), gold, " ", icon.getSilverCoin(), silver, " ", icon.getCopperCoin(), copper));
}

function money.getString(money) {
	return money.getStringColor(money, "§f");
}

function money.getStringColor(money, color) {
	a = money.split(money);
	gold = a[0];
	silver = a[1];
	copper = a[2];
	if(gold == 0) {
		gold_string = "";
	} else {
		gold_string = string.concat(icon.getGoldCoin(), color, string.number(gold));;
	}
	if(silver == 0) {
		silver_string = "";
	} else {
		silver_string = string.concat(icon.getSilverCoin(), color, string.number(silver));;
	}
	if(copper == 0) {
		copper_string = "";
	} else {
		copper_string = string.concat(icon.getCopperCoin(), color, string.number(copper));;
	}
	if(gold == 0 && silver == 0 && copper == 0) {
		copper_string = string.concat(icon.getCopperCoin(), color, string.number(0));;
	}
	return string.concat(gold_string, silver_string, copper_string);
}

function money.split(money) {
	array = array.new(3);
	gold = math.roundDown(money / 4096);
	pre_silver = money % 4096;;
	silver = math.roundDown(pre_silver / 64);
	bronze = pre_silver % 64;
	array[0] = gold;
	array[1] = silver;
	array[2] = bronze;
	return array;
}

function money.splitCap(money) {
	//cap liegt bei 266304 (64 gold + 64 silver + 64 bronze)
	if(money > 266304) {
		snuvi.debug("error on money.splitCap");
		return null;
	}
	gold = math.roundDown(money / 4096);
	if(gold > 64) {
		gold = 64;
	}
	money -= gold * 4096;
	silver = math.roundDown(money / 64);
	if(silver > 64) {
		silver = 64;
	}
	money -= silver * 64;
	array = array.new(3);
	array[0] = gold;
	array[1] = silver;
	array[2] = money;
	return array;
}

//--------------------------------------------------
//Plot-Utils
//--------------------------------------------------

function plot.getFromId(plot_id, world) {
	iter = plot.iterator(world);
	while(hasNext(iter)) {
		plot = next(iter);
		if(plot.getId(plot) == plot_id) {
			return plot;
		}
	}
	return null;
}

function plot.calcCost(world, arg1, arg2) {
//function plot.calcCost(world, length, width) {
//function plot.calcCost(world, loc1, loc2) {
	if(isDouble(arg1)) {
		length = arg1;
		width = arg2;
	} else {
		x1 = loc.getX(arg1);
		z1 = loc.getZ(arg1);
		x2 = loc.getX(arg2);
		z2 = loc.getZ(arg2);
		length = math.abs(x1 - x2) + 1;
		width = math.abs(z1 - z2) + 1;
	}
	if(world.getName(world) == "creative") {
		factor = 1;
	} else {
		factor = 3;
	}
	return length * width * factor;
}

function plot.getIdFromLocation(location) {
	list = plot.get(location);
	if(list.getSize(list) == 0) {
		plot_id = null;
	} else {
		plot = list.getIndex(list, 0);
		plot_id = plot.getId(plot);
	}
	return plot_id;
}

function plot.getIdListFromLocation(location) {
	list = plot.get(location);
	for(i = 0; i < list.getSize(list); i++) {
		plot = list.getIndex(list, i);
		list.setIndex(list, i, plot.getId(plot));
	}
	return list;
}

function plot.getHighestId(location) {
	list = plot.get(location);
	iter = iterator(list);
	highest = -1;
	while(hasNext(iter)) {
		plot_id = plot.getId(next(iter));
		if(plot_id > highest) {
			highest = plot_id;
		}
	}
	return highest;
}

function plot.addPlayer(plot, player_name) {
	list = plot.getOwners(plot);
	uuid = player.getUuid(player_name);
	if(!list.contains(list, uuid)) {
		list.add(list, uuid);
	}
}

function plot.removePlayer(plot, player_name) {
	list = plot.getOwners(plot);
	uuid = player.getUuid(player_name);
	list.remove(list, uuid);
	player_id = player.getId(player.getUuid(player_name));
	plot.removeRank(plot, player_id);
}

function plot.getOwnersString(plot) {
	list = plot.getOwners(plot);
	if(list.getSize(list) == 0) {
		return "";
	}
	owners_list = list.new();
	for(i = 0; i < list.getSize(list); i++) {
		list.add(owners_list, player.getName(list.getIndex(list, i)));
	}
	return string.concatList(owners_list, " / ", 0, list.getSize(owners_list) - 1);
}

function plot.isLeader(plot, player_or_id) {
	return plot.getRank(plot, player_or_id) == "leader";
}

function plot.getLeaderName(plot) {
	plot_leader_id = plot.getLeaderId(plot);
	if(plot_leader_id == null) {
		return "";
	}
	return player.getNameFromId(plot_leader_id);
}

function plot.getLeaderId(plot) {
	map = plot.getRanksMap(plot);
	iter = map.iterator(map);
	while(hasNext(iter)) {
		element = next(iter);
		rank = map.getValue(element);
		if(rank == "leader") {
			p_id = map.getKey(element);
		}
	}
	return p_id;
}

function plot.setLeader(plot, player_or_id) {
	plot.setRank(plot, player_or_id, "leader");
}

function plot.isMod(plot, player_or_id) {
	return plot.getRank(plot, player_or_id) == "mod";
}

function plot.getMods(plot) {
	list = list.new();
	map = plot.getRanksMap(plot);
	iter = map.iterator(map);
	while(hasNext(iter)) {
		element = next(iter);
		rank = map.getValue(element);
		if(rank == "mod") {
			list.add(list, map.getKey(element));
		}
	}
	return list;
}

function plot.setMod(plot, player_or_id) {
	plot.setRank(plot, player_or_id, "mod");
}

function plot.canOpenChests(plot, player_or_id) {
	return plot.getRank(plot, player_or_id) == "chest";
}

function plot.setChest(plot, player_or_id) {
	plot.setRank(plot, player_or_id, "chest");
}

function plot.getAllRanks() {
	return getScriptVar("plot_ranks");
}

function plot.getRanksMap(plot) {
	plot_id = plot.getId(plot);
	plot_ranks_map = plot.getAllRanks();
	map = map.get(plot_ranks_map, plot_id);
	if(map == null) {
		map = map.new();
	}
	return map;
}

function plot.getChestRanks(plot) {
	list = list.new();
	map = plot.getRanksMap(plot);
	iter = map.iterator(map);
	while(hasNext(iter)) {
		element = next(iter);
		rank = map.getValue(element);
		if(rank == "chest") {
			list.add(list, map.getKey(element));
		}
	}
	return list;
}

function plot.getRank(plot, player_or_id) {
	map = plot.getRanksMap(plot);
	player_id = player.getValidId(player_or_id);
	rank = map.get(map, player_id);
	return rank;
}

function plot.setRank(plot, player_or_id, rank) {
	player_id = player.getValidId(player_or_id);
	plot_id = plot.getId(plot);
	//Cache
	plot_ranks_map = plot.getAllRanks();
	map = plot.getRanksMap(plot);
	map.add(map, player_id, rank);
	map.add(plot_ranks_map, plot_id, map);
	//DB
	stmt = databank.prepare("INSERT INTO new_plotranks (plot_id, player_id, rank) VALUES (?,?,?) ON DUPLICATE KEY UPDATE rank = ?");
	databank.setInt(stmt, 1, plot_id);
	databank.setInt(stmt, 2, player_id);
	databank.setString(stmt, 3, rank);
	databank.setString(stmt, 4, rank);
	databank.workerExecute(stmt);
}

function plot.removeRank(plot, player_or_id) {
	player_id = player.getValidId(player_or_id);
	plot_id = plot.getId(plot);
	//Cache
	plot_ranks_map = plot.getAllRanks();
	map = plot.getRanksMap(plot);
	map.remove(map, player_id);
	map.add(plot_ranks_map, plot_id, map);
	//DB
	stmt = databank.prepare("DELETE FROM new_plotranks WHERE player_id = ? AND plot_id = ?;");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, plot_id);
	databank.workerExecute(stmt);
}

function plot.removeAllPlayers(plot) {
	list = plot.getOwners(plot);
	iter = iterator(list);
	while(hasNext(iter)) {
		plot.removeRank(plot, player.getId(next(iter)));
	}
}

function plot.setEdges(plot, location1, location2) {
	//Alte Daten abrufen
	plot_name = plot.getName(plot);
	plot_id = plot.getId(plot);
	list = plot.getOwners(plot);
	flags = plot.getFlags(plot);
	//Neues Plot erstellen und altes Plot löschen
	plot.remove(plot, loc.getWorld(location1));
	new_plot = plot.add(location1, location2, plot_id);
	//Alte Daten auf neuem Plot setzen
	plot.setName(new_plot, plot_name);
	new_list = plot.getOwners(new_plot);
	for(i = 0; i < list.getSize(list); i++) {
		list.add(new_list, list.getIndex(list, i));
	}
	plot.setFlags(new_plot, flags, true);
	return new_plot;
}

function plot.getType(plot) {
	if(plot.isCity(plot)) {
		type = "§4[§cCity§4]";
	} elseif(plot.isFree(plot)) {
		type = "§3[§bFree§3]";
	} elseif(plot.isSub(plot)) {
		type = "§6[§eSubPlot§6]";
	} else {
		type = "§6[§ePlot§6]";
	}
	return type;
}

function plot.isPlot(plot) {
	return !plot.isCity(plot) && !plot.isFree(plot) && !plot.isSub(plot);
}

function plot.isExplosive(plot) {
	return plot.hasFlags(plot, calcLeftShift(27));
}

function plot.isCity(plot) {
	return plot.hasFlags(plot, calcLeftShift(28));
}

function plot.isFree(plot) {
	return plot.hasFlags(plot, calcLeftShift(29));
}

function plot.isSub(plot) {
	return plot.hasFlags(plot, calcLeftShift(30));
}

function plot.setCity(plot, boolean) {
	plot.setFlags(plot, calcLeftShift(28), boolean);
}

function plot.setFree(plot, boolean) {
	plot.setFlags(plot, calcLeftShift(29), boolean);
	plot.setFlags(plot, calcLeftShift(30), !boolean); //Sub-Plot entfernen
}

function plot.setSub(plot, boolean) {
	plot.setFlags(plot, calcLeftShift(30), boolean);
	plot.setFlags(plot, calcLeftShift(29), !boolean); //Free-Plot entfernen
}

//--------------------------------------------------
//Loc-Utils
//--------------------------------------------------

function loc.getHighestPoint(loc) {
	y = 319;
	loc.setY(loc, y);
	while(y > 0 && block.isAir(block.get(loc))) {
		loc.setY(loc, y);
		y = y - 10;
	}
	while(!block.isAir(block.get(loc))) {
		loc.setY(loc, y);
		y++;
	}
	return loc;
}

function loc.getStringColon(loc) {
	world_name = world.getName(loc.getWorld(loc));
	x = string.number(loc.getX(loc));
	y = string.number(loc.getY(loc));
	z = string.number(loc.getZ(loc));
	return string.concat(world_name, ":", x, ":", y, ":", z);
}

function loc.getStringSpace(loc) {
	world_name = world.getName(loc.getWorld(loc));
	x = string.number(loc.getX(loc));
	y = string.number(loc.getY(loc));
	z = string.number(loc.getZ(loc));
	return string.concat(world_name, " ", x, " ", y, " ", z);
}

function loc.getStringRounded(loc, separator) {
	x = string.number(math.round(loc.getX(loc)));
	y = string.number(math.round(loc.getY(loc)));
	z = string.number(math.round(loc.getZ(loc)));
	return string.concat(separator, x, separator, y, separator, z);
}

function loc.isSameWorld(loc1, loc2) {
	return world.getName(loc.getWorld(loc1)) == world.getName(loc.getWorld(loc2));
}

function loc.getSubPlot(location) {
	list = plot.get(location);
	iter = iterator(list);
	while(hasNext(iter)) {
		plot = next(iter);
		if(plot.isSub(plot)) {
			return plot;
		}
	}
	return null;
}

function loc.isCity(location) {
	list = plot.get(location);
	iter = iterator(list);
	while(hasNext(iter)) {
		plot = next(iter);
		if(plot.isCity(plot)) {
			return true;
		}
	}
	return false;
}

function loc.hasPlotId(location, plot_id) {
	return list.contains(plot.getIdListFromLocation(location), plot_id);
}

function loc.hasPlotName(location, plot_name) {
	list = plot.get(location);
	iter = iterator(list);
	while(hasNext(iter)) {
		plot = next(iter);
		if(plot.getName(plot) == plot_name) {
			return true;
		}
	}
	return false;
}

function loc.isInSurvWorld(location) {
	world_name = world.getName(loc.getWorld(location));
	if(world_name == "world") {
		return true;
	} elseif(world_name == "world_the_end") {
		return true;
	} elseif(world_name == "world_nether") {
		return true;
	}
	return false;
}

function loc.isInGamesWorld(location) {
	return loc.getWorld(location) == world.getGames();
}

function loc.isInCreativeWorld(location) {
	return loc.getWorld(location) == world.getCreative();
}

function loc.round(location) {
	world = loc.getWorld(location);
	x = math.round(loc.getX(location));
	y = math.round(loc.getY(location));
	z = math.round(loc.getZ(location));
	return loc.new(world, x, y, z);
}

//--------------------------------------------------
//Survival-Utils
//--------------------------------------------------

function living.setAi(bool) {
	config = getServerConfig();
	config.set(config, "spawnWithAi", bool);
	config.saveAsync(config);
}

function living.getAi() {
	config = getServerConfig();
	return config.getBool(config, "spawnWithAi", true);
}

function living.setHand(living, item) {
	living.setEquip(living, slot.getHand(), item);
}

function living.getHand(living) {
	return living.getEquip(living, slot.getHand());
}

function living.getOffHand(living) {
	return living.getEquip(living, slot.getOffHand());
}

//--------------------------------------------------
//Afk-Utils
//--------------------------------------------------

function player.isAfk(player) {
	player_uuid = player.getUuid(player);
	afk_map = getScriptVar("afk_map");
	return map.contains(afk_map, player_uuid);
}

function player.setAfk(player, boolean) {
	player_uuid = player.getUuid(player);
	afk_map = getScriptVar("afk_map");
	if(boolean) {
		map.add(afk_map, player_uuid, loc.getYaw(entity.getLocation(player)));
	} else {
		map.remove(afk_map, player_uuid);
	}
}

//--------------------------------------------------
//PvP-Utils
//--------------------------------------------------

function hasPvpOn(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getBool(config, "pvp", false);
}

function setPvp(player_or_id, bool) {
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "pvp", bool);
	config.saveAsync(config);
}

//--------------------------------------------------
//Rank-Utils
//--------------------------------------------------

function getRank(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	return config.getString(config, "rank", "§3User");
}

function setRank(player_or_id, rank) {
	rank = string.replace(rank, "&", "§");
	config = playerdata.getSurvival(player_or_id);
	config.set(config, "rank", rank);
	config.saveAsync(config);
}

function offerRank(player, tech_name) {
	rank = rank.getFromTechName(tech_name);
	msg(player, text.merge(text.new(string.getPrefix("§6Commands")), text.new(" "), text.new("New rank available: "), text.getHoverText(string.getClickText(string.concat("[§", rank, "§r]"), string.concat("/setrank ", player.getName(player), " &", rank)), "Click to set")));
}

function rank.offerClan(clan_id, tech_name) {
	leader_uuid = clan.getLeader(clan_id);
	leader = player.get(leader_uuid);
	if(leader == null) {
		mail.send("marvinius", player.getName(leader_uuid), string.concat("New rank available: ", tech_name));
	} else {
		offerRank(leader, tech_name);
	}
}

function rank.checkCriteria(player, tech_name) {
	//Playtime
	if(tech_name == "rank.newcomer") {
		return player.getTotalPlaytime(player) >= 1200; //20 Stunden
	}
	if(tech_name == "rank.frequenter") {
		return player.getTotalPlaytime(player) >= 6000; //100 Stunden
	}
	if(tech_name == "rank.legend") {
		return player.getTotalPlaytime(player) >= 42000; //700 Stunden
	}
	//Challenges
	if(tech_name == "rank.challenger") {
		return player.getADTChallengeAmounts(player) >= 1;
	}
	if(tech_name == "rank.mobhunter") {
		return player.getAEChallengeAmounts(player) >= 1;
	}
	if(tech_name == "rank.collector") {
		return player.getAIhallengeAmounts(player) >= 1;
	}
	//Adventure
	/*if(tech_name == "rank.adventurer") {
		return player.getAdventureAmounts(player) >= 1;
	}
	if(tech_name == "rank.explorer") {
		return player.getAdventureAmounts(player) >= 5;
	}
	if(tech_name == "rank.pioneer") {
		return player.getAdventureAmounts(player) >= 10;
	}*/
	//Clans
	/*if(tech_name == "rank.commander") {
		if(player.isClanLeader(player)) {
			clan_id = player.getClanId(player);
			return clan.getMembersAmount(clan_id) >= 5;
		}
		return false;
	}
	if(tech_name == "rank.chief") {
		if(player.isClanLeader(player)) {
			clan_id = player.getClanId(player);
			return clan.getMembersAmount(clan_id) >= 10;
		}
		return false;
	}
	if(tech_name == "rank.lord") {
		if(player.isClanLeader(player)) {
			clan_id = player.getClanId(player);
			return clan.getMembersAmount(clan_id) >= 15;
		}
		return false;
	}*/
	//Quests
	if(tech_name == "rank.volunteer") {
		return quest.getCounter(player) >= 15;
	}
	if(tech_name == "rank.friend") {
		return quest.getCounter(player) >= 50;
	}
	if(tech_name == "rank.altruist") {
		return quest.getCounter(player) >= 500;
	}
	//Plots
	if(tech_name == "rank.settler") {
		return player.usedHisFreePlot(player);
	}
	if(tech_name == "rank.colonizer") {
		return player.hasBigPlotCreated(player);
	}
	if(tech_name == "rank.major") {
		return player.hasPlotRaised(player);
	}
	//Team
	if(tech_name == "rank.owner") {
		return perm.has("isOwner", player);
	}
	if(tech_name == "rank.admin") {
		return perm.has("isAdmin", player);
	}
	if(tech_name == "rank.builder") {
		return perm.has("isBuilder", player);
	}
	if(tech_name == "rank.dev") {
		return perm.has("isDev", player);
	}
	if(tech_name == "rank.moderator") {
		return perm.has("isMod", player);
	}
	if(tech_name == "rank.supporter") {
		return perm.has("isSupporter", player);
	}
	//Other
	if(tech_name == "rank.vip") {
		return perm.has("isVIP", player);
	}
	if(tech_name == "rank.influencer") {
		return perm.has("isYT", player) || perm.has("isStreamer", player);
	}
	if(tech_name == "rank.sponsor") {
		return perm.has("isSponsor", player);
	}
	if(tech_name == "rank.user") {
		return true;
	}
	return perm.has("setrank.other", player);
}

function rank.getRankArray() {
	return getScriptVar("ranks");
}
function rank.getFromTechName(tech_name) {
	a = rank.getRankArray();
	a_size = array.getSize(a);
	for(i = 0; i < a_size; i++) {
		if(a[i, 0] == tech_name) {
			return a[i, 1];
		}
	}
	return null;
}

function rank.getTechName(rank) {
	a = rank.getRankArray();
	a_size = array.getSize(a);
	for(i = 0; i < a_size; i++) {
		if(a[i, 1] == rank) {
			return a[i, 0];
		}
	}
	return null;
}

function rank.choose(player, tech_name) {
	rank = rank.getFromTechName(tech_name);
	msg(player, string.getClickText(string.concat(" [§", rank, "§r]"), string.concat("/setrank ", player.getName(player), " &", rank)));
}

function rank.showAll(player) {
	a = rank.getRankArray();
	a_size = array.getSize(a);
	for(i = 0; i < a_size; i++) {
		tech_name = a[i, 0];
		if(rank.checkCriteria(player, tech_name)) {
			rank.choose(player, tech_name);
		}
	}
}

//--------------------------------------------------
//Perm-Utils
//--------------------------------------------------

function perm.addGroupToPlayer(player_id, perm_id) {
	stmt = databank.prepare("INSERT INTO new_playerperms (player_id, perm_id) VALUES (?,?);");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, perm_id);
	databank.workerExecute(stmt);
	
	list = player.getPerms(player_id);
	list.add(list, perm_id);

	perm.initPlayer(player_id);
}

function perm.removeGroupFromPlayer(player_id, perm_id) {
	stmt = databank.prepare("DELETE FROM new_playerperms WHERE player_id = ? AND perm_id = ?;");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, perm_id);
	databank.workerExecute(stmt);
	
	list = player.getPerms(player_id);
	list.remove(list, perm_id);
	
	player_uuid = player.getUuidFromId(player_id);
	player = player.get(player_uuid);
	if(player != null) {
		perm.unloadGroupFromPlayer(perm_id, player);
	}
}

function perm.simUser(player) {
	perm.clear(player);
	perm.loadGroupToPlayer(0, player);
	perm.loadGroupToPlayer(14, player);
	perm.update(player);
}

function player.removeAllPerms(player_id) {
	stmt = databank.prepare("DELETE FROM new_playerperms WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	databank.workerExecute(stmt);
	perm.initPlayer(player_id);
}

function perm.getAll() {
	return getScriptVar("player_perms");
}

function player.getPerms(player_or_id) {
	player_id = player.getValidId(player_or_id);
	map = perm.getAll();
	list = map.get(map, player_id);
	if(list == null) {
		list = list.new();
		map.add(map, player_id, list);
	}
	return map.getOrDefault(perm.getAll(), player_id, list.new());
}

function player.getPermsFromDatabank(player_or_id) {
	player_id = player.getValidId(player_or_id);
	permslist = list.new();
	stmt = databank.prepare("SELECT perm_id FROM new_playerperms WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	while(databank.next(result)) {
		list.add(permslist, databank.getInt(result, 1));
	}
	databank.close(result);
	databank.close(stmt);
	return permslist;
}

function perm.setGroups(permgroups) {
	setScriptVar("permgroups", permgroups);
}

function perm.getGroups() {
	return getScriptVar("permgroups");
}

function perm.getNameFromId(permgroup_id) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(i == permgroup_id) {
			return a[i, 0];
		}
	}
	return null;
}

function perm.getRankFromId(permgroup_id) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(i == permgroup_id) {
			return a[i, 1];
		}
	}
	return null;
}

function perm.getIdFromGroupname(permgroup_name) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(a[i, 0] == permgroup_name) {
			return i;
		}
	}
	return null;
}

function perm.getRankFromGroupname(permgroup_name) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(a[i, 0] == permgroup_name) {
			return a[i, 1];
		}
	}
	return null;
}

function perm.isGroupName(permgroup_name) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(a[i, 0] == permgroup_name) {
			return true;
		}
	}
	return false;
}

function player.hasPermGroup(player_id, perm_id) {
	permslist = player.getPerms(player_id);
	return list.contains(permslist, perm_id);
}

function perm.loadGroupToPlayer(group_id, player) {
	list = perm.getGroupList(group_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		perm = next(iter);
		perm.add(perm, player);
	}
}

function perm.unloadGroupFromPlayer(group_id, player) {
	list = perm.getGroupList(group_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		perm = next(iter);
		perm.remove(perm, player);
	}
}

function perm.getGroupList(group_id) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(i == group_id) {
			return a[i, 2];
		}
	}
	return null;
}

function perm.isAwardable(group_id) {
	a = perm.getGroups();
	for(i = 0; i < array.getSize(a); i++) {
		if(i == group_id) {
			return a[i, 3];
		}
	}
	return null;
}

function perm.initPlayer(player_or_id) {
	player = player.getValid(player_or_id);
	if(player == null) {
		return;
	}
	perm.clear(player);
	perm.loadGroupToPlayer(0, player);
	permslist = player.getPerms(player);
	iter = iterator(permslist);
	while(hasNext(iter)) {
		perm.loadGroupToPlayer(next(iter), player);
	}
	perm.update(player);
	command.sendHelp(player);
}

//--------------------------------------------------
//Nickname-Utils
//--------------------------------------------------

function player.setNickName(player, nickname) {
	map.add(getScriptVar("nicknames"), player.getUuid(player), nickname);
}

function player.getNickName(player) {
	return map.getOrDefault(getScriptVar("nicknames"), player.getUuid(player), player.getName(player));
}

function player.removeNickName(player) {
	map.remove(getScriptVar("nicknames"), player.getUuid(player));
}

function player.isNicked(player) {
	return map.contains(getScriptVar("nicknames"), player.getUuid(player));
}

//--------------------------------------------------
//Mail-Utils
//--------------------------------------------------

function mail.send(from_name, to_name, string_message) {
	server_config = getServerConfig();
	mail_id = config.getDouble(server_config, "mail_id", 0) + 1;
	config.set(server_config, "mail_id", mail_id);
	config.saveAsync(server_config);
	
	from_id = player.getId(player.getUuid(from_name));
	to_id = player.getId(player.getUuid(to_name));
	
	stmt = databank.prepare("INSERT INTO mails (mail_id, from_id, to_id, readed, time, message) VALUES (?, ?, ?, ?, ?, ?);");
	databank.setInt(stmt, 1, mail_id);
	databank.setInt(stmt, 2, from_id);
	databank.setInt(stmt, 3, to_id);
	databank.setBool(stmt, 4, false);
	databank.setLong(stmt, 5, time.getMillis());
	databank.setString(stmt, 6, string_message);
	databank.workerExecute(stmt);
	
	//Wenn Spieler online, dann Pushmeldung veranlassen
	p = read.player(to_name);
	if(p != null) {
	msg(p, text.merge(text.new(string.concat(string.getPrefix("§bMail"), " §rYou´ve got a new mail from §b", from_name, ". ")), string.getClickText("[§cClick§r]", "/mail new")));
	}
}

function mail.checkForNew(player) {
	stmt = databank.prepare("SELECT mail_id, from_id, time, message FROM mails WHERE to_id = ? AND readed = false;");
	to_id = player.getId(player);
	databank.setInt(stmt, 1, to_id);
	result = databank.execute(stmt);
	nextrow = databank.next(result);
	if(!nextrow) {
		databank.close(result);
		databank.close(stmt);
		return;
	}
	newmails = 0;
	while(nextrow) {
		newmails++;
		nextrow = databank.next(result);
	}
	databank.close(result);
	databank.close(stmt);
	if(newmails > 0) {
		if(newmails > 1) {
			msg(player, text.merge(text.new(string.concat(string.getPrefix("§bMail"), " §rYou´ve got §b", string.number(newmails), "§r new mails. ")), string.getClickText("[§cClick§r]", "/mail new")));;
		} else {
			msg(player, text.merge(text.new(string.concat(string.getPrefix("§bMail"), " §rYou´ve got §b1 §rnew mail. ")), string.getClickText("[§cClick§r]", "/mail new")));;
		}
	}
}

//--------------------------------------------------
//Friend-Utils
//--------------------------------------------------

function friend.check(player_id, friend_id) {
	stmt = databank.prepare("SELECT friend_id FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, friend_id);
	databank.setInt(stmt, 3, friend_id);
	databank.setInt(stmt, 4, player_id);
	result = databank.execute(stmt);
	if(databank.next(result)) {
		temp = true;
	} else {
		temp = false;
	}
	databank.close(result);
	databank.close(stmt);
	return temp;
}

function friend.add(player_id, friend_id) {
	stmt = databank.prepare("INSERT INTO friends (player_id, friend_id, time) VALUES (?, ?, ?);");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, friend_id);
	databank.setLong(stmt, 3, time.getMillis());
	databank.workerExecute(stmt);
}

function friend.delete(player_id, friend_id) {
	stmt = databank.prepare("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);");
	databank.setInt(stmt, 1, player_id);
	databank.setInt(stmt, 2, friend_id);
	databank.workerExecute(stmt);
}

function friend.getList(player_id) {
	list = list.new();
	stmt = databank.prepare("SELECT friend_id FROM friends WHERE player_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	while(databank.next(result)) {
		list.add(list, databank.getInt(result, 1));
	}
	databank.close(result);
	databank.close(stmt);
	
	stmt = databank.prepare("SELECT player_id FROM friends WHERE friend_id = ?;");
	databank.setInt(stmt, 1, player_id);
	result = databank.execute(stmt);
	while(databank.next(result)) {
		list.add(list, databank.getInt(result, 1));
	}
	databank.close(result);
	databank.close(stmt);
	return list;
}

//--------------------------------------------------
//Clan-Utils
//--------------------------------------------------

function clan.getIdList() {
	file = file.new("scripts/configs/clan_data");
	if(file.exists(file) && file.isDirectory(file)) {
		list = file.getList(file);
	} else {
		list = list.new();
	}
	id_list = list.new();
	iter = iterator(list);
	while(hasNext(iter)) {
		element = next(iter);
		file_name = file.getName(element);
		file_name = string.replace(file_name, ".0.snuvic", "");
		list.add(id_list, read.number(file_name));
	}
	return id_list;
}

function clan.loadData() {
	list = clan.getIdList();
	iter = iterator(list);
	map = map.new();
	while(hasNext(iter)) {
		clan_id = next(iter);
		config = config.new("scripts/configs/clan_data", clan_id);
		if(config.exists(config)) {
			config.load(config);
		}
		map.add(map, clan_id, config);
	}
	setScriptVar("clan_data", map);
}

function clan.getData(clan_id) {
	if(clan_id == null) {
		snuvi.debug("script termed. clan_id was null");
		term();
	}
	map = getScriptVar("clan_data");
	config = map.get(map, clan_id);
	if(config == null) {
		config = config.new("scripts/configs/clan_data", clan_id);
		if(config.exists(config)) {
			config.load(config);
		}
		map.add(map, clan_id, config);
	}
	return config;
}

function clan.setName(clan_id, name) {
	config = clan.getData(clan_id);
	config.set(config, "name", name);
	config.saveAsync(config);
}

function clan.getName(clan_id) {
	config = clan.getData(clan_id);
	temp = config.getString(config, "name", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function clan.setTag(clan_id, tag) {
	config = clan.getData(clan_id);
	config.set(config, "tag", tag);
	config.saveAsync(config);
}

function clan.getTag(clan_id) {
	config = clan.getData(clan_id);
	temp = config.getString(config, "tag", "null");
	if(temp == "null") {
		return null;
	}
	return temp;
}

function clan.setMoney(clan_id, money) {
	config = clan.getData(clan_id);
	config.set(config, "money", money);
	config.saveAsync(config);
}

function clan.getMoney(clan_id) {
	config = clan.getData(clan_id);
	return config.getDouble(config, "money", 0);
}

function clan.addMoney(clan_id, money) {
	config = clan.getData(clan_id);
	new_money = config.getDouble(config, "money", 0) + money;
	config.set(config, "money", new_money);
	config.saveAsync(config);
}

function clan.subMoney(clan_id, money) {
	config = clan.getData(clan_id);
	new_money = config.getDouble(config, "money", 0) - money;
	config.set(config, "money", new_money);
	config.saveAsync(config);
}

function clan.setSpawn(clan_id, location) {
	config = clan.getData(clan_id);
	config.set(config, "spawn", string.location(location));
	config.saveAsync(config);
}

function clan.getSpawn(clan_id) {
	config = clan.getData(clan_id);
	location = config.getString(config, "spawn", "null");
	if(location == "null") {
		return null;
	}
	return read.location(location);
}

function clan.getIdFromName(name) {
	list = clan.getIdList();
	iter = iterator(list);
	while(hasNext(iter)) {
		clan_id = next(iter);
		if(clan.getName(clan_id) == name) {
			return clan_id;
		}
	}
	return null;
}

function clan.getIdFromTag(clan_tag) {
	list = clan.getIdList();
	iter = iterator(list);
	while(hasNext(iter)) {
		clan_id = next(iter);
		if(clan.getTag(clan_id) == clan_tag) {
			return clan_id;
		}
	}
	return null;
}

function clan.isExistingTag(clan_tag) {
	return !(clan.getIdFromTag(clan_tag) == null);
}

function clan.isExistingName(name) {
	return !(clan.getIdFromName(name) == null);
}

function clan.getNextFreeId() {
	server_config = getServerConfig();
	id = config.getDouble(server_config, "clan.id.next", 0) + 1;
	config.set(server_config, "clan.id.next", id);
	config.saveAsync(server_config);
	return id;
}

function clan.create(name, tag) {
	clan_id = clan.getNextFreeId();
	config = clan.getData(clan_id);
	config.set(config, "name", name);
	config.set(config, "tag", tag);
	config.set(config, "members", 0);
	config.save(config);
	return clan_id;
}

function clan.getLeader(clan_id) {
	list = clan.getMembersList(clan_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		player_uuid = next(iter);
		player_id = player.getId(player_uuid);
		if(player.isClanLeader(player_id)) {
			return player_uuid;
		}
	}
	return null;
}

function clan.getMembersAmount(clan_id) {
	config = clan.getData(clan_id);
	return config.getDouble(config, "members", 0);
}

function clan.setMembersAmount(clan_id, amount) {
	config = clan.getData(clan_id);
	config.set(config, "members", amount);
	config.saveAsync(config);
}

function clan.addMember(clan_id, player_or_id, role) {
	//Player
	player.setClanId(player_or_id, clan_id);
	player.setClanRole(player_or_id, role);
	//Clan
	new_amount = clan.getMembersAmount(clan_id) + 1;
	if(isPlayer(player_or_id)) {
		player_uuid = player.getUuid(player_or_id);
	} else {
		player_uuid = player.getUuidFromId(player_or_id);
	}
	config = clan.getData(clan_id);
	config.set(config, string.concat("player_", new_amount), text(player_uuid));
	config.set(config, "members", new_amount);
	config.saveAsync(config);
}

function clan.removeMember(clan_id, player_or_id) {
	//Player
	player.setClanId(player_or_id, -1);
	player.setClanRole(player_or_id, "null");
	if(isPlayer(player_or_id)) {
		player_uuid = player.getUuid(player_or_id);
	} else {
		player_uuid = player.getUuidFromId(player_or_id);
	}
	//Clan
	config = clan.getData(clan_id);
	amount = config.getDouble(config, "members", 0);
	for(i = 1; i <= amount; i++) {
		if(config.getString(config, string.concat("player_", i), "null") == text(player_uuid)) {
			break;
		}
	}
	if(i != amount) {
		config.set(config, string.concat("player_", i), config.getString(config, string.concat("player_", amount), "null"));
	}
	config.set(config, string.concat("player_", amount), "null");
	config.set(config, "members", amount - 1);
	config.saveAsync(config);
}

function clan.delete(clan_id) {
	//Members
	list = clan.getMembersList(clan_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		player_uuid = next(iter);
		player_id = player.getId(player_uuid);
		player.setClanId(player_id, -1);
		player.setClanRole(player_id, "null");
	}
	//Clan
	config.delete(clan.getData(clan_id));
	map.remove(getScriptVar("clan_data"), clan_id);
}

function clan.getMembersList(clan_id) {
	list = list.new();
	config = clan.getData(clan_id);
	amount = config.getDouble(config, "members", 0);
	for(i = 1; i <= amount; i++) {
		player_uuid = read.uuid(config.getString(config, string.concat("player_", i), "null"));
		list.add(list, player_uuid);
	}
	return list;
}

function clan.updateHeadNames(clan_id) {
	list = clan.getMembersList(clan_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		p = player.get(next(iter));
		if(p != null) {
			player.setHeadName(p);
		}
	}
}

function clan.msg(clan_id, text_or_string) {
	list = clan.getMembersList(clan_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		p = player.get(next(iter));
		if(p != null) {
			msg.prefix(p, "§2Clan", text_or_string);
		}
	}
}

function clan.mail(clan_id, from_name, string_message) {
	list = clan.getMembersList(clan_id);
	iter = iterator(list);
	while(hasNext(iter)) {
		to_name = player.getName(next(iter));
		mail.send(from_name, to_name, string_message);
	}
}

//--------------------------------------------------
//Party-Utils
//--------------------------------------------------

function player.isInParty(player) {
	return player.getPartyId(player) != null;
}

function party.same(player1, player2) {
	return player.getPartyId(player1) == player.getPartyId(player2);
}

function player.isPartyLeader(player) {
	return player.getPartyRank(player) == "Leader";
}

function player.isPartyLeaderOrMod(player) {
	return player.getPartyRank(player) != "Player";
}

function player.getPartyId(player) {
	return map.get(getScriptVar("party_ids"), player.getUuid(player));
}

function player.setPartyId(player, party_id) {
	map.add(getScriptVar("party_ids"), player.getUuid(player), party_id);
}

function player.delPartyId(player) {
	map.remove(getScriptVar("party_ids"), player.getUuid(player));
}

function player.getPartyRank(player) {
	return map.get(getScriptVar("party_ranks"), player.getUuid(player));
}

function player.setPartyRank(player, rank) {
	map.add(getScriptVar("party_ranks"), player.getUuid(player), rank);
}

function player.delPartyRank(player) {
	map.remove(getScriptVar("party_ranks"), player.getUuid(player));
}

function party.getList(party_id) {
	return map.get(getScriptVar("party_lists"), party_id);
}

function party.setList(party_id, list) {
	map = getScriptVar("party_lists");
	map.add(map, party_id, list);
	setScriptVar("party_lists", map);
}

function party.addPlayer(party_id, player) {
	list.add(party.getList(party_id), player.getUuid(player));
	player.setPartyId(player, party_id);
}

//--------------------------------------------------
//Scheduler-Utils
//--------------------------------------------------

function scheduler.add(data_array) {
	list.add(scheduler.getList(), data_array);
}

function scheduler.getList() {
	return getScriptVar("scheduler_list");
}

function scheduler.addFly(ticks, player, bool) {
	a = array.new(4);
	a[0] = 0;
	a[1] = ticks;
	a[2] = player;
	a[3] = bool;
	scheduler.add(a);
}

function scheduler.msgPrefix(ticks, player, prefix, text_or_string) {
	a = array.new(5);
	a[0] = 1;
	a[1] = ticks;
	a[2] = player;
	a[3] = prefix;
	a[4] = text_or_string;
	scheduler.add(a);
}

function scheduler.msg(ticks, player, text_or_string) {
	a = array.new(4);
	a[0] = 2;
	a[1] = ticks;
	a[2] = player;
	a[3] = text_or_string;
	scheduler.add(a);
}

function scheduler.setBlockMaterial(ticks, block, material, block_update) {
	a = array.new(5);
	a[0] = 3;
	a[1] = ticks;
	a[2] = block;
	a[3] = material;
	a[4] = block_update;
	scheduler.add(a);
}

function scheduler.questFinish(ticks, script, player) {
	a = array.new(4);
	a[0] = 4;
	a[1] = ticks;
	a[2] = script;
	a[3] = player;
	scheduler.add(a);
}

function scheduler.setBurning(ticks, entity, seconds) {
	a = array.new(4);
	a[0] = 5;
	a[1] = ticks;
	a[2] = entity;
	a[3] = seconds;
	scheduler.add(a);
}

function scheduler.spawnEntity(ticks, type, location) {
	a = array.new(4);
	a[0] = 6;
	a[1] = ticks;
	a[2] = type;
	a[3] = location;
	scheduler.add(a);
}

function scheduler.removeEntity(ticks, entity) {
	a = array.new(3);
	a[0] = 7;
	a[1] = ticks;
	a[2] = entity;
	scheduler.add(a);
}

function scheduler.giveItem(ticks, player, item) {
	a = array.new(4);
	a[0] = 8;
	a[1] = ticks;
	a[2] = player;
	a[3] = item;
	scheduler.add(a);
}

function scheduler.giveSingleItem(ticks, player, item) {
	a = array.new(4);
	a[0] = 9;
	a[1] = ticks;
	a[2] = player;
	a[3] = item;
	scheduler.add(a);
}

function scheduler.setBlockData(ticks, block, blockdata, block_update) {
	a = array.new(5);
	a[0] = 10;
	a[1] = ticks;
	a[2] = block;
	a[3] = blockdata;
	a[4] = block_update;
	scheduler.add(a);
}

//--------------------------------------------------
//Icon-Utils
//--------------------------------------------------

function icon.getGoldCoin() {
	return string.fromCode(63489);
}

function icon.getSilverCoin() {
	return string.fromCode(63490);
}

function icon.getCopperCoin() {
	return string.fromCode(63491);
}

function icon.getExp() {
	return string.fromCode(63492);
}

function icon.getBookshelf() {
	return string.fromCode(63493);
}

function icon.getCraftingTable() {
	return string.fromCode(63494);
}

function icon.getCompass() {
	return string.fromCode(63495);
}

function icon.getCake() {
	return string.fromCode(63496);
}

function icon.getEnderpearl() {
	return string.fromCode(63497);
}

function icon.getHeart() {
	return string.fromCode(63498);
}

function icon.getHalfHeart() {
	return string.fromCode(63499);
}

function icon.getEmptyHeart() {
	return string.fromCode(63500);
}

//--------------------------------------------------
//Challenge-Utils
//--------------------------------------------------

function challenge.display(player, id, challenge, string_message, stage, all_stages) {
	sb.add(player, id, string.concat("§a", challenge, ": ", string_message, " [", string.number(stage), "/", string.number(all_stages), "]"));
}

function challenge.removeDisplay(player, id) {
	sb.remove(player,  id);
}

function player.addChallenge(player_or_id, challenge) {
	config = playerdata.getSurvival(player_or_id);
	string = config.getString(config, "challenge", "");
	if(string == "") {
		config.set(config, "challenge", challenge);
	} else {
		config.set(config, "challenge", string.concat(string, "%", challenge));
	}
	config.saveAsync(config);
}

function player.removeChallenge(player_or_id, challenge) {
	config = playerdata.getSurvival(player_or_id);
	string = config.getString(config, "challenge", "");
	string = string.replace(string, string.concat(challenge, "%"), "");
	string = string.replace(string, string.concat("%", challenge), "");
	string = string.replace(string, challenge, "");
	config.set(config, "challenge", string);
	config.saveAsync(config);
}

function player.getChallenges(player_or_id) {
	config = playerdata.getSurvival(player_or_id);
	string = config.getString(config, "challenge", "");
	a = string.split("%", string);
	s = set.new();
	for(i = 0; i < array.getSize(a); i++) {
		set.add(s, a[i]);
	}
	return s;
}

function challenge.playerHas(player_or_id, challenge) {
	return set.contains(player.getChallenges(player_or_id), challenge);
}