FastWorldReset/fastworldreset.sk

options:
#------------- Start of Configuration -------------
	#recommended to have this as true for things which have to never save changes
	#NOTE: this will function only if the world has been edited since last reset, if it hasn't been edited, to save performance it will not do useless reset. YAY!
	
	ResetResettableWorldsOnRestart: true
	AutoDeleteClonesOnRestart: true
	#whether /fwr create  will look for existing world folder or allow to create a new blank one. 
	#Creating blank world will not function for resetting (as there will be no template) until you update template by running /fwr create on the same world again.
	#useful for when you want to copypaste a map into a newly created world and then make it resettable
	#without having to go through another world management plugin to do it
	AllowCreatingNewWorlds: false 

#------------- End of Configuration -------------
#The script starts here, only edit if you know what you are doing.

import:
	org.bukkit.Bukkit
	org.bukkit.WorldCreator
	java.lang.System
	java.io.File
	java.util.Date
	org.apache.commons.io.FileUtils
	org.apache.commons.io.comparator.LastModifiedFileComparator
	java.util.Arrays
	java.nio.file.Files
	java.nio.file.Paths
on script load:
	wait a tick #needed to wait for plugins to load

	set {-fwrcache::bukkitgetserver} to Bukkit.getServer()
	set {-fwrcache::mainworld} to {-fwrcache::bukkitgetserver}.getWorlds().get(0)
	set {-fwrcache::fileseparator} to File.separator
	set {-fwrcache::worlddir} to {-fwrcache::bukkitgetserver}.getWorldContainer().getPath()
	delete {-govindask}
	if {-fwrcache::bukkitgetserver}.getPluginManager().getPlugin("GovindaSK") is set:
		send "[FastWorldReset] GovindaSK found! Enabling faster chunk unloads." to console
		set {-govindask} to true
	else:
		send "[FastWorldReset] GovindaSK not found, falling back to a slower, reflection way of unloading chunks. (2 errors related to chunk unloading will appear, but you can safely ignore them)" to console
	
	wait 5 seconds
	#get list of world generators for /fwr generator command
	
	delete {-worldgenerators::*}
	
	set {_plugins::*} to ...{-fwrcache::bukkitgetserver}.getPluginManager().getPlugins()
	
	loop {_plugins::*}:
	
	
		
		set {_value} to loop-value.getDefaultWorldGenerator("%{-fwrcache::mainworld}%", "")
	
		if {_value} is set:
			delete {_value}
			
			add 1 to {_i}
			set {_name} to loop-value.getDescription().getName()
			set {-worldgenerators::%{_name}%} to {_name}

event "world_reset_start":
	patterns: 
		start of world reset
		world reset start
	event-values: world
event "world_reset_complete":
	patterns: 
		complete of world reset
		world reset complete
	event-values: world
	
function unloadChunks(world: world, saving: boolean) :: boolean:
	set {-resetting::%{_world}%} to true
	set {_n} to now
	
	#requires GovindaSK
	
	if {-govindask} is set:
		if {_saving} is true:
			unload all chunks in {_world} with saving
		else:
			unload all chunks in {_world} without saving
	#if GovindaSK is not found, fall back to skript-reflect way of unloading chunks
	else:
		loop ...{_world}.getLoadedChunks():
			loop-value.unload({_saving})

	#send "[FastWorldReset] &bUnloading chunks of &e%{_world}% &btook %difference between {_n} and now%" to console
	delete {-resetting::%{_world}%}
	if amount of ...{_world}.getLoadedChunks() is 0:
		return true
	else:
		return false
function teleportOut(world: world) :: boolean:
	if {fastworldreset::exitpoint} is not a location:
		delete {fastworldreset::exitpoint}
	set {_spawnpoint} to {fastworldreset::exitpoint} ? (spawn point of "%{-fwrcache::mainworld}%" parsed as a world)
	
	loop all players in {_world}:
		if passenger of loop-player is set:
			loop passengers of loop-player:
				make loop-value-2 dismount
		teleport loop-player to {_spawnpoint}
	return true
function unloadWorld(world: world, saving: boolean = true) :: boolean:
	set {_n} to now
	#teleport players out
	
	teleportOut({_world}) = true
		
	#unload the world
	
	Bukkit.unloadWorld("%{_world}%", {_saving})
	send "World unload took %difference between {_n} and now%" to console
	return true
