hotbar: wrap

.gitignore

@@ -1 +1,2 @@
 Packages/
+ServerPackages/

ReplicatedFirst/ClientBootstrap.client.lua

@@ -0,0 +1,13 @@
+--!native
+--!optimize 2
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+if not game:IsLoaded() then
+	game.Loaded:Wait()
+end
+
+local Bootstrap = require(ReplicatedStorage:WaitForChild("Client"):WaitForChild("Bootstrap"))
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+Bootstrap.start()

ReplicatedStorage/Client/Bootstrap.lua

@@ -0,0 +1,83 @@
+--!native
+--!optimize 2
+
+local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local LoadingScreen = require(ReplicatedStorage.Client.LoadingScreen)
+local ModLoader = require(ReplicatedStorage.Shared.ModLoader)
+local ChunkManager = require(ReplicatedStorage.Shared.ChunkManager)
+local PlacementManager = require(ReplicatedStorage.Shared.PlacementManager)
+
+local Bootstrap = {}
+
+local started = false
+
+local function ensureFlag(name: string)
+	local objects = ReplicatedStorage:WaitForChild("Objects")
+	local existing = objects:FindFirstChild(name)
+	if existing and existing:IsA("BoolValue") then
+		return existing
+	end
+	local ready = Instance.new("BoolValue")
+	ready.Name = name
+	ready.Value = true
+	ready.Parent = objects
+	return ready
+end
+
+local contentProvider = game:GetService("ContentProvider")
+
+local function waitForGameLoaded()
+	if game:IsLoaded() then
+		return
+	end
+	game.Loaded:Wait()
+end
+
+function Bootstrap.start()
+	if started then
+		return
+	end
+	started = true
+
+	contentProvider:PreloadAsync(game:GetDescendants())
+	
+	ensureFlag("ClientReady")
+	local screen = LoadingScreen.mount()
+
+	screen.setStatus("Connecting...")
+	screen.setDetail("Waiting for server")
+	screen.setProgress(0.2)
+
+	task.wait(1)
+
+	waitForGameLoaded()
+
+	local modsFolder = ReplicatedStorage:WaitForChild("Mods")
+	local totalMods = #modsFolder:GetChildren()
+	local modProgressWeight = 0.6
+
+	ModLoader.loadModsC(function(index, total, modInstance, success)
+		total = total > 0 and total or math.max(totalMods, 1)
+		local ratio = index / total
+		screen.setStatus(`Modloading progress: {index}/{total}`)
+		screen.setDetail(`Loading {modInstance.Name}`)
+		screen.setProgress(0.05 + ratio * modProgressWeight)
+		if not success then
+			screen.setDetail(`Failed loading {modInstance.Name}; continuing`)
+		end
+	end)
+
+	ensureFlag("CSMLLoaded") -- needed
+
+	screen.setStatus("Joining world...")
+	screen.setDetail("Syncing with server")
+	screen.setProgress(0.7)
+
+	task.wait(0.5)
+
+	screen.close()
+end
+
+return Bootstrap

ReplicatedStorage/Client/LoadingScreen/App.lua

@@ -0,0 +1,70 @@
+--!native
+--!optimize 2
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Roact = require(ReplicatedStorage.Packages.roact)
+
+local ProgressBar = require(script.Parent.Components.ProgressBar)
+
+local theme = {
+	background = Color3.fromRGB(17, 17, 27),
+	text = Color3.fromRGB(255, 255, 255),
+	subtext = Color3.fromRGB(205, 214, 244),
+}
+
+local function LoadingScreen(props)
+	local status = props.status or "Loading game..."
+	local detail = props.detail or "Preloading..."
+	local progress = props.progress or 0
+	local visible = props.visible
+
+	return Roact.createElement("ScreenGui", {
+		Name = "LoadingScreen",
+		DisplayOrder = 9999,
+		IgnoreGuiInset = true,
+		ResetOnSpawn = false,
+		ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
+		Enabled = visible ~= false,
+	}, {
+		Root = Roact.createElement("Frame", {
+			Size = UDim2.fromScale(1, 1),
+			BackgroundColor3 = theme.background,
+			BorderSizePixel = 0,
+		}, {
+			Title = Roact.createElement("TextLabel", {
+				AnchorPoint = Vector2.new(0.5, 0.5),
+				Position = UDim2.new(0.5, 0, 0.5, 0),
+				BackgroundTransparency = 1,
+				Font = Enum.Font.Code,
+				Text = status,
+				TextColor3 = theme.text,
+				TextSize = 32,
+				TextWrapped = true,
+				AutomaticSize = Enum.AutomaticSize.XY,
+				TextXAlignment = Enum.TextXAlignment.Center,
+				TextYAlignment = Enum.TextYAlignment.Center,
+			}, {
+				Gradient = Roact.createElement("UIGradient", {
+					Color = ColorSequence.new({
+						ColorSequenceKeypoint.new(0, Color3.fromRGB(245, 194, 231)),
+						ColorSequenceKeypoint.new(0.5, Color3.fromRGB(203, 166, 247)),
+						ColorSequenceKeypoint.new(1, Color3.fromRGB(137, 180, 250)),
+					}),
+					Rotation = 30,
+					Transparency = NumberSequence.new({
+						NumberSequenceKeypoint.new(0, 0),
+						NumberSequenceKeypoint.new(1, 0),
+					}),
+				}),
+			}),
+			Progress = Roact.createElement(ProgressBar, {
+				AnchorPoint = Vector2.new(0.5, 1),
+				Position = UDim2.new(0.5, 0, 1, -32),
+				progress = progress,
+				detail = detail,
+			}),
+		}),
+	})
+end
+
+return LoadingScreen

ReplicatedStorage/Client/LoadingScreen/Components/ProgressBar.lua

@@ -0,0 +1,101 @@
+--!native
+--!optimize 2
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Roact = require(ReplicatedStorage.Packages.roact)
+
+local theme = {
+	background = Color3.fromRGB(30, 30, 46),
+	text = Color3.fromHex("#cdd6f4"),
+	holder = Color3.fromRGB(17, 17, 27),
+	fill = Color3.fromRGB(255, 255, 255),
+	stroke = Color3.fromRGB(49, 50, 68),
+	holderStroke = Color3.fromRGB(108, 112, 134),
+}
+
+local function ProgressBar(props)
+	local function progressToTransparency(v: number)
+		local p = math.clamp(v or 0, 0, 1)
+		return NumberSequence.new({
+			NumberSequenceKeypoint.new(0, 0),
+			NumberSequenceKeypoint.new(p, 0),
+			NumberSequenceKeypoint.new(p, 1),
+			NumberSequenceKeypoint.new(1, 1),
+		})
+	end
+
+	local gradientTransparency: NumberSequence
+	if typeof(props.progress) == "table" and props.progress.map then
+		gradientTransparency = props.progress:map(progressToTransparency)
+	else
+		gradientTransparency = progressToTransparency(props.progress or 0)
+	end
+
+	return Roact.createElement("Frame", {
+		Name = "ProgressBar",
+		AnchorPoint = props.AnchorPoint or Vector2.new(0.5, 1),
+		Position = props.Position or UDim2.new(0.5, 0, 1, -32),
+		Size = props.Size or UDim2.new(0, 500, 0, 32),
+		BackgroundColor3 = theme.background,
+		BorderSizePixel = 0,
+	}, {
+		Label = Roact.createElement("TextLabel", {
+			AnchorPoint = Vector2.new(0, 0),
+			Position = UDim2.new(0, 16, 0, -32),
+			Size = UDim2.new(1, -32, 0, 18),
+			BackgroundTransparency = 1,
+			Font = Enum.Font.Code,
+			Text = props.detail,
+			TextColor3 = theme.text,
+			TextSize = 18,
+			TextXAlignment = Enum.TextXAlignment.Left,
+			TextYAlignment = Enum.TextYAlignment.Top,
+		}),
+		Corner = Roact.createElement("UICorner", {
+			CornerRadius = UDim.new(0, 16),
+		}),
+		Stroke = Roact.createElement("UIStroke", {
+			Color = theme.stroke,
+			ApplyStrokeMode = Enum.ApplyStrokeMode.Border,
+			Thickness = 1,
+		}),
+		FillHolder = Roact.createElement("Frame", {
+			Name = "FillHolder",
+			AnchorPoint = Vector2.new(0, 1),
+			Position = UDim2.new(0, 8, 1, -8),
+			Size = UDim2.new(1, -16, 0, 16),
+			BackgroundColor3 = theme.holder,
+			BorderSizePixel = 0,
+		}, {
+			Corner = Roact.createElement("UICorner", {
+				CornerRadius = UDim.new(0, 8),
+			}),
+			Stroke = Roact.createElement("UIStroke", {
+				Color = theme.holderStroke,
+				ApplyStrokeMode = Enum.ApplyStrokeMode.Border,
+				Thickness = 1,
+			}),
+			Fill = Roact.createElement("Frame", {
+				AnchorPoint = Vector2.new(0, 0),
+				BackgroundColor3 = theme.fill,
+				BorderSizePixel = 0,
+				Size = UDim2.new(1, 0, 1, 0),
+			}, {
+				Corner = Roact.createElement("UICorner", {
+					CornerRadius = UDim.new(0, 8),
+				}),
+				Gradient = Roact.createElement("UIGradient", {
+					Color = ColorSequence.new({
+						ColorSequenceKeypoint.new(0, Color3.fromHex("#f5c2e7")),
+						ColorSequenceKeypoint.new(0.5, Color3.fromHex("#cba6f7")),
+						ColorSequenceKeypoint.new(1, Color3.fromHex("#89b4fa")),
+					}),
+					Transparency = gradientTransparency,
+					Rotation = 0,
+				}),
+			}),
+		}),
+	})
+end
+
+return ProgressBar

ReplicatedStorage/Client/LoadingScreen/init.lua

@@ -0,0 +1,55 @@
+--!native
+--!optimize 2
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Roact = require(ReplicatedStorage.Packages.roact)
+local Players = game:GetService("Players")
+
+local App = require(script.App)
+
+local LoadingScreen = {}
+
+function LoadingScreen.mount(target: Instance?)
+	local playerGui = target or Players.LocalPlayer:WaitForChild("PlayerGui")
+	local statusBinding, setStatus = Roact.createBinding("Loading...")
+	local detailBinding, setDetail = Roact.createBinding("Preparing client")
+	local progressBinding, setProgress = Roact.createBinding(0)
+	local visibleBinding, setVisible = Roact.createBinding(true)
+
+	local handle = Roact.mount(Roact.createElement(App, {
+		status = statusBinding,
+		detail = detailBinding,
+		progress = progressBinding,
+		visible = visibleBinding,
+	}), playerGui, "RoactLoadingScreen")
+
+	local closed = false
+	local function close()
+		if closed then
+			return
+		end
+		closed = true
+		setVisible(false)
+		Roact.unmount(handle)
+		handle = nil
+	end
+
+	return {
+		setStatus = function(text: string)
+			setStatus(text)
+		end,
+		setDetail = function(text: string)
+			setDetail(text)
+		end,
+		setProgress = function(value: number)
+			setProgress(math.clamp(value or 0, 0, 1))
+		end,
+		show = function()
+			setVisible(true)
+		end,
+		hide = close,
+		close = close,
+	}
+end
+
+return LoadingScreen

ReplicatedStorage/Shared/ChunkManager/Chunk.lua

@@ -196,6 +196,19 @@ function Chunk:Unload()
 	end)
 end
 
+function Chunk:UnloadImmediate()
+	self.loaded = false
+	pcall(function()
+		self.unloadChunkHook()
+	end)
+	pcall(function()
+		if self.instance then
+			self.instance.Parent = nil
+			self.instance:Destroy()
+		end
+	end)
+end
+
 -- DO NOT INTERACT WITH CHUNK AFTER CALLING THIS
 function Chunk:Destroy() 
 	self.data = {}	

ReplicatedStorage/Shared/ChunkManager/init.lua

@@ -13,6 +13,7 @@ local Globals = require(script.Parent:WaitForChild("Globals"))
 
 local remote = game:GetService("ReplicatedStorage"):WaitForChild("RecieveChunkPacket")
 local tickremote = game:GetService("ReplicatedStorage"):WaitForChild("Tick")
+local Players = game:GetService("Players")
 
 local ChunkFolder = Instance.new("Folder")
 ChunkFolder.Name = "$blockscraft_client"
@@ -23,7 +24,7 @@ local CHUNK_RADIUS = Globals.RenderDistance or 5
 local LOAD_BATCH = Globals.LoadBatch or 8
 local RESYNC_INTERVAL = Globals.ResyncInterval or 5
 local RESYNC_RADIUS = Globals.ResyncRadius or 2
-local DEBUG_RESYNC = true
+local DEBUG_RESYNC = false
 local FORCELOAD_CHUNKS = {
 	{0, 1, 0}
 }
