смотри:
это скрипт UI:
--!strict

--------------------------------------------------------------------------------
-- FishClient.local.lua
-- Локальный скрипт, отвечающий за интерфейс (UI) инвентаря, магазина удочек,
-- бестиария, трейдов и т.д. + анимации (TweenService) или "флоп" для рыбы в руках.
--
-- В этом варианте:
-- • При показе моделей рыбы/удочек в ViewportFrame они
-- - Масштабируются и центрируются
-- - Ставятся под нужным углом
-- - Крутятся вокруг оси
-- • "Цена за кг" в Бестиарии более крупная, лучше видна.
-- • Исправлены проблемы отсутствия видимости/ориентации.
--------------------------------------------------------------------------------

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

--------------------------------------------------------------------------------
-- RemoteEvents
--------------------------------------------------------------------------------
local inventoryRemoteEvent = ReplicatedStorage:WaitForChild("InventoryRemoteEvent")
local bestiaryRemoteEvent = ReplicatedStorage:WaitForChild("BestiaryRemoteEvent")
local rodShopRemoteEvent = ReplicatedStorage:WaitForChild("RodShopRemoteEvent")
local tradeRemoteEvent = ReplicatedStorage:WaitForChild("TradeRemoteEvent")

local fishModelsFolder = ReplicatedStorage:WaitForChild("FishModels")

--------------------------------------------------------------------------------
-- Помощные функции для оформления GUI
--------------------------------------------------------------------------------
local function applyCornerAndStroke(instanceGui: GuiObject, cornerRadius: number, strokeThickness: number, strokeColor: Color3)
local uiCorner = Instance.new("UICorner")
uiCorner.CornerRadius = UDim.new(0, cornerRadius)
uiCorner.Parent = instanceGui

local uiStroke = Instance.new("UIStroke")
uiStroke.Thickness = strokeThickness
uiStroke.Color = strokeColor
uiStroke.Parent = instanceGui
end

local function applyGradientBackground(frame: Frame, color1: Color3, color2: Color3)
local gradient = Instance.new("UIGradient")
gradient.Color = ColorSequence.new{
ColorSequenceKeypoint.new(0, color1),
ColorSequenceKeypoint.new(1, color2),
}
gradient.Rotation = 90
gradient.Parent = frame
end

--------------------------------------------------------------------------------
-- Функция для загрузки модели в ViewportFrame:
-- • Клонирует модель (рыбу или удочку)
-- • Масштабирует и центрирует в (0,0,0)
-- • Поворачивает под углом (зависит от isFish)
-- • Ставит камеру на нужное расстояние
-- • Возвращает clone и camera, чтобы можно было крутить
--------------------------------------------------------------------------------
local function spawnModelInViewport(worldModel: WorldModel, folderName: string, modelName: string, isFish: boolean)
-- Ищем папку (для рыбы это fishModelsFolder, для удочек может быть другая, но здесь пример)
local folder = nil
if isFish then
folder = fishModelsFolder:FindFirstChild(folderName)
else
-- Для удочки в этом примере нет отдельной структуры,
-- но если у вас есть "Rod" или что-то, придётся искать там.
-- Ниже строка сохранена просто как пример.
folder = ReplicatedStorage:FindFirstChild(folderName)
if not folder then
folder = fishModelsFolder:FindFirstChild(folderName) -- fallback
end
end
if not folder then return nil end

local originalModel = folder:FindFirstChild(modelName)
if not originalModel or not originalModel:IsA("Model") then
return nil
end

-- Клонируем
local clone = originalModel:Clone()
clone.Parent = worldModel

-- Все части Anchored
for _, part in ipairs(clone:GetDescendants()) do
if part:IsA("BasePart") then
part.Anchored = true
end
end

-- Рассчитаем BoundingBox (центр и размеры)
local cf, size = clone:GetBoundingBox()
local maxDim = math.max(size.X, size.Y, size.Z)

-- Скажем, хотим поместить в область ~5×5×5 (можно менять)
local desiredSize = 5
if maxDim < 0.01 then
maxDim = 0.01
end
local scaleFactor = desiredSize / maxDim

-- Применяем масштаб
for _, part in ipairs(clone:GetDescendants()) do
if part:IsA("BasePart") then
part.Size = part.Size * scaleFactor
end
end

-- Ещё раз берём BoundingBox после масштабирования
cf, size = clone:GetBoundingBox()

-- Сдвигаем модель в (0,0,0), чтобы её центр оказался в Origin
-- Инвертируем cf (центр модели) и применяем
clone:PivotTo(cf:Inverse() * cf) -- эквивалентно pivot в (0,0,0)

-- Небольшой наклон/поворот:
-- • Для рыбы, например, чуть под наклоном (30 градусов вокруг X, +180 по Y)
-- • Для удочки — чуть иначе
if isFish then
clone:PivotTo(CFrame.Angles(math.rad(30), math.rad(180), 0))
else
clone:PivotTo(CFrame.Angles(0, math.rad(180), 0))
end

-- Создаём камеру
local camera = Instance.new("Camera")
camera.Parent = worldModel

-- Располагаем камеру на расстоянии, пропорциональном габаритам (например, *1.5)
local dist = math.max(size.X, size.Y, size.Z) * 1.5
-- Ставим камеру перед моделью (0,0,dist)
camera.CFrame = CFrame.new(0, 0, dist)
return clone, camera
end

--------------------------------------------------------------------------------
-- АНИМАЦИИ инструментов (рыбы, удочки) при экипировке
--------------------------------------------------------------------------------

-- Простая анимация удочки (покачивание).
local function equipRodAnimation(tool: Tool)
if not tool then return end

-- Ищем PrimaryPart в удочке или любую часть
local primaryPart = nil
for _, part in ipairs(tool:GetDescendants()) do
if part:IsA("BasePart") or part:IsA("MeshPart") then
primaryPart = part
break
end
end
if not primaryPart then return end

local angle = 0
local connection: RBXScriptConnection?
connection = RunService.Heartbeat:Connect(function(dt)
if not tool.Parent or not tool.Parent:IsA("Model") then
if connection then connection:Disconnect() end
return
end

angle += dt * 60
local rot = math.sin(math.rad(angle)) * 10
local cframe = primaryPart.CFrame * CFrame.Angles(0, 0, math.rad(rot))
primaryPart.CFrame = cframe
end)
end

-- "Флоп"-анимация для рыбы, когда игрок держит её в руке (локально).
local function flopFishAnimation(fishModel: Model)
if not fishModel or not fishModel.PrimaryPart then return end

local primaryPart = fishModel.PrimaryPart
local angle = 0
local amplitude = 10
local speed = 2

local connection: RBXScriptConnection?
connection = RunService.Heartbeat:Connect(function(dt)
if not fishModel.Parent then
if connection then connection:Disconnect() end
return
end
if not fishModel.PrimaryPart then
if connection then connection:Disconnect() end
return
end

angle += dt * speed * 100
local offsetRot = math.sin(math.rad(angle)) * amplitude
primaryPart.CFrame = primaryPart.CFrame * CFrame.Angles(0, 0, math.rad(offsetRot / 30))
end)
end

--------------------------------------------------------------------------------
-- Главное окно интерфейса
--------------------------------------------------------------------------------
local screenGui = Instance.new("ScreenGui")
screenGui.Name = "FishingInventoryUI"
screenGui.ResetOnSpawn = false
screenGui.Parent = playerGui

--------------------------------------------------------------------------------
-- Кнопка (сбоку) для открытия/закрытия главного окна
--------------------------------------------------------------------------------
local toggleButton = Instance.new("TextButton")
toggleButton.Name = "ToggleButton"
toggleButton.Size = UDim2.new(0, 40, 0, 100)
toggleButton.Position = UDim2.new(0, 0, 0.5, -50)
toggleButton.BackgroundColor3 = Color3.fromRGB(50, 50, 90)
toggleButton.Text = "<"
toggleButton.TextColor3 = Color3.fromRGB(255, 255, 255)
toggleButton.Font = Enum.Font.GothamBold
toggleButton.TextSize = 24
toggleButton.Parent = screenGui
applyCornerAndStroke(toggleButton, 8, 2, Color3.fromRGB(20,20,50))
applyGradientBackground(toggleButton, Color3.fromRGB(60,60,120), Color3.fromRGB(40,40,80))

--------------------------------------------------------------------------------
-- Главное окно (инвентарь и кнопки)
--------------------------------------------------------------------------------
local mainFrame = Instance.new("Frame")
mainFrame.Name = "MainFrame"
mainFrame.Size = UDim2.new(0, 420, 0, 340)
mainFrame.Position = UDim2.new(0, 60, 0, 200)
mainFrame.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
mainFrame.BorderSizePixel = 0
mainFrame.Visible = false
mainFrame.Parent = screenGui
applyCornerAndStroke(mainFrame, 10, 2, Color3.fromRGB(0, 0, 0))
applyGradientBackground(mainFrame, Color3.fromRGB(70, 70, 70), Color3.fromRGB(40, 40, 40))

local titleLabel = Instance.new("TextLabel")
titleLabel.Name = "TitleLabel"
titleLabel.Size = UDim2.new(1, 0, 0, 40)
titleLabel.BackgroundColor3 = Color3.fromRGB(80, 80, 120)
titleLabel.BorderSizePixel = 0
titleLabel.Text = "Рыболовное меню"
titleLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
titleLabel.TextScaled = true
titleLabel.Font = Enum.Font.GothamBold
titleLabel.Parent = mainFrame
applyCornerAndStroke(titleLabel, 0, 0, Color3.fromRGB(0, 0, 0))

--------------------------------------------------------------------------------
-- Кнопки действия (левый блок)
--------------------------------------------------------------------------------
local leftBlock = Instance.new("Frame")
leftBlock.Name = "LeftBlock"
leftBlock.Size = UDim2.new(0, 140, 1, -50)
leftBlock.Position = UDim2.new(0, 10, 0, 50)
leftBlock.BackgroundTransparency = 1
leftBlock.Parent = mainFrame

local refreshButton = Instance.new("TextButton")
refreshButton.Name = "RefreshButton"
refreshButton.Size = UDim2.new(0, 120, 0, 32)
refreshButton.Position = UDim2.new(0, 0, 0, 0)
refreshButton.BackgroundColor3 = Color3.fromRGB(100, 100, 130)
refreshButton.Text = "Обновить"
refreshButton.TextColor3 = Color3.fromRGB(255, 255, 255)
refreshButton.Font = Enum.Font.GothamBold
refreshButton.TextSize = 14
refreshButton.Parent = leftBlock
applyCornerAndStroke(refreshButton, 6, 1, Color3.fromRGB(20,20,40))

local sellAllButton = Instance.new("TextButton")
sellAllButton.Name = "SellAllButton"
sellAllButton.Size = UDim2.new(0, 120, 0, 32)
sellAllButton.Position = UDim2.new(0, 0, 0, 40)
sellAllButton.BackgroundColor3 = Color3.fromRGB(150, 100, 100)
sellAllButton.Text = "Продать всё"
sellAllButton.TextColor3 = Color3.fromRGB(255, 255, 255)
sellAllButton.Font = Enum.Font.GothamBold
sellAllButton.TextSize = 14
sellAllButton.Parent = leftBlock
applyCornerAndStroke(sellAllButton, 6, 1, Color3.fromRGB(40,20,20))

