Create me a roblox script that allows me to grab and move objects and doors based on my mouse location when holding the right mouse button, that I can still interact with wherever I move them to my mouse location

To create a Roblox script that allows players to grab and move objects and doors with their mouse while holding the right mouse button, you'll need to use a LocalScript. Below is an example of how you can achieve this within Roblox Studio.

Here’s a step-by-step guide followed by the complete code:

### Step-by-Step Instructions:

1. **Create Remote Events**: You'll need to set up RemoteEvents to communicate between the LocalScript and ServerScript.
   - Insert a RemoteEvent into `ReplicatedStorage` and name it `MoveObject`.

2. **Create the LocalScript**:
   - Insert a LocalScript into StarterPlayerScripts or StarterGui.

3. **Create the ServerScript**:
   - Insert a Script into ServerScriptService.

### LocalScript Code:
This LocalScript handles mouse input and sends the target object to the server for manipulation.

```lua
-- LocalScript in StarterPlayerScripts or StarterGui
local player = game.Players.LocalPlayer
local mouse = player:GetMouse()
local rs = game:GetService("ReplicatedStorage")
local moveObjectEvent = rs:WaitForChild("MoveObject")

local selectedObject = nil
local isMoving = false

mouse.Button2Down:Connect(function()
    if mouse.Target then
        selectedObject = mouse.Target
        isMoving = true
    end
end)

mouse.Button2Up:Connect(function()
    selectedObject = nil
    isMoving = false
end)

game:GetService("RunService").RenderStepped:Connect(function()
    if isMoving and selectedObject then
        moveObjectEvent:FireServer(selectedObject, mouse.Hit.Position)
    end
end)
```

### ServerScript Code:
This Script in ServerScriptService processes movements and updates the position of the objects.

```lua
-- Script in ServerScriptService
local rs = game:GetService("ReplicatedStorage")
local moveObjectEvent = rs:WaitForChild("MoveObject")

moveObjectEvent.OnServerEvent:Connect(function(player, targetObject, newPosition)
    if targetObject:IsA("BasePart") or targetObject:IsA("UnionOperation") then
        targetObject.Position = Vector3.new(newPosition.X, targetObject.Position.Y, newPosition.Z)
    end
end)
```

### Explanation of the Code:

- **LocalScript**:
  - The script listens for the right mouse button press (Button2).
  - It checks if there's a target object to grab; if so, it sets the `selectedObject` to that object and flags `isMoving` as true.
  - When the right mouse button is released, it resets the `selectedObject` and `isMoving`.
  - Every frame on `RenderStepped`, if `isMoving` is true, it sends the position of the mouse to the server along with the targeted object.

- **ServerScript**:
  - Listens for the event fired from the LocalScript.
  - Checks if the selected object is a BasePart or UnionOperation (you can add more types if needed).
  - Updates the `Position` of the target object to the new position received from the client.

### Notes:
- Ensure that the parts are anchored if you want them to be moved and not fall due to gravity.
- You can modify the code to make it possible to rotate or manipulate properties as needed.
- Make sure to test this in Play mode, as some features may not work in Edit mode.

This script gives you a basic framework to grab and move objects with the mouse using the right mouse button while providing a clean separation between client-side and server-side logic.

Update (2025-09-12):
Creating a Roblox script that allows you to grab and move objects or doors with the mouse while holding the right mouse button can be achieved using LocalScripts and the UserInputService.

Here's a basic implementation of such a script:

1. **Insert a LocalScript**: You need to create a LocalScript in the StarterPlayerScripts service for it to run properly.

2. **Script Code**: Here's the script you can use:

```lua
local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")
local Player = Players.LocalPlayer
local Mouse = Player:GetMouse()

local selectedObject = nil
local isDragging = false
local offset = Vector3.new(0, 0, 0)

-- Function to start dragging
local function startDrag()
    if selectedObject and selectedObject:IsA("BasePart") then
        isDragging = true
        offset = Mouse.Hit.p - selectedObject.Position
    end
end

-- Function to stop dragging
local function stopDrag()
    isDragging = false
    selectedObject = nil
end

-- Mouse click function
Mouse.Button2Down:Connect(function()
    local target = Mouse.Target
    if target then
        selectedObject = target
        startDrag()
    end
end)

-- Stop dragging on right mouse button release
Mouse.Button2Up:Connect(stopDrag)

-- Update the position of the object while dragging
game:GetService("RunService").RenderStepped:Connect(function()
    if isDragging and selectedObject then
        local newPosition = Mouse.Hit.p - offset
        selectedObject.Position = Vector3.new(newPosition.X, selectedObject.Position.Y, newPosition.Z) -- Maintain original Y position
    end
end)
```

### Explanation of the Script:
1. **UserInputService**: This service is used to handle input from the user, specifically mouse clicks.
2. **Mouse and Player**: The script accesses the player's mouse for detecting target objects.
3. **Variables**:
   - `selectedObject`: To store the currently selected object.
   - `isDragging`: A boolean to check if the object is currently being dragged.
   - `offset`: To determine the position offset between the mouse and the object.
4. **startDrag and stopDrag**: Functions that handle the dragging state.
5. **Mouse Events**:
   - `Mouse.Button2Down`: Triggers when the right mouse button is clicked. It sets `selectedObject` to the target the mouse is pointing at.
   - `Mouse.Button2Up`: Stops the dragging process.
6. **RenderStepped**: Updates the position of the object to follow the mouse while maintaining its Y-coordinate.

### Important Notes:
- Make sure you run this script in a safe environment where you have permissions to move the objects.
- This script assumes that you only want to drag items that are `BasePart` types. Modify accordingly if you want to include other types.
- You may need to adjust the handling of Y-coordinate logic based on your game's design (e.g., if you want the object to float or snap differently).

### Testing the Script:
To test, simply play the game and right-click on an object or door while holding the right mouse button to drag it around. Make sure that the objects you are trying to manipulate have the appropriate properties set for interactions.