@@ -31,6 +32,20 @@ local FORCELOAD_CHUNKS = {
 local unloadingChunks = {}
 local pendingChunkRequests = {}
 
+local lastChunkKey: string? = nil
+local lastHeavyTick = 0
+local HEAVY_TICK_INTERVAL = 1.5
+local lastUnloadSweep = 0
+local UNLOAD_SWEEP_INTERVAL = 3 -- slower sweep cadence
+local MAX_LOADED_CHUNKS = 0
+local SPAWN_CHUNK_KEY: string? = nil
+local playerFrozen = false
+local storedMovementState = nil
+
+local function worldToChunkCoord(v: number): number
+	return math.floor((v + 16) / 32)
+end
+
 local CHUNK_OFFSETS = {}
 do
 	for y = -CHUNK_RADIUS, CHUNK_RADIUS do
@@ -43,6 +58,27 @@ do
 	table.sort(CHUNK_OFFSETS, function(a, b)
 		return a[4] < b[4]
 	end)
+	MAX_LOADED_CHUNKS = math.max(1, math.floor(#CHUNK_OFFSETS * 2)) -- tighter cap than full render cube
+	if FORCELOAD_CHUNKS[1] then
+		local forced = FORCELOAD_CHUNKS[1]
+		SPAWN_CHUNK_KEY = `{forced[1]},{forced[2]},{forced[3]}`
+	end
+end
+
+function ChunkManager:UnloadAllNow()
+	for key, chunk in pairs(Chunk.AllChunks) do
+		unloadingChunks[key] = true
+		pcall(function()
+			if chunk.loaded then
+				chunk:UnloadImmediate()
+			end
+		end)
+		pcall(function()
+			chunk:Destroy()
+		end)
+		Chunk.AllChunks[key] = nil
+		unloadingChunks[key] = nil
+	end
 end
 
 local function Swait(l)
@@ -51,6 +87,126 @@ local function Swait(l)
 	end
 end
 
+local function setCharacterFrozen(shouldFreeze: boolean)
+	local player = Players.LocalPlayer
+	if not player then
+		return
+	end
+	local character = player.Character
+	if not character then
+		return
+	end
+	local humanoid = character:FindFirstChildOfClass("Humanoid")
+	local root = character:FindFirstChild("HumanoidRootPart")
+	if not humanoid or not root then
+		return
+	end
+	if shouldFreeze == playerFrozen then
+		return
+	end
+	if shouldFreeze then
+		if not storedMovementState then
+			storedMovementState = {
+				walkSpeed = humanoid.WalkSpeed,
+				autoRotate = humanoid.AutoRotate,
+			}
+			if humanoid.UseJumpPower then
+				storedMovementState.jumpPower = humanoid.JumpPower
+			else
+				storedMovementState.jumpHeight = humanoid.JumpHeight
+			end
+		end
+		humanoid.AutoRotate = false
+		humanoid.WalkSpeed = 0
+		if humanoid.UseJumpPower then
+			humanoid.JumpPower = 0
+		else
+			humanoid.JumpHeight = 0
+		end
+		root.Anchored = true
+	else
+		root.Anchored = false
+		if storedMovementState then
+			humanoid.AutoRotate = storedMovementState.autoRotate
+			humanoid.WalkSpeed = storedMovementState.walkSpeed
+			if humanoid.UseJumpPower and storedMovementState.jumpPower then
+				humanoid.JumpPower = storedMovementState.jumpPower
+			elseif storedMovementState.jumpHeight then
+				humanoid.JumpHeight = storedMovementState.jumpHeight
+			end
+		end
+		storedMovementState = nil
+	end
+	playerFrozen = shouldFreeze
+end
+
+local function getLocalPlayerChunkPos()
+	local player = Players.LocalPlayer
+	if not player then
+		return nil
+	end
+	local character = player.Character
+	if not character then
+		return nil
+	end
+	local root = character:FindFirstChild("HumanoidRootPart")
+	if not root then
+		return nil
+	end
+	local pos = root.Position
+	return {
+		x = worldToChunkCoord(pos.X),
+		y = worldToChunkCoord(pos.Y),
+		z = worldToChunkCoord(pos.Z)
+	}
+end
+
+local function isWithinRenderDistance(chunkPos: Vector3, centerChunkPos): boolean
+	if not centerChunkPos then
+		return false
+	end
+	return math.abs(chunkPos.X - centerChunkPos.x) <= CHUNK_RADIUS
+		and math.abs(chunkPos.Y - centerChunkPos.y) <= CHUNK_RADIUS
+		and math.abs(chunkPos.Z - centerChunkPos.z) <= CHUNK_RADIUS
+end
+
+local function shouldSkipUnload(key: string): boolean
+	return SPAWN_CHUNK_KEY ~= nil and key == SPAWN_CHUNK_KEY
+end
+
+local function scheduleChunkUnload(key: string, chunk)
+	if not chunk or unloadingChunks[key] then
+		return
+	end
+	unloadingChunks[key] = true
+	task.defer(function()
+		chunk:Unload()
+		chunk:Destroy()
+		Chunk.AllChunks[key] = nil
+		unloadingChunks[key] = nil
+	end)
+end
+
+local function evictOutOfRangeChunks(centerChunkPos)
+	if not centerChunkPos then
+		return
+	end
+	local loadedCount = 0
+	for key, loadedChunk in pairs(Chunk.AllChunks) do
+		if loadedChunk.loaded and not shouldSkipUnload(key) then
+			local inRange = isWithinRenderDistance(loadedChunk.pos, centerChunkPos)
+			if inRange then
+				loadedCount += 1
+				if loadedCount > MAX_LOADED_CHUNKS then
+					scheduleChunkUnload(key, loadedChunk)
+				end
+			else
+				scheduleChunkUnload(key, loadedChunk)
+			end
+		end
+	end
+end
+
 function ChunkManager:GetChunk(x, y, z)
 	local key = `{x},{y},{z}`
 	if Chunk.AllChunks[key] then
@@ -86,7 +242,10 @@ local function ensureNeighboringChunksLoaded(x, y, z)
 
 	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()
+		local neighbor = ChunkManager:GetChunk(nx, ny, nz)
+		if neighbor then
+			neighbor:Tick()
+		end
 	end
 end
 
@@ -110,6 +269,7 @@ function ChunkManager:LoadChunk(x, y, z)
 		chunk.instance = instance
 		chunk.loaded = true
 		unloadingChunks[key] = nil
+		evictOutOfRangeChunks(getLocalPlayerChunkPos())
 	end)
 end
 
@@ -225,33 +385,51 @@ end
 
 function ChunkManager:Tick()
 	ChunkManager:ForceTick()
-	local player = game:GetService("Players").LocalPlayer
+	local player = Players.LocalPlayer
 	if not player.Character then
 		return
 	end
 
 	local pos = player.Character:GetPivot().Position
 	local chunkPos = {
-		x = math.round(pos.X / 32),
+		x = worldToChunkCoord(pos.X),
-		y = math.round(pos.Y / 32),
+		y = worldToChunkCoord(pos.Y),
-		z = math.round(pos.Z / 32)
+		z = worldToChunkCoord(pos.Z)
 	}
+	local ck = `{chunkPos.x},{chunkPos.y},{chunkPos.z}`
+	local currentChunk = Chunk.AllChunks[ck]
+	local now = tick()
+	local shouldHeavyTick = (ck ~= lastChunkKey) or (now - lastHeavyTick >= HEAVY_TICK_INTERVAL)
+	lastChunkKey = ck
+	if shouldHeavyTick then
+		lastHeavyTick = now
+	end
 
-	task.defer(function()
+	setCharacterFrozen(not (currentChunk and currentChunk.loaded))
-		local processed = 0
+
-		for _, offset in ipairs(CHUNK_OFFSETS) do
+	if shouldHeavyTick then
-			local cx, cy, cz = chunkPos.x + offset[1], chunkPos.y + offset[2], chunkPos.z + offset[3]
+		task.defer(function()
-			local chunk = ChunkManager:GetChunk(cx, cy, cz)
+			local processed = 0
-			chunk.inhabitedTime = tick()
+			for _, offset in ipairs(CHUNK_OFFSETS) do
-			if not chunk.loaded then
+				local cx, cy, cz = chunkPos.x + offset[1], chunkPos.y + offset[2], chunkPos.z + offset[3]
-				ChunkManager:LoadChunk(cx, cy, cz)
+				local chunk = ChunkManager:GetChunk(cx, cy, cz)
-				processed += 1
+				if chunk then
-				if processed % LOAD_BATCH == 0 then
+					chunk.inhabitedTime = now
-					Swait(1)
+					if not chunk.loaded then
+						ChunkManager:LoadChunk(cx, cy, cz)
+						processed += 1
+						if processed % LOAD_BATCH == 0 then
+							Swait(1)
+						end
+					end
 				end
 			end
+		end)
+	else
+		if currentChunk then
+			currentChunk.inhabitedTime = now
 		end
-	end)
+	end
 	
 	--[[
 	task.defer(function()
@@ -275,15 +453,12 @@ function ChunkManager:Tick()
 	end)
 	--]]
 
-	for key, loadedChunk in pairs(Chunk.AllChunks) do
+	if now - lastUnloadSweep >= UNLOAD_SWEEP_INTERVAL then
-		if tick() - loadedChunk.inhabitedTime > 15 and not unloadingChunks[key] then
+		lastUnloadSweep = now
-			unloadingChunks[key] = true
+		for key, loadedChunk in pairs(Chunk.AllChunks) do
-			task.defer(function()
+			if now - loadedChunk.inhabitedTime > 30 and not unloadingChunks[key] and not shouldSkipUnload(key) then -- keep chunks around longer before unloading
-				loadedChunk:Unload()
+				scheduleChunkUnload(key, loadedChunk)
-				loadedChunk:Destroy()
+			end
-				Chunk.AllChunks[key] = nil
-				unloadingChunks[key] = nil
-			end)
 		end
 	end
 end
@@ -295,9 +470,9 @@ function ChunkManager:ResyncAroundPlayer(radius: number)
 	end
 	local pos = player.Character:GetPivot().Position
 	local chunkPos = {
-		x = math.round(pos.X / 32),
+		x = worldToChunkCoord(pos.X),
-		y = math.round(pos.Y / 32),
+		y = worldToChunkCoord(pos.Y),
-		z = math.round(pos.Z / 32)
+		z = worldToChunkCoord(pos.Z)
 	}
 	for y = -radius, radius do
 		for x = -radius, radius do
@@ -327,6 +502,12 @@ function ChunkManager:Init()
 	ChunkFolder.Parent = game:GetService("Workspace")
 	ChunkManager:ForceTick()
 
+	tickremote.OnClientEvent:Connect(function(m)
+		if m == "U_ALL" then
+			ChunkManager:UnloadAllNow()
+		end
+	end)
+
 	task.defer(function()
 		while true do
 			wait(2)

ReplicatedStorage/Shared/ClientState.lua

@@ -0,0 +1,130 @@
+--!native
+--!optimize 2
+
+local RunService = game:GetService("RunService")
+
+if RunService:IsServer() then
+	error("ClientState can only be required on the client")
+end
+
+local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local Replica = require(ReplicatedStorage.Packages.replica)
+
+local ClientState = {}
+
+local HOTBAR_SIZE = 10
+
+local localPlayer = Players.LocalPlayer
+local replicaForPlayer = nil
+local changed = Instance.new("BindableEvent")
+
+local function fireChanged()
+	changed:Fire()
+end
+
+local function onReplicaNew(replica)
+	local tags = replica.Tags or {}
+	if tags.UserId ~= localPlayer.UserId and tags.Player ~= localPlayer then
+		return
+	end
+
+	replicaForPlayer = replica
+	replica:OnChange(fireChanged)
+	fireChanged()
+end
+
+Replica.OnNew("ClientState", onReplicaNew)
+Replica.RequestData()
+
+function ClientState:IsReady(): boolean
+	return replicaForPlayer ~= nil
+end
+
+function ClientState:GetReplica()
+	return replicaForPlayer
+end
+
+function ClientState:GetSelectedSlot(): number?
+	if not replicaForPlayer then
+		return nil
+	end
+	return replicaForPlayer.Data.selectedSlot
+end
+
+local function getInventory()
+	return replicaForPlayer and replicaForPlayer.Data.inventory or nil
+end
+
+function ClientState:GetItemInfo(blockId: any)
+	if not replicaForPlayer or not blockId then
+		return nil
+	end
+	local inv = getInventory()
+	local entry = inv and inv[tostring(blockId)]
+	if not entry then
+		return nil
+	end
+
+	return {
+		id = tostring(blockId),
+		name = entry.name or tostring(blockId),
+		count = entry.count,
+	}
+end
+
+function ClientState:GetHotbarSlots(): {string}
+	if not replicaForPlayer then
+		local slots = table.create(HOTBAR_SIZE)
+		for i = 1, HOTBAR_SIZE do
+			slots[i] = ""
+		end
+		return slots
+	end
+
+	return replicaForPlayer.Data.hotbar or {}
+end
+
+function ClientState:GetSlotInfo(slot: number)
+	if not replicaForPlayer then
+		return nil
+	end
+	local hotbar = replicaForPlayer.Data.hotbar
+	if not hotbar then
+		return nil
+	end
+	local id = hotbar[slot]
+	if not id then
+		return nil
+	end
+	return ClientState:GetItemInfo(id)
+end
+
+function ClientState:GetSelectedBlock()
+	if not replicaForPlayer then
+		return nil
+	end
+	local slot = ClientState:GetSelectedSlot()
+	if not slot then
+		return nil
+	end
+	return ClientState:GetSlotInfo(slot)
+end
+
+function ClientState:SetSelectedSlot(slot: number)
+	if not replicaForPlayer then
+		return
+	end
+	local hotbar = replicaForPlayer.Data.hotbar
+	if not hotbar then
+		return
+	end
+	if slot and slot >= 1 and slot <= HOTBAR_SIZE then
+		replicaForPlayer:FireServer("SelectHotbarSlot", slot)
+	end
+end
+
+ClientState.Changed = changed.Event
+
+return ClientState

ReplicatedStorage/Shared/ModLoader.lua

@@ -31,10 +31,13 @@ function ML.loadModsS()
 	end	
 end
 
-function ML.loadModsC()
+function ML.loadModsC(onProgress: ((number, number, Instance, boolean) -> ())?)
 	print("[CSModLoader] Loading Mods")
 
-	for _, m in pairs(ModsFolder:GetChildren()) do
+	local mods = ModsFolder:GetChildren()
+	local total = #mods
+
+	for i, m in ipairs(mods) do
 		local success, reason = pcall(function()
 			-- ignore type err
 			local mod: modContext = require(m)
@@ -44,6 +47,11 @@ function ML.loadModsC()
 		if not success then
 			warn(`[CSModLoader] Error loading {m.Name}: {reason}`)
 		end
+		if onProgress then
+			pcall(function()
+				onProgress(i, total, m, success)
+			end)
+		end
 	end
 end
 

ReplicatedStorage/Shared/PlacementManager.lua

@@ -0,0 +1,711 @@
+--!native
+--!optimize 2
+
+local PlacementManager = {}
+
+local ChunkManager = require("./ChunkManager")
+local Util = require("./Util")
+
+local DEBUG_PLACEMENT = false
+local function debugPlacementLog(...: any)
+	if DEBUG_PLACEMENT then
+		Util.StudioLog(...)
+	end
+end
+
+local function debugPlacementWarn(...: any)
+	if DEBUG_PLACEMENT then
+		Util.StudioWarn(...)
+	end
+end
+
+PlacementManager.ChunkFolder = ChunkManager.ChunkFolder
+
+local raycastParams = RaycastParams.new()
+raycastParams.FilterDescendantsInstances = {PlacementManager.ChunkFolder}
+raycastParams.FilterType = Enum.RaycastFilterType.Include
+raycastParams.IgnoreWater = true
+
+local Mouse: Mouse = nil
+local lastNormalId: Enum.NormalId? = nil
+local lastRaycastFailure: string? = nil
+local lastSelectedChunkKey: string? = nil
+local lastSelectedBlockKey: string? = nil
+local duplicateResyncCooldown: {[string]: number} = {}
+local BREAK_ROLLBACK_TIMEOUT = 0.6
+local pendingBreaks = {}
+local clearSelection
+
+if _G.__BLOCKSCRAFT_PLACEMENT_MANAGER then
+	return _G.__BLOCKSCRAFT_PLACEMENT_MANAGER
+end
+_G.__BLOCKSCRAFT_PLACEMENT_MANAGER = PlacementManager
+
+PlacementManager.SelectionBox = script.SelectionBox:Clone()
+PlacementManager.SelectionBox.Name = "$SelectionBox"..(game:GetService("RunService"):IsServer() and "_SERVER" or "")
+PlacementManager.SelectionBox.Parent = game:GetService("Workspace"):FindFirstChildOfClass("Terrain")
+PlacementManager.SelectionBox.Adornee = nil
+PlacementManager.SelectionBox:GetPropertyChangedSignal("Adornee"):Connect(function()
+	local adornee = PlacementManager.SelectionBox.Adornee
+	if not adornee then
+		return
+	end
+	adornee.AncestryChanged:Connect(function(_, parent)
+		if not parent then
+			clearSelection("adornee destroyed")
+		end
+	end)
+end)
+
+-- Trash method TODO: Fix this
+local function findChunkFolderFromDescendant(inst: Instance): Instance?
+	local current = inst
+	while current and current.Parent do
+		if current.Parent == PlacementManager.ChunkFolder then
+			return current
+		end
+		-- Fallback: match by name in case the ChunkFolder reference differs (e.g. recreated/parented later)
+		if current.Parent:IsA("Folder") and current.Parent.Name == (PlacementManager.ChunkFolder and PlacementManager.ChunkFolder.Name) then
+			return current
+		end
+		current = current.Parent
+	end
+	return nil
+end
+
+local function findBlockRoot(inst: Instance, chunkFolder: Instance): Instance?
+	local current = inst
+	while current and current ~= chunkFolder do
+		if current:IsA("BasePart") then
+			return current
+		end
+		current = current.Parent
+	end
+	return nil
+end
+
+local function resolveBlockInstance(chunkFolder: Instance, chunkName: string, blockName: string): Instance?
+	local chunkInst = chunkFolder:FindFirstChild(chunkName)
+	if not chunkInst then
+		return nil
+	end
+	return chunkInst:FindFirstChild(blockName)
+end
+
+clearSelection = function(reason: string?)
+	PlacementManager.SelectionBox.Adornee = nil
+	PlacementManager.SelectionBox.Parent = nil
+	lastNormalId = nil
+	lastSelectedChunkKey = nil
+	lastSelectedBlockKey = nil
+	if reason then
+		lastRaycastFailure = reason
+	end
+end
+
+local function setSelection(target: Instance, parent: Instance)
+	PlacementManager.SelectionBox.Parent = parent
+	PlacementManager.SelectionBox.Adornee = target
+end
+
+local function findChunkAndBlock(inst: Instance): (string?, string?)
+	local root = PlacementManager.ChunkFolder
+	if not root then
+		return nil, nil
+	end
+	local current = inst
+	while current and current.Parent do
+		-- case: current parent is the chunk folder root; then current is the chunk itself (no block name yet)
+		if current.Parent == root then
+			return current.Name, inst.Name
+		end
+		-- case: grandparent is chunk folder root; parent is chunk, current is block/model
+		if current.Parent.Parent == root then
+			return current.Parent.Name, current.Name
+		end
+		current = current.Parent
+	end
+	return nil, nil
+end
+
+local function vectorToNormalId(normal: Vector3): Enum.NormalId
+	local ax, ay, az = math.abs(normal.X), math.abs(normal.Y), math.abs(normal.Z)
+	if ax >= ay and ax >= az then
+		return normal.X >= 0 and Enum.NormalId.Right or Enum.NormalId.Left
+	elseif ay >= ax and ay >= az then
+		return normal.Y >= 0 and Enum.NormalId.Top or Enum.NormalId.Bottom
+	else
+		return normal.Z >= 0 and Enum.NormalId.Back or Enum.NormalId.Front
+	end
+end
+
+local function makeChunkKey(cx: number, cy: number, cz: number): string
+	return `{cx},{cy},{cz}`
+end
+
+local function makeBlockKey(x: number, y: number, z: number): string
+	return `{x},{y},{z}`
+end
+
+local function getPendingBreak(chunkKey: string, blockKey: string)
+	local chunkMap = pendingBreaks[chunkKey]
+	if not chunkMap then
+		return nil
+	end
+	return chunkMap[blockKey]
+end
+
+local function clearPendingBreak(chunkKey: string, blockKey: string)
+	local chunkMap = pendingBreaks[chunkKey]
+	if not chunkMap then
+		return
+	end
+	chunkMap[blockKey] = nil
+	if not next(chunkMap) then
+		pendingBreaks[chunkKey] = nil
+	end
+end
+
+local function clearPendingBreaksForChunk(chunkKey: string)
+	pendingBreaks[chunkKey] = nil
+end
+
+local function scheduleBreakRollback(cx: number, cy: number, cz: number, x: number, y: number, z: number)
+	task.delay(BREAK_ROLLBACK_TIMEOUT, function()
+		local chunkKey = makeChunkKey(cx, cy, cz)
+		local blockKey = makeBlockKey(x, y, z)
+		local pending = getPendingBreak(chunkKey, blockKey)
+		if not pending then
+			return
+		end
+		clearPendingBreak(chunkKey, blockKey)
+		local chunk = ChunkManager:GetChunk(cx, cy, cz)
+		if pending.data and chunk then
+			chunk:CreateBlock(x, y, z, pending.data)
+		end
+		ChunkManager:RefreshChunk(cx, cy, cz)
+	end)
+end
+
+local function normalIdToOffset(normal: Enum.NormalId): Vector3
+	if normal == Enum.NormalId.Top then
+		return Vector3.new(0, 1, 0)
+	elseif normal == Enum.NormalId.Bottom then
+		return Vector3.new(0, -1, 0)
+	elseif normal == Enum.NormalId.Left then
+		return Vector3.new(-1, 0, 0)
+	elseif normal == Enum.NormalId.Right then
+		return Vector3.new(1, 0, 0)
+	elseif normal == Enum.NormalId.Back then
+		return Vector3.new(0, 0, 1)
+	elseif normal == Enum.NormalId.Front then
+		return Vector3.new(0, 0, -1)
+	end
+	return Vector3.new(0, 0, 0)
+end
+
+local function offsetChunkBlock(chunk: Vector3, block: Vector3, offset: Vector3)
+	local cx, cy, cz = chunk.X, chunk.Y, chunk.Z
+	local bx, by, bz = block.X + offset.X, block.Y + offset.Y, block.Z + offset.Z
+
+	if bx < 1 then
+		bx = 8
+		cx -= 1
+	elseif bx > 8 then
+		bx = 1
+		cx += 1
+	end
+
+	if by < 1 then
+		by = 8
+		cy -= 1
+	elseif by > 8 then
+		by = 1
+		cy += 1
+	end
+
+	if bz < 1 then
+		bz = 8
+		cz -= 1
+	elseif bz > 8 then
+		bz = 1
+		cz += 1
+	end
+
+	return Vector3.new(cx, cy, cz), Vector3.new(bx, by, bz)
+end
+
+local function getPlayerPosition(): Vector3?
+	local player = game:GetService("Players").LocalPlayer
+	local character = player and player.Character
+	if not character then
+		return nil
+	end
+	local root = character:FindFirstChild("HumanoidRootPart")
+	return root and root.Position or nil
+end
+
+local MAX_REACH = 512
+
+local function isWithinReach(cx: number, cy: number, cz: number, x: number, y: number, z: number): boolean
+	-- Client-side reach loosened; rely on server authority
+	return true
+end
+
+local function ensureChunkFolder(): Instance?
+	if PlacementManager.ChunkFolder and PlacementManager.ChunkFolder.Parent then
+		return PlacementManager.ChunkFolder
+	end
+	local found = workspace:FindFirstChild("$blockscraft_client")
+	if found then
+		PlacementManager.ChunkFolder = found
+		return found
+	end
+	return nil
+end
+
+-- Gets the block and normalid of the block (and surface) the player is looking at
+function PlacementManager:Raycast(skipSelection: boolean?)
+	if not Mouse then
+		Mouse = game:GetService("Players").LocalPlayer:GetMouse()
+	end
+	local chunkFolder = ensureChunkFolder()
+	if not chunkFolder then
+		if not skipSelection then
+			clearSelection("chunk folder missing")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+
+	raycastParams.FilterDescendantsInstances = {chunkFolder}
+	local cam = workspace.CurrentCamera
+	if not cam then
+		lastRaycastFailure = "no camera"
+		return
+	end
+	local ray = Mouse.UnitRay
+	local result = workspace:Raycast(ray.Origin, ray.Direction * MAX_REACH, raycastParams)
+	if not result then
+		if not skipSelection then
+			clearSelection("raycast miss")
+		end
+		script.RaycastResult.Value = nil
+		debugPlacementLog("[PLACE][CLIENT][RAYCAST]", "miss")
+		return
+	end
+
+	local objLookingAt = result.Instance
+	if not objLookingAt then
+		if not skipSelection then
+			clearSelection("raycast nil instance")
+		end
+		script.RaycastResult.Value = nil
+		debugPlacementWarn("[PLACE][CLIENT][RAYCAST]", "nil instance in result")
+		return
+	end
+
+	local hitChunkFolder = findChunkFolderFromDescendant(objLookingAt)
+	if not hitChunkFolder then
+		debugPlacementWarn(
+			"[PLACE][CLIENT][REJECT]",
+			"target not in chunk folder",
+			objLookingAt:GetFullName(),
+			"parent",
+			objLookingAt.Parent and objLookingAt.Parent:GetFullName() or "nil"
+		)
+		if not skipSelection then
+			clearSelection("target not in chunk folder")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+	if hitChunkFolder:GetAttribute("ns") == true then
+		debugPlacementWarn(
+			"[PLACE][CLIENT][REJECT]",
+			"chunk flagged ns",
+			hitChunkFolder:GetFullName()
+		)
+		if not skipSelection then
+			clearSelection("target chunk marked ns")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+	PlacementManager.ChunkFolder = chunkFolder
+
+	local blockRoot = findBlockRoot(objLookingAt, chunkFolder) or objLookingAt
+	local chunkName, blockName = findChunkAndBlock(blockRoot)
+	if not chunkName or not blockName then
+		if not skipSelection then
+			clearSelection("failed to resolve chunk/block")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+	local okChunk, chunkCoords = pcall(function()
+		return Util.BlockPosStringToCoords(chunkName)
+	end)
+	local okBlock, blockCoords = pcall(function()
+		return Util.BlockPosStringToCoords(blockName)
+	end)
+	if not okChunk or not okBlock then
+		if not skipSelection then
+			clearSelection("failed to parse chunk/block names")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+	local chunkKey = makeChunkKey(chunkCoords.X, chunkCoords.Y, chunkCoords.Z)
+	local blockKey = makeBlockKey(blockCoords.X, blockCoords.Y, blockCoords.Z)
+
+	-- block is being optimistically broken, do not highlight it
+	if getPendingBreak(chunkKey, blockKey) then
+		if not skipSelection then
+			clearSelection("block pending break")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+
+	-- hide selection if block no longer exists (air/removed)
+	local chunk = ChunkManager:GetChunk(chunkCoords.X, chunkCoords.Y, chunkCoords.Z)
+	local blockData = chunk and chunk:GetBlockAt(blockCoords.X, blockCoords.Y, blockCoords.Z)
+	if not blockData or blockData == 0 or blockData.id == 0 then
+		if not skipSelection then
+			clearSelection("block missing/air")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+	local blockInstance = resolveBlockInstance(chunkFolder, chunkName, blockName) or blockRoot
+	if not blockInstance then
+		if not skipSelection then
+			clearSelection("missing block instance")
+		end
+		script.RaycastResult.Value = nil
+		return
+	end
+
+	lastRaycastFailure = nil
+	if not skipSelection then
+		if lastSelectedChunkKey ~= chunkKey or lastSelectedBlockKey ~= blockKey then
+			setSelection(blockInstance, PlacementManager.ChunkFolder)
+			lastSelectedChunkKey = chunkKey
+			lastSelectedBlockKey = blockKey
+		end
+	end
+	script.RaycastResult.Value = objLookingAt
+	lastNormalId = vectorToNormalId(result.Normal)
+	debugPlacementLog(
+		"[PLACE][CLIENT][RAYCAST][HIT]",
+		blockInstance:GetFullName(),
+		"chunkFolder",
+		hitChunkFolder:GetFullName(),
+		"blockName",
+		blockInstance.Name,
+		"normal",
+		lastNormalId.Name
+	)
+	return objLookingAt, lastNormalId
+end
+
+function PlacementManager:RaycastGetResult()
+	return script.RaycastResult.Value
+end
+
+local remotes = game:GetService("ReplicatedStorage"):WaitForChild("Remotes")
+local placeRemote = remotes:WaitForChild("PlaceBlock")
+local breakRemote = remotes:WaitForChild("BreakBlock")
+local tickRemote = game:GetService("ReplicatedStorage").Tick
+
+-- FIRES REMOTE
+function PlacementManager:PlaceBlock(cx, cy, cz, x, y, z, blockId: string)
+	debugPlacementLog("[PLACE][CLIENT][PLACE_CALL]", "chunk", cx, cy, cz, "block", x, y, z, "blockId", blockId)
+	if blockId == "hand" then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "hand cannot place")
+		return
+	end
+	if typeof(cx) ~= "number" or typeof(cy) ~= "number" or typeof(cz) ~= "number" then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "chunk type", cx, cy, cz, x, y, z, blockId)
+		return
+	end
+	if typeof(x) ~= "number" or typeof(y) ~= "number" or typeof(z) ~= "number" then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "block type", cx, cy, cz, x, y, z, blockId)
+		return
+	end
+	if x < 1 or x > 8 or y < 1 or y > 8 or z < 1 or z > 8 then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "block bounds", cx, cy, cz, x, y, z, blockId)
+		return
+	end
+	if not isWithinReach(cx, cy, cz, x, y, z) then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "reach", cx, cy, cz, x, y, z, blockId)
+		return
+	end
+
+	-- ensure chunk is present/rendered client-side
+	local chunk = ChunkManager:GetChunk(cx, cy, cz)
+	if chunk and not chunk.loaded then
+		ChunkManager:LoadChunk(cx, cy, cz)
+	end
+	if not chunk then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "missing chunk", cx, cy, cz, x, y, z, blockId)
+		return
+	end
+
+	-- allow sending even if the client thinks the id matches; server truth wins
+	if chunk then
+		local existing = chunk:GetBlockAt(x, y, z)
+		local existingId = existing and existing.id
+		if existingId and tostring(existingId) == tostring(blockId) then
+			debugPlacementLog(
+				"[PLACE][CLIENT][DUPLICATE]",
+				"still sending",
+				"chunk",
+				cx,
+				cy,
+				cz,
+				"block",
+				x,
+				y,
+				z,
+				"existingId",
+				existingId,
+				"blockId",
+				blockId
+			)
+			local ck = makeChunkKey(cx, cy, cz)
+			local last = duplicateResyncCooldown[ck]
+			if not last or (tick() - last) > 0.5 then
+				duplicateResyncCooldown[ck] = tick()
+				task.defer(function()
+					ChunkManager:RefreshChunk(cx, cy, cz)
+				end)
+			end
+		else
+			debugPlacementLog(
+				"[PLACE][CLIENT][EXISTING]",
+				"chunk",
+				cx,
+				cy,
+				cz,
+				"block",
+				x,
+				y,
+				z,
+				"existingId",
+				existingId
+			)
+		end
+	end
+
+	-- optimistic local apply; server will correct on tick
+	if chunk then
+		chunk:CreateBlock(x, y, z, {
+			id = tonumber(blockId) or blockId,
+			state = {},
+		})
+	end
+
+	debugPlacementLog("[PLACE][CLIENT][SEND]", cx, cy, cz, x, y, z, blockId)
+	placeRemote:FireServer(cx, cy, cz, x, y, z, blockId)
+end
+
+-- FIRES REMOTE
+function PlacementManager:BreakBlock(cx, cy, cz, x, y, z)
+	if typeof(cx) ~= "number" or typeof(cy) ~= "number" or typeof(cz) ~= "number" then
+		return
+	end
+	if typeof(x) ~= "number" or typeof(y) ~= "number" or typeof(z) ~= "number" then
+		debugPlacementWarn("[BREAK][CLIENT][REJECT]", "block type", cx, cy, cz, x, y, z)
+		return
+	end
+	if x < 1 or x > 8 or y < 1 or y > 8 or z < 1 or z > 8 then
+		debugPlacementWarn("[BREAK][CLIENT][REJECT]", "block bounds", cx, cy, cz, x, y, z)
+		return
+	end
+	if not isWithinReach(cx, cy, cz, x, y, z) then
+		debugPlacementWarn("[BREAK][CLIENT][REJECT]", "reach", cx, cy, cz, x, y, z)
+		return
+	end
+
+	local chunk = ChunkManager:GetChunk(cx, cy, cz)
+	local blockData = chunk and chunk:GetBlockAt(x, y, z) or nil
+	local chunkKey = makeChunkKey(cx, cy, cz)
+	local blockKey = makeBlockKey(x, y, z)
+	if getPendingBreak(chunkKey, blockKey) then
+		debugPlacementLog("[BREAK][CLIENT][SKIP]", "pending rollback", cx, cy, cz, x, y, z)
+		return
+	end
+	pendingBreaks[chunkKey] = pendingBreaks[chunkKey] or {}
+	pendingBreaks[chunkKey][blockKey] = {
+		data = blockData,
+		time = tick(),
+	}
+	if blockData then
+		chunk:RemoveBlock(x, y, z)
+	end
+	scheduleBreakRollback(cx, cy, cz, x, y, z)
+	debugPlacementLog("[BREAK][CLIENT][SEND]", cx, cy, cz, x, y, z)
+	breakRemote:FireServer(cx, cy, cz, x, y, z)
+end
+
+-- CLIENTSIDED: only apply server-validated changes
+local function applyPlaceBlockLocal(cx, cy, cz, x, y, z, blockData)
+	local chunk = ChunkManager:GetChunk(cx, cy, cz)
+	if chunk and not chunk.loaded then
+		ChunkManager:LoadChunk(cx, cy, cz)
+	end
+	chunk:CreateBlock(x, y, z, blockData)
+end
+
+-- CLIENTSIDED: only apply server-validated changes
+local function applyBreakBlockLocal(cx, cy, cz, x, y, z)
+	local chunk = ChunkManager:GetChunk(cx, cy, cz)
+	if chunk and not chunk.loaded then
+		ChunkManager:LoadChunk(cx, cy, cz)
+	end
+	if not chunk then
+		return
+	end
+	local chunkKey = makeChunkKey(cx, cy, cz)
+	local blockKey = makeBlockKey(x, y, z)
+	if getPendingBreak(chunkKey, blockKey) then
+		clearPendingBreak(chunkKey, blockKey)
+		return
+	end
+	chunk:RemoveBlock(x, y, z)
+end
+
+function PlacementManager:GetBlockAtMouse(skipSelection: boolean?): nil | {chunk:Vector3, block: Vector3}
+	pcall(function()
+		PlacementManager:Raycast(skipSelection)
+	end)
+	local selectedPart = PlacementManager:RaycastGetResult()
+	--print(selectedPart and selectedPart:GetFullName() or nil)
+	if selectedPart == nil then
+		if not skipSelection then
+			clearSelection()
+		end
+		script.RaycastResult.Value = nil
+		debugPlacementLog("[PLACE][CLIENT][TARGET]", "no selectedPart after raycast", lastRaycastFailure)
+		return nil
+	end
+	local chunkName, blockName = findChunkAndBlock(selectedPart)
+	if not chunkName or not blockName then
+		debugPlacementWarn(
+			"[PLACE][CLIENT][TARGET]",
+			"failed to find chunk/block from selection",
+			selectedPart:GetFullName()
+		)
+		return nil
+	end
+
+	local okChunk, chunkCoords = pcall(function()
+		return Util.BlockPosStringToCoords(chunkName :: string)
+	end)
+	local okBlock, blockCoords = pcall(function()
+		return Util.BlockPosStringToCoords(blockName :: string)
+	end)
+	if not okChunk or not okBlock then
+		debugPlacementWarn(
+			"[PLACE][CLIENT][TARGET]",
+			"failed to parse names",
+			"chunkName",
+			chunkName,
+			"blockName",
+			blockName
+		)
+		return nil
+	end
+	debugPlacementLog(
+		"[PLACE][CLIENT][TARGET]",
+		"chunk",
+		chunkName,
+		"block",
+		blockName,
+		"normal",
+		(lastNormalId and lastNormalId.Name) or "nil"
+	)
+
+	return {
+		chunk = chunkCoords,
+		block = blockCoords
+	}
+
+end
+
+function PlacementManager:GetTargetAtMouse(skipSelection: boolean?): nil | {chunk:Vector3, block: Vector3, normal: Enum.NormalId}
+	local hit = PlacementManager:GetBlockAtMouse(skipSelection)
+	if not hit then
+		return nil
+	end
+	local normal = lastNormalId or Enum.NormalId.Top
+
+	return {
+		chunk = hit.chunk,
+		block = hit.block,
+		normal = normal
+	}
+end
+
+function PlacementManager:GetPlacementAtMouse(skipSelection: boolean?): nil | {chunk:Vector3, block: Vector3}
+	local hit = PlacementManager:GetTargetAtMouse(skipSelection)
+	if not hit then
+		return nil
+	end
+	local offset = normalIdToOffset(hit.normal)
+	local placeChunk, placeBlock = offsetChunkBlock(hit.chunk, hit.block, offset)
+	debugPlacementLog(
+		"[PLACE][CLIENT][PLACE_TARGET]",
+		"target chunk",
+		hit.chunk,
+		"target block",
+		hit.block,
+		"normal",
+		hit.normal.Name,
+		"place chunk",
+		placeChunk,
+		"place block",
+		placeBlock
+	)
+	return {
+		chunk = placeChunk,
+		block = placeBlock
+	}
+end
+
+function PlacementManager:DebugGetPlacementOrWarn(skipSelection: boolean?)
+	local placement = PlacementManager:GetPlacementAtMouse(skipSelection)
+	if not placement then
+		debugPlacementWarn("[PLACE][CLIENT][REJECT]", "no placement target under mouse", lastRaycastFailure)
+	end
+	return placement
+end
+
+function PlacementManager:Init()
+	game:GetService("RunService").RenderStepped:Connect(function()
+		local a,b = pcall(function()
+			PlacementManager:Raycast()
+		end)
+		if not a then
+			clearSelection("raycast error")
+			script.RaycastResult.Value = nil
+		end
+	end)
+	tickRemote.OnClientEvent:Connect(function(m, cx, cy, cz, x, y, z, d)
+		--warn("PROPOGATED TICK", m, cx, cy, cz, x, y, z, d)
+		if m == "B_C" then
+			applyPlaceBlockLocal(cx, cy, cz, x, y ,z, d)
+		end
+		if m == "B_D" then
+			applyBreakBlockLocal(cx, cy, cz, x, y ,z)
+		end
+		if m == "C_R" then
+			clearPendingBreaksForChunk(makeChunkKey(cx, cy, cz))
+			ChunkManager:RefreshChunk(cx, cy, cz)
+		end
+	end)
+end
+
+return PlacementManager

