Trabalhos

-- Server-side source of truth for prices. Never trust the client with prices.
local SHOP_CATALOG = {
  SwordCommon    = { price = 50,  displayName = "Common Sword" },
  SwordRare      = { price = 200, displayName = "Rare Sword" },
  PotionHeal     = { price = 15,  displayName = "Healing Potion" },
  SpeedBoostGear = { price = 80,  displayName = "Speed Boost" },
}

local function attemptPurchase(player, itemId)
  local item = SHOP_CATALOG[itemId]
  local data = sessionCache[player.UserId]

  if not item or not data then
    return false, "Invalid item or player data not loaded"
  end

  if data.coins < item.price then
    return false, "Not enough coins"
  end

  data.coins -= item.price
  data.inventory[itemId] = (data.inventory[itemId] or 0) + 1

  return true, item.displayName
end

-- Server-side source of truth. Client never decides what it owns or what it …
local DROPPER_CATALOG = {
  BasicDropper   = { price = 0,    income = 1  }, -- free starter dropper
  FastDropper    = { price = 250,  income = 3  },
  PremiumDropper = { price = 1000, income = 10 },
}

local function claimPlot(player)
  if playerPlots[player.UserId] then
    return -- already owns a plot
  end

  local plot = findOpenPlot()
  if not plot then
    return
  end

  plotOwners[plot] = player.UserId
  playerPlots[player.UserId] = plot
  plot.Owner.Value = player.Name

  local progress = loadProgress(player)
  playerCash[player.UserId] = progress.cash
end

local function runRound()
  local arenaModel, dummyHumanoid = ArenaFactory.Build()
  local spawnPart = arenaModel:FindFirstChild("ArenaSpawn")
  local arenaCFrame = spawnPart and spawnPart.CFrame or arenaModel:GetPivot()

  teleportAllTo(arenaCFrame)
  Net.FireAll("RoundStateChanged", { state = "Round" })

  -- Quem spawna no meio do round (entrada tardia / respawn) vai
  -- direto para a arena em vez de ficar preso no lobby.
  local charConns = {}
  local function hookPlayer(player)
    charConns[player] = player.CharacterAdded:Connect(function(character)
      task.wait(0.5)
      character:PivotTo(arenaCFrame)
    end)
  end
  for _, player in ipairs(Players:GetPlayers()) do hookPlayer(player) end
  local addedConn = Players.PlayerAdded:Connect(hookPlayer)

  -- Condição de vitória: o dummy morre. Nada mais encerra o round.
  dummyHumanoid.Died:Wait()

  addedConn:Disconnect()
  for _, conn in pairs(charConns) do conn:Disconnect() end

-- Seconds between player-detection scans per NPC while patrolling. Each scan
-- costs one raycast per player in the server (line-of-sight check), so with
-- many NPCs and many players this — not pathfinding — is the real hot path.
-- 0.2s is imperceptible to a player (they can't tell an NPC "noticed" them
-- 200ms late) but cuts the scan load ~12x compared to scanning every
-- Heartbeat at 60fps (60 scans/s -> 5 scans/s per NPC).
NPCConfig.DETECTION_INTERVAL = 0.2

-- Seconds between PathfindingService:ComputeAsync() calls per NPC while
-- chasing. Recomputing every Heartbeat is expensive at any real NPC count
-- and unnecessary — a path that is half a second stale is still a
-- reasonable approximation of "walk toward the target".
NPCConfig.PATH_RECOMPUTE_INTERVAL = 0.5

-- A identidade vem do snapshot, não do nome da parte: uma Tool também tem
-- um filho chamado "Handle", e comparar por nome escalaria o offset de
-- empunhadura sem redimensionar a ferramenta — ela sairia da mão.
local function scaleForPart(part)
  if part and snapshot.uniformParts[part] then
    return uniformScale   -- cabeça e tudo pendurado nela
  end
  return bodyScale          -- torso e membros: altura e largura separadas
end

-- Quanto os pés ficam abaixo do pivô antes e depois, para levantar o modelo
-- pela diferença em vez de redimensioná-lo para dentro do chão e deixar o
-- solver de física empurrá-lo para fora.
local originalDrop = originalLegY + (0.5 * originalRootY) + snapshot.hipHeight
local scaledDrop = originalDrop * scaleY

for part, originalSize in pairs(snapshot.partSizes) do
  if part.Parent then
    part.Size = originalSize * scaleForPart(part)
  end
end

sprintEvent.OnServerEvent:Connect(function(player, wantsToSprint)
  if typeof(wantsToSprint) ~= "boolean" then
    return -- payload malformado/exploit: ignora em silêncio
  end

  local stamina = staminaByPlayer[player]
  if not stamina then
    return
  end

  if wantsToSprint then
    if stamina > MIN_STAMINA_TO_START then
      sprintingByPlayer[player] = true
    end
    -- stamina baixa: o pedido é só descartado — sem erro, sem superfície de …
  else
    sprintingByPlayer[player] = false
  end
end)