paper-snuvi-scripts/utils/u_games.txt

@simplelobby
ignoreGoto("checklobby");
wait();
if(event == "entity_damage") {
	if(!isPlayer(entity)) {
		goto("simplelobby");
	}
	player = entity;
	if(!player.hasMinigameId(player, script_id)) {
		goto("simplelobby");
	}
	cancel = true;
	if(minigame.hasSpecificLobbyHandling()) {
		gosub("specificLobbyHandling");
	}
	goto("simplelobby");
}
if(event == "entity_mount") {
	if(!isPlayer(entity)) {
		goto("simplelobby");
	}
	player = entity;
}
if(event == "custom_command") {
	if(!isPlayer(sender)) {
		goto("simplelobby");
	}
	player = sender;
}
if(!player.hasMinigameId(player, script_id)) {
	goto("simplelobby");
}
if(minigame.hasSpecificLobbyHandling()) {
	gosub("specificLobbyHandling");
}
if(event == "minigame_join") {
	gosub("lobbycore");
}
elseif(event == "block_break" || event == "block_place") {
	cancel = true;
}
elseif(event == "player_quit" || event == "player_giveup") {
	gosub("leavelobbycore");
}
elseif(event == "custom_command") {
	if(command == "startgame") {
		if(minigame.hasManualStart()) {
			if(minigame.isStarting()) {
				msg.prefix(player, gamename, "Already started.");
				goto("simplelobby");
			}
			goto("startcountdown");
		}
		//jumpstart
		if(!perm.has("startgame.jump", player)) {
			perm.no("startgame.jump", player);
			goto("simplelobby");
		}
		if(minigame.isStarting()) {
			if(noticetime > 5) {
				noticetime = 5;
				minigame.speakAll(gamename, "Left time reduced to §b5 §rseconds.");
				goto("simplelobby");
			}
			msg.prefix(player, gamename, "Left time can't be reduced.");
			goto("simplelobby");
		}
		msg.prefix(player, gamename, "Game is not starting.");
	}
}
goto("simplelobby");

@startcountdown
if(!minigame.canStart()) {
	minigame.waiting();
	goto("simplelobby");
}
minigame.setStarting(true);
if(noticetime == 5) {
	minigame.titleAll(gamename, mapname, 20, 60, 20);
}
if(noticetime == 1) {
	minigame.speakAll(gamename, string.concat("The game starts in §b", string.number(noticetime), " §rsecond."));
} else {
	minigame.speakAll(gamename, string.concat("The game starts in §b", string.number(noticetime), " §rseconds."));
}
if(noticetime == 0) {
	sign.started(gamesignloc);
	goto("finalstart");
}

if(noticetime > 30) {
	s_time = 200; //10s
} elseif(noticetime > 5) {
	s_time = 100; //5s
} else {
	s_time = 20; //1s
}
noticetime -= s_time / 20;
sgoto(s_time, "startcountdown");
player_list = minigame.getPlayers(script_id);
p_amount = list.getSize(player_list);
for(i = 0; i < p_amount; i++) {
	p = player.get(list.getIndex(player_list, i));
	sound.spawnForPlayer(p, join_sound, sound_category_ambient);
}
goto("simplelobby");

@lobbycore
minigame.speakAll(gamename, string.concat("§8", player.getNickName(player), "§r joined the game."));
if(!minigame.hasNoLobbyTeleport()) {
	modTimer.entityTeleport(player, lobbyspawnloc);
}
if(minigame.doPlayerResetInCore()) {
	resetplayer(player);
}
title.send(player, text.new(gamename), text.new(mapname));
if(minigame.hasManualStart()) {
	return;
}
if(!minigame.isStarting()) {
	if(minigame.canStart()) {
		goto("startcountdown");
	}
	minigame.waiting();
}
return;

@leavelobbycore
minigame.speakAll(gamename, string.concat("§8", player.getNickName(player), "§r left the game."));
script = script.getFromId(script_id);
if(player.isPartyLeader(player)) {
	leader_uuid = player.getUuid(player);
	player_list = minigame.getPlayers(script_id);
	list = party.getList(player.getPartyId(player));
	iter = iterator(list);
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		if(list.contains(player_list, p_uuid)) {
			minigame.kickPlayer(script, p);
		}
	}
} else {
	minigame.kickPlayer(script, player);
}
p_amount = minigame.getPlayerAmount(script_id);
if(p_amount == 0) {
	minigame.term(script, gamesignloc);
}
if(!minigame.canStart()) {
	minigame.waiting();
	goto("simplelobby");
}
return;