ReplicatedStorage/Shared/PlacementState.lua

@@ -23,6 +23,8 @@ function PlacementState:SetSelected(id: string?, name: string?)
 	selectedId = id or ""
 	selectedName = name or selectedId
 	valueObject.Value = selectedName or ""
+	local Util = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("Util"))
+	Util.StudioLog("[PLACE][CLIENT][SELECT]", "id", selectedId, "name", selectedName)
 	changed:Fire(selectedId, selectedName)
 end
 

ReplicatedStorage/Shared/Util.lua

@@ -1,5 +1,24 @@
+local RunService = game:GetService("RunService")
+local IS_STUDIO = RunService:IsStudio()
+local ENABLE_STUDIO_LOG = false
+
 local module = {}
 
+-- Prints only when running in Studio (avoids noisy live logs)
+function module.StudioLog(...: any)
+	if not IS_STUDIO or not ENABLE_STUDIO_LOG then
+		return
+	end
+	print(...)
+end
+
+function module.StudioWarn(...: any)
+	if not IS_STUDIO or not ENABLE_STUDIO_LOG then
+		return
+	end
+	warn(...)
+end
+
 function module.isNaN(n: number): boolean
 	-- NaN is never equal to itself
 	return n ~= n

ServerScriptService/Actor/ClientState.lua