local sellHandButton = Instance.new("TextButton")
sellHandButton.Name = "SellHandButton"
sellHandButton.Size = UDim2.new(0, 120, 0, 32)
sellHandButton.Position = UDim2.new(0, 0, 0, 80)
sellHandButton.BackgroundColor3 = Color3.fromRGB(120, 100, 150)
sellHandButton.Text = "Продать в руках"
sellHandButton.TextColor3 = Color3.fromRGB(255, 255, 255)
sellHandButton.Font = Enum.Font.GothamBold
sellHandButton.TextSize = 14
sellHandButton.Parent = leftBlock
applyCornerAndStroke(sellHandButton, 6, 1, Color3.fromRGB(20,20,40))

local moneyLabel = Instance.new("TextLabel")
moneyLabel.Name = "MoneyLabel"
moneyLabel.Size = UDim2.new(0, 120, 0, 32)
moneyLabel.Position = UDim2.new(0, 0, 0, 120)
moneyLabel.BackgroundColor3 = Color3.fromRGB(20, 60, 20)
moneyLabel.Text = "Деньги: 0"
moneyLabel.TextColor3 = Color3.fromRGB(255, 255, 0)
moneyLabel.TextScaled = true
moneyLabel.Font = Enum.Font.GothamBold
moneyLabel.Parent = leftBlock
applyCornerAndStroke(moneyLabel, 6, 1, Color3.fromRGB(0,0,0))

local bestiaryButton = Instance.new("TextButton")
bestiaryButton.Name = "BestiaryButton"
bestiaryButton.Size = UDim2.new(0, 120, 0, 32)
bestiaryButton.Position = UDim2.new(0, 0, 0, 160)
bestiaryButton.BackgroundColor3 = Color3.fromRGB(100, 150, 100)
bestiaryButton.Text = "Бестиарий"
bestiaryButton.TextColor3 = Color3.fromRGB(255, 255, 255)
bestiaryButton.Font = Enum.Font.GothamBold
bestiaryButton.TextSize = 14
bestiaryButton.Parent = leftBlock
applyCornerAndStroke(bestiaryButton, 6, 1, Color3.fromRGB(20,40,20))

local openRodShopButton = Instance.new("TextButton")
openRodShopButton.Name = "OpenRodShopButton"
openRodShopButton.Size = UDim2.new(0, 120, 0, 32)
openRodShopButton.Position = UDim2.new(0, 0, 0, 200)
openRodShopButton.BackgroundColor3 = Color3.fromRGB(180, 180, 100)
openRodShopButton.Text = "Магазин удочек"
openRodShopButton.TextColor3 = Color3.fromRGB(40, 40, 40)
openRodShopButton.TextScaled = true
openRodShopButton.Font = Enum.Font.GothamBold
openRodShopButton.Parent = leftBlock
applyCornerAndStroke(openRodShopButton, 6, 1, Color3.fromRGB(40,40,0))

--------------------------------------------------------------------------------
-- Список рыбы в инвентаре (справа)
--------------------------------------------------------------------------------
local fishScroll = Instance.new("ScrollingFrame")
fishScroll.Name = "FishScroll"
fishScroll.Size = UDim2.new(0, 240, 1, -60)
fishScroll.Position = UDim2.new(1, -250, 0, 50)
fishScroll.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
fishScroll.BorderSizePixel = 0
fishScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
fishScroll.ScrollingDirection = Enum.ScrollingDirection.Y
fishScroll.Parent = mainFrame
applyCornerAndStroke(fishScroll, 8, 2, Color3.fromRGB(20,20,20))
applyGradientBackground(fishScroll, Color3.fromRGB(70,70,70), Color3.fromRGB(40,40,40))

local layout = Instance.new("UIListLayout")
layout.Parent = fishScroll
layout.FillDirection = Enum.FillDirection.Vertical
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Padding = UDim.new(0, 5)

--------------------------------------------------------------------------------
-- Открытие/закрытие главного окна
--------------------------------------------------------------------------------
local isMenuOpen = false
toggleButton.MouseButton1Click:Connect(function()
isMenuOpen = not isMenuOpen
mainFrame.Visible = isMenuOpen
toggleButton.Text = isMenuOpen and ">" or "<"
end)

--------------------------------------------------------------------------------
-- Перетаскивание mainFrame (ЛКМ)
--------------------------------------------------------------------------------
local dragging = false
local dragInput: InputObject?
local dragStart: Vector3?
local startPos: UDim2?

mainFrame.InputBegan:Connect(function(input)
if input.UserInputType == Enum.UserInputType.MouseButton1 then
dragging = true
dragStart = input.Position
startPos = mainFrame.Position
input.Changed:Connect(function()
if input.UserInputState == Enum.UserInputState.End then
dragging = false
end
end)
end
end)

mainFrame.InputChanged:Connect(function(input)
if input.UserInputType == Enum.UserInputType.MouseMovement then
dragInput = input
end
end)

UserInputService.InputChanged:Connect(function(input)
if input == dragInput and dragging and dragStart and startPos then
local delta = input.Position - dragStart
mainFrame.Position = UDim2.new(
startPos.X.Scale,
startPos.X.Offset + delta.X,
startPos.Y.Scale,
startPos.Y.Offset + delta.Y
)
end
end)

--------------------------------------------------------------------------------
-- Обработчики кнопок
--------------------------------------------------------------------------------
refreshButton.MouseButton1Click:Connect(function()
inventoryRemoteEvent:FireServer("getInventory")
end)

sellAllButton.MouseButton1Click:Connect(function()
inventoryRemoteEvent:FireServer("sellAll")
end)

sellHandButton.MouseButton1Click:Connect(function()
inventoryRemoteEvent:FireServer("sellInHand")
end)

--------------------------------------------------------------------------------
-- Функция обновления списка рыбы
--------------------------------------------------------------------------------
local function updateFishList(fishList: {{toolName:string, weight:number, price:number}})
for _, child in ipairs(fishScroll:GetChildren()) do
if child:IsA("TextLabel") then
child:Destroy()
end
end

for _, fishData in ipairs(fishList) do
local fishItem = Instance.new("TextLabel")
fishItem.BackgroundColor3 = Color3.fromRGB(80, 80, 80)
fishItem.Size = UDim2.new(1, -10, 0, 38)
fishItem.TextColor3 = Color3.fromRGB(255, 255, 255)
fishItem.Font = Enum.Font.Gotham
fishItem.TextSize = 15
fishItem.TextWrapped = true

-- Красивый формат: "Название | 3 кг | $10"
local namePart = tostring(fishData.toolName or "?")
local weightPart = tostring(fishData.weight or "?")
local pricePart = tostring(fishData.price or "?")
fishItem.Text = string.format("%s\nВес: %s кг | Цена: $%s", namePart, weightPart, pricePart)

fishItem.Parent = fishScroll
applyCornerAndStroke(fishItem, 8, 1, Color3.fromRGB(0,0,0))
end

