create me a roblox script that allows me to control unanchored parts to wherever my mouse is located when holding the e key and you left click to throw

Certainly! Below is a simple Roblox Lua script that allows players to control unanchored parts with their mouse. When holding the 'E' key, the player can move the part to their mouse's position, and when they left-click, the part will be thrown.

### Local Script
You should place this script in a `LocalScript` inside `StarterPlayerScripts` or any other appropriate location for local scripts.

```lua
-- LocalScript

local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local userInputService = game:GetService("UserInputService")

local selectedPart = nil
local holdingE = false

-- Function to move the part to the mouse
local function movePartToMouse()
    if selectedPart and holdingE then
        local targetPosition = mouse.Hit.p
        selectedPart.Position = targetPosition
    end
end

-- Function to throw the part
local function throwPart()
    if selectedPart then
        selectedPart.Anchored = false
        selectedPart.Velocity = (mouse.Hit.p - selectedPart.Position).unit * 50 -- Adjust the speed factor as needed
        selectedPart = nil
    end
end

-- Function called when a key is pressed/released
local function onInputBegan(input)
    if input.KeyCode == Enum.KeyCode.E then
        holdingE = true
    end
end

local function onInputEnded(input)
    if input.KeyCode == Enum.KeyCode.E then
        holdingE = false
    elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
        throwPart()
    end
end

-- Detect when to manage part selection
local function onMouseClick()
    if selectedPart then
        selectedPart.Anchored = false
        selectedPart = nil
    else
        -- Check what part was clicked
        local target = mouse.Target
        if target and target:IsA("Part") and not target.Anchored then
            selectedPart = target
            selectedPart.Anchored = true -- Anchor it while controlled
            print("Selected part:", selectedPart.Name)
        end
    end
end

-- Connect events
userInputService.InputBegan:Connect(onInputBegan)
userInputService.InputEnded:Connect(onInputEnded)
mouse.Button1Down:Connect(onMouseClick)

game:GetService("RunService").RenderStepped:Connect(movePartToMouse)
```

### Important Notes:

1. **Unanchored Parts**: Make sure the parts you want to control are unanchored in the game. The script only works with unanchored parts.

2. **Adjusting Power**: In the `throwPart` function, the speed of the throw is determined by `50`. You can adjust this value based on how fast you want the part to be thrown.

3. **Selecting Parts**: The script allows you to click a part to select it. If it’s unanchored, it will become controlled. Click it again or left-click anywhere to release it.

4. **Preventing Conflicts**: Make sure that no other scripts are interfering with the movement of the parts. 

5. **Local vs. Server Scripts**: Please note this is a local script meant for client-side execution, and it may have limitations if you need multiplayer synchronization. 

This script can be further enhanced with features like limits on how far away you can throw parts or cooldowns to prevent spamming. Happy scripting!

Update (2026-03-28):
Creating a complete Roblox script as requested involves several components, including mouse detection, GUI creation, and the ability to manipulate unanchored parts. Below you'll find an example of how you might implement such a system. Please ensure that you have the necessary permissions to test and run scripts in your Roblox game.

### Step 1: Create a LocalScript

You'll want to create a LocalScript in `StarterPlayerScripts` or `StarterGui`.

