Work

-- 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" })

  -- Anyone who spawns mid-round (late join / respawn) is sent
  -- straight into the arena instead of stranded in the 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)

  -- Win condition: the dummy dies. Nothing else ends the 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

-- Identity comes from the snapshot, not the part's name: a Tool also has a
-- child called "Handle", and matching by name would scale a tool's grip
-- offset while never resizing the tool — drifting it out of the hand.
local function scaleForPart(part)
  if part and snapshot.uniformParts[part] then
    return uniformScale   -- head and anything hanging off it
  end
  return bodyScale          -- torso and limbs: height vs. width separately
end

-- How far the feet sit below the pivot before and after, so the model is
-- lifted by the difference instead of being resized into the floor and
-- shoved out by the physics solver.
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 -- malformed/exploited payload, ignore silently
  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
    -- too low: the request is just dropped — no error, no exploit surface
  else
    sprintingByPlayer[player] = false
  end
end)