--Optional
    function TDTK.AWaveBegins(number)
        -- Is triggered at the start of every wave
    end
    --Optional
    function TDTK.AUnitIsCreated(unitObj)
        -- Is triggered when a creep has been created by the TDTK System
        -- unitObj.this is the triggering unit
    end
    --Optional
    function TDTK.AUnitDies(unitObj)
        -- Is triggered when a creep (which belongs to the TDTK System) dies
        -- unitObj.this is the triggering unit
    end
    --Optional
    function TDTK.AUnitEntersFinalDestination(unitObj)
        -- Is triggered when a creep (which belongs to the TDTK System) reaches the end
        -- unitObj.this is the triggering unit
    end
    --Optional
    function TDTK.APlayerCompletedAllWaves(playerObj)
        -- Is triggered when a Player has complete all Waves
        -- playerObj.this is the triggering player
    end
    --Optional
    function TDTK.APlayerIsDefeat(playerObj)
        -- Is triggered when a Player has lost all of his life
        -- playerObj.this is the triggering player
    end
 

UnitType:OnAlive() -- Is called when the unit is created
UnitType:OnDeath() -- Is called when the unit dies
 

    -- Inherit from TDTK.UnitType
    local BreederType = TDTK.UnitType():Create()
    -- Create a BreederType Class
    function BreederType:Create(parentId, childId)
        local this = TDTK.UnitType():Create(FourCC(parentId))
        -------------------------------------------------------------
        --Here goes your custom values that will be use in OnAlive and OnDeath
        this.childId = FourCC(childId) -- use FourCC to convert the string to id
        this.count = 2 -- default creep count
        -------------------------------------------------------------
        self.__index = self
        setmetatable(this, self)
        return this
    end
    -- Override the OnDeath function (we dont need OnAlive in this example)
    function BreederType:OnDeath(unitObj)
        for i = 1, self.count, 1 do
            local loc = GetUnitLoc(unitObj.this)
            -- Create a creep and saves it in the TDTK database
            local childObj = TDTK.Unit().NewUnit(loc, self.childId)
            RemoveLocation(loc)
            -- Copy all information from the parent creep (path, current destination). This information is also provided to the WaveManager
            childObj:CopyState(unitObj)
            -- Immediately order the creep to move to the current destination
            childObj:Order()
        end
    end

    -- Add the new UnitTypes to the TDTK System
    -- Bandit will Spawn 2 Spiders on death
    BreederType:Create("nban","nspb")
    -- Ogre Mage will Spawn 1 Grunt on death
    local unitType = BreederType:Create("nomg","ogru")
    unitType.count = 1
 

------------------------------------------------------------------------------------------------------
-- Tower Defence Toolkit (TDTK) v0.2
-- By B1Gbull#2338
------------------------------------------------------------------------------------------------------
TDTK = {}
-- Global values that can be changed inside the Settings() function
TDTK.globals = {
    wave = {
        interval = 30,
        gold = 0
    },
    startResource = {
        gold = 0,
        lumber = 0,
        life = 20
    },
    text = {
        playerLoseLife = "${1} life remaining", -- Use ${1} to show the player life
        newWave = "Wave ${1}/${2}", -- Use ${1} to show the current wave number and/or ${2} to show the last wave number
        waveDialog = "Wave in:" -- =nil will remove the dialog
    }
}
-- Global references
TDTK.collection = {
    unit = {},
    unitType = {},
    region = {},
    waveManager = {},
    player = {},
    timer = {}
}

local Event = {onEnterRegionTrigger}
local Util = {}
-- Classes
local Region = {}
TDTK.Region = function() return Region end
local WaveManager = {}
TDTK.WaveManager = function() return WaveManager end
local Wave = {}
TDTK.Wave = function() return Wave end
local WaveType = {}
TDTK.WaveType = function() return WaveType end
local Unit = {}
TDTK.Unit = function() return Unit end
local UnitType = {}
TDTK.UnitType = function() return UnitType end
local Timer = {}
TDTK.Timer = function() return Timer end
local User = {} -- Player is already taken
TDTK.Player = function() return User end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
-- Global functions that can be overwritten
function TDTK.Settings()
    Util.Error("Error: No Settings found")
