chore: refractor
This commit is contained in:
683
ReplicatedStorage/Shared/PlacementManager.lua
Normal file
683
ReplicatedStorage/Shared/PlacementManager.lua
Normal file
@@ -0,0 +1,683 @@
|
||||
--!native
|
||||
--!optimize 2
|
||||
|
||||
local PlacementManager = {}
|
||||
|
||||
local ChunkManager = require("./ChunkManager")
|
||||
local Util = require("./Util")
|
||||
|
||||
local DEBUG_PLACEMENT = true
|
||||
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()
|
||||
if not Mouse then
|
||||
Mouse = game:GetService("Players").LocalPlayer:GetMouse()
|
||||
end
|
||||
local chunkFolder = ensureChunkFolder()
|
||||
if not chunkFolder then
|
||||
clearSelection("chunk folder missing")
|
||||
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
|
||||
clearSelection("raycast miss")
|
||||
script.RaycastResult.Value = nil
|
||||
debugPlacementLog("[PLACE][CLIENT][RAYCAST]", "miss")
|
||||
return
|
||||
end
|
||||
|
||||
local objLookingAt = result.Instance
|
||||
if not objLookingAt then
|
||||
clearSelection("raycast nil instance")
|
||||
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"
|
||||
)
|
||||
clearSelection("target not in chunk folder")
|
||||
script.RaycastResult.Value = nil
|
||||
return
|
||||
end
|
||||
if hitChunkFolder:GetAttribute("ns") == true then
|
||||
debugPlacementWarn(
|
||||
"[PLACE][CLIENT][REJECT]",
|
||||
"chunk flagged ns",
|
||||
hitChunkFolder:GetFullName()
|
||||
)
|
||||
clearSelection("target chunk marked ns")
|
||||
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
|
||||
clearSelection("failed to resolve chunk/block")
|
||||
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
|
||||
clearSelection("failed to parse chunk/block names")
|
||||
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
|
||||
clearSelection("block pending break")
|
||||
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
|
||||
clearSelection("block missing/air")
|
||||
script.RaycastResult.Value = nil
|
||||
return
|
||||
end
|
||||
local blockInstance = resolveBlockInstance(chunkFolder, chunkName, blockName) or blockRoot
|
||||
if not blockInstance then
|
||||
clearSelection("missing block instance")
|
||||
script.RaycastResult.Value = nil
|
||||
return
|
||||
end
|
||||
|
||||
lastRaycastFailure = nil
|
||||
if lastSelectedChunkKey ~= chunkKey or lastSelectedBlockKey ~= blockKey then
|
||||
setSelection(blockInstance, PlacementManager.ChunkFolder)
|
||||
lastSelectedChunkKey = chunkKey
|
||||
lastSelectedBlockKey = blockKey
|
||||
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 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(): nil | {chunk:Vector3, block: Vector3}
|
||||
pcall(function()
|
||||
PlacementManager:Raycast()
|
||||
end)
|
||||
local selectedPart = PlacementManager:RaycastGetResult()
|
||||
--print(selectedPart and selectedPart:GetFullName() or nil)
|
||||
if selectedPart == nil then
|
||||
clearSelection()
|
||||
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(): 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)
|
||||
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()
|
||||
local placement = PlacementManager:GetPlacementAtMouse()
|
||||
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
|
||||
Reference in New Issue
Block a user