function resetWorld(input: text, sender: object):
	#mark world save as non-set
	if {-fastworldreset::shouldreset::%{_input}%} is set:
		delete {-fastworldreset::shouldreset::%{_input}%}
	set {_world} to {_input} parsed as a world
	#stats for problem identification
					
	add 1 to {-resetstats::%{_input}%::worldbased}
	set {-resetstats::%{_input}%::last} to "world"
	if {_world} is a world:
		set {_input} to "%{_world}%"
		unloadWorld({_world}, false) is not true:
			send "&a&lFastWorldReset&2&l> &cThere was an error in unloading the world &e%{_world}%&c, see console and report any problems to author Govindas." to console
			stop

	set {-resetting::%{_input}%} to now
	
	set {_worlddir} to {-fwrcache::worlddir}
	
	if {fastworldresetclone::%{_input}%} is set:
		set {_template} to {fastworldresetclone::%{_input}%}
	else:
		set {_template} to {_input}
	
	set {_source} to new File("%{_worlddir}%/FastWorldReset/%{_template}%/region")
	set {_target} to new File("%{_worlddir}%/%{_input}%/region")
	
	create new section stored in {_section}:
		FileUtils.copyDirectory({_source}, {_target})
		
	run section {_section} async and wait

	if {worldgenerator::%{_template}%} is set:
		{-fwrcache::bukkitgetserver}.createWorld(new WorldCreator({_input}).generator({worldgenerator::%{_template}%}))
	else:
		{-fwrcache::bukkitgetserver}.createWorld(new WorldCreator({_input}))
		
	set {fastworldreset::lastreset::%{_input}%} to new Date().getTime() #unix time, not using vanilla skript syntax as we need milliseconds support
	
	send "&a&lFastWorldReset&2&l> &cReset &e%{_input}% &cvia world-based method." to {_sender}
		
	delete {-resetting::%{_input}%}
		
	set {_ev::world} to {_input} parsed as a world
	set {_evt} to custom event "world_reset_complete" with {_ev::*} 
	call event {_evt}
import:
	org.bukkit.World$Environment
on world load:
	{-resetting::%event-world%} is set:
		delete {-resetting::%event-world%}
	#mark world as not saved
	{-fastworldreset::shouldreset::%event-world%} is set:
		delete {-fastworldreset::shouldreset::%event-world%}

#it looks like environment setting makes the world load.. different data, so things disappear on environment change, so I am not releasing it for now, just keeping this function.

function loadWorld(world: text, generator: text = "", environment: text = ""):
	set {-initload::%{_world}%} to true
	if {_generator} is "":
		if {worldgenerator::%{_world}%} is set:
			set {_generator} to {worldgenerator::%{_world}%}
	if {_environment} is "":
		set {_environment} to {worldenvironment::%{_world}%} ? "NORMAL"
	{_generator} is not "":
		{-fwrcache::bukkitgetserver}.createWorld(new WorldCreator({_world}).generator({_generator}).environment(Environment.valueOf({_environment} in uppercase)))
	else:
		{-fwrcache::bukkitgetserver}.createWorld(new WorldCreator({_world}))
		
#blacklist of things that can do bad stuff in windows/linux if used in folder names.