end
function TDTK.AWaveBegins(number)
end
function TDTK.AUnitIsCreated(unitObj)
end
function TDTK.AUnitDies(unitObj)
end
function TDTK.AUnitEntersFinalDestination(unitObj)
end
function TDTK.APlayerCompletedAllWaves(playerObj)
end
function TDTK.APlayerIsDefeat(playerObj)
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
-- Initializes the system
TDTK.Init = function()
    Event.onEnterRegionTrigger = CreateTrigger()
    TriggerAddAction(Event.onEnterRegionTrigger, Event.OnEnterRegion)
    local trig = CreateTrigger()
    TriggerRegisterAnyUnitEventBJ(trig, EVENT_PLAYER_UNIT_DEATH)
    TriggerAddAction(trig, Event.OnUnitDie)
    local ExpiredFunc = function()
        local t = TDTK.collection.timer[GetExpiredTimer()]
        TDTK.Settings()
        User.SetStartResource()
        SetPlayerState(Player(23), PLAYER_STATE_GIVES_BOUNTY, 1)
        Timer:Create(1, true, Unit.OrderIdle)
        WaveManager.Execute()
        t:Remove()
    end
    Timer:Create(0.01,false,ExpiredFunc)
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
--local trigger events that are used
Event.OnEnterRegion = function()
    local unit = GetTriggerUnit()
    local unitObj = Unit.Get(unit)
    if unitObj ~= nil then
        --Check if triggering region is the current destination of the unit
        local region = unitObj:GetCurrentDestination()
        if region.this == GetTriggeringRegion() then
            --Set the next destination for triggering unit
            unitObj:SetNextDestination()
            if unitObj:GetCurrentDestination() ~= nil then
                --Order unit to move to his destination
                unitObj:Order()
            else
                --Final region reached
                TDTK.AUnitEntersFinalDestination(unitObj)
                unitObj:RemoveLife()
                unitObj:Clear()
                RemoveUnit(unitObj.this)
            end
        end
    end
end
Event.OnUnitDie = function()
    local unit = GetTriggerUnit()
    local unitObj = Unit.Get(unit)
    if unitObj ~= nil then
        TDTK.AUnitDies(unitObj)
        unitObj:OnDeath()
        unitObj:Clear()
    end
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
--Is used to track the triggering rect from GetTriggeringRegion()
function Region:Create(rect)
    local this = {}
    this.this = CreateRegion()
    this.rect = rect
    RegionAddRect(this.this, rect)
    self.__index = self
    setmetatable(this, self)
    TDTK.collection.region[this.rect] = this
    return this
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
--Contains all information about a path
function WaveManager:Create()
    local this = {}
    this.regions = {}
    this.players = {}
    this.waves = {}
    this.enabled = true
    self.__index = self
    setmetatable(this, self)
    TDTK.collection.waveManager[this] = this
    return this
end
--Add a new Region as destination
function WaveManager:AddDestination(regionName)
    local rectRegion = _G["gg_rct_"..tostring(regionName)]
    if rectRegion then
        local regionObj = TDTK.collection.region[rectRegion]
        if regionObj == nil then
            regionObj = Region:Create(rectRegion)
            TriggerRegisterEnterRegionSimple(Event.onEnterRegionTrigger, regionObj.this)
        end
        table.insert(self.regions, regionObj)
        return regionObj
    else
        return nil
    end
end
function WaveManager:AddPlayer(number)
    local playerNum = math.max(number-1,0)
    playerNum = math.min(playerNum,23)
    local player = Player(playerNum)
    if GetPlayerSlotState(player) == PLAYER_SLOT_STATE_PLAYING and GetPlayerController(player) == MAP_CONTROL_USER then
        local playerObj = User:Create(Player(playerNum))
        playerObj.waveManagers[self] = self
        self.players[player] = playerObj
        table.insert(playerObj.waveManagers, self)
    end
end
--Return the region by index. 1 = spawn region ...
function WaveManager:GetDestinationByIndex(index)
    return self.regions[index]