//--------------------------------------------------
//Minigame-Utils
//--------------------------------------------------

function minigame.setLobbyCounter(seconds) {
	$lobby_counter_init = seconds;
	$noticetime = seconds;
}

function minigame.getLobbyCounter() {
	if($lobby_counter_init == null) {
		$lobby_counter_init = 20;
		$noticetime = 20;
	}
	return $lobby_counter_init;
}

function minigame.setNoLobbyTeleport(bool) {
	$no_lobby_tp = bool;
}

function minigame.hasNoLobbyTeleport() {
	bool = $no_lobby_tp;
	if(bool == null) {
		bool = false;
	}
	return bool;
}

function minigame.setPlayerResetInCore(bool) {
	$no_core_reset = !bool;
}

function minigame.doPlayerResetInCore() {
	if($no_core_reset == null) {
		$no_core_reset = false;
	}
	return !$no_core_reset;
}

function minigame.setManualStart(bool) {
	$manual_start = bool;
}

function minigame.hasManualStart() {
	bool = $manual_start;
	if(bool == null) {
		bool = false;
	}
	return bool;
}

function minigame.setIndivStartCheck(bool) {
	$indiv_start_check = bool;
}

function minigame.hasIndivStartCheck() {
	bool = $indiv_start_check;
	if(bool == null) {
		bool = false;
	}
	return bool;
}

function minigame.setSpecificLobbyHandling(bool) {
	$specific_lobby_handling = bool;
}

function minigame.hasSpecificLobbyHandling() {
	bool = $specific_lobby_handling;
	if(bool == null) {
		bool = false;
	}
	return bool;
}

function minigame.setMinPlayers(amount) {
	$minplayers = amount;
}

function minigame.getMinPlayers() {
	return $minplayers;
}

function minigame.setMaxPlayers(amount) {
	$maxplayers = amount;
}

function minigame.getMaxPlayers() {
	return $maxplayers;
}

function minigame.isStarting() {
	return $starting;
}

function minigame.setStarting(bool) {
	$starting = bool;
}

function minigame.setSingleplayer() {
	$singleplayer = true;
}

function minigame.setMultiplayer() {
	$singleplayer = false;
}

function minigame.isSingleplayer() {
	return $singleplayer;
}

function minigame.isMultiplayer() {
	return !$singleplayer;
}

function minigame.waiting() {
	minigame.setStarting(false);
	$noticetime = minigame.getLobbyCounter();
	if(minigame.hasManualStart()) {
		minigame.speakAll($gamename, "Start process stopped.");
		return;
	}
	waitfor = minigame.getMinPlayers() - minigame.getPlayerAmount($script_id);
	if(waitfor == 1) {
		minigame.speakAll($gamename, string.concat("Waiting for §b", string.number(waitfor), " §rplayer."));
		return;
	}
	if(waitfor == 0) {
		minigame.speakAll($gamename, string.concat("Waiting for §b", string.number(waitfor), " §rplayers, but start conditions are not met."));
		return;
	}
	minigame.speakAll($gamename, string.concat("Waiting for §b", string.number(waitfor), " §rplayers."));
}

function minigame.canStart() {
	if(minigame.hasIndivStartCheck()) {
		return minigame.canStartIndiv();
	}
	player_list = minigame.getPlayers($script_id);
	p_amount = list.getSize(player_list);
	return p_amount >= minigame.getMinPlayers();
}

function minigame.initStart() {
	minigame.loadLobbyEvents();
	minigame.setupMultiplayer();
}

function minigame.clearItems(location, radius) {
	entity.removeAll("org.bukkit.entity.Item", location, radius);
}

function minigame.setTabName(player, game_tab, team_color) {
	if(team_color == null) {
		team_color = "§r";
	}
	player_name = player.getName(player);
	display_name = string.concat(game_tab, " §7| ", team_color, player_name);
	player.setDisplayName(player, text.new(display_name));
}

