hotbar: wrap

.gitignore

@@ -1 +1,2 @@
-Packages/
+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/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}
 }
@@ -35,7 +36,11 @@ local lastChunkKey: string? = nil
 local lastHeavyTick = 0
 local HEAVY_TICK_INTERVAL = 1.5
 local lastUnloadSweep = 0
-local UNLOAD_SWEEP_INTERVAL = 1.5
+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)
@@ -53,6 +58,11 @@ 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()
@@ -77,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
@@ -112,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
 
@@ -136,6 +269,7 @@ function ChunkManager:LoadChunk(x, y, z)
 		chunk.instance = instance
 		chunk.loaded = true
 		unloadingChunks[key] = nil
+		evictOutOfRangeChunks(getLocalPlayerChunkPos())
 	end)
 end
 
@@ -251,7 +385,7 @@ end
 
 function ChunkManager:Tick()
 	ChunkManager:ForceTick()
-	local player = game:GetService("Players").LocalPlayer
+	local player = Players.LocalPlayer
 	if not player.Character then
 		return
 	end
@@ -263,6 +397,7 @@ function ChunkManager:Tick()
 		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
@@ -270,26 +405,29 @@ function ChunkManager:Tick()
 		lastHeavyTick = now
 	end
 
+	setCharacterFrozen(not (currentChunk and currentChunk.loaded))
+
 	if shouldHeavyTick then
 		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 = now
-				if not chunk.loaded then
-					ChunkManager:LoadChunk(cx, cy, cz)
-					processed += 1
-					if processed % LOAD_BATCH == 0 then
-						Swait(1)
+				if chunk then
+					chunk.inhabitedTime = now
+					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
-		local current = Chunk.AllChunks[ck]
-		if current then
-			current.inhabitedTime = now
+		if currentChunk then
+			currentChunk.inhabitedTime = now
 		end
 	end
 	
@@ -318,14 +456,8 @@ function ChunkManager:Tick()
 	if now - lastUnloadSweep >= UNLOAD_SWEEP_INTERVAL then
 		lastUnloadSweep = now
 		for key, loadedChunk in pairs(Chunk.AllChunks) do
-			if now - loadedChunk.inhabitedTime > 15 and not unloadingChunks[key] then
-				unloadingChunks[key] = true
-				task.defer(function()
-					loadedChunk:Unload()
-					loadedChunk:Destroy()
-					Chunk.AllChunks[key] = nil
-					unloadingChunks[key] = nil
-				end)
+			if now - loadedChunk.inhabitedTime > 30 and not unloadingChunks[key] and not shouldSkipUnload(key) then -- keep chunks around longer before unloading
+				scheduleChunkUnload(key, loadedChunk)
 			end
 		end
 	end

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

@@ -6,7 +6,7 @@ local PlacementManager = {}
 local ChunkManager = require("./ChunkManager")
 local Util = require("./Util")
 
-local DEBUG_PLACEMENT = true
+local DEBUG_PLACEMENT = false
 local function debugPlacementLog(...: any)
 	if DEBUG_PLACEMENT then
 		Util.StudioLog(...)
@@ -79,7 +79,7 @@ local function findBlockRoot(inst: Instance, chunkFolder: Instance): Instance?
 		if current:IsA("BasePart") then
 			return current
 		end
-	current = current.Parent
+		current = current.Parent
 	end
 	return nil
 end
@@ -265,13 +265,15 @@ local function ensureChunkFolder(): Instance?
 end
 
 -- Gets the block and normalid of the block (and surface) the player is looking at
-function PlacementManager:Raycast()
+function PlacementManager:Raycast(skipSelection: boolean?)
 	if not Mouse then
 		Mouse = game:GetService("Players").LocalPlayer:GetMouse()
 	end
 	local chunkFolder = ensureChunkFolder()
 	if not chunkFolder then
-		clearSelection("chunk folder missing")
+		if not skipSelection then
+			clearSelection("chunk folder missing")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -285,7 +287,9 @@ function PlacementManager:Raycast()
 	local ray = Mouse.UnitRay
 	local result = workspace:Raycast(ray.Origin, ray.Direction * MAX_REACH, raycastParams)
 	if not result then
-		clearSelection("raycast miss")
+		if not skipSelection then
+			clearSelection("raycast miss")
+		end
 		script.RaycastResult.Value = nil
 		debugPlacementLog("[PLACE][CLIENT][RAYCAST]", "miss")
 		return
@@ -293,7 +297,9 @@ function PlacementManager:Raycast()
 
 	local objLookingAt = result.Instance
 	if not objLookingAt then
-		clearSelection("raycast nil instance")
+		if not skipSelection then
+			clearSelection("raycast nil instance")
+		end
 		script.RaycastResult.Value = nil
 		debugPlacementWarn("[PLACE][CLIENT][RAYCAST]", "nil instance in result")
 		return