```lua
-- LocalScript

local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local UserInputService = game:GetService("UserInputService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local throwStrength = 50
local mode = "single" -- or "radius"
local partsInRadius = {}

-- GUI Elements
local ScreenGui = Instance.new("ScreenGui", player.PlayerGui)
local ThrowStrengthSlider = Instance.new("Slider", ScreenGui)
local ModeToggleButton = Instance.new("TextButton", ScreenGui)

-- GUI Setup
ThrowStrengthSlider.Size = UDim2.new(0, 200, 0, 50)
ThrowStrengthSlider.Position = UDim2.new(0, 100, 0, 100)
ThrowStrengthSlider.MinValue = 0
ThrowStrengthSlider.MaxValue = 100

ModeToggleButton.Size = UDim2.new(0, 200, 0, 50)
ModeToggleButton.Position = UDim2.new(0, 100, 0, 200)
ModeToggleButton.Text = "Toggle Mode: " .. mode

-- Function to update throw strength
ThrowStrengthSlider.Changed:Connect(function()
	throwStrength = ThrowStrengthSlider.Value
end)

-- Function to toggle mode
ModeToggleButton.MouseButton1Click:Connect(function()
	if mode == "single" then
		mode = "radius"
		ModeToggleButton.Text = "Toggle Mode: " .. mode
	else
		mode = "single"
		ModeToggleButton.Text = "Toggle Mode: " .. mode
	end
end)

-- Unanchored Part Handling
local function getAllUnanchoredParts()
	local parts = {}
	for _, part in pairs(workspace:GetChildren()) do
		if part:IsA("BasePart") and not part.Anchored then
			table.insert(parts, part)
		end
	end
	return parts
end

local function throwPart(part)
	if part and part:IsA("BasePart") then
		local direction = (mouse.Hit.p - part.Position).unit * throwStrength
		part.Velocity = direction
	end
end

-- Control Parts with Mouse
UserInputService.InputBegan:Connect(function(input, gameProcessedEvent)
	if gameProcessedEvent then return end

	if input.KeyCode == Enum.KeyCode.E then
		local parts = mode == "single" and {mouse.Target} or getAllUnanchoredParts()

		for _, part in pairs(parts) do
			if part and part:IsA("BasePart") then
				part.Position = mouse.Hit.p
			end
		end

	elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
		local parts = mode == "single" and {mouse.Target} or getAllUnanchoredParts()
		for _, part in pairs(parts) do
			throwPart(part)
		end
	end
end)
```

### Step 2: Explanation of the Script

1. **Mouse Control**: The script takes the mouse position to set the position of the unanchored parts when the "E" key is held down.
  
2. **Throwing Logic**: When the left mouse button is clicked, the script applies a force to throw the unanchored part in the direction of the mouse.

3. **Throw Strength Control**: A slider (noting you'll need to create a Slider GUI if it's not built in your project) is used to set the throw strength, adjusting how far or fast the part will be thrown.

4. **Mode Toggle**: You can toggle between "single" (interacting with only the clicked part) and "radius" (interacting with all unanchored parts).

5. **Unanchored Part Detection**: The script gathers all unanchored parts in the workspace.

### Note

1. Make sure you have unanchored parts present in the game for the script to work appropriately.
2. UI components (like the slider and button) need to be created and calibrated per your game design, as Roblox might require specific types (i.e., `TextButton`, `Frame`, etc.).
3. This code is illustrative and may need modifications based on your game’s structure.

### Testing

Test the functionality in a Roblox Studio environment where you can control objects safely. It is also crucial to handle permissions and ensure the player can manipulate parts as expected when testing.

Update (2026-03-28):
Creating a Roblox script that allows you to control unanchored parts with your mouse and includes a GUI for power control can be quite extensive. Below, I'll outline a basic version of such a script which you can expand upon as needed. This will give you a starting point for your Roblox Game.

### LocalScript for Mouse Control
First, you will need the LocalScript to track mouse movement and handle user input.

1. **Insert a LocalScript** into `StarterPlayerScripts`.

```lua
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local rs = game:GetService("RunService")
local gui = Instance.new("ScreenGui", player:WaitForChild("PlayerGui"))

local powerSlider = Instance.new("TextButton", gui)
powerSlider.Size = UDim2.new(0, 200, 0, 50)
powerSlider.Position = UDim2.new(0.5, -100, 0, 0)
powerSlider.Text = "Power: 0"
local power = 0

local selectedPart = nil
local dragging = false

local function updatePower()
    powerSlider.Text = "Power: " .. power
end

mouse.Button1Down:Connect(function()
    if dragging and selectedPart then
        -- Throw the part
        selectedPart.Velocity = (mouse.Hit.p - selectedPart.Position).unit * power
        selectedPart = nil
        dragging = false
        power = 0  -- Reset the power
        updatePower()
    end
end)

-- Adjust power with E key
mouse.KeyDown:Connect(function(key)
    if key == "e" then
        if not dragging then
            -- Create selection box or similar feedback
            local targetedParts = workspace:GetPartsInRegion3(Region3.new(
                mouse.Hit.p - Vector3.new(5, 5, 5),
                mouse.Hit.p + Vector3.new(5, 5, 5)
            ))
            for _, part in pairs(targetedParts) do
                if part:IsA("BasePart") and not part.Anchored then
                    selectedPart = part
                    break
                end
            end
            if selectedPart then
                dragging = true
            end
        else
            dragging = false
            selectedPart = nil
        end
    end
    if dragging then
        if key == "w" then
            power = power + 1
            updatePower()
        elseif key == "s" then
            power = math.max(0, power - 1)
            updatePower()
        end
    end
end)

rs.RenderStepped:Connect(function()
    if dragging and selectedPart then
        selectedPart.Position = mouse.Hit.p + Vector3.new(0, selectedPart.Size.Y / 2, 0)
    end
end)
```

