---------------------------------------------------------------------
-----------------------   Script Data Part   ------------------------
-----------------------   Slime Spawn Kill   ------------------------
---------------------------------------------------------------------

SpawnData =
{
	Slime = { Index = "AutoESlime00", X = 6500, Y = 8000, Dir = 0, Radius = 3000, Lot = 20, },
}

RewardData =
{
	[1] = { Index = "IM_CS", MinLot = 1, MaxLot = 5, },
}

EventData =
{
	RoundLimit = 3,
	RoundTimeLimit = 60,
	
	EventInitDelay = 21600, ---21600,
	EventRestartDelay = 43200, ---43200,
	
	CastbarDelay = 3000,
}

require("common")

MemBlock = {}

function Event_Dummy( Var )
cExecCheck( "Event_Dummy" )

	if Var.EventStart <= cCurSec() then
		Var.FuncStep = "Event_RoundSpawn"
	end

	return ReturnAI.END
end

function Event_Exit( Var, Message )
cExecCheck( "Event_Exit" )

	--> Clear spawns
	for i=SpawnData.Slime.Lot, 1, -1 do
		if Var.RoundSpawns[i] ~= nil and Var.RoundSpawns[i].Handle ~= nil then
			cKillObject( Var.RoundSpawns[i].Handle )
		end
	end
	
	Var.RoundActive = false
	Var.RoundExpire = 0
	Var.Round = 0
	
	Var.RoundSpawns = {}
	
	--> Clear master handle
	--cNPCVanish( Var.Handle )
	
	--> Debug error
	cAssertLog( Message )

	--> Announce event end
	cNoticeString( Var.MapIndex, "The Slime Slaughter Event has terminated!" )
	
	--> Reset new start & set dummy step
	Var.EventStart = cCurSec() + EventData.EventRestartDelay
	Var.FuncStep = "Event_Dummy"
	
	return ReturnAI.END
end

function Event_RoundWinner( NPCHandle, PlyHandle )
cExecCheck( "Event_RoundWinner" )

	local NPCVar = MemBlock[NPCHandle]
	
	if NPCVar == nil then
		cAssertLog( "Event_RoundWinner->NPCVar is nil" )
		return
	end

	local MasterVar = MemBlock[NPCVar.MasterHandle]
	
	if MasterVar == nil then
		cAssertLog( "Event_RoundWinner->MasterVar is nil" )
		return
	end
	
	local PlayerName = cGetPlayerName( PlyHandle )
	
	if PlayerName == nil then
		cAssertLog( "Event_RoundWinner->PlyHandle is nil" )
		return
	end
	
	if NPCVar.TrueSpawn then
	
		NPCVar.TrueSpawn = false
		
		--> Reward player
		for i=1, #RewardData do
			local RewardLot = math.random( RewardData[i].MinLot, RewardData[i].MaxLot )
			cRewardItem( PlyHandle, RewardData[i].Index, RewardLot )
		end
		
		--> End round
		Event_RoundExpire( MasterVar, PlayerName .. " has won round " .. MasterVar.Round .. "!" )
	end
end

function Event_RoundExpire( Var, Announcement )
cExecCheck( "Event_RoundExpire" )

	--> Deactivate
	Var.RoundActive = false

	--> Clear spawns
	for i=SpawnData.Slime.Lot, 1, -1 do
		local SpawnVar = Var.RoundSpawns[i]
		if SpawnVar ~= nil then
			SpawnVar.TrueSpawn = false
			if SpawnVar.Handle ~= nil then
				cKillObject( SpawnVar.Handle )
			end
		end
		SpawnVar = nil
	end
	
	Var.RoundSpawns = {}
	
	--> Announce expiry
	cNoticeString( Var.MapIndex, Announcement )
	
	--> Begin new round
	if Var.Round < EventData.RoundLimit then
		Event_RoundSpawn( Var )
	end
end