@@ -0,0 +1,196 @@
+--!native
+--!optimize 2
+
+local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+
+local Replica = require(ReplicatedStorage.Packages.replica)
+
+local ClientStateService = {}
+
+local HOTBAR_SIZE = 10
+
+local token = Replica.Token("ClientState")
+
+local blockCatalog = {}
+local playerReplicas = {} :: {[Player]: any}
+local blocksFolder: Folder? = nil
+local readyConnections = {} :: {[Player]: RBXScriptConnection}
+
+local function sortBlocks()
+	table.sort(blockCatalog, function(a, b)
+		local na = tonumber(a.id)
+		local nb = tonumber(b.id)
+		if na and nb then
+			return na < nb
+		end
+		if na then
+			return true
+		end
+		if nb then
+			return false
+		end
+		return a.id < b.id
+	end)
+end
+
+local function rebuildBlockCatalog()
+	table.clear(blockCatalog)
+	if not blocksFolder then
+		return
+	end
+
+	for _, block in ipairs(blocksFolder:GetChildren()) do
+		local id = block:GetAttribute("n")
+		if id ~= nil then
+			local displayName = block:GetAttribute("name") or block:GetAttribute("displayName") or block:GetAttribute("dn") or block.Name
+			table.insert(blockCatalog, {
+				id = tostring(id),
+				name = displayName,
+			})
+		end
+	end
+	sortBlocks()
+end
+
+local function makeBaseState()
+	local inventory = {}
+	local hotbar = {}
+
+	for _, entry in ipairs(blockCatalog) do
+		inventory[entry.id] = {
+			name = entry.name,
+			count = 999999,
+		}
+		if #hotbar < HOTBAR_SIZE then
+			table.insert(hotbar, entry.id)
+		end
+	end
+
+	return {
+		inventory = inventory,
+		hotbar = hotbar,
+		selectedSlot = #hotbar > 0 and 1 or 0,
+	}
+end
+
+local function sanitizeSelection(hotbar, selectedSlot)
+	if type(selectedSlot) ~= "number" then
+		return (#hotbar > 0) and 1 or 0
+	end
+	if selectedSlot < 1 or selectedSlot > HOTBAR_SIZE then
+		return (#hotbar > 0) and 1 or 0
+	end
+	return selectedSlot
+end
+
+local function refreshReplica(replica)
+	local state = makeBaseState()
+	replica:Set({"inventory"}, state.inventory)
+	replica:Set({"hotbar"}, state.hotbar)
+	replica:Set({"selectedSlot"}, sanitizeSelection(state.hotbar, replica.Data.selectedSlot))
+end
+
+function ClientStateService:SetBlocksFolder(folder: Folder?)
+	blocksFolder = folder
+	rebuildBlockCatalog()
+	for _, replica in pairs(playerReplicas) do
+		refreshReplica(replica)
+	end
+end
+
+function ClientStateService:GetReplica(player: Player)
+	return playerReplicas[player]
+end
+
+function ClientStateService:GetSelectedBlockId(player: Player)
+	local replica = playerReplicas[player]
+	if not replica then
+		return nil
+	end
+	local data = replica.Data
+	local hotbar = data.hotbar or {}
+	local selectedSlot = sanitizeSelection(hotbar, data.selectedSlot)
+	return hotbar[selectedSlot]
+end
+
+function ClientStateService:HasInInventory(player: Player, blockId: any): boolean
+	local replica = playerReplicas[player]
+	if not replica or not blockId then
+		return false
+	end
+	local inv = replica.Data.inventory
+	return inv and inv[tostring(blockId)] ~= nil or false
+end
+
+local function handleReplicaEvents(player: Player, replica)
+	replica.OnServerEvent:Connect(function(plr, action, payload)
+		if plr ~= player then
+			return
+		end
+
+		if action == "SelectHotbarSlot" then
+			local slot = tonumber(payload)
+			local hotbar = replica.Data.hotbar
+			if not hotbar then
+				return
+			end
+			if slot and slot >= 1 and slot <= HOTBAR_SIZE then
+				replica:Set({"selectedSlot"}, slot)
+			end
+		end
+	end)
+end
+
+local function onPlayerAdded(player: Player)
+	local replica = Replica.New({
+		Token = token,
+		Tags = {
+			UserId = player.UserId,
+			Player = player,
+		},
+		Data = makeBaseState(),
+	})
+
+	if Replica.ReadyPlayers[player] then
+		replica:Subscribe(player)
+	else
+		readyConnections[player] = Replica.NewReadyPlayer:Connect(function(newPlayer)
+			if newPlayer ~= player then
+				return
+			end
+			if readyConnections[player] then
+				readyConnections[player]:Disconnect()
+				readyConnections[player] = nil
+			end
+			replica:Subscribe(player)
+		end)
+	end
+
+	handleReplicaEvents(player, replica)
+	playerReplicas[player] = replica
+end
+
+local function onPlayerRemoving(player: Player)
+	local replica = playerReplicas[player]
+	if replica then
+		replica:Destroy()
+		playerReplicas[player] = nil
+	end
+	if readyConnections[player] then
+		readyConnections[player]:Disconnect()
+		readyConnections[player] = nil
+	end
+end
+
+function ClientStateService:Init()
+	rebuildBlockCatalog()
+
+	for _, player in ipairs(Players:GetPlayers()) do
+		onPlayerAdded(player)
+	end
+	Players.PlayerAdded:Connect(onPlayerAdded)
+	Players.PlayerRemoving:Connect(onPlayerRemoving)
+end
+
+return ClientStateService

ServerScriptService/Actor/ServerChunkManager/TerrainGen/init.lua

@@ -0,0 +1,102 @@
+--!native
+--!optimize 2
+
+local TerrainGen = {}
+
+local ChunkManager = require(game:GetService("ReplicatedStorage"):WaitForChild("Shared").ChunkManager)
+local Chunk = require(game:GetService("ReplicatedStorage"):WaitForChild("Shared").ChunkManager.Chunk)
+
+TerrainGen.ServerChunkCache = {} :: {[typeof("")]: typeof(Chunk.new(0,0,0))}
+
+local function chunkKeyFromCoords(x: number, y: number, z: number): string
+	return `{x},{y},{z}`
+end
+
+function TerrainGen:UnloadAllChunks(): number
+	local count = 0
+	for key in pairs(TerrainGen.ServerChunkCache) do
+		TerrainGen.ServerChunkCache[key] = nil
+		count += 1
+	end
+	return count
+end
+
+local function worldToChunkCoord(v: number): number
+	return math.floor((v + 16) / 32)
+end
+
+function TerrainGen:PreloadNearPlayers(radius: number, yRadius: number?): number
+	local Players = game:GetService("Players")
+	local r = radius or 5
+	local ry = yRadius or 1
+	local loaded = 0
+	for _, player in ipairs(Players:GetPlayers()) do
+		local character = player.Character
+		local root = character and character:FindFirstChild("HumanoidRootPart")
+		if root then
+			local pos = root.Position
+			local cx = worldToChunkCoord(pos.X)
+			local cy = worldToChunkCoord(pos.Y)
+			local cz = worldToChunkCoord(pos.Z)
+			for y = -ry, ry do
+				for x = -r, r do
+					for z = -r, r do
+						TerrainGen:GetChunk(cx + x, cy + y, cz + z)
+						loaded += 1
+					end
+				end
+			end
+		end
+	end
+	return loaded
+end
+
+-- Load a chunk from the DataStore or generate it if not found
+function TerrainGen:GetChunk(x, y, z)
+	local key = chunkKeyFromCoords(x, y, z)
+	if TerrainGen.ServerChunkCache[key] then
+		return TerrainGen.ServerChunkCache[key]
+	end
+
+	-- Generate a new chunk if it doesn't exist
+	local chunk = Chunk.new(x, y, z)
+	if y == 1 then
+		for cx = 1, 8 do
+			for cz = 1, 8 do
+				chunk:CreateBlock(cx, 1, cz, { id = "mc:grass_block", state = {} })
+			end
+		end
+	end
+	if y == 0 then
+		for cx = 1, 8 do
+			for cy = 1, 8 do
+				for cz = 1, 8 do
+					chunk:CreateBlock(cx, cy, cz, { id = "mc:dirt_block", state = {} })
+				end
+			end
+		end
+	end
+
+	TerrainGen.ServerChunkCache[key] = chunk
+	return chunk
+end
+
+-- Fake Chunk
+function TerrainGen:GetFakeChunk(x, y, z)
+
+	-- Generate a new chunk if it doesn't exist
+	local chunk = Chunk.new(x, y, z)
+	for cy = 1,8 do
+		for cx = 1, 8 do
+			for cz = 1, 8 do
+				chunk:CreateBlock(cx, cy, cz, { id = "invalid", state = {} })
+			end
+		end
+	end
+
+	return chunk
+end
+
+TerrainGen.CM = ChunkManager
+
+return TerrainGen

ServerScriptService/Actor/ServerChunkManager/init.server.lua

@@ -2,15 +2,39 @@
 --!optimize 2
 
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
-
+local ServerStorage = game:GetService("ServerStorage")
+local ClientStateService = require(script.Parent.ClientState)
 
 local Shared = ReplicatedStorage:WaitForChild("Shared")
 local ModsFolder = ReplicatedStorage:WaitForChild("Mods")
+local BlocksFolderRS = ReplicatedStorage:FindFirstChild("Blocks") or Instance.new("Folder")
+BlocksFolderRS.Name = "Blocks"
+BlocksFolderRS.Parent = ReplicatedStorage
+local BlocksFolderSS = ServerStorage:FindFirstChild("Blocks") or Instance.new("Folder")
+BlocksFolderSS.Name = "Blocks"
+BlocksFolderSS.Parent = ServerStorage
 
 local Util = require(Shared.Util)
-local TG = require("./ServerChunkManager/TerrainGen")
+local TG = require(script.TerrainGen)
 local Players = game:GetService("Players")
 
+local blockIdMap = {}
+local rebuildBlockIdMap
+
+local function syncBlocksToServerStorage()
+	BlocksFolderSS:ClearAllChildren()
+	for _, child in ipairs(BlocksFolderRS:GetChildren()) do
+		child:Clone().Parent = BlocksFolderSS
+	end
+	ClientStateService:SetBlocksFolder(BlocksFolderSS)
+	if rebuildBlockIdMap then
+		rebuildBlockIdMap()
+	end
+end
+
+BlocksFolderRS.ChildAdded:Connect(syncBlocksToServerStorage)
+BlocksFolderRS.ChildRemoved:Connect(syncBlocksToServerStorage)
+
 do
 	local workspaceModFolder = game:GetService("Workspace"):WaitForChild("mods")
 
@@ -22,6 +46,8 @@ end
 
 local ML = require(Shared.ModLoader)
 ML.loadModsS()
+syncBlocksToServerStorage()
+ClientStateService:Init()
 
 do
 	local bv = Instance.new("BoolValue")
@@ -67,7 +93,7 @@ local tickRemote = ReplicatedStorage.Tick
 local remotes = ReplicatedStorage:WaitForChild("Remotes")
 local placeRemote = remotes:WaitForChild("PlaceBlock")
 local breakRemote = remotes:WaitForChild("BreakBlock")
-local blocksFolder = ReplicatedStorage:WaitForChild("Blocks")
+local blocksFolder = BlocksFolderSS
 local function propogate(a, cx, cy, cz, x, y, z, bd)
 	task.synchronize()
 	tickRemote:FireAllClients(a, cx, cy, cz, x, y, z, bd)
@@ -75,9 +101,8 @@ local function propogate(a, cx, cy, cz, x, y, z, bd)
 end
 
 local MAX_REACH = 512
-local blockIdMap = {}
 
-local function rebuildBlockIdMap()
+rebuildBlockIdMap = function()
 	table.clear(blockIdMap)
 	for _, block in ipairs(blocksFolder:GetChildren()) do
 		local id = block:GetAttribute("n")
@@ -113,6 +138,17 @@ local function resolveBlockId(blockId: any): string | number | nil
 	return blockIdMap[blockId]
 end
 
+local function playerCanUseBlock(player: Player, resolvedId: any): boolean
+	if not ClientStateService:HasInInventory(player, resolvedId) then
+		return false
+	end
+	local selected = ClientStateService:GetSelectedBlockId(player)
+	if not selected then
+		return false
+	end
+	return tostring(selected) == tostring(resolvedId)
+end
+
 local function getServerChunk(cx: number, cy: number, cz: number)
 	task.desynchronize()
 	local chunk = TG:GetChunk(cx, cy, cz)
@@ -138,13 +174,22 @@ local function isBlockInsidePlayer(blockPos: Vector3): boolean
 	return false
 end
 
-local DEBUG_PLACEMENT = true
+local DEBUG_PLACEMENT = false
+local function debugPlacementLog(...: any)
+	if DEBUG_PLACEMENT then
+		Util.StudioLog(...)
+	end
+end
+
+local function debugPlacementWarn(...: any)
+	if DEBUG_PLACEMENT then
+		Util.StudioWarn(...)
+	end
+end
 
 placeRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z, blockId)
 	local function reject(reason: string)
-		if DEBUG_PLACEMENT then
+		debugPlacementWarn("[PLACE][REJECT]", player.Name, reason, "chunk", cx, cy, cz, "block", x, y, z, "id", blockId)
-			warn("[PLACE][REJECT]", player.Name, reason, "chunk", cx, cy, cz, "block", x, y, z, "id", blockId)
-		end
 		return
 	end
 	
@@ -167,6 +212,9 @@ placeRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z, blockId)
 	if not resolvedId then
 		return reject("invalid id")
 	end