@@ -308,7 +314,9 @@ function PlacementManager:Raycast()
 			"parent",
 			objLookingAt.Parent and objLookingAt.Parent:GetFullName() or "nil"
 		)
-		clearSelection("target not in chunk folder")
+		if not skipSelection then
+			clearSelection("target not in chunk folder")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -318,7 +326,9 @@ function PlacementManager:Raycast()
 			"chunk flagged ns",
 			hitChunkFolder:GetFullName()
 		)
-		clearSelection("target chunk marked ns")
+		if not skipSelection then
+			clearSelection("target chunk marked ns")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -327,7 +337,9 @@ function PlacementManager:Raycast()
 	local blockRoot = findBlockRoot(objLookingAt, chunkFolder) or objLookingAt
 	local chunkName, blockName = findChunkAndBlock(blockRoot)
 	if not chunkName or not blockName then
-		clearSelection("failed to resolve chunk/block")
+		if not skipSelection then
+			clearSelection("failed to resolve chunk/block")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -338,7 +350,9 @@ function PlacementManager:Raycast()
 		return Util.BlockPosStringToCoords(blockName)
 	end)
 	if not okChunk or not okBlock then
-		clearSelection("failed to parse chunk/block names")
+		if not skipSelection then
+			clearSelection("failed to parse chunk/block names")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -347,7 +361,9 @@ function PlacementManager:Raycast()
 
 	-- block is being optimistically broken, do not highlight it
 	if getPendingBreak(chunkKey, blockKey) then
-		clearSelection("block pending break")
+		if not skipSelection then
+			clearSelection("block pending break")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
@@ -356,22 +372,28 @@ function PlacementManager:Raycast()
 	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
-		clearSelection("block missing/air")
+		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
-		clearSelection("missing block instance")
+		if not skipSelection then
+			clearSelection("missing block instance")
+		end
 		script.RaycastResult.Value = nil
 		return
 	end
 
 	lastRaycastFailure = nil
-	if lastSelectedChunkKey ~= chunkKey or lastSelectedBlockKey ~= blockKey then
-		setSelection(blockInstance, PlacementManager.ChunkFolder)
-		lastSelectedChunkKey = chunkKey
-		lastSelectedBlockKey = blockKey
+	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)
@@ -400,6 +422,10 @@ 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
@@ -551,14 +577,16 @@ local function applyBreakBlockLocal(cx, cy, cz, x, y, z)
 	chunk:RemoveBlock(x, y, z)
 end
 
-function PlacementManager:GetBlockAtMouse(): nil | {chunk:Vector3, block: Vector3}
+function PlacementManager:GetBlockAtMouse(skipSelection: boolean?): nil | {chunk:Vector3, block: Vector3}
 	pcall(function()
-		PlacementManager:Raycast()
+		PlacementManager:Raycast(skipSelection)
 	end)
 	local selectedPart = PlacementManager:RaycastGetResult()
 	--print(selectedPart and selectedPart:GetFullName() or nil)
 	if selectedPart == nil then
-		clearSelection()
+		if not skipSelection then
+			clearSelection()
+		end
 		script.RaycastResult.Value = nil
 		debugPlacementLog("[PLACE][CLIENT][TARGET]", "no selectedPart after raycast", lastRaycastFailure)
 		return nil
@@ -607,8 +635,8 @@ function PlacementManager:GetBlockAtMouse(): nil | {chunk:Vector3, block: Vector
 
 end
 
-function PlacementManager:GetTargetAtMouse(): nil | {chunk:Vector3, block: Vector3, normal: Enum.NormalId}
-	local hit = PlacementManager:GetBlockAtMouse()
+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
@@ -621,8 +649,8 @@ function PlacementManager:GetTargetAtMouse(): nil | {chunk:Vector3, block: Vecto
 	}
 end
 
-function PlacementManager:GetPlacementAtMouse(): nil | {chunk:Vector3, block: Vector3}
-	local hit = PlacementManager:GetTargetAtMouse()
+function PlacementManager:GetPlacementAtMouse(skipSelection: boolean?): nil | {chunk:Vector3, block: Vector3}
+	local hit = PlacementManager:GetTargetAtMouse(skipSelection)
 	if not hit then
 		return nil
 	end
@@ -647,8 +675,8 @@ function PlacementManager:GetPlacementAtMouse(): nil | {chunk:Vector3, block: Ve
 	}
 end
 
-function PlacementManager:DebugGetPlacementOrWarn()
-	local placement = PlacementManager:GetPlacementAtMouse()
+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

ReplicatedStorage/Shared/Util.lua

@@ -1,18 +1,19 @@
 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 then
+	if not IS_STUDIO or not ENABLE_STUDIO_LOG then
 		return
 	end
 	print(...)
 end
 
 function module.StudioWarn(...: any)
-	if not IS_STUDIO then
+	if not IS_STUDIO or not ENABLE_STUDIO_LOG then
 		return
 	end
 	warn(...)

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

@@ -63,9 +63,7 @@ function TerrainGen:GetChunk(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 = {} })
+				chunk:CreateBlock(cx, 1, cz, { id = "mc:grass_block", state = {} })
 			end
 		end
 	end
