chore: init

src/ReplicatedStorage/Shared/ChunkManager/init.lua

@@ -0,0 +1,232 @@
+local ChunkManager = {}
+
+local RunService = game:GetService("RunService")
+
+local Chunk = require("./ChunkManager/Chunk")
+local BlockManager = require("./ChunkManager/BlockManager")
+local ChunkBuilder = require("./ChunkManager/ChunkBuilder")
+
+local remote = game:GetService("ReplicatedStorage"):WaitForChild("RecieveChunkPacket")
+local tickremote = game:GetService("ReplicatedStorage"):WaitForChild("Tick")
+
+local ChunkFolder = Instance.new("Folder")
+ChunkFolder.Name = "$blockscraft_client"
+
+ChunkManager.ChunkFolder = ChunkFolder
+
+local CHUNK_RADIUS = 5
+local LOAD_BATCH = 8
+local FORCELOAD_CHUNKS = {
+	{0, 1, 0}
+}
+
+local unloadingChunks = {}
+local pendingChunkRequests = {}
+
+local CHUNK_OFFSETS = {}
+do
+	for y = -CHUNK_RADIUS, CHUNK_RADIUS do
+		for x = -CHUNK_RADIUS, CHUNK_RADIUS do
+			for z = -CHUNK_RADIUS, CHUNK_RADIUS do
+				table.insert(CHUNK_OFFSETS, {x, y, z, (x * x) + (y * y) + (z * z)})
+			end
+		end
+	end
+	table.sort(CHUNK_OFFSETS, function(a, b)
+		return a[4] < b[4]
+	end)
+end
+
+local function Swait(l)
+	task.synchronize()
+	for _ = 1, l do
+		RunService.Stepped:Wait()
+	end
+end
+
+function ChunkManager:GetChunk(x, y, z)
+	local key = `{x},{y},{z}`
+	if Chunk.AllChunks[key] then
+		return Chunk.AllChunks[key]
+	end
+
+	if pendingChunkRequests[key] then
+		task.synchronize()
+		while pendingChunkRequests[key] do
+			task.wait()
+		end
+		return Chunk.AllChunks[key]
+	end
+
+	task.synchronize()
+	pendingChunkRequests[key] = true
+	local ok, data = pcall(function()
+		return remote:InvokeServer(x, y, z)
+	end)
+	if not ok then
+		data = {}
+	end
+	task.synchronize()
+	local ch = Chunk.from(x, y, z, data)
+	Chunk.AllChunks[key] = ch
+	pendingChunkRequests[key] = nil
+	return ch
+end
+
+local function ensureNeighboringChunksLoaded(x, y, z)
+	local offsets = {
+		{1, 0, 0}, {-1, 0, 0},
+		{0, 1, 0}, {0, -1, 0},
+		{0, 0, 1}, {0, 0, -1}
+	}
+
+	for _, offset in ipairs(offsets) do
+		local nx, ny, nz = x + offset[1], y + offset[2], z + offset[3]
+		ChunkManager:GetChunk(nx, ny, nz):Tick()
+	end
+end
+
+function ChunkManager:LoadChunk(x, y, z)
+	local key = `{x},{y},{z}`
+	if unloadingChunks[key] or not Chunk.AllChunks[key] or Chunk.AllChunks[key].loaded then
+		return
+	end
+
+	unloadingChunks[key] = true
+	task.defer(function()
+		task.desynchronize()
+		ensureNeighboringChunksLoaded(x, y, z)
+
+		local chunk = Chunk.AllChunks[key]
+		if not chunk then
+			chunk = ChunkManager:GetChunk(x, y, z)
+			Chunk.AllChunks[key] = chunk
+		end
+
+		task.synchronize()
+		local instance = ChunkBuilder:BuildChunk(chunk, ChunkFolder)
+		chunk.instance = instance
+		chunk.loaded = true
+		unloadingChunks[key] = nil
+	end)
+end
+
+function ChunkManager:ForceTick()
+	for _, coords in ipairs(FORCELOAD_CHUNKS) do
+		local key = `{coords[1]},{coords[2]},{coords[3]}`
+		local chunk = Chunk.AllChunks[key]
+		if not chunk then
+			ChunkManager:LoadChunk(coords[1], coords[2], coords[3])
+		else
+			chunk:Tick()
+		end
+	end
+end
+
+function ChunkManager:TickI()
+	for key, chunk in pairs(Chunk.AllChunks) do
+		if tick() - chunk.inhabitedTime <= 5 then
+			tickremote:FireServer(key)
+		end
+	end
+end
+
+function ChunkManager:Tick()
+	ChunkManager:ForceTick()
+	local player = game:GetService("Players").LocalPlayer
+	if not player.Character then
+		return
+	end
+
+	local pos = player.Character:GetPivot().Position
+	local chunkPos = {
+		x = math.round(pos.X / 32),
+		y = math.round(pos.Y / 32),
+		z = math.round(pos.Z / 32)
+	}
+
+	task.defer(function()
+		local processed = 0
+		for _, offset in ipairs(CHUNK_OFFSETS) do
+			local cx, cy, cz = chunkPos.x + offset[1], chunkPos.y + offset[2], chunkPos.z + offset[3]
+			local chunk = ChunkManager:GetChunk(cx, cy, cz)
+			chunk.inhabitedTime = tick()
+			if not chunk.loaded then
+				ChunkManager:LoadChunk(cx, cy, cz)
+				processed += 1
+				if processed % LOAD_BATCH == 0 then
+					Swait(1)
+				end
+			end
+		end
+	end)
+	
+	--[[
+	task.defer(function()
+		for y = 0, 2 do
+			task.defer(function()
+				for x = -CHUNK_RADIUS, CHUNK_RADIUS do
+					task.desynchronize()
+					for z = -CHUNK_RADIUS, CHUNK_RADIUS do
+						local cx, cy, cz = chunkPos.x + x, y, chunkPos.z + z
+						local key = `{cx},{cy},{cz}`
+						local chunk = ChunkManager:GetChunk(cx, cy, cz)
+						chunk.inhabitedTime = tick()
+						if not chunk.loaded then
+							ChunkManager:LoadChunk(cx, cy, cz)
+							Swait(2)
+						end
+					end
+					task.synchronize()
+				end
+			end)
+			Swait(10)
+		end
+	end)
+	--]]
+
+	for key, loadedChunk in pairs(Chunk.AllChunks) do
+		if tick() - loadedChunk.inhabitedTime > 15 and not unloadingChunks[key] then
+			unloadingChunks[key] = true
+			task.defer(function()
+				task.synchronize()
+				loadedChunk:Unload()
+				loadedChunk:Destroy()
+				Chunk.AllChunks[key] = nil
+				unloadingChunks[key] = nil
+			end)
+		end
+	end
+end
+
+function ChunkManager:Init()
+	if not RunService:IsClient() then
+		error("ChunkManager:Init can only be called on the client")
+	end
+
+	ChunkFolder.Parent = game:GetService("Workspace")
+	ChunkManager:ForceTick()
+
+	task.defer(function()
+		while true do
+			wait(2)
+			ChunkManager:TickI()
+		end
+	end)
+
+	task.defer(function()
+		while true do
+			task.defer(function()
+				local success, err = pcall(function()
+					ChunkManager:Tick()
+				end)
+				if not success then
+					warn("[CHUNKMANAGER]", err)
+				end
+			end)
+			Swait(20)
+		end
+	end)
+end
+
+return ChunkManager