+	if not playerCanUseBlock(player, resolvedId) then
+		return reject("not in inventory/hotbar")
+	end
 
 	local blockPos = Util.ChunkPosToCFrame(Vector3.new(cx, cy, cz), Vector3.new(x, y, z)).Position
 	if isBlockInsidePlayer(blockPos) then
@@ -178,9 +226,7 @@ placeRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z, blockId)
 	if existing and existing.id and existing.id ~= 0 then
 		if existing.id == resolvedId then
 			-- same block already there; treat as success without changes
-			if DEBUG_PLACEMENT then
+			debugPlacementLog("[PLACE][OK][NOOP]", player.Name, "chunk", cx, cy, cz, "block", x, y, z, "id", resolvedId)
-				print("[PLACE][OK][NOOP]", player.Name, "chunk", cx, cy, cz, "block", x, y, z, "id", resolvedId)
-			end
 			return
 		end
 		-- allow replacement when different id: remove then place
@@ -192,9 +238,7 @@ placeRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z, blockId)
 	}
 	chunk:CreateBlock(x, y, z, data)
 	propogate("B_C", cx, cy, cz, x, y, z, data)
-	if DEBUG_PLACEMENT then
+	debugPlacementLog("[PLACE][OK]", player.Name, "chunk", cx, cy, cz, "block", x, y, z, "id", resolvedId)
-		print("[PLACE][OK]", player.Name, "chunk", cx, cy, cz, "block", x, y, z, "id", resolvedId)
-	end
 end)
 
 breakRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z)