function minigame.loadLobbyEvents() {
	event.load("minigame_join");
	event.load("player_quit");
	event.load("player_giveup");
	event.load("block_break");
	event.load("block_place");
	event.load("block_click");
	event.load("entity_damage");
	event.load("custom_command");
}

function minigame.setupMultiplayer() {
	$noticetime = minigame.getLobbyCounter();
	minigame.setMultiplayer();
	minigame.setStarting(false);
	$sound_category_ambient = sound.getCategory("AMBIENT");
	$sound_category_player = sound.getCategory("PLAYERS");
	$join_sound = sound.get("BLOCK_NOTE_BLOCK_BASS");
	$pling_sound = sound.get("BLOCK_NOTE_BLOCK_PLING");
}

function minigame.setLastPos(player) {
	map.add(getScriptVar("lobbylastpos"), player.getUuid(player), entity.getLocation(player));
}

function minigame.getLastPos(player) {
	return map.getOrDefault(getScriptVar("lobbylastpos"), player.getUuid(player), world.getGamesSpawn());
}

function minigame.isStarted(sign_block) {
	return sign.getString(sign_block, 3) == "§bStarted";
}

function minigame.getSignLoc(sign_name) {
	return map.get(getScriptVar("gamesigns"), sign_name);
}

function minigame.term(script, gamesignloc) {
	setScriptVar("sign_loc", gamesignloc);
	script.callEvent("term_script");
	sign.ready(gamesignloc);
	script.term(script);
}

function minigame.speakAll(prefix, message) {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		msg.prefix(p, prefix, message);
	}
}

function minigame.msgAll(message) {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		if(p != null) {
			msg.string(p, message);
		}
	}
}

function minigame.displayAll(line, message) {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		sb.add(p, line, message);
	}
}

function minigame.titleAll(title, subtitle, fadeIn, show, fadeOut) {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		title.send(p, text.new(title), text.new(subtitle));
	}
}

function minigame.displayRemoveAll(line) {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		sb.remove(p, line);
	}
}

function minigame.displayClearAll() {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		sb.clearGame(p);
	}
}

function minigame.statsHeader(player, gamename, colorcode) {
	msg.string(player, string.concat("[", gamename, "§r] §r---= ", colorcode, "Statistic §r=---"));
}

function minigame.statsLine(player, colorcode, string, value) {
	msg.string(player, string.concat(colorcode, " -§r ", string, ": ", colorcode, value));
}

function getTeamWithLowestPeople(team_lists, numberofteams) {
	teamlist = map.get(team_lists, 0);
	lowest = list.getSize(teamlist);
	lowestteam = 0;
	for(i = 1; i < numberofteams; i++) {
		teamlist = map.get(team_lists, i);
		size = list.getSize(teamlist);
		if(size < lowest) {
			lowest = size;
			lowestteam = i;
		}
	}
	return lowestteam;
}

function minigame.getScriptId(script_or_id) {
	if(isDouble(script_or_id)) {
		return script_or_id;
	}
	return script.getId(script_or_id);
}

function minigame.kickPlayer(script_or_id, player) {
	script_id = minigame.getScriptId(script_or_id);
	resetplayer(player);
	player.tpGamesLobby(player);
	list = minigame.getPlayers(script_id);
	list.remove(list, player.getUuid(player));
	sign.players($gamesignloc, list.getSize(list), $maxplayers);
	set.remove(player.getMinigameIds(player), script_id);
}

function minigame.kickAllPlayers(script_or_id) {
	script_id = minigame.getScriptId(script_or_id);
	player_list = minigame.getPlayers(script_id);
	list = list.copy(player_list); //Copy list to preven concurrent modification
	iter = iterator(list);
	while(hasNext(iter)) {
		p = player.get(next(iter));
		if(p != null) {
			minigame.kickPlayer(script_id, p);
		}
	}
}

function minigame.getPlayerAmount(script_id) {
	list = minigame.getPlayers(script_id);
	return list.getSize(list);
}

function minigame.getPlayers(script_id) {
	map = getScriptVar("script_players");
	list = map.get(map, script_id);
	if(list == null) {
		list = list.new();
		map.add(map, script_id, list);
	}
	return list;
}

