@name 
@persist [Wirelinks Usage Production]:table
@persist RemovalFilter:string Filter:table
@persist FoundEntities:array MaxEntities SortNum LinkNum
@persist ResourceNode:entity MultCap

@model models/bull/various/gyroscope.mdl
if(duped())
{
    reset()
}
if(first()|dupefinished())
{
    Disable = owner():lastSaid()=="disable"
    entity():setMaterial("Models/effects/splodearc_sheet")
    entity():setColor(vec(0,255,0))
    MultCap = 20
    ######################################################################################################
    ############################---START OF GENERATOR CONSTANTS---########################################
    ######################################################################################################
    #Water Pump
    Usage["generator_liquid_water models/chipstiks_ls3_models/largeh2opump/largeh2opump.mdl",number]=172
    Production["generator_liquid_water models/chipstiks_ls3_models/largeh2opump/largeh2opump.mdl",number]=464
    
    Usage["generator_liquid_water models/ce_ls3additional/water_pump/water_pump.mdl",number]=33
    Production["generator_liquid_water models/ce_ls3additional/water_pump/water_pump.mdl",number]=259
    
    Usage["generator_liquid_water models/props_phx/life_support/gen_water.mdl",number]=13
    Production["generator_liquid_water models/props_phx/life_support/gen_water.mdl",number]=97
    
    #----Heavy Water Electrolyzer-----#
    
    Usage["generator_liquid_hvywater models/ce_ls3additional/water_heater/water_heater.mdl",number]=81
    Production["generator_liquid_hvywater models/ce_ls3additional/water_heater/water_heater.mdl",number]=80
    
    Usage["generator_liquid_hvywater models/chipstiks_ls3_models/nitrogenliquifier/nitrogenliquifier.mdl",number]=84
    Production["generator_liquid_hvywater models/chipstiks_ls3_models/nitrogenliquifier/nitrogenliquifier.mdl",number]=83
    
    Usage["generator_liquid_hvywater models/props_wasteland/laundry_washer003.mdl",number]=350
    Production["generator_liquid_hvywater models/props_wasteland/laundry_washer003.mdl",number]=345
    
    #----Steam Turbine-----#
    
    Usage["generator_energy_steam_turbine models/ce_ls3additional/water_heater/water_heater.mdl",number]=31
    Production["generator_energy_steam_turbine models/ce_ls3additional/water_heater/water_heater.mdl",number]=278
    
    #----Water Air Extractor-----#
    
    Usage["generator_gas_o2h_water models/ce_ls3additional/water_heater/water_heater.mdl",number]=578
    Production["generator_gas_o2h_water models/ce_ls3additional/water_heater/water_heater.mdl",number]=289
    
    Usage["generator_gas_o2h_water models/ce_ls3additional/water_air_extractor/water_air_extractor.mdl",number]=117
    Production["generator_gas_o2h_water models/ce_ls3additional/water_air_extractor/water_air_extractor.mdl",number]=59
    
    Usage["generator_gas_o2h_water models/lifesupport/generators/waterairextractor.mdl",number]=250
    Production["generator_gas_o2h_water models/lifesupport/generators/waterairextractor.mdl",number]=125
    ######################################################################################################
    #############################---END OF GENERATOR CONSTANTS---#########################################
    ######################################################################################################
    
    
    ##User Defined Functions
    function wirelink createWL(Ent:entity)
    {
        Ent:makeWirelink()
        return Ent:getWirelink()
    }
    function void generatorControl(WL:wirelink, On:number)
    {
        WL["On",number]=On
    }
    function void generatorControl(WL:wirelink, On:number, Mult:number)
    {
        WL["On",number]=On
        WL["Multiplier",number]=Mult
    }
    function void addWirelink(Index:string,E:entity)
    {
        Wirelinks[Index,wirelink] = createWL(E)
        Wirelinks[Index,wirelink]["Mute",number] = 1
        #Wirelinks[Index,wirelink]["Overdrive",number] = 1
    }
    function void makeTable(IndexPrefix:string,Values:array,Limit:number)
    {
        Table = table()
        for(I=1,Values:count())
        {
            Table[Values[I,string],number] = Limit
        }
        Filter[IndexPrefix+" table",table] = Table
        Filter[IndexPrefix,string] = IndexPrefix
    }
    function void setUsage()
    {
        foreach(K,V:wirelink=Wirelinks)
        {
            TempEnt = V:entity()
            Usage[TempEnt:type(),number] = Usage[TempEnt:type()+" "+TempEnt:model(),number]
            Production[TempEnt:type(),number] = Production[TempEnt:type()+" "+TempEnt:model(),number]
        }
    }
    function void generatorManage(Docked:number)
    {
        local Node = Wirelinks["node",wirelink]
        local Resources = Wirelinks["storage_cache",wirelink]
        
        local Energy = Resources["Energy",number]
        local MaxEnergy = Resources["Max Energy",number]
        
        local Water = Resources["Water",number]
        local MaxWater = Resources["Max Water",number]
        
        local Steam = Resources["Steam",number]
        local MaxSteam = Resources["Max Steam",number]
        
        local Oxygen = Resources["Oxygen",number]
        local MaxOxygen = Resources["Max Oxygen",number]
        
        local Hydrogen = Resources["Hydrogen",number]
        local MaxHydrogen = Resources["Max Hydrogen",number]
        
        local HeavyWater = Resources["Hvy Water",number]
        local MaxHeavyWater = Resources["Max Hvy Water",number]
        
        local Capacitor = Node["Capacitor",number]
        local MaxCapacitor = Node["Max Capacitor",number]
        
        foreach(K,V:wirelink=Wirelinks)
        {
            K = K:explode(" ")[1,string]
            local Use = Usage[K,number]
            local Make = Production[K,number]
            switch(K)
            {
                case "generator_liquid_water",
                    On=(Docked) 
                        ? (Energy>5) & (Water<MaxWater*0.95)
                        : 0
                    
                    Mult=min(Energy/(Use*1.75),(MaxWater-Water)/(1.05*Make),MultCap)
                    generatorControl(V,On,Mult)
                    break
                    
                case "generator_liquid_hvywater",
                    On=(Docked) 
                        ? (Energy>15) & (Water>50) & ((Steam<MaxSteam*0.95) | HeavyWater<MaxHeavyWater*0.9)
                        : ((Energy>MaxEnergy*0.1) & (Water>MaxWater*0.25)) & ((Steam<MaxSteam*0.7) | HeavyWater<MaxHeavyWater*0.1)
                        
                    Mult=min(Energy/(Use*0.6),Water/(Use*1.1),max((MaxSteam-Steam)/(1.5*Make),MaxHeavyWater-HeavyWater),MultCap)
                    generatorControl(V,On,Mult)
                    break
                    
                case "generator_energy_steam_turbine",
                    On=(Docked) 
                        ? ((Energy<MaxEnergy*0.985) & (Steam>2))
                        : (((Energy < MaxEnergy*0.7) | Water<MaxWater*0.05) & (Steam>0))
                        
                    Mult=min(Steam/(Use*1.15),max(((MaxEnergy-Energy)/(1.5*Make)),(MaxWater-Water)/(1.5*Use)),MultCap)
                    generatorControl(V,On,Mult)
                    break
                
                case "generator_gas_o2h_water",
                    On=(Docked) 
                        ? (Energy>min(MaxEnergy*0.1,50000)) & (Oxygen<MaxOxygen|Hydrogen<MaxHydrogen) & (Water>MaxWater*0.1|Water>500000)
                        : ((Energy>min(MaxEnergy*0.1,50000)) & (Water>min(MaxWater*0.1,10000))) & (Oxygen<min(MaxOxygen*0.1,10000))
                        
                    Mult=min(Water/(Use*6),max((MaxOxygen-Oxygen)/(1.5*Make),(MaxHydrogen-Hydrogen)/(1.5*Make*2)),MultCap)
                    generatorControl(V,On,Mult)
                    break
                case "generator_energy_fusion",
                    On = ((Energy<MaxEnergy*0.15) | (Capacitor<MaxCapacitor*0.9)) & (HeavyWater>min(MaxHeavyWater*0.05,200))
                    generatorControl(V,On)
                    break
                default,
                    break
            }
        }
    }
    #End Functions
    makeTable("LifeSupport",array("generator_liquid_hvywater","generator_energy_steam_turbine","generator_gas_o2h_water"),1)
    
    makeTable("FusionGenerators",array("generator_energy_fusion"),4)
    
    makeTable("Storage",array("storage_cache"),1)
    
    RemovalFilter = "prop wire gmod func"
    
    FoundEntities = entity():getConstraints()
    MaxEntities = FoundEntities:count()
    
    local Const=invert(FoundEntities)
    local Concat=Const:keys():concat(" ")
    local FoundCore = Concat:find("ship_core")
    
    if(MaxEntities>3 & !Disable & FoundCore)
    {
        SortNum = 1
        runOnTick(1)
    }
    else
    {
        if(!FoundCore)
        {
            setName("Disabled - No ship / no core detected.")
        }
        else
        {
            setName("Disabled - No ship detected or dupe is still in progress.")
        }
    }
}
while(perf() & SortNum <= MaxEntities)
{
    local SortedEnt = FoundEntities[SortNum,entity]
    local Class = SortedEnt:type()
    
    if(RemovalFilter:find(Class:left(4)))
    {
        FoundEntities:remove(SortNum)
        SortNum--
    }
    elseif(Class == "generator_liquid_water")
    {
        addWirelink(Class,SortedEnt)
    }
    elseif(Class == "ship_core")
    {
        
        if((SortedEnt:rdNodeSize()>=ResourceNode:rdNodeSize()  & SortedEnt:pos():distance(entity():pos()) < ResourceNode:pos():distance(entity():pos()))| !ResourceNode)
        {
            addWirelink("node",SortedEnt)
            ResourceNode = SortedEnt
            #print(toString(ResourceNode)+"asdf")
            FoundEntities:remove(SortNum)
            SortNum--
        }
    }
    else
    {
        foreach(K,V:table=Filter)
        {
            if(V:exists(Class))
            {
                if(V[Class,number] == 1)
                {
                    V:remove(Class)
                    addWirelink(Class,SortedEnt)
                }
                else
                {
                    V[Class,number] = V[Class,number] - 1
                    addWirelink(Class + " " + toString(SortedEnt:id()),SortedEnt)
                }
                
            }
        }
    }
    
    MaxEntities=FoundEntities:count()
    SortNum++
    
    if(SortNum > MaxEntities)
    {
        Name=""
        foreach(K,V:string=Filter)
        {
            if(Filter[V+" table",table]:count()==0)
            {
                Name = Name + V + " "
            }
            else
            {
                Filter:remove(K)
            }
        }
        setName(Name)
        if(ResourceNode)
        {
            LinkNum = 1
            MaxEntities = FoundEntities:count()
        }
    }
}
while(perf() & LinkNum > 0 & LinkNum <= MaxEntities)
{
    LinkedEnt=FoundEntities[LinkNum,entity]
    if(LinkedEnt:rdNetID()==0 & LinkedEnt:pos():distance(ResourceNode:pos()) <= ResourceNode:rdNodeSize())
    {
        LinkedEnt:link(ResourceNode)
    }
    LinkNum++
    
    if(LinkNum>MaxEntities)
    {
        runOnTick(0)
        runOnRDTick(1)
        setUsage()
    }
}
if(Filter:exists("LifeSupport") & !Wirelinks:exists("generator_liquid_water"))
{
    findIncludeClass("generator_liquid_water")
    Found=findInSphere(ResourceNode:pos(),ResourceNode:rdNodeSize())
    if(Found>0)
    {
        FoundPumps=findToArray()
        for(I=1,FoundPumps:count())
        {
            TempEnt=FoundPumps[I,entity]
            Const=invert(TempEnt:getConstraints())
            Concat=Const:keys():concat(" ")
            if(TempEnt:owner() == owner() & Concat:find("resource_node") == 0 & Concat:find("ship_core") == 0)
            {
                TempEnt:link(ResourceNode)
                addWirelink(TempEnt:type(),TempEnt)
                setUsage()
                break
            }
        }
    }
}   
elseif(Filter:exists("LifeSupport"))
{
    Pump=Wirelinks["generator_liquid_water",wirelink]
    if( !Pump:entity() | Pump:entity():pos():distance(ResourceNode:pos())>ResourceNode:rdNodeSize())
    {
        Wirelinks:remove("generator_liquid_water")
    }
}
Docked=Wirelinks["generator_liquid_water",wirelink]:entity():isUnderWater()
generatorManage(Docked)