### Explanation
- The local script retrieves the player's mouse and listens for specific key events.
- An unanchored part is selected by holding the `E` key, allowing the player to drag it around with their mouse.
- Power can be adjusted by pressing `W` to increase and `S` to decrease.
- Upon left-clicking, the selected part is thrown with velocity based on the set power.

### GUI Slider
In this script, we just have a simple `TextButton` serving as a power indicator. A more sophisticated slider could be implemented for better user interaction.

### Notes
- Ensure that the parts you want to control are unanchored and are of type `BasePart`.
- This script contains basic functionality; you may want to add error handling, and visuals (like selection indicators), and refine it based on your project needs.
- Remember that testing and iterating on your script while in Roblox Studio will help you refine the mechanics and fix any potential bugs.

This is a basic script; of course, feel free to customize it further based on your requirements. Enjoy building!

Update (2026-03-28):
Creating a Roblox script that allows a player to pick up unanchored parts using the mouse, throw them, and change the mode to grab all parts within a certain radius can be accomplished through local scripts. Below is an example of how such a script can be structured. 

### Note:
Ensure you are working in a LocalScript context for this to work properly, as LocalScripts can access the player's input, while normal Scripts cannot. 

### LocalScript Example:
```lua
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()

local selectedParts = {}
local mode = "single" -- "single" or "radius"
local throwPower = 50 -- default throw power
local isHolding = false

-- Function to grab parts
local function grabParts()
    if mode == "single" then
        local target = mouse.Target
        if target and target:IsA("BasePart") and not target.Anchored then
            table.insert(selectedParts, target)
            target.Massless = true -- Prevent physics issues while controlling
        end
    elseif mode == "radius" then
        local radius = 10 -- Adjust the radius as needed
        for _, part in pairs(workspace:GetChildren()) do
            if part:IsA("BasePart") and not part.Anchored and (part.Position - mouse.Hit.Position).magnitude <= radius then
                table.insert(selectedParts, part)
                part.Massless = true -- Prevent physics issues while controlling
            end
        end
    end
end

-- Function to throw parts
local function throwParts()
    for _, part in pairs(selectedParts) do
        part.Massless = false
        local direction = (mouse.Hit.p - part.Position).unit -- Direction to throw
        part.Velocity = direction * throwPower
    end
    selectedParts = {} -- Clear selection after throwing
end

-- Main loop to detect input
local function onInput(input, gameProcessed)
    if gameProcessed then return end

    if input.UserInputType == Enum.UserInputType.Keyboard then
        if input.KeyCode == Enum.KeyCode.E then
            isHolding = true
            grabParts()
        end
    elseif input.UserInputType == Enum.UserInputType.MouseButton1 then
        if isHolding then
            throwParts()
            isHolding = false
        end
    end
end

-- Function to change mode (single/radius)
local function toggleMode()
    if mode == "single" then
        mode = "radius"
    else
        mode = "single"
    end
end

-- Detect key press to toggle mode
local UserInputService = game:GetService("UserInputService")
UserInputService.InputBegan:Connect(onInput)

-- Bind the mode toggling to a specific key (for example, M)
UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if not gameProcessed and input.KeyCode == Enum.KeyCode.M then
        toggleMode()
    end
end)

-- Cleanup when removing this script
game.Players.PlayerRemoving:Connect(function()
    for _, part in pairs(selectedParts) do
        part.Massless = false -- Restore mass
    end
end)
```

### Explanation:
- **Mouse Targeting:** The script checks for the target part the mouse is hovering over when 'E' is pressed.
- **Select Parts:** Parts can be selected individually or in a radius. Parts are marked as `Massless` while controlled to avoid physics issues.
- **Throwing Parts:** After selecting parts, left-clicking (MouseButton1) will throw them in the direction of the mouse cursor with a specified power.
- **Toggling Modes:** Pressing 'M' allows the player to switch between single part selection and radius selection.
- **Handling Cleanup:** Restores mass when the player leaves to prevent issues.

### Usage:
Place the script within StarterPlayerScripts or similar execution context to ensure proper access to local player controls. Make sure to test and refine the throw power and radius as needed for your game design!