function minigame.setWon(player_or_id, game_short, amount) {
	config = playerdata.getGames(player_or_id);
	config.set(config, string.concat("won.", game_short), amount);
	config.saveAsync(config);
}

function minigame.getWon(player_or_id, game_short) {
	config = playerdata.getGames(player_or_id);
	return config.getDouble(config, string.concat("won.", game_short), 0);
}

function minigame.setPlayed(player_or_id, game_short, amount) {
	config = playerdata.getGames(player_or_id);
	config.set(config, string.concat("played.", game_short), amount);
	config.saveAsync(config);
}

function minigame.getPlayed(player_or_id, game_short) {
	config = playerdata.getGames(player_or_id);
	return config.getDouble(config, string.concat("played.", game_short), 0);
}

function minigame.addPlayed(player_or_id, game_short, amount) {
	config = playerdata.getGames(player_or_id);
	new_amount = config.getDouble(config, string.concat("played.", game_short), 0) + amount;
	config.set(config, string.concat("played.", game_short), new_amount);
	config.saveAsync(config);
}

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

function player.tpGamesLobby(player) {
	modTimer.entityTeleport(player, minigame.getLastPos(player));
	inv = player.getInv(player);
	inv.setItem(inv, 0, item.create("COMPASS", 1, null, null));
}

function player.hasMinigameId(player, script_id) {
	if(player == null) {
		return false;
	}
	if(script_id == null) {
		return false;
	}
	set = player.getMinigameIds(player);
	return set.contains(set, script_id);
}

function resetplayer(player) {
	living.cleareffects(player);
	living.setHealth(player, 20);
	player.setHunger(player, 20);
	player.setSaturation(player, 5);
	player.clearInventory(player);
	player.setSpeed(player, 1);
	entity.setGravity(player, true);
	inv.close(player);
	money.display(player, money.get(player));
	player.setTabName(player);
	sb.clearGame(player);
}

//--------------------------------------------------
//Ranking-Utils
//--------------------------------------------------

//Tabelle in Datenbank registrieren
function ranking.register(rankingtable) {
	databank.workerExecute(databank.prepare(string.concat("CREATE TABLE IF NOT EXISTS ", rankingtable, " (player_id INT NOT NULL PRIMARY KEY, points INT NOT NULL, sec_points INT);")));
}

//Setzt die Rekord-Punkte eines Spielers
function ranking.setPoints(rankingtable, player_or_id, points) {
	stmt = databank.prepare(string.concat("INSERT INTO ", rankingtable, " (points, player_id) VALUES (?,?) ON DUPLICATE KEY UPDATE points = ?;"), false);
	databank.setInt(stmt, 1, points);
	databank.setInt(stmt, 2, player.getValidId(player_or_id));
	databank.setInt(stmt, 3, points);
	databank.workerExecute(stmt);
}

//Setzt die primären und sekundären Rekord-Punkte eines Spielers
function ranking.setSecPoints(rankingtable, player_or_id, points, sec_points) {
	stmt = databank.prepare(string.concat("INSERT INTO ", rankingtable, " (points, sec_points, player_id) VALUES (?,?,?) ON DUPLICATE KEY UPDATE points = ?, sec_points = ?;"), false);
	databank.setInt(stmt, 1, points);
	databank.setInt(stmt, 2, sec_points);
	databank.setInt(stmt, 3, player.getValidId(player_or_id));
	databank.setInt(stmt, 4, points);
	databank.setInt(stmt, 5, sec_points);
	databank.workerExecute(stmt);
}

//Gibt die gesamte Rangtabelle zurück. Liste mit Arrays
function ranking.getArray(rankingtable, order, order2) {
	ranking_list = list.new();
	if(order2 == null) {
		stmt = databank.prepare(string.concat("SELECT player_id, points,sec_points FROM ", rankingtable, " ORDER BY points ", order, ";"));
	} else {
		stmt = databank.prepare(string.concat("SELECT player_id, points,sec_points FROM ", rankingtable, " ORDER BY points ", order, ", sec_points ", order2, ";"));
	}
	result = databank.execute(stmt);
	while(databank.next(result)) {
		a = array.new(3);
		a[0] = databank.getInt(result, 1); //player_id
		a[1] = databank.getInt(result, 2); //points
		a[2] = databank.getInt(result, 3); //sec_points
		list.add(ranking_list, a);
	}
	databank.close(result);
	databank.close(stmt);
	return ranking_list;
}