@@ -73,9 +71,7 @@ function TerrainGen:GetChunk(x, y, z)
 		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 = {} })
+					chunk:CreateBlock(cx, cy, cz, { id = "mc:dirt_block", state = {} })
 				end
 			end
 		end
@@ -93,9 +89,7 @@ function TerrainGen:GetFakeChunk(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 = {} })
+				chunk:CreateBlock(cx, cy, cz, { id = "invalid", state = {} })
 			end
 		end
 	end

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)
@@ -176,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

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
@@ -22,4 +24,4 @@ UIS.InputEnded:Connect(function(k)
 		script.Parent.CrosshairLabel.Visible = not v
 		script.Parent.DummyButton.Modal = v
 	end
-end)
+end)

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,15 +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
 
@@ -51,33 +52,34 @@ local function isTextInputFocused(): boolean
 	return config ~= nil and config.IsFocused
 end
 
-local function buildHotbarIds(): {string}
-	local ids = {}
-	local names = {}
-	for _, block in ipairs(blocksFolder:GetChildren()) do
-		local id = block:GetAttribute("n")
-		if id ~= nil then
-			local n = tonumber(id)
-			if n and n > 0 then
-				local idStr = tostring(n)
-				table.insert(ids, idStr)
-				names[idStr] = block:GetAttribute("displayName") or block:GetAttribute("dn") or block.Name
-			end
-		end
+local function resolveSelectedSlot(slots, desired)
+	if desired and desired >= 1 and desired <= HOTBAR_SIZE then
+		return desired
 	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)
@@ -129,42 +131,46 @@ end
 local Hotbar = Roact.Component:extend("Hotbar")
 
 function Hotbar:init()
+	local slots, names, selected = buildHotbarFromState()
 	self.state = {
-		slots = nil,
-		names = nil,
-		selected = 1,
+		slots = slots,
+		names = names,
+		selected = selected,
 	}
-	local slots, names = buildHotbarIds()
-	self.state.slots = slots
-	self.state.names = names
-	local initialId = slots and slots[1] or ""
-	if initialId and initialId ~= "" then
-		local initialName = names and (names[initialId] or initialId) or initialId
-		PlacementState:SetSelected(initialId, initialName)
-	end
 
-	self._updateSlots = function()
-		local nextSlots, nextNames = buildHotbarIds()
+	self._syncFromClientState = function()
+		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
-			name = self.state.names[id] or id
+		if rawId ~= "" then
+			name = self.state.names[rawId] or rawId
 		end
-		Util.StudioLog("[PLACE][CLIENT][SELECT]", "slot", slot, "id", id, "name", name)
-		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)
@@ -202,7 +208,7 @@ function Hotbar:init()
 		elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
 			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()
+			local mouseBlock = PM:DebugGetPlacementOrWarn(true) -- skip selection outline on right click
 			if not mouseBlock then
 				return
 			end
@@ -244,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
@@ -256,19 +262,20 @@ end
 
 function Hotbar:didMount()
 	self._connections = {
-		blocksFolder.ChildAdded:Connect(self._updateSlots),
-		blocksFolder.ChildRemoved:Connect(self._updateSlots),
+		ClientState.Changed:Connect(self._syncFromClientState),
 		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
-		name = self.state.names[id] or id
+	if rawId ~= "" and self.state.names then
+		name = self.state.names[rawId] or rawId
 	end
-	PlacementState:SetSelected(id, name)
+	PlacementState:SetSelected(effectiveId, name)
 end
 
 function Hotbar:willUnmount()
@@ -308,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),
@@ -339,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),
@@ -353,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,
@@ -406,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 ML = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("ModLoader"))
-
-ML.loadModsC()
+local objects = ReplicatedStorage:WaitForChild("Objects", 9e9)
+objects:WaitForChild("MLLoaded", 9e9)
+objects:WaitForChild("CSMLLoaded", 9e9)
 
 do
 	local PM = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("PlacementManager"))
@@ -26,4 +26,4 @@ end
 do
 	local CM = require(ReplicatedStorage:WaitForChild("Shared"):WaitForChild("ChunkManager"))
 	CM:Init()
-end
+end

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

@@ -2,43 +2,51 @@
   "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"
-      },
-      "$ignoreUnknownInstances": true
+        "$path": "StarterPlayer/StarterPlayerScripts"
+      }
     },
+
     "Workspace": {
       "$className": "Workspace",
       "$ignoreUnknownInstances": true,
-      "$path": "src/Workspace"
+      "$path": "Workspace"
     }
   }
-}
+}

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/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"