@@ -219,10 +263,12 @@ breakRemote.OnServerEvent:Connect(function(player, cx, cy, cz, x, y, z)
 		task.synchronize()
 		tickRemote:FireClient(player, "C_R", cx, cy, cz, 0, 0, 0, 0)
 		task.desynchronize()
+		debugPlacementLog("[BREAK][NOOP]", player.Name, "chunk", cx, cy, cz, "block", x, y, z)
 		return
 	end
 	chunk:RemoveBlock(x, y, z)
 	propogate("B_D", cx, cy, cz, x, y, z, 0)
+	debugPlacementLog("[BREAK][OK]", player.Name, "chunk", cx, cy, cz, "block", x, y, z)
 end)
 
 task.desynchronize()

ServerScriptService/CmdrCommands/ChunkCullWorld.lua

@@ -0,0 +1,79 @@
+return {
+	Name = "chunkcull",
+	Aliases = {"cullchunks", "resetchunks"},
+	Description = "Unload all server chunk cache instantly, then preload only chunks near players (and force clients to unload/resync).",
+	Group = "Admin",
+	Args = {
+		{
+			Type = "integer",
+			Name = "radius",
+			Description = "Horizontal chunk radius around each player to preload",
+			Optional = true,
+			Default = 5,
+		},
+		{
+			Type = "integer",
+			Name = "yRadius",
+			Description = "Vertical chunk radius around each player to preload",
+			Optional = true,
+			Default = 1,
+		},
+	},
+	Run = function(context, radius, yRadius)
+		local ReplicatedStorage = game:GetService("ReplicatedStorage")
+		local Players = game:GetService("Players")
+
+		local terrainGen = require(
+			game:GetService("ServerScriptService")
+				:WaitForChild("Actor")
+				:WaitForChild("ServerChunkManager")
+				:WaitForChild("TerrainGen")
+		)
+
+		local tickRemote = ReplicatedStorage:WaitForChild("Tick")
+
+		local r = radius or 5
+		local ry = yRadius or 1
+
+		local unloaded = 0
+		pcall(function()
+			unloaded = terrainGen:UnloadAllChunks()
+		end)
+
+		-- Tell all clients to immediately drop their local chunk instances
+		pcall(function()
+			tickRemote:FireAllClients("U_ALL", 0, 0, 0, 0, 0, 0, 0)
+		end)
+
+		-- Preload server chunks around players (reduces initial lag spikes after cull)
+		local preloaded = 0
+		pcall(function()
+			preloaded = terrainGen:PreloadNearPlayers(r, ry)
+		end)
+
+		-- Force clients to resync around themselves
+		local resyncCount = 0
+		for _, player in ipairs(Players:GetPlayers()) do
+			local character = player.Character
+			local root = character and character:FindFirstChild("HumanoidRootPart")
+			if root then
+				local pos = root.Position
+				local cx = math.floor((pos.X + 16) / 32)
+				local cy = math.floor((pos.Y + 16) / 32)
+				local cz = math.floor((pos.Z + 16) / 32)
+				for y = -ry, ry do
+					for x = -r, r do
+						for z = -r, r do
+							tickRemote:FireClient(player, "C_R", cx + x, cy + y, cz + z, 0, 0, 0, 0)
+							resyncCount += 1
+						end
+					end
+				end
+			end
+		end
+
+		return (
+			"chunkcull done | unloaded=%d | preloaded=%d | resyncPackets=%d | radius=%d yRadius=%d"
+		):format(unloaded, preloaded, resyncCount, r, ry)
+	end,
+}

StarterGui/Crosshair/LocalScript.client.lua

@@ -10,7 +10,9 @@ local UIS = game:GetService("UserInputService")
 local TXTS = game:GetService("TextChatService")
 local TXTS_CIF = TXTS:FindFirstChildOfClass("ChatInputBarConfiguration")
 
-ReplicatedStorage:WaitForChild("Objects"):WaitForChild("MLLoaded")
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
 
 game:GetService("Players").LocalPlayer.CameraMode = Enum.CameraMode.LockFirstPerson
 UIS.MouseIconEnabled = false

StarterGui/Game_UI/LocalScript.client.lua

@@ -10,7 +10,13 @@ local ui = script.Parent
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local PlacementState = require(ReplicatedStorage.Shared.PlacementState)
 
-ReplicatedStorage:WaitForChild("Objects"):WaitForChild("MLLoaded")
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
+local clientReady = ReplicatedStorage.Objects:WaitForChild("ClientReady", 5)
+if clientReady and not clientReady.Value then
+	clientReady:GetPropertyChangedSignal("Value"):Wait()
+end
 
 local cd = ReplicatedStorage.Objects.ChunkDebug:Clone()
 local sky = ReplicatedStorage.Objects.Sky:Clone()

StarterGui/Hotbar/LocalScript.client.lua

@@ -9,14 +9,16 @@ local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local UIS = game:GetService("UserInputService")
 local TextChatService = game:GetService("TextChatService")
 
-ReplicatedStorage:WaitForChild("Objects"):WaitForChild("MLLoaded")
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
 
 local Roact = require(ReplicatedStorage.Packages.roact)
 local PM = require(ReplicatedStorage.Shared.PlacementManager)
 local BlockManager = require(ReplicatedStorage.Shared.ChunkManager.BlockManager)
 local PlacementState = require(ReplicatedStorage.Shared.PlacementState)
-
+local Util = require(ReplicatedStorage.Shared.Util)
-local blocksFolder = ReplicatedStorage:WaitForChild("Blocks")
+local ClientState = require(ReplicatedStorage.Shared.ClientState)
 
 local HOTBAR_SIZE = 10
 
@@ -50,30 +52,34 @@ local function isTextInputFocused(): boolean
 	return config ~= nil and config.IsFocused
 end
 
-local function buildHotbarIds(): {string}
+local function resolveSelectedSlot(slots, desired)
-	local ids = {}
+	if desired and desired >= 1 and desired <= HOTBAR_SIZE then
-	local names = {}
+		return desired
-	for _, block in ipairs(blocksFolder:GetChildren()) do
-		local id = block:GetAttribute("n")
-		if id ~= nil then
-			local idStr = tostring(id)
-			table.insert(ids, idStr)
-			names[idStr] = block:GetAttribute("displayName") or block:GetAttribute("dn") or block.Name
-		end
 	end
-	table.sort(ids, function(a, b)
-		local na = tonumber(a)
-		local nb = tonumber(b)
-		if na and nb then
-			return na < nb
-		end
-		return a < b
-	end)
-	local slots = table.create(HOTBAR_SIZE)
 	for i = 1, HOTBAR_SIZE do
-		slots[i] = ids[i] or ""
+		if slots[i] and slots[i] ~= "" then
+			return i
+		end
 	end
-	return slots, names
+	return desired or 1
+end
+
+local function buildHotbarFromState()
+	local slots = table.create(HOTBAR_SIZE)
+	local names = {}
+
+	for i = 1, HOTBAR_SIZE do
+		local info = ClientState:GetSlotInfo(i)
+		if info then
+			slots[i] = tostring(info.id)
+			names[slots[i]] = info.name or slots[i]
+		else
+			slots[i] = ""
+		end
+	end
+
+	local selected = resolveSelectedSlot(slots, ClientState:GetSelectedSlot())
+	return slots, names, selected
 end
 
 local function ensurePreviewRig(part: Instance)
@@ -125,50 +131,68 @@ end
 local Hotbar = Roact.Component:extend("Hotbar")
 
 function Hotbar:init()
+	local slots, names, selected = buildHotbarFromState()
 	self.state = {
-		slots = nil,
+		slots = slots,
-		names = nil,
+		names = names,
-		selected = 1,
+		selected = selected,
 	}
-	local slots, names = buildHotbarIds()
-	self.state.slots = slots
-	self.state.names = names
 
-	self._updateSlots = function()
+	self._syncFromClientState = function()
-		local nextSlots, nextNames = buildHotbarIds()
+		local nextSlots, nextNames, nextSelected = buildHotbarFromState()
+		nextSelected = resolveSelectedSlot(nextSlots, nextSelected or self.state.selected)
 		self:setState({
 			slots = nextSlots,
 			names = nextNames,
+			selected = nextSelected,
 		})
+		local rawId = nextSlots[nextSelected] or ""
+		local effectiveId = rawId ~= "" and rawId or "hand"
+		local name = ""
+		if rawId ~= "" then
+			name = nextNames[rawId] or rawId
+		end
+		PlacementState:SetSelected(effectiveId, name)
 	end
 
 	self._setSelected = function(slot: number)
 		if slot < 1 or slot > HOTBAR_SIZE then
 			return
 		end
+		ClientState:SetSelectedSlot(slot)
 		self:setState({
 			selected = slot,
 		})
-		local id = self.state.slots and self.state.slots[slot] or ""
+		local rawId = self.state.slots[slot] or ""
+		local effectiveId = rawId ~= "" and rawId or "hand"
 		local name = ""
-		if id ~= "" and self.state.names then
+		if rawId ~= "" then
-			name = self.state.names[id] or id
+			name = self.state.names[rawId] or rawId
 		end