end
--Return the wave by index. 1 = first wave ...
function WaveManager:GetWaveByIndex(index)
    return self.waves[index]
end
function WaveManager:AddWave(unitCode)
    local id = unitCode and FourCC(unitCode) or nil
    local waveType = WaveType:Create(id)
    local wave = Wave:Create(waveType,self)
    table.insert(self.waves, wave)
    return waveType
end
--Copy the waves from another WaveManager
function WaveManager:CopyWaves(waveManager)
    for _, w in pairs(waveManager.waves) do
        local wave = Wave:Create(w.waveType,self)
        table.insert(self.waves, wave)
    end
end
--Copy the player from another WaveManager
function WaveManager:CopyPlayers(waveManager)
    self.players = waveManager.players
end
--Return the last wave number of the current WaveManager
function WaveManager:GetWaveCount()
    local count = 0
    for _ in pairs(self.waves) do
        count = count + 1
    end
    return count
end
--Checks if the WaveManager has at least 2 destinations, 1 player and 1 wave
--Is Called once after Settings()
function WaveManager:Validate()
    local count = 0
    for _ in pairs(self.regions) do count = count + 1 end
    if count < 2 or next(self.players) == nil or next(self.waves) == nil then
        return false
    end
    return true
end
--Checks whether the manager has completed all waves
function WaveManager:IsComplete()
    for _, w in pairs(self.waves) do
        if w:IsComplete() == false then
            return false
        end
    end
    return true
end
function WaveManager:Disable()
    self.enabled = false
end
--Starts all waves of all WaveManagers
--Called once after Settings()
WaveManager.Execute = function()
    local ExpiredFunc = function()
        local t = TDTK.collection.timer[GetExpiredTimer()]
        local currentIndex = t.arg[1]
        local lastIndex = t.arg[2]
        local dialog = t.arg[3]
        --Start new wave if the timer expire
        for _, wm in pairs(TDTK.collection.waveManager) do
            if wm.enabled then
                local w = wm:GetWaveByIndex(currentIndex)
                w:Execute()
            end
        end
        --Add gold and send a message
        local changeGold = TDTK.globals.wave.gold ~= 0 and true or false
        for _, p in pairs(TDTK.collection.player) do
            if TDTK.globals.text.newWave then
                Util.WarningToPlayer(Util.EmbedToString(TDTK.globals.text.newWave,currentIndex,lastIndex),p.this)
            end
            if changeGold then
                p:AddGold(TDTK.globals.wave.gold)
            end
        end
        TDTK.AWaveBegins(currentIndex)
        --Stops the timer if it is the last one
        if currentIndex >= lastIndex then
            if dialog then
                DestroyTimerDialog(dialog)
            end
            t:Remove()
        end
        --Increase current wave index
        t.arg[1] = t.arg[1] + 1
    end
    local lastIndex = 1
    --Find out the last wave index
    for _, wm in pairs(TDTK.collection.waveManager) do
        if wm:Validate() then
            local count = wm:GetWaveCount()
            if lastIndex < count then
                lastIndex = count
            end
        else
            wm:Disable()
        end
    end
    --Create the wave timer that starts all waves
    local t = Timer:Create(TDTK.globals.wave.interval,true,ExpiredFunc,1,lastIndex)
    if TDTK.globals.text.waveDialog then
        t.arg[3] = CreateTimerDialogBJ(t.this, tostring(TDTK.globals.text.waveDialog))
    end
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
--Stores the static wave information (like UnitType)
function WaveType:Create(unitId)
    local this = {}
    this.unitId = unitId
    this.count = 10
    this.interval = 2
    this.damage = 1
    self.__index = self
    setmetatable(this, self)
    return this
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
function Wave:Create(waveType,waveManager)
    local this = {}
    this.waveType = waveType
    this.waveManager = waveManager
    this.spawnCounter = 0
    this.enabled = waveType.unitId ~= nil and true or false
    this.units = {}
    self.__index = self
    setmetatable(this, self)
    return this