function Event_RoundSpawn( Var )
cExecCheck( "Event_RoundSpawn" )

	--> Activate
	Var.RoundActive = true
	Var.RoundExpire = cCurSec() + EventData.RoundTimeLimit
	Var.Round = Var.Round + 1
	
	--> Announce round spawn
	cNoticeString( Var.MapIndex, "Round " .. Var.Round .. " of Slime Slaughter has started, you have " .. EventData.RoundTimeLimit .. " seconds remaining!" )
	
	--> Spawn mobs and pick a true spawn
	local TrueSpawn = math.random(1, SpawnData.Slime.Lot)
	
	for i=1, SpawnData.Slime.Lot do
	
		local SpawnHandle = cMobRegen_Circle( Var.MapIndex, SpawnData.Slime.Index, SpawnData.Slime.X, SpawnData.Slime.Y, SpawnData.Slime.Radius )
	
		if SpawnHandle ~= nil then
		
			--> Store spawn handle
			MemBlock[SpawnHandle] = {}
			Var.RoundSpawns[i] = MemBlock[SpawnHandle]
		
			--> Assign vars
			MemBlock[SpawnHandle].Handle = SpawnHandle
			MemBlock[SpawnHandle].MasterHandle = Var.Handle
			MemBlock[SpawnHandle].MapIndex = Var.MapIndex
			MemBlock[SpawnHandle].Type = "Spawn"
		
			--> Events
			cAIScriptSet( SpawnHandle, Var.Handle )
			cAIScriptFunc( SpawnHandle, "NPCClick", "Round_SpawnClick" )
			cAIScriptFunc( SpawnHandle, "NPCMenu",  "Round_SpawnCasting" )
		
			if i == TrueSpawn then				
				MemBlock[SpawnHandle].TrueSpawn = true
				TrueSpawn = -1
			end
		end
	end

	Var.FuncStep = "Event_Loop"
	
	return ReturnAI.END
end

function Round_SpawnClick( NPCHandle, PlyHandle, RegistNumber )
cExecCheck( "Round_SpawnClick" )

	local Var = MemBlock[NPCHandle]
	
	if Var ~= nil then
		cCastingBar( PlyHandle, NPCHandle, EventData.CastbarDelay, "ActionProduct" )
	end
end

function Round_SpawnCasting( NPCHandle, PlyHandle, RegistNumber, Menu )
cExecCheck( "Round_SpawnCasting" )

	local Var = MemBlock[NPCHandle]
	
	if Var ~= nil and Var.Handle ~= nil then
		if Var.TrueSpawn then
			--> Round end
			Event_RoundWinner( NPCHandle, PlyHandle )
		else
			--> Vanish mob
			cNPCVanish( NPCHandle )
		end
	end
end

function AutoESlime00( Handle, MapIndex ) return ReturnAI.CPP end

function AutoEvent00( Handle, MapIndex )
cExecCheck( "AutoEvent00" )

	if MapIndex ~= "RouN" then
		return
	end

	local Var = MemBlock[Handle]
	
	if Var == nil then
		MemBlock[Handle] = {}
		Var = MemBlock[Handle]
		
		--> Default Vars
		Var.Handle = Handle
		Var.MapIndex = MapIndex
		Var.Type = "Master"
		
		--> Event Vars
		Var.RoundActive = false
		Var.RoundExpire = 0
		Var.Round = 0
		Var.RoundSpawns = {}
		
		Var.EventStart = cCurSec() + EventData.EventInitDelay
		Var.FuncStep = "Event_Dummy"
		
		--> Announce event start
		cNoticeString( Var.MapIndex, "The Slime Slaughter Event has been executed!" )
	end
	
	return _G[Var.FuncStep]( Var )
end

function Event_Loop( Var )
cExecCheck( "Event_Loop" )

	--> If round expired
	if Var.RoundActive and Var.RoundExpire < cCurSec() then
		Event_RoundExpire( Var, "Round " .. Var.Round .. " has expired!" )
	end
	
	--> If not round active
	if not Var.RoundActive and Var.Round >= EventData.RoundLimit then
		return Event_Exit( Var, "Event_Loop->Slime Slaughter Event expired successfully" )
	end
	
	return ReturnAI.END
end