//Gibt Daten des Spieler von Platz n als Array zurück
function ranking.getArrayFromRank(rankingtable, rank, order, order2) {
	ranking_list = ranking.getArray(rankingtable, order, order2);
	list_size = list.getSize(ranking_list);
	index = rank - 1;
	if(index >= list_size || index < 0) {
		return null;
	}
	a = list.getIndex(ranking_list, index);
	return a;
}

//Gibt den Spieler von Platz n zurück
function ranking.getPlayerIdFromRank(rankingtable, rank, order, order2) {
	a = ranking.getArrayFromRank(rankingtable, rank, order, order2);
	if(a == null) {
		return -1;
	}
	return a[0];
}

//Gibt die Punkte von Platz n zurück
function ranking.getPointsFromRank(rankingtable, rank, order, order2) {
	a = ranking.getArrayFromRank(rankingtable, rank, order, order2);
	if(a == null) {
		return -1;
	}
	return a[1];
}

//Gibt die Top 10 Spieler eines Spiels zurück
function ranking.getTopTenList(rankingtable, order, order2) {
	toptenlist = list.new();
	ranking_list = ranking.getArray(rankingtable, order, order2);
	list_size = list.getSize(ranking_list);
	for(i = 0; i < list_size; i++) {
		list.add(toptenlist, list.getIndex(ranking_list, i));
	}
	return toptenlist;
}

//Gibt die Statistik eines Spiels zurück
function ranking.getPlayerStats(player_id, rankingtable, order, order2) {
	ranking_list = ranking.getArray(rankingtable, order, order2);
	list_size = list.getSize(ranking_list);
	for(i = 0; i < list_size; i++) {
		a = list.getIndex(ranking_list, i);
		if(a[0] == player_id) {
			return a;
		}
	}
	return null;
}

//Gibt den Rang eines Spielers zurück
function ranking.getPlayerRank(player_id, rankingtable, order, order2) {
	ranking_list = ranking.getArray(rankingtable, order, order2);
	list_size = list.getSize(ranking_list);
	for(i = 0; i < list_size; i++) {
		a = list.getIndex(ranking_list, i);
		if(a[0] == player_id) {
			return i + 1;
		}
	}
	return -1;
}

//Entfernt einen Spieler aus der Statistik
function ranking.removePlayer(player_id, rankingtable, game_short) {
	stmt = databank.prepare(string.concat("DELETE FROM ", rankingtable, " WHERE player_id = ?;"));
	databank.setInt(stmt, 1, player_id);
	databank.workerExecute(stmt);
	if(game_short != null) {
		if(minigame.getWon(player_id, game_short) != 0) {
			minigame.setWon(player_id, game_short, 0);
		}
		if(minigame.getPlayed(player_id, game_short) != 0) {
			minigame.setPlayed(player_id, game_short, 0);
		}
	}
}

//--------------------------------------------------
//Sign-Utils
//--------------------------------------------------

function sign.players(sign_block, amount, max) {
	if(!isBlock(sign_block)) {
		sign_block = block.get(sign_block);
	}
	sign.setString(sign_block, 2, string.concat(string.number(amount), "/", string.number(max)));
}

function sign.ready(sign_block) {
	if(!isBlock(sign_block)) {
		sign_block = block.get(sign_block);
	}
	sign.setString(sign_block, 3, "§2Ready");
}

function sign.started(sign_block) {
	if(!isBlock(sign_block)) {
		sign_block = block.get(sign_block);
	}
	sign.setString(sign_block, 3, "§bStarted");
}

function sign.closed(sign_block) {
	if(!isBlock(sign_block)) {
		sign_block = block.get(sign_block);
	}
	sign.setString(sign_block, 3, "§cClosed");
}

//--------------------------------------------------
//SB-Utils
//--------------------------------------------------

function sb.clearGame(player) {
	for(i = 79; i < 100; i++) {
		sb.remove(player, i);
	}
}

function sb.clearGameAll() {
	iter = iterator(minigame.getPlayers($script_id));
	while(hasNext(iter)) {
		p_uuid = next(iter);
		p = player.get(p_uuid);
		sb.clearGame(p);
	}
}