end
--Starts the wave
--Is called when the global wave timer expire
function Wave:Execute()
    if self.enabled then
        self:Spawn()
        local ExpiredFunc = function()
            local t = TDTK.collection.timer[GetExpiredTimer()]
            local wave = t.arg[1]
            if wave.spawnCounter<wave.waveType.count then
                wave:Spawn()
            else
                wave:Disable()
                t:Remove()
            end
        end
        Timer:Create(self.waveType.interval,true,ExpiredFunc,self)
    end
end
--Creates a unit that belongs to the wave
--Is called when the internal spawn timer expire
function Wave:Spawn()
    local loc = GetRandomLocInRect(self.waveManager.regions[1].rect)
    local unitObj = Unit.NewUnit(loc, self.waveType.unitId)
    RemoveLocation(loc)
    self:AddUnit(unitObj)
    self.spawnCounter = self.spawnCounter + 1
end
--Is called every time a unit die
function Wave:IsComplete()
    -- enabled = false means it will no longer spawn untis
    -- But there might be units alive, that belongs to this wave
    if self.enabled == false and next(self.units) == nil then
        return true
    else
        return false
    end
end
function Wave:Disable()
    self.enabled = false
end
--Called when a unit is created to link the unit to the wave
function Wave:AddUnit(unitObj)
    unitObj.wave = self
    self.units[unitObj.this] = unitObj
    TDTK.AUnitIsCreated(unitObj)
    unitObj:OnAlive()
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
-- Player
function User:Create(player)
    local this = TDTK.collection.player[player]
    if this == nil then
        this = {}
        this.this = player
        this.life = 1
        this.waveManagers = {}
        self.__index = self
        setmetatable(this, self)
        TDTK.collection.player[player] = this
    end
    return this
end
--Set startig resource for all player
--Called once after Settings()
User.SetStartResource = function()
    for _, p in pairs(TDTK.collection.player) do
        if TDTK.globals.startResource.life > 0 then
            p.life = TDTK.globals.startResource.life
        end
        if TDTK.globals.startResource.gold > 0 then
            SetPlayerState(p.this, PLAYER_STATE_RESOURCE_GOLD, TDTK.globals.startResource.gold)
        end
        if TDTK.globals.startResource.lumber > 0 then
            SetPlayerState(p.this, PLAYER_STATE_RESOURCE_LUMBER, TDTK.globals.startResource.lumber)
        end
    end
end
User.Get = function(player)
    return TDTK.collection.player[player]
end
--Remove life from Player
--Is called when a unit enters final region
function User:Damage(value)
    self.life = math.max(self.life - value, 0)
    if TDTK.globals.text.playerLoseLife then
        Util.WarningToPlayer(Util.EmbedToString(TDTK.globals.text.playerLoseLife,self.life),self.this)
    end
    if self.life <= 0 then
        --Player is defeat
        TDTK.APlayerIsDefeat(self)
        self:Lose()
        self:Clear()
    end
end
--Player completed all waves
--Is called every time a unit dies
function User:IsComplete()
    for _, wm in pairs(self.waveManagers) do
        if wm:IsComplete() == false then
            return false
        end
    end
    return true
end
function User:Win()
    CustomVictoryBJ(self.this, true, true)
end
function User:Lose()
    CustomDefeatBJ(self.this, "Defeat!")
end
--Remove all references to prevent leaks
--Called after a player win or lose
function User:Clear()
    for _, wm in pairs(self.waveManagers) do
        wm.players[self.this] = nil
        --TDTK.collection.player[self.this] = nil
        if next(wm.players) == nil then
            wm.Disable()
        end
    end
end
function User:AddGold(value)
    local gold = GetPlayerState(self.this, PLAYER_STATE_RESOURCE_GOLD)
    SetPlayerState(self.this, PLAYER_STATE_RESOURCE_GOLD, gold+value)
end
function User:AddLumber(value)
    local lumber = GetPlayerState(self.this, PLAYER_STATE_RESOURCE_LUMBER)
    SetPlayerState(self.this, PLAYER_STATE_RESOURCE_LUMBER,lumber+value)
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
--Base class to inherit from
--See custom unit tutorial
function UnitType:Create(id)
    local this = TDTK.collection.unitType[id]
    if this == nil then
        this = {}
        this.id = id
        self.__index = self
        setmetatable(this, self)
        if id ~= nil then TDTK.collection.unitType[id] = this end
    end
    return this