-		PlacementState:SetSelected(id, name)
+		Util.StudioLog("[PLACE][CLIENT][SELECT]", "slot", slot, "id", effectiveId, "name", name)
+		PlacementState:SetSelected(effectiveId, name)
 	end
 
 	self._handleInput = function(input: InputObject, gameProcessedEvent: boolean)
-		if gameProcessedEvent or isTextInputFocused() then
+		if isTextInputFocused() then
 			return
 		end
 
 		local slot = keyToSlot[input.KeyCode]
 		if slot then
+			if gameProcessedEvent then
+				return
+			end
 			self._setSelected(slot)
 			return
 		end
 
 		if input.UserInputType == Enum.UserInputType.MouseButton1 then
+			Util.StudioLog("[INPUT][CLIENT]", "MouseButton1", "processed", gameProcessedEvent)
+			-- Allow click even if gameProcessedEvent (UI can set this), but only if we're actually pointing at a block
+			if not PM:GetBlockAtMouse() then
+				return
+			end
 			local mouseBlock = PM:GetBlockAtMouse()
 			if not mouseBlock then
 				return
@@ -182,14 +206,26 @@ function Hotbar:init()
 				mouseBlock.block.Z
 			)
 		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
-			local mouseBlock = PM:GetPlacementAtMouse()
+			Util.StudioLog("[INPUT][CLIENT]", "MouseButton2", "processed", gameProcessedEvent)
+			-- Allow click even if gameProcessedEvent (UI can set this), but only if we're actually pointing at a block
+			local mouseBlock = PM:DebugGetPlacementOrWarn(true) -- skip selection outline on right click
 			if not mouseBlock then
 				return
 			end
 			local id = PlacementState:GetSelected()
 			if not id or id == "" then
+				Util.StudioWarn("[PLACE][CLIENT][REJECT]", "no selected id")
 				return
 			end