function blacklist(input: text) :: boolean:
	if {_input} contains "/" or "\" or "*" or "." or ":" or "?" or "<" or ">" or "|" or """":
		return true
	if {_input} is "plugins" or "logs":
		"%{-fwrcache::worlddir}%" is "."
		return true
	if {_input} is "CON" or "PRN" or "AUX" or "NUL" or "COM1" or "COM2" or "COM3" or "COM4" or "COM5" or "COM6" or "COM7" or "COM8" or "COM9" or "LPT1" or "LPT2" or "LPT3" or "LPT4" or "LPT5" or "LPT6" or "LPT7" or "LPT8" or "LPT9":
		return true
	if last character of {_input} = " " or ".":
		return true
		
	return false
command /fastworldreset [<text>] [<text>] [<text>]:
	permission: fastworldreset.use
	aliases: fwr
	trigger:


		if arg 1 is "create":
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cPlease specify world name!"
				stop
			if blacklist(arg 2) is true:
				send "&a&lFastWorldReset&2&l> &cYour input cannot use illegal characters!"
				stop
			if "%{-fwrcache::mainworld}%" = arg 2:
				send "&a&lFastWorldReset&2&l> &cYou cannot use your server's main world for this!"
				stop
			set {_worlddir} to {-fwrcache::worlddir}
			set {_w} to arg 2
			set {_p} to sender
			create section stored in {_section}:
				Files.isDirectory(Paths.get("%{_worlddir}%/FastWorldReset/%{_w}%")) is true:

					send "&a&lFastWorldReset&2&l> &e&l%{_w}% &6Hm.. This world is already in the system of FastWorldReset, but I'll continue, just in case if you are making a change to existing template." to {_p}
					return true
				else:
					return false
			run section {_section} async and store the result in {_notmissing} and wait

				
			set {_world} to arg 2 parsed as a world
			
			if {_world} is a world:
				send "&a&lFastWorldReset&2&l> &6Hm.. seems like this world is already loaded, saving it!"
				send "&a&lFastWorldReset&2&l> &eWaiting for world save..."
				teleport (all players in {_world}) to (spawn point of "%{-fwrcache::mainworld}%" parsed as a world)
				if {_world}.isAutoSave() is true:
					{_world}.setAutoSave(false)
				{_world}.save()
				wait a tick
				Bukkit.unloadWorld("%{_world}%", true)
				while (arg 2 parsed as a world) is a world:
					add 1 to {_maxtime}
					if {_maxtime} is higher than 1000:
						send "&cFailed to unload."
						stop
					wait a tick
					
			#make reset backup of the world
			set {_n} to now
			if {_notmissing} is true:
				set {_w} to arg 2
				set {_source} to new File("%{_worlddir}%/%arg 2%/region")
				set {_target} to new File("%{_worlddir}%/FastWorldReset/%arg 2%/region")
				create new section stored in {_section}:
					FileUtils.deleteDirectory(new File("%{_worlddir}%/FastWorldReset/%{_w}%/region"))
					FileUtils.copyDirectory({_source}, {_target})
				run section {_section} async and wait
			else:
				set {_source} to new File("%{_worlddir}%/%arg 2%")
				set {_target} to new File("%{_worlddir}%/FastWorldReset/%arg 2%")
				set {_targetpath} to "%{_worlddir}%/FastWorldReset/%arg 2%"
				set {_p} to sender
				create new section stored in {_section}:
					FileUtils.copyDirectory({_source}, {_target})
					if {@AllowCreatingNewWorlds} is false:
						Files.isDirectory(Paths.get({_targetpath})) is false:
							send "&a&lFastWorldReset&2&l> &cFailed to copy world! Are file permissions right? Check console for errors." to {_p}
							return true
					return false
				run section {_section} async and store the result in {_failed} and wait
				
				stop if {_failed} is true

				
			set {fastworldreset::lastreset::%arg 2%} to new Date().getTime()
			set {-fastworldresetworld::%arg 2%} to true
			#load world back after reset has been made
			if arg 3 is set:
				set {worldgenerator::%arg 2%} to arg 3
			if (arg 2 parsed as a world) is not a world:
				loadWorld(arg 2)
				
			send "&a&lFastWorldReset&2&l> &aSuccessfully copied &e&l%arg 2% &aand made it resettable in &e&l%difference between {_n} and now%&e! If it doesn't work check console for errors."
	
		else if arg 1 is "reset":
		
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cPlease specify world name!"
				stop
			
			set {_worlddir} to {-fwrcache::worlddir}
			
			if {-fastworldresetworld::%arg 2%} is set:
				set {_world} to arg 2 parsed as a world
				
				if {_world} is not a world:
					set {_worldreset} to true
				else if {fastworldreset::chunkresetdisabled::%arg 2%} or {-fastworldreset::shouldreset::%arg 2%} is set:
					set {_worldreset} to true
				else if {fastworldreset::lastreset::%arg 2%} is not set:
					set {_worldreset} to true
					
				set {_template} to {fastworldresetclone::%arg 2%} ? arg 2
				
				set {_ev::world} to {_world}
				set {_w} to arg 2
				call event (custom event "world_reset_start" with {_ev::*})
				{_worldreset} is not set:
				
					#detect world save as world save event doesn't always call
					
					create section stored in {_section}:
						if ((new File("%{_worlddir}%/%{_w}%/level.dat")).lastModified()) is higher than {fastworldreset::lastreset::%{_w}%}:
							return true
							
					run section {_section} async and store the result in {_worldreset} and wait
				{_worldreset} is true:
					resetWorld(arg 2, sender)
				else:
				
					teleportOut({_world}) = true
					
					#needed to detect improperly reset world when a bad plugin is disturbing reset, such as FastAsyncWorldEdit

					create section stored in {_section}:
						set {_files} to new File("%{_worlddir}%/%{_world}%/region").listFiles()
						Arrays.sort({_files}, LastModifiedFileComparator.LASTMODIFIED_REVERSE)
						return (first element of ...{_files}).lastModified()
					run section {_section} async and store the result in {_modify} and wait

					if unloadChunks({_world}, false) is false:
						send "&a&lFastWorldReset&2&l> &cFailed to unload chunks, falling back to world-based reset method."
						resetWorld(arg 2, sender)
					else:
					
						wait a tick #needed to detect failed avoidance of chunk save caused by bad plugins
						
						#run same section again for comparison

						run section {_section} async and store the result in {_modify2} and wait
						
						difference between {_modify} and {_modify2} is higher than 0:
							send "&a&lFastWorldReset&2&l> &cFailed to not save chunks. Possibly using a bad plugin which does this? Falling back to world-based reset."
							resetWorld(arg 2, sender)
							add 1 to {-resetstats::%arg 2%::worldbased}
							set {-resetstats::%arg 2%::last} to "world (after failed chunk save avoid, likely caused by bad plugin)"
						else:
							send "&a&lFastWorldReset&2&l> &cReset &e%arg 2% &cvia chunks-based method."
						
							#stats for problem identification
						
							add 1 to {-resetstats::%arg 2%::chunkbased}
							set {-resetstats::%arg 2%::last} to "chunk"
							set {_ev::world} to {_world}
							set {_evt} to custom event "world_reset_complete" with {_ev::*} 
							call event {_evt}
			
			else:
				send "&a&lFastWorldReset&2&l> &e&l%arg 2% &cis not a FastWorldReset world!"
		else if arg 1 is "load":
		
			if blacklist(arg 2) is true:
				send "&a&lFastWorldReset&2&l> &cYour input cannot use illegal characters!"
				stop
				
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cPlease specify world name!"
				stop
			if (arg 2 parsed as a world) is a world:
				send "&a&lFastWorldReset&2&l> &cThe world &e%arg 2% &cis already loaded!"
				stop

			loadWorld(arg 2, (arg 3 ? ""))
			(arg 2 parsed as a world) is a world:
				send "&a&lFastWorldReset&2&l> &aSuccessfully loaded the world &e%arg 2%&a."
		else if arg 1 is "clone":

			if arg 2 or arg 3 is not set:
				send "&cUsage: &e/fwr clone <world> <new-world>"
				stop
			if blacklist(arg 3) is true:
				send "&a&lFastWorldReset&2&l> &cYour input cannot use illegal characters!"
				stop
			set {_worlddir} to {-fwrcache::worlddir}

			if (arg 3 parsed as a world) is a world:
				send formatted "&a&lFastWorldReset&2&l> &cThe specified world is already loaded! (%arg 3%)"
				stop
			

			set {_w} to arg 3
			set {_templatedir} to "%{_worlddir}%/FastWorldReset/%arg 2%"
			set {_p} to sender
			create new section stored in {_section}:
				Files.isDirectory(Paths.get({_templatedir})) is false:
					send "&a&lFastWorldReset&2&l> &cThe specified world template is not saved in FastWorldReset folder, thus it cannot be used for cloning." to {_p}
					return true
				else if Files.isDirectory(Paths.get("%{_worlddir}%/%{_w}%")) is true:
					send formatted "&a&lFastWorldReset&2&l> &6Hm... There's already %arg 3% world folder, I'll just load it then." to {_p}
				else:
					FileUtils.copyDirectory((new File("%{_templatedir}%")), (new File("%{_worlddir}%/%{_w}%")))
				return false
			run section {_section} async and store the result in {_stop} and wait
			stop if {_stop} is true
			set {-fastworldresetworld::%arg 3%} to true
			set {fastworldresetclone::%arg 3%} to arg 2
			set {fastworldresetclonename::%arg 3%} to arg 3
			loadWorld(arg 3, {worldgenerator::%arg 2%} ? "")
			

			
			if (arg 3 parsed as a world) is a world:
				send formatted "&a&lFastWorldReset&2&l> &aSuccessfully cloned &e%arg 2% &aworld into &e%arg 3% &aworld!"
				send "&cNote: the cloned world will not load automatically, it just has been loaded now. You have to use &e/fwr create &con it, if you want it to load automatically."
				send "&bYou can configure if world folders of clones get deleted on server startup in the script file."
			set {fastworldreset::lastreset::%arg 3%} to new Date().getTime()
		else if arg 1 is "unload":
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cPlease specify world name!"
				stop
			if "%{-fwrcache::mainworld}%" = arg 2:
				send "&a&lFastWorldReset&2&l> &cYou cannot unload your server's main world!"
				stop
			set {_world} to arg 2 parsed as a world
			{_world} is not a world:
				send "&a&lFastWorldReset&2&l> &cThere is no world loaded by the name of &e%arg 2%&c."
				stop
			unloadWorld({_world}) = true:
				send "&a&lFastWorldReset&2&l> &aSuccessfully unloaded the world &e%arg 2%&a."
			else:
				send "&a&lFastWorldReset&2&l> &cThere was an error in unloading the world &e%{_world}%&c, see console and report any problems to author Govindas."
				
		else if arg 1 is "teleport" or "tp":
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cUsage: &e/fwr teleport <world> [player]"
				stop
			if (arg 2 parsed as a world) is not a world:
				send "&a&lFastWorldReset&2&l> &cThe specified world &e%arg 2% &cis not loaded."
				stop
			if arg 3 is not set:
				set {_player} to player
			else:
				if arg 3 parsed as a player is offline:
					send "&a&lFastWorldReset&2&l> &cThe specified player &e%{_player}% &cis offline."
					stop
				set {_player} to arg 3 parsed as a player
			teleport {_player} to (spawn point of arg 2 parsed as a world)

		else if arg 1 is "delete":
		
			if arg 2 is not set:
				send "&a&lFastWorldReset&2&l> &cPlease specify world name!"
				stop
			if {-fastworldresetworld::%arg 2%} is not set:
				send "&a&lFastWorldReset&2&l> &cYou must specify existing world name."
				stop
			set {_worlddir} to {-fwrcache::worlddir}
			
			{-confirmfwrdelete::%sender%::%arg 2%} is set:
				if difference between {-confirmfwrdelete::%sender%::%arg 2%} and now is higher than 15 seconds:
					delete {-confirmfwrdelete::%sender%::%arg 2%}
			if {-confirmfwrdelete::%sender%::%arg 2%} is not set:
				set {-confirmfwrdelete::%sender%::%arg 2%} to now
				send colored "&a&lFastWorldReset&2&l> &6Are you sure you want to delete %arg 2%? Type the command again to confirm. (You have 15 seconds)"
				stop
				
			if {worldgenerator::%arg 2%} is set:
				delete {worldgenerator::%arg 2%}
				
			if {worldenvironment::%arg 2%} is set:
				delete {worldenvironment::%arg 2%}
				
			if {fastworldreset::chunkresetdisabled::%arg 2%} is set:
				delete {fastworldreset::chunkresetdisabled::%arg 2%} 
				
			if {-resetstats::%arg 2%::*} is set:
				delete {-resetstats::%arg 2%::*}
				
				
			#just in case if it's a clone
			if {fastworldresetclone::%arg 2%} is set:
				delete {fastworldresetclone::%arg 2%}
				set {_clone} to true
				
			if {fastworldresetclonename::%arg 2%} is set:
				delete {fastworldresetclonename::%arg 2%}
			#
				
			delete {-fastworldresetworld::%arg 2%}
			
			if (arg 2 parsed as a world) is a world:
				send "&a&lFastWorldReset&2&l> &6Hm.. Seems like this world is loaded, unloading it and saving!"
				if unloadWorld((arg 2 parsed as a world), true) is true:
					send "&a&lFastWorldReset&2&l> &6Unloaded successfully!"
				else:
					send "&a&lFastWorldReset&2&l> &cFailed to unload."
				
			send "&a&lFastWorldReset&2&l> &aYou have removed world &e&l%arg 2% &afrom the system of FastWorldReset."
			set {_w} to arg 2
			set {_p} to sender
			create section stored in {_section}:
				
				
				if {_clone} is set:
					FileUtils.deleteDirectory(new File("%{_worlddir}%/%{_w}%"))
					send "&a&lFastWorldReset&2&l> &6Since this world is a clone, deleted it from the world folder." to {_p}
				else:
					FileUtils.deleteDirectory(new File("%{_worlddir}%/FastWorldReset/%{_w}%"))
					send colored "&a&lFastWorldReset&2&l> &6Deleted the world template from %{_worlddir}%/FastWorldReset folder, but still kept the world in your world folder for manual deletion." to {_p}
			run section {_section} async and wait
		else if arg 1 is "exit":
			if sender is not a player:
				send "&a&lFastWorldReset&2&l> &cThis command is only executable as a player, if you want this to work on console, please contact the author Govindas."
				stop
			set {fastworldreset::exitpoint} to location of player
			send "&a&lFastWorldReset&2&l> &aYou have successfully set exit point at &e&l%{fastworldreset::exitpoint}%"
		else if arg 1 is "disable-chunk-reset":
			if (arg 2 parsed as a world) is not a world:
				send "&a&lFastWorldReset&2&l> &cThe specified world &e%arg 2% &cis not loaded."
				stop
			if {fastworldreset::chunkresetdisabled::%arg 2%} is not set:
				set {fastworldreset::chunkresetdisabled::%arg 2%} to true
				(arg 2 parsed as a world).setAutoSave(true)
				send "&a&lFastWorldReset&2&l> &aYou have disabled chunk-based reset for the world &e%arg 2% &aplease note that this makes reset slower and more likely to cause lag spikes, but it makes chunks automatically unload in the world as usual, making the world lighter on RAM usage."
			else:
				send "&a&lFastWorldReset&2&l> &cChunk-based reset is already disabled in world &e%arg 2%&c!"
		else if arg 1 is "enable-chunk-reset":
			if (arg 2 parsed as a world) is not a world:
				send "&a&lFastWorldReset&2&l> &cThe specified world &e%arg 2% &cis not loaded."
				stop
			if {fastworldreset::chunkresetdisabled::%arg 2%} is set:
				delete {fastworldreset::chunkresetdisabled::%arg 2%}
				send "&a&lFastWorldReset&2&l> &aYou have enabled chunk-based reset for the world &e%arg 2% &aagain! Yay, faster world reset!"
				(arg 2 parsed as a world).setAutoSave(false)
			else:
				send "&a&lFastWorldReset&2&l> &cChunk-based reset is already enabled for the world &e%arg 2%&c!"
			
		else if arg 1 is "worlds":

			send " "
			send "&6- &a&l Worlds &6-"
			loop all worlds:
				send formatted "&e%loop-world% &6- &e&l%amount of ...loop-world.getLoadedChunks()% &cchunks &e&l%amount of entities in loop-world% &centities"
		
		else if arg 1 is "unload-chunks":
		
			if (arg 2 parsed as a world) is not a world:
				send "&a&lFastWorldReset&2&l> &cThe specified world &e%arg 2% &cis not loaded."
				stop
			if (arg 3 parsed as a boolean) is not a boolean:
				send "&a&lFastWorldReset&2&l> &cUsage: &e/fwr unload-chunks <world> <boolean> &cThe boolean stands for saving true or saving false."
				stop
				
			set {_saving} to arg 3 parsed as a boolean
			set {_world} to arg 2 parsed as a world
			
			set {-unloading::%{_world}%} to true
			
			unloadChunks(({_world}), {_saving}) = true
			delete {-unloading::%{_world}%}
			
			if amount of ...{_world}.getLoadedChunks() is not 0:
				send "&a&lFastWorldReset&2&l> &cSome chunks have failed to unload, due to some plugin or players keeping chunks loaded."
		else if arg 1 is "generator":
			if arg 2 or arg 3 is not set:
				send "&cUsage: &e/fwr generator <world> <generator>"
				send "&cList of World Generators: &eDefault, %{-worldgenerators::*} ? """"%"
				stop
			set {_worlddir} to {-fwrcache::worlddir}
			if {-fastworldresetworld::%arg 2%} is not set:
				send "&a&lFastWorldReset&2&l> &e%arg 2% &cis not a FastWorldReset world."
				stop
			
			else:
				set {_prev} to "%{worldgenerator::%arg 2%}%"
				
				arg 3 is not "Default":
					set {worldgenerator::%arg 2%} to arg 3
				else:
					delete {worldgenerator::%arg 2%}
				if "%{worldgenerator::%arg 2%}%" is {_prev}:
					send formatted "&a&lFastWorldReset&2&l> &e%arg 2% &cis already using &e%arg 3%&c!"
					stop
				send "&a&lFastWorldReset&2&l> &aYou have set the world generator of &e%arg 2% &ato &e%arg 3%"
				
				if {-worldgenerators::%arg 3%} is not set:
					send colored "&cWARNING: The specified generator (%arg 3%) has not been found on the server, but this may be a mistake."
		else if arg 1 is "generators":
			send colored "&a&lFastWorldReset&2&l> &cList of World Generators: &eDefault, %{-worldgenerators::*} ? """"%"
		else if arg 1 is "resetstats":
			if arg 2 is set:
				set {_world} to arg 2
			else:
				set {_world} to "%player's world%"
			if {-resetstats::%{_world}%::last} is set:
				send "&cLast reset type: &e&l%{-resetstats::%{_world}%::last} ? ""Unknown""%"
				send "&cWorld-based resets: &e&l%{-resetstats::%{_world}%::worldbased} ? 0%"
				send "&cChunk-based resets: &e&l%{-resetstats::%{_world}%::chunkbased} ? 0%"
			else:
				send "&a&lFastWorldReset&2&l> &cNo reset data found for this world. Possibly it was never reset since server restart."
		else if arg 1 is "info":
			if arg 2 is not set:
				send "&cUsage: &e/fwr info <world>"
				stop
			{-fastworldresetworld::%arg 2%} is set:
			
				send formatted "&a&lWorld: &e%{-fastworldresetworld::%arg 2%}%"
				
				if {fastworldreset::chunkresetdisabled::%{_world}%} is set:
					set {_type} to "world-based"
				else:
					set {_type} to "chunk-based with fallback to world-based if it fails"
					
				send formatted "&a&lReset Type: &e%{_type}%"
				send formatted "&a&lGenerator: &e%{worldgenerator::%arg 2%} ? ""Default""%"
				
				if arg 2 parsed as a world is a world:
					set {_loaded} to true
				else:
					set {_loaded} to false
				send formatted "&a&lIs Loaded: &e%{_loaded}%"
			else:
				send formatted "&a&lFastWorldReset&2&l> &cThe specified world (%arg 2%) is not a FastWorldReset world."
		else:

			send "&2&l--=-= &a&lFastWorldReset Commands &2&l=-=--"
			send "&f/fwr create <world> [generator]  &a- Add a world to FastWorldReset system or create a completely new world into the system."
			send "&f/fwr delete <world>  &a- Removes the world from FastWorldReset system, does not unload or delete the world."
			send "&f/fwr clone <world> <new-world> &a- Clones a FWR world."
			send "&f/fwr reset <world>  &a- to reset a world. (Must be in FastWorldReset system)"
			send "&f/fwr exit  &a- sets exit point to where players get teleported when their world resets."
			send "&f/fwr load <world> [generator] &a- loads a world. Optionally with a generator."
			send "&f/fwr unload <world> [<true/false>] &a- loads a world. true/false if the world should be saved, defaults to true."
			send formatted "<ttp:&f/fwr unload <world>%new line%&7May be useful for unloading worlds which you no longer need.>&f/fwr unload <world>  &a- unload a world."
			send "&f/fwr unload-chunks <world> <true/false> &a- unloads chunks in the specified world, with saving or without."
			send "&f/fwr tp <world> [player]  &a- teleport to a world or teleport another player to the world."
			send formatted "<ttp:&f/fwr disable-chunk-reset <world>%{_newline}%&7May be useful in situations where the world uses very much RAM and you prefer slower reset than higher RAM usage>&f/fwr disable-chunk-reset <world>  &a- disables chunk-based resetting of the specified world, which makes the chunks unload normally."
			send "&f/fwr enable-chunk-reset <world> &a- enables chunk-based reset, this is enabled by default for fastest speed, see above to disable. (This is only meant for things like minigame maps, not where you need changes to persist across server restarts!)"
			send "&f/fwr worlds &a- shows the list of all worlds and their data."
			send "&f/fwr generator <world> <generator> &a- set a generator for a world."
			send "&f/fwr generators &a- list all world generators detected on the server."
			send "&f/fwr info <world> &a- see information about the specified world."
			send "&f/fwr resetstats &a- useful for debugging of reset bugs."
			send "&6Hover your mouse on the commands to see extra comments and tips."

function initWorlds():

	#just in case if the user hasn't configured variables starting with "-" character to not save to database.
	delete {-fastworldresetworld::*}, {-unloading::*}, {-resetting::*} and {-initload::*}
	
	set {_worlddir} to {-fwrcache::worlddir}
	create section stored in {_section}:
		set {_files::*} to ...new File("%{_worlddir}%/FastWorldReset").listFiles()
		loop {_files::*}:
			Files.isDirectory(Paths.get("%loop-value%")) is true:
				
				set {_value} to "%loop-value%"
				set {_r::*} to split "%loop-value%" by "%{-fwrcache::fileseparator}%FastWorldReset%{-fwrcache::fileseparator}%"
				set {_return::%loop-index%} to {_r::2}
		return {_return::*}
	run section {_section} async and store the result in {_worlds::*} and wait
		
	loop {_worlds::*}:
		set {-fastworldresetworld::%loop-value%} to loop-value
		if {@ResetResettableWorldsOnRestart} is true:
			make console execute command "/fastworldreset reset %loop-value%"
			
		else if loop-value parsed as a world is not a world:
			loadWorld(loop-value)
function deleteClones():
	set {_worlddir} to {-fwrcache::worlddir}
	create section stored in {_section}:
		loop {fastworldresetclone::*}:
			FileUtils.deleteDirectory(new File("%{_worlddir}%/%{fastworldresetclonename::%loop-index%}%"))
	run section {_section} async and wait
	delete {fastworldresetclone::*}
	delete {fastworldresetclonename::*}
	
on skript load:
	wait a second
	initWorlds()
	if {@AutoDeleteClonesOnRestart} is true:
		deleteClones()


#chunk-based reset, which resets by not saving chunks and re-loading them instead of reloading the whole world. it reloads the world only if the world got saved by some system.

on chunk unload:
	{-fastworldresetworld::%event-world%} is set
	{fastworldreset::chunkresetdisabled::%event-world%} is not set
	{-resetting::%event-world%} is not set
	{-unloading::%event-world%} is not set
	cancel event

on world init:
	if {-initload::%event-world%} is set:
		delete {-initload::%event-world%}
		event-world.setKeepSpawnInMemory(false)
	{fastworldresetclone::%event-world%} is set:
		set {_options} to {fastworldresetclone::%event-world%}
	else:
		set {_options} to "%event-world%"
	{-fastworldresetworld::%{_options}%} is set
	{fastworldreset::chunkresetdisabled::%{_options}%} is not set:
		event-world.setAutoSave(false)
		
		#for Paper servers, to disable saving
		
		#setting it to variable for better performance for doing it twice
		set {_config} to event-world.getHandle().paperConfig
		
		set {_config}.autoSavePeriod to 0
		set {_config}.maxAutoSaveChunksPerTick to 0
		
		#needed, because if it is set as true... entity ticking may totally bug out with the way FastWorldReset's chunk-based reset mehod works
		#it may sometimes cause behavior like projectiles constantly teleporting back and never landing if set to true
		set {_config}.skipEntityTickingInChunksScheduledForUnload to false

	event-world.setKeepSpawnInMemory(false)
on world saving:
	{fastworldreset::chunkresetdisabled::%event-world%} is not set
	set {-fastworldreset::shouldreset::%event-world%} to true

on skript unload:
	loop all worlds:
		{-fastworldresetworld::%loop-world%} is set
		{fastworldreset::chunkresetdisabled::%loop-world%} is not set
		unloadWorld(loop-world, false)