end
function UnitType:OnAlive(unitObj) end
function UnitType:OnDeath(unitObj) end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
function Unit:Create(unit)
    local this = TDTK.collection.unit[unit]
    if this == nil then
        this = {}
        this.this = unit
        this.typeObj = UnitType:Create(GetUnitTypeId(unit))
        this.wave = nil
        this.destinationIndex = 1
        self.__index = self
        setmetatable(this, self)
        TDTK.collection.unit[unit] = this
    end
    return this
end
function Unit:OnAlive()
    self.typeObj:OnAlive(self)
end
function Unit:OnDeath()
    self.typeObj:OnDeath(self)
end
Unit.Get = function(unit)
    return TDTK.collection.unit[unit]
end
--Remove all references to prevent leaks
--Called after a unit dies or before is removed
function Unit:Clear()
    self.wave.units[self.this] = nil
    TDTK.collection.unit[self.this] = nil
    local players = self.wave.waveManager.players
    for _, p in pairs(players) do
        if p:IsComplete() and p.life > 0 then
            TDTK.APlayerCompletedAllWaves(p)
            p:Win()
            p:Clear()
        end
    end
end
--Is used to create units for the TDTK System
Unit.NewUnit = function(loc, id)
    local unit = CreateUnitAtLoc(Player(23), id, loc, bj_UNIT_FACING)
    local unitObj = Unit:Create(unit)
    return unitObj
end
--Transfers all information from one to another unit
--See custom unit tutorial
function Unit:CopyState(unitObj)
    self.destinationIndex = unitObj.destinationIndex
    unitObj.wave:AddUnit(self)
end
--Reorder idle units.
--Is called every 1 sec
Unit.OrderIdle = function()
    for _, unitObj in pairs(TDTK.collection.unit) do
        if GetUnitCurrentOrder(unitObj.this) == 0 then
            unitObj:Order()
        end
    end
end
--Order the unit to his current destination
--Is called if the unit reaches his destination or is idle
function Unit:Order()
    region = self:GetCurrentDestination()
    if region ~= nil then
        local loc = GetRectCenter(region.rect)
        IssuePointOrderLoc(self.this, "move", loc)
        RemoveLocation(loc)
    end
end
--Gives the unit the next destination
--Is called if the unit has enter his destination region
function Unit:SetNextDestination()
    self.destinationIndex=self.destinationIndex+1
end
function Unit:GetPlayers()
    return self.wave.waveManager.players
end
function Unit:GetCurrentDestination()
    return self.wave.waveManager:GetDestinationByIndex(self.destinationIndex)
end
--Is Called when the unit reaches the final destination
function Unit:RemoveLife()
    for _, p in pairs(self.wave.waveManager.players) do
        p:Damage(self.wave.waveType.damage)
    end
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
function Timer:Create(duration,isPeriodic,ExpiredFunc,...)
    local this = {}
    this.this = CreateTimer()
    this.arg = {...}
    self.__index = self
    setmetatable(this, self)
    TDTK.collection.timer[this.this] = this
    TimerStart(this.this, duration, isPeriodic, ExpiredFunc)
    return this
end
function Timer:Remove()
    DestroyTimer(self.this)
    TDTK.collection.timer[self] = nil
end
------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
Util.WarningToPlayer = function(text,player)
    DisplayTimedTextToPlayer(player, 0, 0, 2, "|cffe6be00"..tostring(text).."|r")
    local sound = "Sound\\Interface\\Error.flac"
    if GetLocalPlayer() ~= player then
        sound = ""
    end
    PlaySound(sound)
end
Util.Error = function(text)
    DisplayTextToForce( GetPlayersAll(),"|cffff0000"..tostring(text).."|r" )
end
Util.EmbedToString = function(txt,...)
    local arg = {...}
    local newTxt = tostring(txt)
    for i, var in ipairs(arg) do
        newTxt = string.gsub(newTxt,[[${]]..tostring(i)..[[}]], tostring(var))
    end
    return newTxt
end