+			Util.StudioLog(
+				"[PLACE][CLIENT][SEND][CLICK]",
+				"chunk",
+				mouseBlock.chunk,
+				"block",
+				mouseBlock.block,
+				"id",
+				id
+			)
 			PM:PlaceBlock(
 				mouseBlock.chunk.X,
 				mouseBlock.chunk.Y,
@@ -214,7 +250,7 @@ function Hotbar:init()
 			return
 		end
 		local delta = direction > 0 and -1 or 1
-		local nextSlot = math.clamp(self.state.selected + delta, 1, HOTBAR_SIZE)
+		local nextSlot = ((self.state.selected - 1 + delta) % HOTBAR_SIZE) + 1
 		if nextSlot ~= self.state.selected then
 			self._setSelected(nextSlot)
 		end
@@ -226,19 +262,20 @@ end
 
 function Hotbar:didMount()
 	self._connections = {
-		blocksFolder.ChildAdded:Connect(self._updateSlots),
+		ClientState.Changed:Connect(self._syncFromClientState),
-		blocksFolder.ChildRemoved:Connect(self._updateSlots),
 		UIS.InputBegan:Connect(self._handleInput),
 		UIS.InputChanged:Connect(self._handleScroll),
 	}
+	self._syncFromClientState()
 	self:_refreshViewports()
 	-- initialize selection broadcast
-	local id = self.state.slots and self.state.slots[self.state.selected] or ""
+	local rawId = self.state.slots and self.state.slots[self.state.selected] or ""
+	local effectiveId = rawId ~= "" and rawId or "hand"
 	local name = ""
-	if id ~= "" and self.state.names then
+	if rawId ~= "" and self.state.names then
-		name = self.state.names[id] or id
+		name = self.state.names[rawId] or rawId
 	end
-	PlacementState:SetSelected(id, name)
+	PlacementState:SetSelected(effectiveId, name)
 end
 
 function Hotbar:willUnmount()
@@ -278,6 +315,7 @@ function Hotbar:render()
 	for i = 1, HOTBAR_SIZE do
 		local id = self.state.slots[i] or ""
 		local isSelected = i == self.state.selected
+		local displayName = id ~= "" and (self.state.names and self.state.names[id] or id) or ""
 
 		slotElements[`Slot{i-1}`] = Roact.createElement("TextButton", {
 			Size = UDim2.fromOffset(50, 50),
@@ -309,7 +347,7 @@ function Hotbar:render()
 			}),
 			IndexLabel = Roact.createElement("TextLabel", {
 				BackgroundTransparency = 1,
-				Position = UDim2.fromOffset(4, 2),
+				Position = UDim2.fromOffset(8, 4),
 				Size = UDim2.fromOffset(18, 14),
 				Font = Enum.Font.Gotham,
 				Text = i == 10 and "0" or tostring(i),
@@ -323,7 +361,7 @@ function Hotbar:render()
 				Position = UDim2.fromOffset(4, 26),
 				Size = UDim2.new(1, -8, 0, 18),
 				Font = Enum.Font.GothamBold,
-				Text = id,
+				Text = displayName,
 				TextColor3 = colors.text,
 				TextSize = 15,
 				TextWrapped = true,
@@ -376,6 +414,7 @@ function Hotbar:render()
 		BorderSizePixel = 0,
 		Position = UDim2.new(0.5, 0, 1, -80-10),
 		Size = UDim2.fromOffset(0, 25),
+		Visible = selectedName ~= "",
 	}, {
 		Corner = Roact.createElement("UICorner", {
 			CornerRadius = UDim.new(0, 8),

StarterPlayer/StarterPlayerScripts/Actor/ActorInit.client.lua

@@ -7,16 +7,16 @@ end
 
 pcall(function()
 	task.synchronize()
-	game:GetService("Workspace"):WaitForChild("$blockscraft_server",5):Destroy()
+	task.defer(function()
+		game:GetService("Workspace"):WaitForChild("$blockscraft_server",9e9):Destroy()
+	end)
 end)
 
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
-ReplicatedStorage:WaitForChild("Objects"):WaitForChild("MLLoaded")
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
-	
+objects:WaitForChild("MLLoaded", 9e9)
-local ML = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("ModLoader"))
+objects:WaitForChild("CSMLLoaded", 9e9)
-
-ML.loadModsC()
 
 do
 	local PM = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("PlacementManager"))

StarterPlayer/StarterPlayerScripts/Actor/BlockInteraction.client.lua

@@ -0,0 +1,9 @@
+--!native
+--!optimize 2
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
+
+return

StarterPlayer/StarterPlayerScripts/CmdrClient.client.lua

@@ -4,5 +4,9 @@ until game:IsLoaded() == true
 
 local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
+
 local Cmdr = require(ReplicatedStorage:WaitForChild("CmdrClient"))
 Cmdr:SetActivationKeys({ Enum.KeyCode.F2 })

default.project.json

@@ -1,44 +1,52 @@
 {
-  "name": "project",
+  "name": "minecraft-roblox",
   "tree": {
     "$className": "DataModel",
+
     "ReplicatedStorage": {
       "$className": "ReplicatedStorage",
       "$ignoreUnknownInstances": true,
-      "$path": "src/ReplicatedStorage",
+      "$path": "ReplicatedStorage",
+
       "Packages": {
         "$className": "Folder",
         "$path": "Packages"
       }
     },
+
     "ReplicatedFirst": {
       "$className": "ReplicatedFirst",
       "$ignoreUnknownInstances": true,
-      "$path": "src/ReplicatedFirst"
+      "$path": "ReplicatedFirst"
     },
+
     "ServerScriptService": {
       "$className": "ServerScriptService",
       "$ignoreUnknownInstances": true,
-      "$path": "src/ServerScriptService"
+      "$path": "ServerScriptService"
     },
+
     "StarterGui": {
       "$className": "StarterGui",
       "$ignoreUnknownInstances": true,
-      "$path": "src/StarterGui"
+      "$path": "StarterGui"
     },
+
     "StarterPlayer": {
       "$className": "StarterPlayer",
+      "$ignoreUnknownInstances": true,
+
       "StarterPlayerScripts": {
         "$className": "StarterPlayerScripts",
         "$ignoreUnknownInstances": true,
-        "$path": "src/StarterPlayer/StarterPlayerScripts"
+        "$path": "StarterPlayer/StarterPlayerScripts"
-      },
+      }
-      "$ignoreUnknownInstances": true
     },
+
     "Workspace": {
       "$className": "Workspace",
       "$ignoreUnknownInstances": true,
-      "$path": "src/Workspace"
+      "$path": "Workspace"
     }
   }
 }

src/ReplicatedStorage/Shared/PlacementManager.lua

@@ -1,368 +0,0 @@
---!native
---!optimize 2
-
-local PlacementManager = {}
-
-local ChunkManager = require("./ChunkManager")
-local Util = require("./Util")
-
-PlacementManager.ChunkFolder = ChunkManager.ChunkFolder
-
-local raycastParams = RaycastParams.new()
-raycastParams.FilterDescendantsInstances = {PlacementManager.ChunkFolder}
-raycastParams.FilterType = Enum.RaycastFilterType.Include
-raycastParams.IgnoreWater = true
-
-if _G.SB then return nil end
-_G.SB = true
-
-PlacementManager.SelectionBox = script.SelectionBox:Clone()
-PlacementManager.SelectionBox.Name = "$SelectionBox"..(game:GetService("RunService"):IsServer() and "_SERVER" or "")
-PlacementManager.SelectionBox.Parent = game:GetService("Workspace"):FindFirstChildOfClass("Terrain")
-
--- Trash method TODO: Fix this
-local function findChunkFolderFromDescendant(inst: Instance): Instance?
-	local current = inst
-	while current and current.Parent do
-		if current.Parent == PlacementManager.ChunkFolder then
-			return current
-		end
-		current = current.Parent
-	end
-	return nil
-end
-
-local Mouse: Mouse = nil
-local lastNormalId: Enum.NormalId? = nil
-local BREAK_ROLLBACK_TIMEOUT = 0.6
-local pendingBreaks = {}
-
-local function makeChunkKey(cx: number, cy: number, cz: number): string
-	return `{cx},{cy},{cz}`
-end
-
-local function makeBlockKey(x: number, y: number, z: number): string
-	return `{x},{y},{z}`
-end
-
-local function getPendingBreak(chunkKey: string, blockKey: string)
-	local chunkMap = pendingBreaks[chunkKey]
-	if not chunkMap then
-		return nil
-	end
-	return chunkMap[blockKey]
-end
-
-local function clearPendingBreak(chunkKey: string, blockKey: string)
-	local chunkMap = pendingBreaks[chunkKey]
-	if not chunkMap then
-		return
-	end
-	chunkMap[blockKey] = nil
-	if not next(chunkMap) then
-		pendingBreaks[chunkKey] = nil
-	end
-end
-
-local function clearPendingBreaksForChunk(chunkKey: string)
-	pendingBreaks[chunkKey] = nil
-end
-
-local function scheduleBreakRollback(cx: number, cy: number, cz: number, x: number, y: number, z: number)
-	task.delay(BREAK_ROLLBACK_TIMEOUT, function()
-		local chunkKey = makeChunkKey(cx, cy, cz)
-		local blockKey = makeBlockKey(x, y, z)
-		local pending = getPendingBreak(chunkKey, blockKey)
-		if not pending then
-			return
-		end
-		clearPendingBreak(chunkKey, blockKey)
-		local chunk = ChunkManager:GetChunk(cx, cy, cz)
-		if pending.data and chunk then
-			chunk:CreateBlock(x, y, z, pending.data)
-		end
-		ChunkManager:RefreshChunk(cx, cy, cz)
-	end)
-end
-
-local function normalIdToOffset(normal: Enum.NormalId): Vector3
-	if normal == Enum.NormalId.Top then
-		return Vector3.new(0, 1, 0)
-	elseif normal == Enum.NormalId.Bottom then
-		return Vector3.new(0, -1, 0)
-	elseif normal == Enum.NormalId.Left then
-		return Vector3.new(-1, 0, 0)
-	elseif normal == Enum.NormalId.Right then
-		return Vector3.new(1, 0, 0)
-	elseif normal == Enum.NormalId.Back then
-		return Vector3.new(0, 0, 1)
-	elseif normal == Enum.NormalId.Front then
-		return Vector3.new(0, 0, -1)
-	end
-	return Vector3.new(0, 0, 0)
-end
-
-local function offsetChunkBlock(chunk: Vector3, block: Vector3, offset: Vector3)
-	local cx, cy, cz = chunk.X, chunk.Y, chunk.Z
-	local bx, by, bz = block.X + offset.X, block.Y + offset.Y, block.Z + offset.Z
-
-	if bx < 1 then
-		bx = 8
-		cx -= 1
-	elseif bx > 8 then
-		bx = 1
-		cx += 1
-	end
-
-	if by < 1 then
-		by = 8
-		cy -= 1
-	elseif by > 8 then
-		by = 1
-		cy += 1
-	end
-
-	if bz < 1 then
-		bz = 8
-		cz -= 1
-	elseif bz > 8 then
-		bz = 1
-		cz += 1
-	end
-
-	return Vector3.new(cx, cy, cz), Vector3.new(bx, by, bz)
-end
-
-local function getPlayerPosition(): Vector3?
-	local player = game:GetService("Players").LocalPlayer
-	local character = player and player.Character
-	if not character then
-		return nil
-	end
-	local root = character:FindFirstChild("HumanoidRootPart")
-	return root and root.Position or nil
-end
-
-local MAX_REACH = 512
-
-local function isWithinReach(cx: number, cy: number, cz: number, x: number, y: number, z: number): boolean
-	-- Client-side reach loosened; rely on server authority
-	return true
-end
-
--- Gets the block and normalid of the block (and surface) the player is looking at
-function PlacementManager:Raycast()
-	if not Mouse then
-		Mouse = game:GetService("Players").LocalPlayer:GetMouse()
-	end
-	local objLookingAt = Mouse.Target
-	local dir = Mouse.TargetSurface or Enum.NormalId.Top
-	if not objLookingAt then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return
-	end
-	
-	--if not objLookingAt:IsDescendantOf(ChunkManager.ChunkFolder) then return end
-	local chunkFolder = findChunkFolderFromDescendant(objLookingAt)
-	if not chunkFolder then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return
-	end
-	if chunkFolder:GetAttribute("ns") == true then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return
-	end
-	PlacementManager.SelectionBox.Adornee = objLookingAt
-	script.RaycastResult.Value = objLookingAt
-	lastNormalId = dir
-	return objLookingAt, dir
-end
-
-function PlacementManager:RaycastGetResult()
-	return script.RaycastResult.Value
-end
-
-local remotes = game:GetService("ReplicatedStorage"):WaitForChild("Remotes")
-local placeRemote = remotes:WaitForChild("PlaceBlock")
-local breakRemote = remotes:WaitForChild("BreakBlock")
-local tickRemote = game:GetService("ReplicatedStorage").Tick
-
--- FIRES REMOTE
-function PlacementManager:PlaceBlock(cx, cy, cz, x, y, z, blockId: string)
-	-- ensure chunk is present/rendered client-side
-	local chunk = ChunkManager:GetChunk(cx, cy, cz)
-	if chunk and not chunk.loaded then
-		ChunkManager:LoadChunk(cx, cy, cz)
-	end
-
-	-- if the client already thinks this block is the same id, skip sending
-	if chunk then
-		local existing = chunk:GetBlockAt(x, y, z)
-		local existingId = existing and existing.id
-		if existingId and tostring(existingId) == tostring(blockId) then
-			return
-		end
-	end
-
-	-- optimistic local apply; server will correct on tick
-	if chunk then
-		chunk:CreateBlock(x, y, z, {
-			id = tonumber(blockId) or blockId,
-			state = {},
-		})
-	end
-
-	placeRemote:FireServer(cx, cy, cz, x, y, z, blockId)
-end
-
--- FIRES REMOTE
-function PlacementManager:BreakBlock(cx, cy, cz, x, y, z)
-	if typeof(cx) ~= "number" or typeof(cy) ~= "number" or typeof(cz) ~= "number" then
-		return
-	end
-	if typeof(x) ~= "number" or typeof(y) ~= "number" or typeof(z) ~= "number" then
-		return
-	end
-	if x < 1 or x > 8 or y < 1 or y > 8 or z < 1 or z > 8 then
-		return
-	end
-	if not isWithinReach(cx, cy, cz, x, y, z) then
-		return
-	end
-
-	local chunk = ChunkManager:GetChunk(cx, cy, cz)
-	local blockData = chunk and chunk:GetBlockAt(x, y, z) or nil
-	local chunkKey = makeChunkKey(cx, cy, cz)
-	local blockKey = makeBlockKey(x, y, z)
-	if getPendingBreak(chunkKey, blockKey) then
-		return
-	end
-	pendingBreaks[chunkKey] = pendingBreaks[chunkKey] or {}
-	pendingBreaks[chunkKey][blockKey] = {
-		data = blockData,
-		time = tick(),
-	}
-	if blockData then
-		chunk:RemoveBlock(x, y, z)
-	end
-	scheduleBreakRollback(cx, cy, cz, x, y, z)
-	breakRemote:FireServer(cx, cy, cz, x, y, z)
-end
-
--- CLIENTSIDED: only apply server-validated changes
-local function applyPlaceBlockLocal(cx, cy, cz, x, y, z, blockData)
-	local chunk = ChunkManager:GetChunk(cx, cy, cz)
-	if chunk and not chunk.loaded then
-		ChunkManager:LoadChunk(cx, cy, cz)
-	end
-	chunk:CreateBlock(x, y, z, blockData)
-end
-
--- CLIENTSIDED: only apply server-validated changes
-local function applyBreakBlockLocal(cx, cy, cz, x, y, z)
-	local chunk = ChunkManager:GetChunk(cx, cy, cz)
-	if chunk and not chunk.loaded then
-		ChunkManager:LoadChunk(cx, cy, cz)
-	end
-	if not chunk then
-		return
-	end
-	local chunkKey = makeChunkKey(cx, cy, cz)
-	local blockKey = makeBlockKey(x, y, z)
-	if getPendingBreak(chunkKey, blockKey) then
-		clearPendingBreak(chunkKey, blockKey)
-		return
-	end
-	chunk:RemoveBlock(x, y, z)
-end
-
-function PlacementManager:GetBlockAtMouse(): nil | {chunk:Vector3, block: Vector3}
-	local selectedPart = PlacementManager:RaycastGetResult()
-	--print(selectedPart and selectedPart:GetFullName() or nil)
-	if selectedPart == nil then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return nil
-	end
-	if not selectedPart.Parent then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return nil
-	end
-	if not selectedPart.Parent then
-		PlacementManager.SelectionBox.Adornee = nil
-		script.RaycastResult.Value = nil
-		lastNormalId = nil
-		return nil
-	end
-	local chunkCoords = Util.BlockPosStringToCoords(selectedPart.Parent.Name)
-	local blockCoords = Util.BlockPosStringToCoords(selectedPart.Name)
-
-	return {
-		chunk = chunkCoords,
-		block = blockCoords
-	}
-
-end
-
-function PlacementManager:GetTargetAtMouse(): nil | {chunk:Vector3, block: Vector3, normal: Enum.NormalId}
-	local hit = PlacementManager:GetBlockAtMouse()
-	if not hit then
-		return nil
-	end
-	local normal = lastNormalId or Enum.NormalId.Top
-
-	return {
-		chunk = hit.chunk,
-		block = hit.block,
-		normal = normal
-	}
-end
-
-function PlacementManager:GetPlacementAtMouse(): nil | {chunk:Vector3, block: Vector3}
-	local hit = PlacementManager:GetTargetAtMouse()
-	if not hit then
-		return nil
-	end
-	local offset = normalIdToOffset(hit.normal)
-	local placeChunk, placeBlock = offsetChunkBlock(hit.chunk, hit.block, offset)
-	return {
-		chunk = placeChunk,
-		block = placeBlock
-	}
-end
-
-function PlacementManager:Init()
-	game:GetService("RunService").RenderStepped:Connect(function()
-		local a,b = pcall(function()
-			PlacementManager:Raycast()
-		end)
-		if not a then
-			PlacementManager.SelectionBox.Adornee = nil
-			script.RaycastResult.Value = nil
-		end
-	end)
-	tickRemote.OnClientEvent:Connect(function(m, cx, cy, cz, x, y, z, d)
-		--warn("PROPOGATED TICK", m, cx, cy, cz, x, y, z, d)
-		if m == "B_C" then
-			applyPlaceBlockLocal(cx, cy, cz, x, y ,z, d)
-		end
-		if m == "B_D" then
-			applyBreakBlockLocal(cx, cy, cz, x, y ,z)
-		end
-		if m == "C_R" then
-			clearPendingBreaksForChunk(makeChunkKey(cx, cy, cz))
-			ChunkManager:RefreshChunk(cx, cy, cz)
-		end
-	end)
-end
-
-return PlacementManager

src/ServerScriptService/Actor/PlayerScale.server.lua

@@ -1,47 +0,0 @@
---!native
---!optimize 2
-
-local Players = game:GetService("Players")
-
-local SCALE = 1.4
-
-local function applyScale(character: Model)
-	if character.ScaleTo then
-		pcall(function()
-			character:ScaleTo(SCALE)
-		end)
-		return
-	end
-
-	local humanoid = character:FindFirstChildOfClass("Humanoid")
-	if not humanoid then
-		return
-	end
-
-	if humanoid.RigType == Enum.HumanoidRigType.R15 then
-		for _, name in ipairs({"BodyHeightScale", "BodyWidthScale", "BodyDepthScale", "HeadScale"}) do
-			local scaleValue = humanoid:FindFirstChild(name)
-			if scaleValue then
-				scaleValue.Value = SCALE
-			end
-		end
-	end
-end
-
-local function onCharacterAdded(character: Model)
-	character:WaitForChild("Humanoid", 5)
-	applyScale(character)
-end
-
-local function onPlayerAdded(player: Player)
-	player.CharacterAdded:Connect(onCharacterAdded)
-	if player.Character then
-		onCharacterAdded(player.Character)
-	end
-end
-
-for _, player in ipairs(Players:GetPlayers()) do
-	onPlayerAdded(player)
-end
-
-Players.PlayerAdded:Connect(onPlayerAdded)

src/ServerScriptService/Actor/ServerChunkManager/TerrainGen/init.lua

@@ -1,73 +0,0 @@
---!native
---!optimize 2
-
-local TerrainGen = {}
-
-local deflate = require("./TerrainGen/Deflate")
-
-local DSS = game:GetService("DataStoreService")
-local WORLDNAME = "DEFAULT"
-local WORLDID = "b73bb5a6-297d-4352-b637-daec7e8c8f3e"
-local Store = DSS:GetDataStore("BlockscraftWorldV1", WORLDID)
-
-local ChunkManager = require(game:GetService("ReplicatedStorage"):WaitForChild("Shared").ChunkManager)
-local Chunk = require(game:GetService("ReplicatedStorage"):WaitForChild("Shared").ChunkManager.Chunk)
-
-TerrainGen.ServerChunkCache = {} :: {[typeof("")]: typeof(Chunk.new(0,0,0))}
-
--- Load a chunk from the DataStore or generate it if not found
-function TerrainGen:GetChunk(x, y, z)
-	local key = `{x},{y},{z}`
-	if TerrainGen.ServerChunkCache[key] then
-		return TerrainGen.ServerChunkCache[key]
-	end
-	
-	-- Generate a new chunk if it doesn't exist
-	local chunk = Chunk.new(x, y, z)
-	if y == 1 then
-		for cx = 1, 8 do
-			for cz = 1, 8 do
-				--local perlin = math.noise(((x*8)+cx)/100,((z*8)+cz)/100)
-				chunk:CreateBlock(cx, 1, cz, { id = 1, state = {} })
-				--chunk:CreateBlock(x, 2, z, { id = 1, state = {} })
-			end
-		end
-	end
-	if y == 0 then
-		for cx = 1, 8 do
-			for cy = 1, 8 do
-				for cz = 1, 8 do
-					--local perlin = math.noise(((x*8)+cx)/100,((z*8)+cz)/100)
-					chunk:CreateBlock(cx, cy, cz, { id = 2, state = {} })
-					--chunk:CreateBlock(x, 2, z, { id = 1, state = {} })
-				end
-			end
-		end
-	end
-
-	TerrainGen.ServerChunkCache[key] = chunk
-	return chunk
-end
-
--- Fake Chunk
-function TerrainGen:GetFakeChunk(x, y, z)
-
-	-- Generate a new chunk if it doesn't exist
-	local chunk = Chunk.new(x, y, z)
-	for cy = 1,8 do
-		for cx = 1, 8 do
-			for cz = 1, 8 do
-				--local perlin = math.noise(((x*8)+cx)/100,((z*8)+cz)/100)
-				chunk:CreateBlock(cx, cy, cz, { id = -2, state = {} })
-				--chunk:CreateBlock(x, 2, z, { id = 1, state = {} })
-			end
-		end
-	end
-
-	return chunk
-end
-
-
-TerrainGen.CM = ChunkManager
-
-return TerrainGen

src/StarterPlayer/StarterPlayerScripts/Actor/BlockInteraction.client.lua

@@ -1,4 +0,0 @@
---!native
---!optimize 2
-
-return

wally.lock

@@ -7,10 +7,15 @@ name = "evaera/cmdr"
 version = "1.12.0"
 dependencies = []
 
+[[package]]
+name = "ivasmigins/replica"
+version = "0.1.0"
+dependencies = []
+
 [[package]]
 name = "ocbwoy3-development-studios/minecraft-roblox"
 version = "0.1.0"
-dependencies = [["cmdr", "evaera/cmdr@1.12.0"], ["roact", "roblox/roact@1.4.4"]]
+dependencies = [["cmdr", "evaera/cmdr@1.12.0"], ["replica", "ivasmigins/replica@0.1.0"], ["roact", "roblox/roact@1.4.4"]]
 
 [[package]]
 name = "roblox/roact"

wally.toml

@@ -7,3 +7,4 @@ realm = "shared"
 [dependencies]
 cmdr = "evaera/cmdr@1.12.0"
 roact = "roblox/roact@1.4.4"
+replica = "ivasmigins/replica@0.1.0"