fishScroll.CanvasSize = UDim2.new(0, 0, 0, (#fishList * 42))
end

--------------------------------------------------------------------------------
-- Слушаем инвентарь
--------------------------------------------------------------------------------
inventoryRemoteEvent.OnClientEvent:Connect(function(action, data)
if action == "inventoryData" then
local fishList = data.fishList
local money = data.money
moneyLabel.Text = "Деньги: " .. tostring(money)
updateFishList(fishList)

elseif action == "soldAllResult" then
local totalMoney = data.totalMoney
moneyLabel.Text = "Деньги: " .. tostring(totalMoney)
-- Обновить список после продажи
inventoryRemoteEvent:FireServer("getInventory")

elseif action == "soldInHandResult" then
if data.error then
warn("Ошибка: ".. data.error)
else
local totalMoney = data.totalMoney
moneyLabel.Text = "Деньги: " .. tostring(totalMoney)
inventoryRemoteEvent:FireServer("getInventory")
end
end
end)

--------------------------------------------------------------------------------
-- Бестиарий (с анимированным ViewportFrame)
--------------------------------------------------------------------------------
local bestiaryFrame = Instance.new("Frame")
bestiaryFrame.Name = "BestiaryFrame"
bestiaryFrame.Size = UDim2.new(0, 620, 0, 440)
bestiaryFrame.Position = UDim2.new(0.5, -310, 0.5, -220)
bestiaryFrame.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
bestiaryFrame.BorderSizePixel = 0
bestiaryFrame.Visible = false
bestiaryFrame.Parent = screenGui
applyCornerAndStroke(bestiaryFrame, 10, 2, Color3.fromRGB(0,0,0))
applyGradientBackground(bestiaryFrame, Color3.fromRGB(70,70,70), Color3.fromRGB(40,40,40))

local bestiaryTitle = Instance.new("TextLabel")
bestiaryTitle.Size = UDim2.new(1, 0, 0, 40)
bestiaryTitle.BackgroundColor3 = Color3.fromRGB(80, 80, 100)
bestiaryTitle.Text = "Бестиарий рыб"
bestiaryTitle.TextColor3 = Color3.fromRGB(255, 255, 255)
bestiaryTitle.TextScaled = true
bestiaryTitle.Font = Enum.Font.GothamBold
bestiaryTitle.Parent = bestiaryFrame
applyCornerAndStroke(bestiaryTitle, 0, 0, Color3.fromRGB(0,0,0))

local closeBestiaryButton = Instance.new("TextButton")
closeBestiaryButton.Size = UDim2.new(0, 30, 0, 30)
closeBestiaryButton.Position = UDim2.new(1, -35, 0, 5)
closeBestiaryButton.Text = "X"
closeBestiaryButton.TextColor3 = Color3.fromRGB(255, 255, 255)
closeBestiaryButton.BackgroundColor3 = Color3.fromRGB(150, 50, 50)
closeBestiaryButton.Font = Enum.Font.GothamBold
closeBestiaryButton.Parent = bestiaryFrame
applyCornerAndStroke(closeBestiaryButton, 6, 1, Color3.fromRGB(60,0,0))

closeBestiaryButton.MouseButton1Click:Connect(function()
bestiaryFrame.Visible = false
end)

local bestiaryScroll = Instance.new("ScrollingFrame")
bestiaryScroll.Name = "BestiaryScroll"
bestiaryScroll.Size = UDim2.new(1, -20, 1, -50)
bestiaryScroll.Position = UDim2.new(0, 10, 0, 40)
bestiaryScroll.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
bestiaryScroll.BorderSizePixel = 0
bestiaryScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
bestiaryScroll.ScrollingDirection = Enum.ScrollingDirection.Y
bestiaryScroll.Parent = bestiaryFrame
applyCornerAndStroke(bestiaryScroll, 8, 2, Color3.fromRGB(30,30,30))
applyGradientBackground(bestiaryScroll, Color3.fromRGB(70,70,70), Color3.fromRGB(50,50,50))

local bestiaryLayout = Instance.new("UIListLayout")
bestiaryLayout.Parent = bestiaryScroll
bestiaryLayout.FillDirection = Enum.FillDirection.Vertical
bestiaryLayout.SortOrder = Enum.SortOrder.LayoutOrder
bestiaryLayout.Padding = UDim.new(0, 5)

local rarityColors = {
normal = Color3.fromRGB(120, 120, 120),
rare = Color3.fromRGB(0, 170, 255),
epic = Color3.fromRGB(128, 0, 128),
legend = Color3.fromRGB(0, 255, 0),
mythic = Color3.fromRGB(255, 100, 255),
exotic = Color3.fromRGB(255, 150, 0)
}

bestiaryButton.MouseButton1Click:Connect(function()
bestiaryRemoteEvent:FireServer("getBestiary")
end)

bestiaryRemoteEvent.OnClientEvent:Connect(function(action, data)
if action == "bestiaryData" then
for _, child in ipairs(bestiaryScroll:GetChildren()) do
if child:IsA("Frame") then
child:Destroy()
end
end

local totalCount = 0
for _, folderInfo in ipairs(data) do
for _, fishInfo in ipairs(folderInfo.fish) do
totalCount += 1
local rarityName = (fishInfo.rarity or folderInfo.folderName or "normal"):lower()
local color = rarityColors[rarityName] or Color3.fromRGB(255, 255, 255)

local fishCard = Instance.new("Frame")
fishCard.BackgroundColor3 = Color3.fromRGB(80, 80, 80)
fishCard.Size = UDim2.new(1, -10, 0, 180)
fishCard.BorderSizePixel = 0
fishCard.Parent = bestiaryScroll
applyCornerAndStroke(fishCard, 8, 1, Color3.fromRGB(0,0,0))

local rarityBar = Instance.new("Frame")
rarityBar.Size = UDim2.new(0, 10, 1, 0)
rarityBar.BackgroundColor3 = color
rarityBar.BorderSizePixel = 0
rarityBar.Parent = fishCard

local fishNameLabel = Instance.new("TextLabel")
fishNameLabel.BackgroundTransparency = 1
fishNameLabel.Size = UDim2.new(0.5, -20, 0, 28)
fishNameLabel.Position = UDim2.new(0, 20, 0, 5)
fishNameLabel.Text = tostring(fishInfo.name or "???")
fishNameLabel.TextColor3 = Color3.new(1,1,1)
fishNameLabel.TextScaled = true
fishNameLabel.Font = Enum.Font.GothamBold
fishNameLabel.Parent = fishCard

local fishDescLabel = Instance.new("TextLabel")
fishDescLabel.BackgroundTransparency = 1
fishDescLabel.Size = UDim2.new(0.5, -20, 0, 50)
fishDescLabel.Position = UDim2.new(0, 20, 0, 35)
fishDescLabel.Text = tostring(fishInfo.description or "")
fishDescLabel.TextColor3 = Color3.new(1,1,1)
fishDescLabel.TextWrapped = true
fishDescLabel.TextSize = 14
fishDescLabel.Font = Enum.Font.Gotham
fishDescLabel.Parent = fishCard

local priceLabel = Instance.new("TextLabel")
priceLabel.BackgroundTransparency = 1
priceLabel.Size = UDim2.new(0.5, -20, 0, 34)
priceLabel.Position = UDim2.new(0, 20, 0, 85)
priceLabel.Text = "Цена за кг: ".. tostring(fishInfo.pricePerKilo or 0)
priceLabel.TextColor3 = Color3.fromRGB(255, 255, 0)
priceLabel.TextScaled = true
priceLabel.Font = Enum.Font.GothamBold
priceLabel.Parent = fishCard

local viewport = Instance.new("ViewportFrame")
viewport.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
viewport.Size = UDim2.new(0.5, -10, 1, -10)
viewport.Position = UDim2.new(0.5, 5, 0, 5)
viewport.BorderSizePixel = 0
viewport.Parent = fishCard
applyCornerAndStroke(viewport, 8, 1, Color3.fromRGB(0,0,0))

local worldModel = Instance.new("WorldModel")
worldModel.Parent = viewport

-- Спавним рыбу в WorldModel, с авто-масштабом и камерой
local function showFishInViewport(modelPath: string?)
if not modelPath then return end
local splitted = string.split(modelPath, "/")
local folderName = splitted[1] or "normal"
local modelName = splitted[2] or ""
local clone, cam = spawnModelInViewport(worldModel, folderName, modelName, true)
if not clone or not cam then return end
viewport.CurrentCamera = cam

-- Плавный поворот модели
local angle = 0
local conn
conn = RunService.RenderStepped:Connect(function(dt)
if not worldModel.Parent or fishCard.Parent == nil then
if conn then conn:Disconnect() end
return
end
angle += dt * 40
clone:PivotTo(CFrame.Angles(0, math.rad(angle), 0))
end)
end

showFishInViewport(fishInfo.modelPath)
end
end
bestiaryScroll.CanvasSize = UDim2.new(0,0,0, totalCount * 185)
bestiaryFrame.Visible = true
end
end)

--------------------------------------------------------------------------------
-- Окно "Магазин удочек"
--------------------------------------------------------------------------------
local rodShopFrame = Instance.new("Frame")
rodShopFrame.Name = "RodShopFrame"
rodShopFrame.Size = UDim2.new(0, 620, 0, 420)
rodShopFrame.Position = UDim2.new(0.5, -310, 0.3, 0)
rodShopFrame.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
rodShopFrame.BorderSizePixel = 0
rodShopFrame.Visible = false
rodShopFrame.Parent = screenGui
applyCornerAndStroke(rodShopFrame, 10, 2, Color3.fromRGB(0,0,0))
applyGradientBackground(rodShopFrame, Color3.fromRGB(80,80,80), Color3.fromRGB(40,40,40))

local rodShopTitle = Instance.new("TextLabel")
rodShopTitle.Size = UDim2.new(1, 0, 0, 40)
rodShopTitle.BackgroundColor3 = Color3.fromRGB(100, 100, 120)
rodShopTitle.Text = "Магазин удочек"
rodShopTitle.TextColor3 = Color3.fromRGB(255, 255, 255)
rodShopTitle.TextScaled = true
rodShopTitle.Font = Enum.Font.GothamBold
rodShopTitle.Parent = rodShopFrame
applyCornerAndStroke(rodShopTitle, 0, 0, Color3.fromRGB(0,0,0))

local closeRodShopButton = Instance.new("TextButton")
closeRodShopButton.Size = UDim2.new(0, 30, 0, 30)
closeRodShopButton.Position = UDim2.new(1, -35, 0, 5)
closeRodShopButton.Text = "X"
closeRodShopButton.TextColor3 = Color3.fromRGB(255, 255, 255)
closeRodShopButton.BackgroundColor3 = Color3.fromRGB(150, 50, 50)
closeRodShopButton.Font = Enum.Font.GothamBold
closeRodShopButton.Parent = rodShopFrame
applyCornerAndStroke(closeRodShopButton, 8, 1, Color3.fromRGB(60,0,0))

closeRodShopButton.MouseButton1Click:Connect(function()
rodShopFrame.Visible = false
end)

local rodShopScroll = Instance.new("ScrollingFrame")
rodShopScroll.Name = "RodShopScroll"
rodShopScroll.Size = UDim2.new(1, -20, 1, -50)
rodShopScroll.Position = UDim2.new(0, 10, 0, 40)
rodShopScroll.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
rodShopScroll.BorderSizePixel = 0
rodShopScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
rodShopScroll.ScrollingDirection = Enum.ScrollingDirection.Y
rodShopScroll.Parent = rodShopFrame
applyCornerAndStroke(rodShopScroll, 8, 1, Color3.fromRGB(0,0,0))
applyGradientBackground(rodShopScroll, Color3.fromRGB(70,70,70), Color3.fromRGB(50,50,50))

local rodShopLayout = Instance.new("UIListLayout")
rodShopLayout.Parent = rodShopScroll
rodShopLayout.FillDirection = Enum.FillDirection.Vertical
rodShopLayout.SortOrder = Enum.SortOrder.LayoutOrder
rodShopLayout.Padding = UDim.new(0, 5)

openRodShopButton.MouseButton1Click:Connect(function()
rodShopRemoteEvent:FireServer("getRodShopData")
end)

local function populateRodShop(rodsData, currentMoney)
for _, child in ipairs(rodShopScroll:GetChildren()) do
if child:IsA("Frame") then
child:Destroy()
end
end

local totalCount = 0
for _, rodInfo in ipairs(rodsData) do
totalCount += 1
local rodName = rodInfo.rodName
local rodDesc = rodInfo.description or ""
local rodPrice = rodInfo.price or 0
local rodLuck = rodInfo.luck or 1.0
local rodDurab = rodInfo.durability or 100
local rodMutCh = rodInfo.mutationChance or 1
local isOwned = rodInfo.isOwned == true

local rodCard = Instance.new("Frame")
rodCard.BackgroundColor3 = Color3.fromRGB(80, 80, 100)
rodCard.Size = UDim2.new(1, -10, 0, 200)
rodCard.BorderSizePixel = 0
rodCard.Parent = rodShopScroll
applyCornerAndStroke(rodCard, 8, 1, Color3.fromRGB(0,0,0))

local rodNameLabel = Instance.new("TextLabel")
rodNameLabel.BackgroundTransparency = 1
rodNameLabel.Size = UDim2.new(0.4, -20, 0, 30)
rodNameLabel.Position = UDim2.new(0, 10, 0, 5)
rodNameLabel.Text = rodName
rodNameLabel.TextColor3 = Color3.new(1,1,1)
rodNameLabel.TextScaled = true
rodNameLabel.Font = Enum.Font.GothamBold
rodNameLabel.Parent = rodCard

local rodDescLabel = Instance.new("TextLabel")
rodDescLabel.BackgroundTransparency = 1
rodDescLabel.Size = UDim2.new(0.4, -20, 0, 60)
rodDescLabel.Position = UDim2.new(0, 10, 0, 40)
rodDescLabel.Text = string.format(
"%s\nLuck: x%.2f\nDurability: %d\nMutChance: x%.1f",
rodDesc, rodLuck, rodDurab, rodMutCh
)
rodDescLabel.TextColor3 = Color3.new(1,1,1)
rodDescLabel.TextWrapped = true
rodDescLabel.TextSize = 14
rodDescLabel.Font = Enum.Font.Gotham
rodDescLabel.Parent = rodCard

local priceLabel = Instance.new("TextLabel")
priceLabel.BackgroundTransparency = 1
priceLabel.Size = UDim2.new(0.4, -20, 0, 30)
priceLabel.Position = UDim2.new(0, 10, 0, 110)
priceLabel.Text = "Цена: " .. tostring(rodPrice)
priceLabel.TextColor3 = Color3.fromRGB(255, 255, 0)
priceLabel.TextScaled = true
priceLabel.Font = Enum.Font.GothamBold
priceLabel.Parent = rodCard

local viewport = Instance.new("ViewportFrame")
viewport.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
viewport.Size = UDim2.new(0.4, -10, 1, -10)
viewport.Position = UDim2.new(0.6, 5, 0, 5)
viewport.BorderSizePixel = 0
viewport.Parent = rodCard
applyCornerAndStroke(viewport, 8, 1, Color3.fromRGB(0,0,0))

local worldModel = Instance.new("WorldModel")
worldModel.Parent = viewport

-- Показываем удочку в WorldModel
local function showRodInViewport(rodModelName: string)
-- В отличие от рыбы, мы считаем "isFish = false"
local clone, cam = spawnModelInViewport(worldModel, "Rod", rodModelName, false)
if not clone or not cam then return end
viewport.CurrentCamera = cam

-- Плавный поворот
local angle = 0
local conn
conn = RunService.RenderStepped:Connect(function(dt)
if not worldModel.Parent or rodCard.Parent == nil then
if conn then conn:Disconnect() end
return
end
angle += dt * 40
clone:PivotTo(CFrame.Angles(0, math.rad(angle), 0))
end)
end

showRodInViewport(rodInfo.rodModelName)

local buyButton = Instance.new("TextButton")
buyButton.Size = UDim2.new(0, 90, 0, 32)
buyButton.Position = UDim2.new(0, 10, 0, 150)
buyButton.TextColor3 = Color3.new(1,1,1)
buyButton.Font = Enum.Font.GothamBold
buyButton.TextSize = 14
buyButton.Parent = rodCard
applyCornerAndStroke(buyButton, 6, 1, Color3.fromRGB(0,0,0))

if isOwned then
buyButton.BackgroundColor3 = Color3.fromRGB(70, 120, 70)
buyButton.Text = "Экипировать"
else
if currentMoney < rodPrice then
buyButton.BackgroundColor3 = Color3.fromRGB(100, 100, 100)
buyButton.Text = "Недоступно"
else
buyButton.BackgroundColor3 = Color3.fromRGB(100, 150, 100)
buyButton.Text = "Купить"
end
end

buyButton.MouseButton1Click:Connect(function()
rodShopRemoteEvent:FireServer("buyRod", {
rodModelName = rodInfo.rodModelName
})
end)
end
rodShopScroll.CanvasSize = UDim2.new(0,0,0, totalCount * 205)
end

rodShopRemoteEvent.OnClientEvent:Connect(function(action, data, extra)
if action == "rodShopData" then
populateRodShop(data, extra)
rodShopFrame.Visible = true

elseif action == "buyRodResult" then
if data.success then
moneyLabel.Text = "Деньги: " .. tostring(data.newMoney)
if data.equipped then
print("Удочка экипирована. Деньги:", data.newMoney)
-- Включаем локальную анимацию покачивания удочки
local backpack = player:FindFirstChild("Backpack")
if backpack then
local newRod = backpack:FindFirstChildWhichIsA("Tool")
if newRod and newRod:GetAttribute("RodLuck") then
equipRodAnimation(newRod)
end
end
else
print("Успешная покупка. Деньги:", data.newMoney)
end
rodShopRemoteEvent:FireServer("getRodShopData") -- обновить магазин
else
warn("Ошибка покупки/экипировки: " .. tostring(data.error))
end
end
end)

--------------------------------------------------------------------------------
-- Упрощённый трейд-интерфейс
--------------------------------------------------------------------------------
local tradeGui = Instance.new("Frame")
tradeGui.Name = "TradeGui"
tradeGui.Size = UDim2.new(0, 320, 0, 260)
tradeGui.Position = UDim2.new(1, -330, 1, -270)
tradeGui.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
tradeGui.BorderSizePixel = 0
tradeGui.Visible = false
tradeGui.Parent = screenGui
applyCornerAndStroke(tradeGui, 10, 2, Color3.fromRGB(0,0,0))
applyGradientBackground(tradeGui, Color3.fromRGB(70,70,70), Color3.fromRGB(40,40,40))

local tradeTitle = Instance.new("TextLabel")
tradeTitle.Size = UDim2.new(1, 0, 0, 30)
tradeTitle.BackgroundColor3 = Color3.fromRGB(80, 80, 80)
tradeTitle.Text = "Трейд с ???"
tradeTitle.TextColor3 = Color3.fromRGB(255, 255, 255)
tradeTitle.TextScaled = true
tradeTitle.Font = Enum.Font.GothamBold
tradeTitle.Parent = tradeGui

local closeTradeButton = Instance.new("TextButton")
closeTradeButton.Size = UDim2.new(0, 30, 0, 30)
closeTradeButton.Position = UDim2.new(1, -35, 0, 0)
closeTradeButton.Text = "X"
closeTradeButton.TextColor3 = Color3.new(1,1,1)
closeTradeButton.BackgroundColor3 = Color3.fromRGB(150, 50, 50)
closeTradeButton.Font = Enum.Font.GothamBold
closeTradeButton.Parent = tradeGui
applyCornerAndStroke(closeTradeButton, 6, 1, Color3.fromRGB(60,0,0))

closeTradeButton.MouseButton1Click:Connect(function()
tradeGui.Visible = false
tradeRemoteEvent:FireServer("declineTrade", {})
end)

local moneyBox = Instance.new("TextBox")
moneyBox.Size = UDim2.new(0, 100, 0, 30)
moneyBox.Position = UDim2.new(0, 10, 0, 40)
moneyBox.Text = "0"
moneyBox.TextScaled = true
moneyBox.Font = Enum.Font.Gotham
moneyBox.ClearTextOnFocus = false
moneyBox.TextColor3 = Color3.fromRGB(255,255,255)
moneyBox.Parent = tradeGui
applyCornerAndStroke(moneyBox, 6, 1, Color3.fromRGB(0,0,0))

local moneyLabelTrade = Instance.new("TextLabel")
moneyLabelTrade.Size = UDim2.new(0, 100, 0, 30)
moneyLabelTrade.Position = UDim2.new(0, 120, 0, 40)
moneyLabelTrade.Text = "Денег"
moneyLabelTrade.TextColor3 = Color3.new(1,1,1)
moneyLabelTrade.TextScaled = true
moneyLabelTrade.Font = Enum.Font.GothamBold
moneyLabelTrade.BackgroundTransparency = 1
moneyLabelTrade.Parent = tradeGui

local itemsFrame = Instance.new("ScrollingFrame")
itemsFrame.Size = UDim2.new(0, 290, 0, 100)
itemsFrame.Position = UDim2.new(0, 10, 0, 80)
itemsFrame.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
itemsFrame.BorderSizePixel = 0
itemsFrame.ScrollingDirection = Enum.ScrollingDirection.Y
itemsFrame.CanvasSize = UDim2.new(0,0,0,0)
itemsFrame.Parent = tradeGui
applyCornerAndStroke(itemsFrame, 6, 1, Color3.fromRGB(0,0,0))

local itemsLayout = Instance.new("UIListLayout")
itemsLayout.Parent = itemsFrame
itemsLayout.FillDirection = Enum.FillDirection.Vertical
itemsLayout.SortOrder = Enum.SortOrder.LayoutOrder
itemsLayout.Padding = UDim.new(0, 2)

local updateOfferButton = Instance.new("TextButton")
updateOfferButton.Size = UDim2.new(0, 140, 0, 30)
updateOfferButton.Position = UDim2.new(0, 10, 0, 190)
updateOfferButton.BackgroundColor3 = Color3.fromRGB(100, 100, 180)
updateOfferButton.Text = "Обновить оффер"
updateOfferButton.TextColor3 = Color3.new(1,1,1)
updateOfferButton.Font = Enum.Font.GothamBold
updateOfferButton.Parent = tradeGui
applyCornerAndStroke(updateOfferButton, 6, 1, Color3.fromRGB(0,0,60))

local acceptTradeButton = Instance.new("TextButton")
acceptTradeButton.Size = UDim2.new(0, 140, 0, 30)
acceptTradeButton.Position = UDim2.new(0, 160, 0, 190)
acceptTradeButton.BackgroundColor3 = Color3.fromRGB(100, 150, 100)
acceptTradeButton.Text = "Принять"
acceptTradeButton.TextColor3 = Color3.new(1,1,1)
acceptTradeButton.Font = Enum.Font.GothamBold
acceptTradeButton.Parent = tradeGui
applyCornerAndStroke(acceptTradeButton, 6, 1, Color3.fromRGB(0,60,0))

local currentTradePartnerId: number? = nil

local function populateItemsList()
for _, child in ipairs(itemsFrame:GetChildren()) do
if child:IsA("TextButton") then
child:Destroy()
end
end

local backpack = player:FindFirstChild("Backpack")
local character = player.Character
local items = {}

local function gather(container: Instance)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:FindFirstChildWhichIsA("Model") then
table.insert(items, tool.Name)
end
end
end
if backpack then gather(backpack) end
if character then gather(character) end

for _, itemName in ipairs(items) do
local btn = Instance.new("TextButton")
btn.Size = UDim2.new(1, -4, 0, 30)
btn.Text = itemName
btn.TextScaled = true
btn.Font = Enum.Font.GothamBold
btn.BackgroundColor3 = Color3.fromRGB(80, 80, 80)
btn.TextColor3 = Color3.new(1,1,1)
btn.Name = itemName
btn.Parent = itemsFrame

applyCornerAndStroke(btn, 6, 1, Color3.fromRGB(0,0,0))

btn.MouseButton1Click:Connect(function()
if not btn.Text:find("(добавлен)") then
btn.BackgroundColor3 = Color3.fromRGB(120, 80, 80)
btn.Text = itemName .. " (добавлен)"
else
btn.BackgroundColor3 = Color3.fromRGB(80, 80, 80)
btn.Text = itemName
end
end)
end

itemsFrame.CanvasSize = UDim2.new(0,0,0,#items * 32)
end

updateOfferButton.MouseButton1Click:Connect(function()
local myMoney = tonumber(moneyBox.Text) or 0
local offeredItems = {}
for _, child in ipairs(itemsFrame:GetChildren()) do
if child:IsA("TextButton") then
if child.Text:find("%(добавлен%)") then
table.insert(offeredItems, child.Name)
end
end
end
tradeRemoteEvent:FireServer("updateOffer", {
money = myMoney,
items = offeredItems
})
end)

acceptTradeButton.MouseButton1Click:Connect(function()
tradeRemoteEvent:FireServer("acceptTrade", {})
end)

--------------------------------------------------------------------------------
-- Небольшая логика: нажать E рядом с другим игроком, чтобы кинуть трейд
--------------------------------------------------------------------------------
UserInputService.InputBegan:Connect(function(input, gpe)
if gpe then return end
if input.KeyCode == Enum.KeyCode.E then
local myCharacter = player.Character
if not myCharacter or not myCharacter.PrimaryPart then return end

local closestDist = 5
local targetPlayerId: number? = nil
for _, plr in pairs(Players:GetPlayers()) do
if plr ~= player and plr.Character and plr.Character.PrimaryPart then
local dist = (myCharacter.PrimaryPart.Position - plr.Character.PrimaryPart.Position).Magnitude
if dist < closestDist then
closestDist = dist
targetPlayerId = plr.UserId
end
end
end
if targetPlayerId then
tradeRemoteEvent:FireServer("requestTrade", {targetUserId = targetPlayerId})
end
end
end)

--------------------------------------------------------------------------------
-- Обработка событий tradeRemoteEvent
--------------------------------------------------------------------------------
tradeRemoteEvent.OnClientEvent:Connect(function(action, data)
if action == "tradeCancelled" then
warn("Трейд отменён: ".. tostring(data))
tradeGui.Visible = false
currentTradePartnerId = nil

elseif action == "tradeInvite" then
local fromId = data.fromUserId
local fromName = data.fromName
currentTradePartnerId = fromId

local inviteButton = Instance.new("TextButton")
inviteButton.Size = UDim2.new(0,340, 0,50)
inviteButton.Position = UDim2.new(0.5, -170, 0.7, -25)
inviteButton.BackgroundColor3 = Color3.fromRGB(80, 150, 80)
inviteButton.TextColor3 = Color3.new(1,1,1)
inviteButton.TextScaled = true
inviteButton.Font = Enum.Font.GothamBold
inviteButton.Text = "Игрок ".. fromName .." предлагает трейд (нажми для принятия)"
inviteButton.Parent = screenGui
applyCornerAndStroke(inviteButton, 8, 1, Color3.fromRGB(0,40,0))

inviteButton.MouseButton1Click:Connect(function()
inviteButton:Destroy()
tradeRemoteEvent:FireServer("acceptTrade", {})
tradeGui.Visible = true
tradeTitle.Text = "Трейд с ".. fromName
populateItemsList()
end)

elseif action == "tradeAccepted" then
local fromId = data.fromUserId
print("Игрок ID="..fromId.." принял. Если мы тоже нажмём Принять, сделка состоится.")

elseif action == "tradeSuccess" then
print("Трейд успешно завершён!")
tradeGui.Visible = false
currentTradePartnerId = nil

elseif action == "tradeOfferUpdate" then
local fromId = data.fromUserId
local money = data.moneyOffered
local items = data.itemsOffered
print("Партнёр предлагает:", money, "$ + предметы:", items)

elseif action == "tradeError" then
warn("Ошибка трейда: ".. tostring(data))
end
end)

--------------------------------------------------------------------------------
-- Дополнительная логика: При экипировке рыбы или удочки
-- включаем локальную анимацию (флоп или покачивание).
--------------------------------------------------------------------------------
local function onToolEquipped(tool: Tool)
-- Проверяем, есть ли внутри рыба (Model)
local fishModel = tool:FindFirstChildWhichIsA("Model")
if fishModel then
-- Флоп-анимация рыбы
flopFishAnimation(fishModel)

-- А ещё меняем позицию над головой (сервер тоже меняет,
-- но на клиенте — плавнее)
local character = player.Character
if not character then return end
local rightHand = character:FindFirstChild("RightHand") or character:FindFirstChild("Right Arm")
if not rightHand then
return
end

local function updateFishPosition()
if fishModel and fishModel.PrimaryPart and rightHand then
local handPosition = rightHand.Position
local offsetY = fishModel.PrimaryPart.Size.Y/2 + 15
fishModel:PivotTo(CFrame.new(handPosition.X, handPosition.Y + offsetY, handPosition.Z))
end
end

local conn: RBXScriptConnection?
conn = RunService.Heartbeat:Connect(function()
if not tool.Parent or not tool.Parent:IsDescendantOf(character) then
if conn then conn:Disconnect() end
else
updateFishPosition()
end
end)
end

-- Если это удочка (RodLuck атрибут), включаем покачивание
if tool:GetAttribute("RodLuck") then
equipRodAnimation(tool)
end
end

-- Следим за экипировкой
player.CharacterAdded:Connect(function(char)
local function watchTools(container: Instance)
container.ChildAdded:Connect(function(child)
if child:IsA("Tool") then
child.Equipped:Connect(function()
onToolEquipped(child)
end)
end
end)
end

watchTools(char)
local backpack = player:WaitForChild("Backpack")
watchTools(backpack)

-- Подключаем уже существующие Tool'ы
for _, child in ipairs(char:GetChildren()) do
if child:IsA("Tool") then
child.Equipped:Connect(function()
onToolEquipped(child)
end)
end
end
for _, child in ipairs(backpack:GetChildren()) do
if child:IsA("Tool") then
child.Equipped:Connect(function()
onToolEquipped(child)
end)
end
end
end)

print("LocalScript (UI) загружен! Все фиксы (масштаб/ориентация/цены) применены, должно показывать корректно.")

вот скрипт сервер:
--!strict

--------------------------------------------------------------------------------
-- FishManager.server.lua
-- Основной серверный скрипт, включающий механику ловли рыбы, покупки и
-- экипировки удочек, торговлю рыбой, сохранение/загрузку данных и систему трейдов.
-- + Исправление: возвращена механика перемещения пойманной рыбы над головой
-- (подобно вашему первому скрипту), используя событие Equipped и Heartbeat.
--------------------------------------------------------------------------------

local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local DataStoreService = game:GetService("DataStoreService")
local TweenService = game:GetService("TweenService")

--------------------------------------------------------------------------------
-- //===== RemoteEvents =====\\
--------------------------------------------------------------------------------
local catchRemoteEventName = "RequestFishCatch"
local inventoryRemoteEventName = "InventoryRemoteEvent"
local bestiaryRemoteEventName = "BestiaryRemoteEvent"
local rodShopRemoteEventName = "RodShopRemoteEvent"
local tradeRemoteEventName = "TradeRemoteEvent"

local catchRemoteEvent = ReplicatedStorage:FindFirstChild(catchRemoteEventName)
or Instance.new("RemoteEvent", ReplicatedStorage)
catchRemoteEvent.Name = catchRemoteEventName

local inventoryRemoteEvent = ReplicatedStorage:FindFirstChild(inventoryRemoteEventName)
or Instance.new("RemoteEvent", ReplicatedStorage)
inventoryRemoteEvent.Name = inventoryRemoteEventName

local bestiaryRemoteEvent = ReplicatedStorage:FindFirstChild(bestiaryRemoteEventName)
or Instance.new("RemoteEvent", ReplicatedStorage)
bestiaryRemoteEvent.Name = bestiaryRemoteEventName

local rodShopRemoteEvent = ReplicatedStorage:FindFirstChild(rodShopRemoteEventName)
or Instance.new("RemoteEvent", ReplicatedStorage)
rodShopRemoteEvent.Name = rodShopRemoteEventName

local tradeRemoteEvent = ReplicatedStorage:FindFirstChild(tradeRemoteEventName)
or Instance.new("RemoteEvent", ReplicatedStorage)
tradeRemoteEvent.Name = tradeRemoteEventName

--------------------------------------------------------------------------------
-- Папка для моделей рыб (FishModels) в ReplicatedStorage
--------------------------------------------------------------------------------
local fishModelsFolder = Instance.new("Folder")
fishModelsFolder.Name = "FishModels"
fishModelsFolder.Parent = ReplicatedStorage

-- Папка для моделей удочек (Tools) в ServerStorage
local rodFolder = ServerStorage:FindFirstChild("Rod")
if not rodFolder then
warn("[FishManager] В ServerStorage нет папки 'Rod'! Создайте её и положите туда модели/Tools удочек.")
end

--------------------------------------------------------------------------------
-- Копируем папки с моделями рыб из ServerStorage в ReplicatedStorage (FishModels)
--------------------------------------------------------------------------------
local fishFolders = { "normal", "rare", "epic", "legend", "mythic", "exotic" }
for _, folderName in ipairs(fishFolders) do
local srcFolder = ServerStorage:FindFirstChild(folderName)
if srcFolder and srcFolder:IsA("Folder") then
local destFolder = Instance.new("Folder")
destFolder.Name = folderName
destFolder.Parent = fishModelsFolder

for _, fishModel in ipairs(srcFolder:GetChildren()) do
if fishModel:IsA("Model") then
local cloneModel = fishModel:Clone()
cloneModel.Parent = destFolder
end
end
end
end

--------------------------------------------------------------------------------
-- РАЗДЕЛ 2: Настройки редкости, шансов и цен
--------------------------------------------------------------------------------
local fishRarities = {
-- name, chance, difficulty, minW, maxW, pricePerKg
{ name = "normal", chance = 35, difficulty = 1, minWeight = 1, maxWeight = 10, pricePerKg = 0.2 },
{ name = "epic", chance = 25, difficulty = 2, minWeight = 5, maxWeight = 20, pricePerKg = 0.4 },
{ name = "rare", chance = 20, difficulty = 3, minWeight = 10, maxWeight = 50, pricePerKg = 0.6 },
{ name = "legend", chance = 10, difficulty = 4, minWeight = 20, maxWeight = 100, pricePerKg = 1.0 },
{ name = "mythic", chance = 5, difficulty = 5, minWeight = 50, maxWeight = 50000, pricePerKg = 2.0 },
{ name = "exotic", chance = 5, difficulty = 6, minWeight = 500, maxWeight = 100000,pricePerKg = 3.0 },
}

local function getRarityDataByName(rarityName: string)
for _, data in ipairs(fishRarities) do
if data.name == rarityName then
return data
end
end
return nil
end

--------------------------------------------------------------------------------
-- РАЗДЕЛ 2.1: Специальные (редкие) мутации
--------------------------------------------------------------------------------
local specialMutations = {
{
chance = 5,
priceFactor = 1.2,
displayName = "Свечение",
colorOverride = Color3.new(1, 1, 0.6)
},
{
chance = 3,
priceFactor = 1.5,
displayName = "Радиоактивная",
colorOverride = Color3.new(0.3, 1, 0.3)
},
{
chance = 2,
priceFactor = 1.8,
displayName = "Ангельская",
colorOverride = Color3.new(1, 0.8, 1)
},
{
chance = 10,
priceFactor = 1.1,
displayName = "Пятнистая",
colorOverride = Color3.new(0.8, 0.5, 0.4)
},
{
chance = 4,
priceFactor = 1.3,
displayName = "Пигментная",
colorOverride = Color3.new(1, 0.6, 0.8)
},
{
chance = 1,
priceFactor = 2.2,
displayName = "Нереальная",
colorOverride = Color3.new(0.9, 0.2, 1)
},
{
chance = 2,
priceFactor = 1.7,
displayName = "Ледяная",
colorOverride = Color3.new(0.6, 0.9, 1)
},
{
chance = 3,
priceFactor = 1.5,
displayName = "Огненная",
colorOverride = Color3.new(1, 0.3, 0.2)
},
{
chance = 5,
priceFactor = 1.25,
displayName = "Золотая",
colorOverride = Color3.new(1, 0.85, 0.3)
},
{
chance = 2,
priceFactor = 1.6,
displayName = "Призрачная",
colorOverride = Color3.new(0.7, 0.7, 0.7)
},
}

local function getRandomSpecialMutation(rodMutationChance: number?)
rodMutationChance = rodMutationChance or 1
local totalWeight = 0
for _, mut in ipairs(specialMutations) do
totalWeight += mut.chance * rodMutationChance
end

local roll = math.random() * totalWeight
local cumulative = 0
for _, mut in ipairs(specialMutations) do
cumulative += mut.chance * rodMutationChance
if roll <= cumulative then
return mut
end
end
return nil
end

--------------------------------------------------------------------------------
-- Функция подправки шансов на редкость, если удочка (RodLuck > 1)
--------------------------------------------------------------------------------
local function adjustRaritiesForRodLuck(rodLuck: number)
if rodLuck <= 1 then
-- без изменений
return fishRarities
end

local newTable = {}
for _, rarData in ipairs(fishRarities) do
local copy = {}
for k, v in pairs(rarData) do
copy[k] = v
end

-- Условно немного усиливаем шансы на высокий редкий тир
if copy.name == "legend" or copy.name == "mythic" or copy.name == "exotic" then
copy.chance = math.floor(copy.chance * rodLuck)
else
-- Для "простых" наоборот можно слегка уменьшить
copy.chance = math.max(1, math.floor(copy.chance * 0.8))
end
table.insert(newTable, copy)
end

return newTable
end

--------------------------------------------------------------------------------
-- Генерация редкости рыбы с учётом rodLuck
--------------------------------------------------------------------------------
local function getRarityFolder(rodLuck: number)
local adjustedFishRarities = adjustRaritiesForRodLuck(rodLuck)

local totalChance = 0
for _, rData in ipairs(adjustedFishRarities) do
totalChance += rData.chance
end

local randomNumber = math.random(1, totalChance)
local cumulative = 0
for _, rData in ipairs(adjustedFishRarities) do
cumulative += rData.chance
if randomNumber <= cumulative then
return rData.name, rData.difficulty, rData.minWeight, rData.maxWeight
end
end
return "normal", 1, 1, 10
end

--------------------------------------------------------------------------------
-- Получить случайную модель рыбы (из ServerStorage) по редкости
--------------------------------------------------------------------------------
local function getRandomFishModel(rarityName: string)
local rarityFolder = ServerStorage:FindFirstChild(rarityName)
if not rarityFolder then
warn("Папка редкости '" .. rarityName .. "' не найдена в ServerStorage.")
return nil
end
local fishModels = rarityFolder:GetChildren()
if #fishModels == 0 then
warn("В папке редкости '".. rarityName .."' нет моделей рыб!")
return nil
end
return fishModels[ math.random(1, #fishModels) ]
end

--------------------------------------------------------------------------------
-- Устанавливаем размер рыбы (модель) на основе предполагаемого веса
--------------------------------------------------------------------------------
local function setRandomSize(fishClone: Model, fallbackMinW: number, fallbackMaxW: number)
local fishMinW = fishClone:GetAttribute("FishMinWeight") or fallbackMinW
local fishMaxW = fishClone:GetAttribute("FishMaxWeight") or fallbackMaxW
if fishMinW < 1 then fishMinW = 1 end
if fishMaxW < fishMinW then fishMaxW = fishMinW end

local randomWeight = math.random(fishMinW, fishMaxW)
local scaleFactor = 0.5 + (randomWeight / fishMaxW * 1.5)

for _, desc in ipairs(fishClone:GetDescendants()) do
if desc:IsA("BasePart") or desc:IsA("MeshPart") then
desc.Size = desc.Size * scaleFactor
end
end
fishClone:SetAttribute("Weight", randomWeight)
return randomWeight
end

--------------------------------------------------------------------------------
-- Сбор всех данных о рыбе (для бестиария)
--------------------------------------------------------------------------------
local function getAllFishData()
local result = {}
for _, folderName in ipairs(fishFolders) do
local folder = ServerStorage:FindFirstChild(folderName)
if folder and folder:IsA("Folder") then
local folderData = {
folderName = folderName,
fish = {}
}
for _, fishModel in ipairs(folder:GetChildren()) do
if fishModel:IsA("Model") then
local fishName = fishModel:GetAttribute("FishName") or fishModel.Name
local fishDesc = fishModel:GetAttribute("FishDescription") or ""
local fishPrice = fishModel:GetAttribute("FishPricePerKilo") or 0
local fishRarity = fishModel:GetAttribute("FishRarity") or folderName

table.insert(folderData.fish, {
name = fishName,
description = fishDesc,
pricePerKilo = fishPrice,
rarity = fishRarity,
modelPath = folderName .. "/" .. fishModel.Name
})
end
end
table.insert(result, folderData)
end
end
return result
end

bestiaryRemoteEvent.OnServerEvent:Connect(function(player, action)
if action == "getBestiary" then
local data = getAllFishData()
bestiaryRemoteEvent:FireClient(player, "bestiaryData", data)
end
end)

--------------------------------------------------------------------------------
-- РАЗДЕЛ 4: Стрик (FishStreak) + Billboard
--------------------------------------------------------------------------------
local function getOrCreateStreak(player: Player)
local leaderstats = player:FindFirstChild("leaderstats")
if not leaderstats then
leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
leaderstats.Parent = player
end

local fishStreak = leaderstats:FindFirstChild("FishStreak")
if not fishStreak then
fishStreak = Instance.new("IntValue")
fishStreak.Name = "FishStreak"
fishStreak.Value = 0
fishStreak.Parent = leaderstats
end
return fishStreak
end

local function createOrUpdateStreakGUI(character: Model, streakValue: number)
if not character then return end
local head = character:FindFirstChild("Head")
if not head then return end

local existingBillboard = head:FindFirstChild("StreakBillboard")
if not existingBillboard then
local billboard = Instance.new("BillboardGui")
billboard.Name = "StreakBillboard"
billboard.Size = UDim2.new(4, 0, 1, 0)
billboard.StudsOffset = Vector3.new(0, 2, 0)
billboard.AlwaysOnTop = true
billboard.Parent = head

local textLabel = Instance.new("TextLabel")
textLabel.Name = "StreakLabel"
textLabel.Size = UDim2.new(1, 0, 1, 0)
textLabel.BackgroundTransparency = 1
textLabel.TextScaled = true
textLabel.Font = Enum.Font.SourceSansBold
textLabel.TextColor3 = Color3.new(1, 1, 1)
textLabel.Text = "Streak: " .. tostring(streakValue)
textLabel.Parent = billboard
else
local textLabel = existingBillboard:FindFirstChild("StreakLabel")
if textLabel then
textLabel.Text = "Streak: " .. tostring(streakValue)
end
end
end

local function updateCharacterStreak(player: Player)
local character = player.Character
if not character then return end
local fishStreak = getOrCreateStreak(player)
createOrUpdateStreakGUI(character, fishStreak.Value)
end

--------------------------------------------------------------------------------
-- РАЗДЕЛ 5: DataStore + sessionData
--------------------------------------------------------------------------------
local MAIN_DATA_STORE_NAME = "FishingGameDataStore"
local playerDataStore = DataStoreService:GetDataStore(MAIN_DATA_STORE_NAME)

-- sessionData: {
-- [userId] = {
-- money=0,
-- inventory={...},
-- rods={ {rodModelName=?, rodLuck=?, rodPrice=?, rodDurab=?, rodMutationChance=?, equipped=?}, ... }
-- }
-- }
local sessionData: {[number]: any} = {}

local function savePlayerData(userId: number)
local dataToSave = sessionData[userId]
if not dataToSave then return end

local success, err = pcall(function()
playerDataStore:SetAsync("player_"..tostring(userId), dataToSave)
end)
if not success then
warn("[FishManager] Ошибка сохранения для игрока "..userId..": "..tostring(err))
end
end

local function loadPlayerData(userId: number)
local data
local success, err = pcall(function()
data = playerDataStore:GetAsync("player_"..tostring(userId))
end)
if not success then
warn("[FishManager] Ошибка загрузки данных для игрока "..userId..": "..tostring(err))
return nil
end
return data
end

local function getOrCreateMoney(player: Player)
local leaderstats = player:FindFirstChild("leaderstats")
if not leaderstats then
leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
leaderstats.Parent = player
end

local money = leaderstats:FindFirstChild("Money")
if not money then
money = Instance.new("IntValue")
money.Name = "Money"
money.Value = 0
money.Parent = leaderstats
end
return money
end

--------------------------------------------------------------------------------
-- Доп. функция: перемещение рыбы над рукой, пока та экипирована (как в вашем 1 скрипте)
--------------------------------------------------------------------------------
local function attachFishOverheadMovement(fishTool: Tool, fishClone: Model, player: Player)
fishTool.Equipped:Connect(function()
local character = player.Character
if not character then return end

local rightHand = character:FindFirstChild("RightHand")
or character:FindFirstChild("Right Arm")
if not rightHand then return end

-- Для безопасного отключения цикла, когда Tool убрали или переэкипировали
local conn
conn = RunService.Heartbeat:Connect(function()
-- Если Tool ушёл из персонажа (уже не экипирован), отключаемся
if fishTool.Parent ~= character then
if conn then
conn:Disconnect()
end
return
end
-- Иначе поддерживаем позицию
if fishClone and fishClone.PrimaryPart and rightHand then
local handPos = rightHand.Position
local offsetY = fishClone.PrimaryPart.Size.Y / 2 + 6
fishClone:SetPrimaryPartCFrame(CFrame.new(
handPos.X, handPos.Y + offsetY, handPos.Z
))
end
end)
end)
end

--------------------------------------------------------------------------------
-- РАЗДЕЛ 6: PlayerAdded + PlayerRemoving (Загрузка/Сохранение)
--------------------------------------------------------------------------------
Players.PlayerAdded:Connect(function(player)
local userId = player.UserId

if not sessionData[userId] then
sessionData[userId] = {
money = 0,
inventory = {},
rods = {},
}
end

local loadedData = loadPlayerData(userId)
if loadedData then
sessionData[userId] = loadedData
if not sessionData[userId].rods then
sessionData[userId].rods = {}
end
if not sessionData[userId].inventory then
sessionData[userId].inventory = {}
end
end

local money = getOrCreateMoney(player)
money.Value = sessionData[userId].money or 0

local fishStreak = getOrCreateStreak(player)

-- Восстанавливаем рыбу
local backpack = player:WaitForChild("Backpack")
for _, fishItem in ipairs(sessionData[userId].inventory) do
local fishTool = Instance.new("Tool")
fishTool.RequiresHandle = false

local combinedMutationName = fishItem.mutation or "Стандартная"
if fishItem.specialMutation and fishItem.specialMutation ~= "" then
combinedMutationName = fishItem.specialMutation .. " " .. combinedMutationName
end

fishTool.Name = string.format("[%s] %s %s (%d кг)",
fishItem.rarity,
combinedMutationName,
fishItem.name,
fishItem.weight
)

local rarityFolder = ServerStorage:FindFirstChild(fishItem.rarity)
local fishClone: Model? = nil

if rarityFolder then
local fishModel = rarityFolder:FindFirstChild(fishItem.name)
if fishModel then
fishClone = fishModel:Clone()
local rarityData = getRarityDataByName(fishItem.rarity)
local maxW = rarityData and rarityData.maxWeight or 10

local scaleFactor = 0.5 + (fishItem.weight / maxW * 1.5)
for _, desc in ipairs(fishClone:GetDescendants()) do
if desc:IsA("BasePart") or desc:IsA("MeshPart") then
desc.Size = desc.Size * scaleFactor
desc.CanCollide = false
end
end
fishClone:SetAttribute("Weight", fishItem.weight)

-- Если была "спец" окраска
for _, mutConf in ipairs(specialMutations) do
if fishItem.specialMutation == mutConf.displayName then
for _, desc in ipairs(fishClone:GetDescendants()) do
if desc:IsA("BasePart") or desc:IsA("MeshPart") then
desc.Color = mutConf.colorOverride or desc.Color
end
end
end
end

fishClone.Parent = fishTool
if not fishClone.PrimaryPart then
local primaryPart = fishClone:FindFirstChildWhichIsA("BasePart")
or fishClone:FindFirstChildWhichIsA("MeshPart")
if primaryPart then
fishClone.PrimaryPart = primaryPart
end
end
end
end

fishTool.Parent = backpack

-- ВАЖНО: возвращаем механику "рыба над головой", если экипировать
if fishClone then
attachFishOverheadMovement(fishTool, fishClone, player)
end
end

-- Восстанавливаем удочки
for _, rodInfo in ipairs(sessionData[userId].rods) do
if rodInfo.equipped then
local rodModel = rodFolder and rodFolder:FindFirstChild(rodInfo.rodModelName)
if rodModel then
local function createRodToolFromModel()
if rodModel:IsA("Tool") then
return rodModel:Clone()
else
local finalTool = Instance.new("Tool")
finalTool.Name = rodModel.Name
finalTool.RequiresHandle = false

for _, child in ipairs(rodModel:GetChildren()) do
local c = child:Clone()
c.Parent = finalTool
end
return finalTool
end
end

local rodTool = createRodToolFromModel()
if rodTool then
rodTool:SetAttribute("RodLuck", rodInfo.rodLuck or 1.0)
rodTool:SetAttribute("RodPrice", rodInfo.rodPrice or 100)
rodTool:SetAttribute("RodDurability", rodInfo.rodDurab or 100)
rodTool:SetAttribute("RodMutationChance", rodInfo.rodMutationChance or 1)
rodTool.Parent = backpack
end
end
end
end

player.CharacterAdded:Connect(function(character)
task.wait(1)
createOrUpdateStreakGUI(character, fishStreak.Value)
end)
end)

Players.PlayerRemoving:Connect(function(player)
local userId = player.UserId
if sessionData[userId] then
local moneyObj = player:FindFirstChild("leaderstats")
and player.leaderstats:FindFirstChild("Money")
if moneyObj then
sessionData[userId].money = moneyObj.Value
end

-- Собираем рыбу
sessionData[userId].inventory = {}
local function gatherFishTools(container: Instance)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:FindFirstChildWhichIsA("Model") then
local fishModel = tool:FindFirstChildWhichIsA("Model")
local foundWeight = fishModel and fishModel:GetAttribute("Weight") or 0

local bracketStart, bracketEnd = tool.Name:find("%[(.+)%]")
local rarity = "normal"
if bracketStart then
rarity = tool.Name:sub(bracketStart+1, bracketEnd-1)
end

local knownSizeNames = {
"Крошечная","Средняя","Большая","Огромная",
"Гигантская","НЕВЕРОЯТНАЯ","Стандартная"
}
local fullStrAfterRarity = tool.Name:sub((bracketEnd or 0)+2)
local weightIndex = fullStrAfterRarity:find("%(%d+ кг%)")
local nameWithoutWeight = ""
if weightIndex then
nameWithoutWeight = fullStrAfterRarity:sub(1, weightIndex-2)
end

local foundSize = "Стандартная"
local foundSpecial = ""
for _, sz in ipairs(knownSizeNames) do
local idx = nameWithoutWeight:find(sz)
if idx then
foundSize = sz
foundSpecial = nameWithoutWeight:sub(1, idx-2)
break
end
end
foundSpecial = foundSpecial:gsub("^%s+", ""):gsub("%s+$", "")
local fishName = nameWithoutWeight:sub(#foundSpecial+2)
fishName = fishName:gsub("^%s+", ""):gsub("%s+$", "")
if fishName == "" then
fishName = fishModel.Name
end

table.insert(sessionData[userId].inventory, {
rarity = rarity,
weight = foundWeight,
name = fishName,
mutation = foundSize,
specialMutation = foundSpecial
})
end
end
end

local backpack = player:FindFirstChild("Backpack")
if backpack then
gatherFishTools(backpack)
end
local character = player.Character
if character then
gatherFishTools(character)
end

-- Собираем удочки
for _, rodObj in ipairs(sessionData[userId].rods) do
rodObj.equipped = false
end

local function gatherRod(container: Instance)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:GetAttribute("RodLuck") then
local rodName = tool.Name
local rodLuck = tool:GetAttribute("RodLuck") or 1.0
local rodPrice = tool:GetAttribute("RodPrice") or 100
local rodDurab = tool:GetAttribute("RodDurability") or 100
local rodMutCh = tool:GetAttribute("RodMutationChance") or 1

local found = false
for _, r in ipairs(sessionData[userId].rods) do
if r.rodModelName == rodName then
r.rodLuck = rodLuck
r.rodPrice = rodPrice
r.rodDurab = rodDurab
r.rodMutationChance = rodMutCh
r.equipped = true
found = true
break
end
end
if not found then
table.insert(sessionData[userId].rods, {
rodModelName = rodName,
rodLuck = rodLuck,
rodPrice = rodPrice,
rodDurab = rodDurab,
rodMutationChance = rodMutCh,
equipped = true
})
end
end
end
end
if backpack then gatherRod(backpack) end
if character then gatherRod(character) end

savePlayerData(userId)
end
end)

--------------------------------------------------------------------------------
-- РАЗДЕЛ 7: Ловля рыбы (мини-игра)
--------------------------------------------------------------------------------
local pendingFishData: {[number]: any} = {}

catchRemoteEvent.OnServerEvent:Connect(function(player, action, data)
data = data or {}
local userId = player.UserId

if action == "startCatch" then
local rodLuckValue = 1
local rodMutationChance = 1

local character = player.Character
if character then
local equippedTool = character:FindFirstChildWhichIsA("Tool")
if equippedTool then
local rLuck = equippedTool:GetAttribute("RodLuck")
if rLuck then
rodLuckValue = rLuck
end
local rMutCh = equippedTool:GetAttribute("RodMutationChance")
if rMutCh then
rodMutationChance = rMutCh
end
end
end

local rarityName, difficulty, minW, maxW = getRarityFolder(rodLuckValue)
local fishModel = getRandomFishModel(rarityName)
if not fishModel then return end

local fishClone = fishModel:Clone()
local randomWeight = setRandomSize(fishClone, minW, maxW)

local function getSizeMutationByWeight(weight: number, rarity: string)
if weight <= 5 then
return "Крошечная"
elseif weight <= 25 then
return "Средняя"
elseif weight <= 100 then
return "Большая"
elseif weight <= 500 and rarity == "legend" then
return "Огромная"
elseif weight <= 1000 and rarity == "mythic" then
return "Гигантская"
elseif weight > 1000 and rarity == "exotic" then
return "НЕВЕРОЯТНАЯ"
else
return "Стандартная"
end
end
local sizeMutation = getSizeMutationByWeight(randomWeight, rarityName)

local specialMutationInfo = getRandomSpecialMutation(rodMutationChance)
local specialMutationName = specialMutationInfo and specialMutationInfo.displayName or ""

pendingFishData[userId] = {
rarityName = rarityName,
difficulty = difficulty,
fishModel = fishModel,
weight = randomWeight,
sizeMutation = sizeMutation,
specialMutation = specialMutationName,
specialMutFactor= specialMutationInfo and specialMutationInfo.priceFactor or 1,
specialColor = specialMutationInfo and specialMutationInfo.colorOverride
}

catchRemoteEvent:FireClient(player, "challengeStart", {
rarityName = rarityName,
difficulty = difficulty,
weight = randomWeight,
mutation = sizeMutation,
fishName = fishModel.Name,
specialMutation = specialMutationName,
rodLuck = rodLuckValue
})

elseif action == "challengeResult" then
local succeeded = data.success
local fishInfo = pendingFishData[userId]
if not fishInfo then return end

if succeeded then
local rarityName = fishInfo.rarityName
local fishClone = fishInfo.fishModel:Clone()
local randomWeight = fishInfo.weight
local sizeMutation = fishInfo.sizeMutation
local specialMutation = fishInfo.specialMutation or ""
local colorOver = fishInfo.specialColor

local rarityData = getRarityDataByName(rarityName)
local finalMaxW = rarityData and rarityData.maxWeight or 10
local scaleFactor = 0.5 + (randomWeight / finalMaxW * 1.5)

for _, desc in ipairs(fishClone:GetDescendants()) do
if desc:IsA("BasePart") or desc:IsA("MeshPart") then
desc.Size = desc.Size * scaleFactor
desc.CanCollide = false
if colorOver then
desc.Color = colorOver
end
end
end
fishClone:SetAttribute("Weight", randomWeight)

local fishTool = Instance.new("Tool")
local finalName = {}
if specialMutation ~= "" then
table.insert(finalName, specialMutation)
end
table.insert(finalName, sizeMutation)
table.insert(finalName, fishClone.Name)
local joinedName = table.concat(finalName, " ")

fishTool.Name = string.format("[%s] %s (%d кг)", rarityName, joinedName, randomWeight)
fishTool.RequiresHandle = false
fishClone.Parent = fishTool

if not fishClone.PrimaryPart then
local primary = fishClone:FindFirstChildWhichIsA("BasePart")
or fishClone:FindFirstChildWhichIsA("MeshPart")
if primary then
fishClone.PrimaryPart = primary
else
warn("[FishManager] У рыбы нет PrimaryPart.")
end
end

local fishStreak = getOrCreateStreak(player)
fishStreak.Value = fishStreak.Value + 1
updateCharacterStreak(player)

local backpack = player:WaitForChild("Backpack")
fishTool.Parent = backpack

-- ВАЖНО: здесь тоже подключаем механику "рыба парит над головой"
attachFishOverheadMovement(fishTool, fishClone, player)

else
local fishStreak = getOrCreateStreak(player)
fishStreak.Value = 0
updateCharacterStreak(player)
end
pendingFishData[userId] = nil
end
end)

--------------------------------------------------------------------------------
-- РАЗДЕЛ 8: Инвентарь (продажа рыбы)
--------------------------------------------------------------------------------
local function getFishPrice(rarityName: string, weight: number, specialMutFactor: number?)
specialMutFactor = specialMutFactor or 1
local data = getRarityDataByName(rarityName)
if not data then return 0 end
local pricePerKg = data.pricePerKg or 0
local basePrice = weight * pricePerKg
local finalPrice = basePrice * specialMutFactor
return math.floor(finalPrice * 100 + 0.5) / 100
end

inventoryRemoteEvent.OnServerEvent:Connect(function(player, action, payload)
local userId = player.UserId
local dataForUser = sessionData[userId]
if not dataForUser then return end

local moneyValue = getOrCreateMoney(player)

if action == "getInventory" then
local fishList = {}
local function gather(container)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:FindFirstChildWhichIsA("Model") then
local fishModel = tool:FindFirstChildWhichIsA("Model")
local weight = fishModel and fishModel:GetAttribute("Weight") or 0
local bracketStart, bracketEnd = tool.Name:find("%[(.+)%]")
local rarityName = "normal"
if bracketStart then
rarityName = tool.Name:sub(bracketStart+1, bracketEnd-1)
end
local finalPrice = getFishPrice(rarityName, weight, 1)
table.insert(fishList, {
toolName = tool.Name,
rarity = rarityName,
weight = weight,
price = finalPrice
})
end
end
end
local backpack = player:FindFirstChild("Backpack")
local character = player.Character
if backpack then gather(backpack) end
if character then gather(character) end

inventoryRemoteEvent:FireClient(player, "inventoryData", {
fishList = fishList,
money = moneyValue.Value
})

elseif action == "sellAll" then
local totalEarned = 0
local function sellIn(container)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:FindFirstChildWhichIsA("Model") then
local fishModel = tool:FindFirstChildWhichIsA("Model")
local weight = fishModel and fishModel:GetAttribute("Weight") or 0
local bracketStart, bracketEnd = tool.Name:find("%[(.+)%]")
local rarity = "normal"
if bracketStart then
rarity = tool.Name:sub(bracketStart+1, bracketEnd-1)
end

-- доп. проверка на "спец"мут
local isSpecial = false
for _, sm in ipairs(specialMutations) do
if tool.Name:find(sm.displayName) then
isSpecial = true
break
end
end
local factor = isSpecial and 1.5 or 1
local price = getFishPrice(rarity, weight, factor)

totalEarned = totalEarned + price
tool:Destroy()
end
end
end
local backpack = player:FindFirstChild("Backpack")
local character = player.Character
if backpack then sellIn(backpack) end
if character then sellIn(character) end

moneyValue.Value = moneyValue.Value + math.floor(totalEarned)
inventoryRemoteEvent:FireClient(player, "soldAllResult", {
earned = math.floor(totalEarned),
totalMoney = moneyValue.Value
})

elseif action == "sellInHand" then
local character = player.Character
if not character then return end

local equippedTool = character:FindFirstChildWhichIsA("Tool")
if equippedTool and equippedTool:FindFirstChildWhichIsA("Model") then
local fishModel = equippedTool:FindFirstChildWhichIsA("Model")
local weight = fishModel:GetAttribute("Weight") or 0
local bracketStart, bracketEnd = equippedTool.Name:find("%[(.+)%]")
local rarityName = "normal"
if bracketStart then
rarityName = equippedTool.Name:sub(bracketStart+1, bracketEnd-1)
end
local factor = 1
for _, sm in ipairs(specialMutations) do
if equippedTool.Name:find(sm.displayName) then
factor = 1.5
break
end
end
local price = getFishPrice(rarityName, weight, factor)
moneyValue.Value = moneyValue.Value + math.floor(price)
equippedTool:Destroy()

inventoryRemoteEvent:FireClient(player, "soldInHandResult", {
earned = math.floor(price),
totalMoney = moneyValue.Value
})
else
inventoryRemoteEvent:FireClient(player, "soldInHandResult", {
error = "Нет рыбы в руках!"
})
end
end
end)

--------------------------------------------------------------------------------
-- РАЗДЕЛ 9: Магазин удочек (Rod Shop)
--------------------------------------------------------------------------------
local function getAllRodsDataForClient(userId)
local result = {}
if not rodFolder then
return result
end

local ownedRodNames: {[string]: boolean} = {}
if sessionData[userId] then
for _, rinfo in ipairs(sessionData[userId].rods) do
ownedRodNames[rinfo.rodModelName] = true
end
end

for _, rodModel in ipairs(rodFolder:GetChildren()) do
if rodModel:IsA("Model") or rodModel:IsA("Folder") or rodModel:IsA("Tool") then
local realName = rodModel:GetAttribute("RodName") or rodModel.Name
local rodDesc = rodModel:GetAttribute("RodDescription") or "Без описания"
local rodPrice = rodModel:GetAttribute("RodPrice") or 100
local rodLuck = rodModel:GetAttribute("RodLuck") or 1.0
local rodDurab = rodModel:GetAttribute("RodDurability") or 100
local rodMutCh = rodModel:GetAttribute("RodMutationChance") or 1
local modelPath = "Rod/" .. rodModel.Name

local isOwned = ownedRodNames[rodModel.Name] == true

table.insert(result, {
rodModelName = rodModel.Name,
rodName = realName,
description = rodDesc,
price = rodPrice,
luck = rodLuck,
durability = rodDurab,
mutationChance= rodMutCh,
modelPath = modelPath,
isOwned = isOwned
})
end
end
return result
end

local function createRodToolFromModel(rodInStorage: Instance)
if rodInStorage:IsA("Tool") then
return rodInStorage:Clone()
else
local finalTool = Instance.new("Tool")
finalTool.RequiresHandle = false
finalTool.Name = rodInStorage.Name

for _, child in ipairs(rodInStorage:GetChildren()) do
local c = child:Clone()
c.Parent = finalTool
end
return finalTool
end
end

rodShopRemoteEvent.OnServerEvent:Connect(function(player, action, payload)
local userId = player.UserId
if not sessionData[userId] then return end

local moneyValue = getOrCreateMoney(player)

if action == "getRodShopData" then
local rodsData = getAllRodsDataForClient(userId)
rodShopRemoteEvent:FireClient(player, "rodShopData", rodsData, moneyValue.Value)

elseif action == "buyRod" then
local rodModelName = payload.rodModelName
if not rodModelName then return end

local rodModel = rodFolder and rodFolder:FindFirstChild(rodModelName)
if not rodModel then
rodShopRemoteEvent:FireClient(player, "buyRodResult", {
success = false,
error = "Удочка не найдена!"
})
return
end

local rodPrice = rodModel:GetAttribute("RodPrice") or 100
local rodLuck = rodModel:GetAttribute("RodLuck") or 1.0
local rodDurab = rodModel:GetAttribute("RodDurability") or 100
local rodMutChance = rodModel:GetAttribute("RodMutationChance") or 1

local rodsList = sessionData[userId].rods
local foundIndex = nil
for i, rinfo in ipairs(rodsList) do
if rinfo.rodModelName == rodModelName then
foundIndex = i
break
end
end

if foundIndex then
-- Уже владеет — просто "экипируем"
-- Снимаем все старые
for _, rinfo in ipairs(rodsList) do
rinfo.equipped = false
end
rodsList[foundIndex].equipped = true

-- Удаляем из рюкзака все удочки
local function removeOldRod(container: Instance)
for _, tool in ipairs(container:GetChildren()) do
if tool:IsA("Tool") and tool:GetAttribute("RodLuck") then
tool:Destroy()
end
end
end
local backpack = player:FindFirstChild("Backpack")
local character = player.Character
if backpack then removeOldRod(backpack) end
if character then removeOldRod(character) end

-- Кладём новую
local rodTool = createRodToolFromModel(rodModel)
if not rodTool then
rodShopRemoteEvent:FireClient(player, "buyRodResult", {
success = false,
error = "Не удалось создать Tool (экипировка)"
})
return
end
rodTool:SetAttribute("RodLuck", rodLuck)
rodTool:SetAttribute("RodPrice", rodPrice)
rodTool:SetAttribute("RodDurability", rodDurab)
rodTool:SetAttribute("RodMutationChance", rodMutChance)

rodTool.Parent = backpack or player

rodShopRemoteEvent:FireClient(player, "buyRodResult", {
success = true,
newMoney = moneyValue.Value,
equipped = true
})
else
-- Покупаем
if moneyValue.Value < rodPrice then
rodShopRemoteEvent:FireClient(player, "buyRodResult", {
success = false,
error = "Недостаточно денег!"
})
return
end
moneyValue.Value = moneyValue.Value - rodPrice

local newRodInfo = {
rodModelName = rodModelName,
rodLuck = rodLuck,
rodPrice = rodPrice,
rodDurab = rodDurab,
rodMutationChance = rodMutChance,
equipped = false
}
table.insert(rodsList, newRodInfo)

rodShopRemoteEvent:FireClient(player, "buyRodResult", {
success = true,
newMoney = moneyValue.Value,
equipped = false
})
end
end
end)

--------------------------------------------------------------------------------
-- РАЗДЕЛ 10: Простейшая система трейдов (пример)
--------------------------------------------------------------------------------
local activeTrades: {[number]: any} = {}

local function cancelTrade(userId: number, reason: string)
local tradeData = activeTrades[userId]
if not tradeData then return end
local partnerId = tradeData.partnerId

tradeRemoteEvent:FireClient(Players:GetPlayerByUserId(userId), "tradeCancelled", reason)
if partnerId then
tradeRemoteEvent:FireClient(Players:GetPlayerByUserId(partnerId), "tradeCancelled", reason)
activeTrades[partnerId] = nil
end
activeTrades[userId] = nil
end

tradeRemoteEvent.OnServerEvent:Connect(function(player, action, payload)
local userId = player.UserId

if action == "requestTrade" then
local targetId = payload and payload.targetUserId
if not targetId then return end

if activeTrades[userId] then
tradeRemoteEvent:FireClient(player, "tradeError", "Вы уже торгуетесь!")
return
end
local targetPlayer = Players:GetPlayerByUserId(targetId)
if not targetPlayer then
tradeRemoteEvent:FireClient(player, "tradeError", "Игрок недоступен!")
return
end

activeTrades[userId] = {
partnerId = targetId,
state = "requested",
itemsOffered = {},
moneyOffered = 0
}
tradeRemoteEvent:FireClient(targetPlayer, "tradeInvite", {
fromUserId = userId,
fromName = player.Name
})

elseif action == "acceptTrade" then
local tradeData = activeTrades[userId]
if not tradeData then
tradeRemoteEvent:FireClient(player, "tradeError", "Нет активного трейда.")
return
end
local partnerId = tradeData.partnerId
local partnerData = activeTrades[partnerId]
if not partnerData then
cancelTrade(userId, "Партнёр прервал сделку")
return
end

tradeData.state = "accepted"
tradeRemoteEvent:FireClient(Players:GetPlayerByUserId(partnerId), "tradeAccepted", {fromUserId = userId})

if partnerData.state == "accepted" then
local myMoneyObj = getOrCreateMoney(player)
local partnerPlayer = Players:GetPlayerByUserId(partnerId)
if not partnerPlayer then
cancelTrade(userId, "Игрок покинул игру.")
return
end
local partnerMoneyObj = getOrCreateMoney(partnerPlayer)

local function hasAllItems(plr: Player, items: {string})
local c = plr.Character
local b = plr:FindFirstChild("Backpack")
local count = 0
for _, itemName in ipairs(items) do
local found = false
if c then
local t = c:FindFirstChild(itemName)
if t and t:IsA("Tool") then
found = true
end
end
if (not found) and b then
local t = b:FindFirstChild(itemName)
if t and t:IsA("Tool") then
found = true
end
end
if found then
count += 1
end
end
return count == #items
end

if myMoneyObj.Value < tradeData.moneyOffered then
cancelTrade(userId, "Недостаточно денег для сделки.")
return
end
if partnerMoneyObj.Value < partnerData.moneyOffered then
cancelTrade(partnerId, "У второго игрока недостаточно денег для сделки.")
return
end
if not hasAllItems(player, tradeData.itemsOffered) then
cancelTrade(userId, "У вас нет некоторых вещей, которые вы предлагаете.")
return
end
if not hasAllItems(partnerPlayer, partnerData.itemsOffered) then
cancelTrade(partnerId, "У второго игрока нет некоторых вещей, которые он предлагает.")
return
end

myMoneyObj.Value = myMoneyObj.Value - tradeData.moneyOffered + partnerData.moneyOffered
partnerMoneyObj.Value = partnerMoneyObj.Value - partnerData.moneyOffered + tradeData.moneyOffered

local function moveItems(fromPlr: Player, toPlr: Player, items: {string})
local fromChar = fromPlr.Character
local fromBack = fromPlr:FindFirstChild("Backpack")
local toBack = toPlr:FindFirstChild("Backpack") or toPlr
for _, itemName in ipairs(items) do
local toolObj = fromChar and fromChar:FindFirstChild(itemName)
if not toolObj then
toolObj = fromBack and fromBack:FindFirstChild(itemName)
end
if toolObj and toolObj:IsA("Tool") then
toolObj.Parent = toBack
end
end
end

moveItems(player, partnerPlayer, tradeData.itemsOffered)
moveItems(partnerPlayer, player, partnerData.itemsOffered)

tradeRemoteEvent:FireClient(player, "tradeSuccess", {})
tradeRemoteEvent:FireClient(partnerPlayer, "tradeSuccess", {})
activeTrades[userId] = nil
activeTrades[partnerId] = nil
end

elseif action == "declineTrade" then
cancelTrade(userId, "Игрок отклонил сделку")

elseif action == "updateOffer" then
local tradeData = activeTrades[userId]
if not tradeData then
tradeRemoteEvent:FireClient(player, "tradeError", "Нет активного трейда.")
return
end
tradeData.moneyOffered = payload.money or 0
tradeData.itemsOffered = payload.items or {}

local partnerId = tradeData.partnerId
if partnerId then
tradeRemoteEvent:FireClient(Players:GetPlayerByUserId(partnerId), "tradeOfferUpdate", {
fromUserId = userId,
moneyOffered = tradeData.moneyOffered,
itemsOffered = tradeData.itemsOffered
})
end
end
end)

print("[FishManager] Скрипт (Server) загружен и готов к работе! С добавленной механикой перемещения рыбы над головой.")

смотри надо исправить тебе все возможные баги с трейдами: 1 баг:если человек которуму ты кинул трейд даже приймет у тебя не откроеться с ним меню, возможно есть и другие баги ! напиши как их исправить, не пиши скрипты полностью просто посмотри как дизайн должен итоговый выглядить: по картинке! и также меню отправки трейда должно быть ещё и с кнопкой отменить! и находиться справа внизу

теперь напиши скрипты полностью добавив и изменив что надо что бы всё работало как я хотел! напиши 2 скрипта полностью и имбовыми!