function OnTick()
	if not isuserauthed then return end
    if not ANNloaded then return end
    if not Allloaded then return end
	local current_tick = GetTickCount()


	if Config.On then
		if ANN == nil then return end
		for enemy_networkID, visible_time in pairs(visibleDB) do
			--Store waypoints
			local hero = GetHeroByNetworkID(enemy_networkID)
			local current_waypoint = {time = GetTickCount(), x = hero.visionPos.x, y = hero.visionPos.z}
			table.insert(stored_waypoints[enemy_networkID], current_waypoint)
			for idx, val in ipairs(stored_waypoints[enemy_networkID]) do
				if GetTickCount() - stored_waypoints[enemy_networkID][idx]["time"] > 1400 then
					table.remove(stored_waypoints[enemy_networkID], idx)
				else
					break
				end
			end
			--Store training data
			if dataDB[enemy_networkID] ~= nil and current_tick - visible_time >= Config.TickLimiter and GetTickCount() - dataDB[enemy_networkID]["last_cached_time"] >= 200 then

				--cache current position
				table.insert(dataDB[enemy_networkID]["movement_table"], hero.visionPos.x)
				table.insert(dataDB[enemy_networkID]["movement_table"], hero.visionPos.z)
				if dataDB[enemy_networkID]["last_cached_time"] ~= nil and dataDB[enemy_networkID]["last_cached_time"] ~= 0 then
					CacheDelta = CacheDelta + (GetTickCount() - dataDB[enemy_networkID]["last_cached_time"])
				end
				dataDB[enemy_networkID]["last_cached_time"] = GetTickCount()
				NumCaches = NumCaches + 1

				--see if it's able to be predicted
				if #dataDB[enemy_networkID]["movement_table"] == 12 then
					dataDB[enemy_networkID]["last_predict_time"] = GetTickCount()
				end

				--see if movement table is too large
				while #dataDB[enemy_networkID]["movement_table"] >= 24 do
					a = table.remove(dataDB[enemy_networkID]["movement_table"], 1)
					b = table.remove(dataDB[enemy_networkID]["movement_table"], 1)
				end

				--after pruning, see if it's stable for caching
				if #dataDB[enemy_networkID]["movement_table"] == 22 then
					dataDB[enemy_networkID]["last_stable_time"] = GetTickCount()
				end


				--cache future waypoint
				local current_waypoints = {}
				table.insert(current_waypoints, Vector(hero.visionPos.x, myHero.y, hero.visionPos.z))
				for i = hero.pathIndex, hero.pathCount do
					path = hero:GetPath(i)
					if path ~= nil and path.x then
						table.insert(current_waypoints, Vector(path.x, myHero.y, path.z))
					end
				end

				table.insert(dataDB[enemy_networkID]["waypoint_table"], {x = current_waypoints[#current_waypoints].x, y = current_waypoints[#current_waypoints].z})
				if #dataDB[enemy_networkID]["waypoint_table"] > 11 then
					table.remove(dataDB[enemy_networkID]["waypoint_table"], 1)
				end



				--See VP Predicted Pos and cache it
				if hero ~= nil then
					local to_push_table = {}
					for idx, val in ipairs(delay_table) do
						local _, _, pred_pos = VP:GetPredictedPos(hero, val - (0.07 + GetLatency() / 2000), math.huge, myHero, false)
						table.insert(to_push_table, pred_pos.x)
						table.insert(to_push_table, pred_pos.z)
					end
					table.insert(dataDB[enemy_networkID]["vpred_table"], to_push_table)
                    if Config.Debug then
                        print('Pushed to VPred table!')
                    end
				end

				if #dataDB[enemy_networkID]["vpred_table"] > 11 then
					table.remove(dataDB[enemy_networkID]["vpred_table"], 1)
				end
				--print('Learning complete!')


				dataDB[enemy_networkID]["has_learned"] = false
			--Utilize training data
			elseif dataDB[enemy_networkID] ~= nil and current_tick - visible_time >= 2100 and not dataDB[enemy_networkID]["has_learned"] and #dataDB[enemy_networkID]["waypoint_table"] >= 11 and GetTickCount() - dataDB[enemy_networkID]["last_stable_time"] >= 0 and #dataDB[enemy_networkID]["movement_table"] >= 22 then
				--normalize results
                if Config.Debug then
                    print('Entering learning phase!')
                end
				local copy_of_movement_table = dataDB[enemy_networkID]["movement_table"]
				local hero = GetHeroByNetworkID(enemy_networkID)
				local hero = GetHeroByNetworkID(enemy_networkID)
				local temp_db = {}
				for i = 1, 10, 1 do
					a = table.remove(copy_of_movement_table, 1)
                      if i % 2 == 0 then
                        a = normalize_valuey(a)
                      else
                        a = normalize_valuex(a)
                      end
					table.insert(temp_db, a)
				end

				local x = table.remove(copy_of_movement_table, 1)
				local y = table.remove(copy_of_movement_table, 1)
				local copy_table = copy_of_movement_table
				for idx, value in ipairs(copy_table) do
                  if idx % 2 == 0 then
                    value = normalize_valuey(value)
                  else
                    value = normalize_valuex(value)
                  end
					copy_table[idx] = value
				end

				table.insert(temp_db, normalize_valuex(x))
				table.insert(temp_db, normalize_valuey(y))
				table.insert(temp_db, normalize_valuex(dataDB[enemy_networkID]["waypoint_table"][6].x))
				table.insert(temp_db, normalize_valuey(dataDB[enemy_networkID]["waypoint_table"][6].y))




				--print(#temp_db)
				--print(temp_db)
				--print(#dataDB[enemy_networkID]["movement_table"])
				if temp_db ~= nil and #copy_table ~= nil and #temp_db == 14 and #copy_table == 10 then
                    local concat_string = table.concat(temp_db, ",")
                    local concat_string2 = table.concat(copy_table, ",")
                    --file2connector:write(concat_string .. "\t" .. concat_string2 .. "\n")
					ANN:backwardPropagate(temp_db, copy_table)
					--print("Backward propagated!")
					if dataDB[enemy_networkID]["last_learn_time"] ~= nil and dataDB[enemy_networkID]["last_learn_time"] ~= 0 then
						LearnDelta = LearnDelta + (GetTickCount() - dataDB[enemy_networkID]["last_learn_time"])
						NumLearn = NumLearn + 1
					end
					dataDB[enemy_networkID]["has_learned"] = true
					dataDB[enemy_networkID]["last_learn_time"] = GetTickCount()
				end


				--lastly compute error post caching.
				if dataDB[enemy_networkID]["vpred_table"] ~= nil and #dataDB[enemy_networkID]["vpred_table"] >= 11 then
                    if Config.Debug then
                        print('Analyzing vpred error!')
                    end
					local vpred_compute_table = dataDB[enemy_networkID]["vpred_table"][6]
					local ANN_compute_table = ANN:forwardPropagate(temp_db)
					local temp_vpred_error, temp_ANN_error = CalculateError(vpred_compute_table, ANN_compute_table, copy_table)
					if temp_vpred_error ~= nil and temp_ANN_error ~= nil and temp_vpred_error >= 0 and temp_ANN_error >= 0 then
						ANN_total_error = ANN_total_error + temp_ANN_error
						VPred_total_error = VPred_total_error + temp_vpred_error
						Error_calcs = Error_calcs + 1
                        if Config.Debug then
                            print('Vpred error analysis completed, nothing seems wrong!')
                        end
                    else
                        if Config.Debug then
                            print('CalculateError function outputs are nil!')
                        end
					end
				end

			end
		end

    if NumCaches > 5001 and NumCaches % 5000 == 0 then
        SendANN()
        --print('Autosending AI info to server')
    end

	end

    if VPred_total_error > 0 and ANN_total_error > 0 and Error_calcs > 0 then
        VPred_average_error = VPred_total_error / Error_calcs
        ANN_average_error = ANN_total_error / Error_calcs
    end

	--Dump options
	if Config.Dumpnow and GetTickCount() - LastDump > 5000 then
		DumpNow()
		LastDump = GetTickCount()
        Config.Dumpnow = false
	end
end

function CalculateError(vpred_table, ANN_table, real_table)
    if #vpred_table ~= #ANN_table then
        if Config.Debug then
            print('vpred table size not equal')
            return nil, nil
        end
    end

    if #real_table ~= #ANN_table then
        if Config.Debug then
            print('ANN table size not equal')
            return nil, nil
        end
    end

	local current_vpred_error = 0
	local current_ANN_error = 0
	for i = 1, #vpred_table, 2 do
		local vpred_point = {x=vpred_table[i], y=vpred_table[i+1]}
		local ann_point = {x = denormalizex(ANN_table[i]), y = denormalizey(ANN_table[i+1])}
		local real_point = {x = denormalizex(real_table[i]), y = denormalizey(real_table[i+1])}
		current_vpred_error = current_vpred_error + GetDistance(vpred_point, real_point)
		current_ANN_error = current_ANN_error + GetDistance(ann_point, real_point)
        if Config.Debug then
            print('CalculateError loop completed, iterating!')
        end
    end
    if current_vpred_error < 0 or current_vpred_error > 100000 then
        return nil, nil
    elseif current_ANN_error < 0 or current_ANN_error > 100000 then
        return nil, nil
    end
	return current_vpred_error, current_ANN_error
end

function normalize_valuex(value)
	if value > 14279 then
		value = 14279
	elseif value < -538 then
		value = -538
	end
	return (value+538)/(14279+538)
end

function normalize_valuey(value)
  if value > 14527 then
    value = 14527
  elseif value < -165 then
    value = -165
  end
  return (value+165)/(14527+165)
end

function denormalizex(value)
	if value > 1 or value < 0 then return end
	value = (value * 14279) - 538
	return value
end

function denormalizey(value)
  if value > 1 or value < 0 then return end
  value = (value * 14527) - 165
  return value
end

function round(num, idp)
	return string.format("%." .. (idp or 0) .. "f", num)
end