YouTube Instagram TikTok How it works FAQ

The fastest way to turn talking videos into clean, searchable text. Free, private and no account required.

About

Built by Rishav Raj with one goal: free transcripts for everyone.

rishav@yttotranscript.com

Transcribe

YouTube to text
YouTube with timestamps
Instagram Reels
TikTok videos

Learn

How it works
FAQ
YouTube transcripts guide

More

Chrome extension
Contact
Privacy policy
Terms of service

© 2026 YTtoTranscript. Made for creators & researchers.

Not affiliated with YouTube, Instagram or TikTok. Respect creators’ copyright.

How To Make A First & Third Person Shooter System | Roblox Studio — Transcript · YTtoTranscript

Home/Transcripts/YouTube

YouTube Transcript

How To Make A First & Third Person Shooter System | Roblox Studio

rnk · 2,090 words · 10 min read · EN

Watch on YouTube

Share X LinkedIn WhatsApp

Below is the complete, readable transcript of How To Make A First & Third Person Shooter System | Roblox Studio by rnk on YouTube. Read the full text, copy any part you need, or generate a transcript for any video with our free tool.

It worked. You did it.

To select your model, you first need to choose if the default avatar will be an R6 or R15.

I personally use R6 as it is simpler to animate and for the nostalgia.

Then you're going to make a gun model or take a free one for a tool box. Make sure there's a mesh or part inside a gun that is the mag. This tutorial will not show how to make your own gun model. Make sure everything in the gun model is unanchored and can't collide.

Once you have picked a gun model, create a blank character. Delete the humanoid description and add inside the humanoid an animator controller and an animator. Remove everything inside the head and change the size of the head to the following numbers. Make sure the head is anchored. Delete the legs, the torso, and the

humanoid root part.

Set the head as the primary part of your model.

Set the arms to the following size. We set the arms in different size because this view model will be used when we are in first person. So, we need more space to see.

Transcribe another video

Paste any YouTube, Instagram or TikTok link to get a free transcript.

Free · No sign-up · Unlimited

Add to Chrome — transcribe in one click

Now, you just have to make it look like the arms are holding the gun.

Once you're done, you can import the parts or meshes inside the gun model into the view model. If you haven't done it already, name your model view model.

Then, you will need to use the plugin Rig Edit, which will be linked in the description, to rig our gun onto our view model. The reason why we do this is so that we can animate our view model later on. And also, it prevents everything to fall apart. To use the rig plugin, you will first

need to click the base part and then the target part. So, for example, if I want to attach my gun to my right arm, I will first select my right arm and then my gun. The order matters. And do not forget to link the arms to the head, whom is the base part.

Duplicate the view model using Ctrl D and name it view TP model.

Set the arm size of the view TP model to the following scale.

In replicated storage, create a folder and name it your gun name. Drag the two view models inside the folder because later we will need to copy them onto workspace. Create a remote event and name it view model remote. This remote will let us have the view model also update in the server.

Create a server script inside the server script service and name and the name doesn't really matter, but I recommend it to be view model server.

In the starter pack, create a tool with the gun name. Inside of the tool, create a local script and name it whatever you want. But I recommend it to be view model handler.

Speaking of handler, you should also need to create a part inside the tool and name it handle. Set its transparency to one and make it not be able to collide.

Should now be all set up for the next step.

Before we start scripting, you're going to have to import a model that is linked in the description. This will let the player move his head depending on where he looks at. We're now going to script. First, create a path name using the tool name. Then, add those variables. Most of them will be explained later when using them.

Hey, hey, hey.

We have two versions of the our view model. One in the third person and one in the first person. We set a equipped variable that is by default unequipped, so false. We also want some sway when we are going to be in the first person. So, let's add some variables on that. Tween service won't be used, but later

we will have to. So, first we need to be able to know when our tool is equipped or not. For that, there's already a function to do so. With tool.equipped and unequipped. In a loop using RenderStepped, we first check if the player isn't dead to break the loop if so. Otherwise, it will just keep running

and break our game, basically. We also want to check if our gun is equipped. If not, we just return the function. To continue scripting, we first need to know if we are in first person or third person. So, we need a function for that. This CFrame.P stands for the position of the CFrame.

It's an It's an abbreviation. Now, we can know when our player is in third person or first person. This is all great, but we haven't done a single thing with our view models. For now, they are just in the ReplicatedStorage. This is where we're going to create a function that duplicates the first-person view model onto the camera

of the player. The reason The why we add gun name when deploying is because we need to differentiate the view models if we have multiple guns. Because if you models will have the same name otherwise.

We will also create a local third-person view model for when the client goes into third person. We will develop more the server side later. But it is important that you have it on the local side to avoid client delays for smooth animations.

We will also make a function for when we are transit from first person to third person.

In this case, we just deleted the first person view model and create the third person view model if they exist. Let's not forget to destroy our view models if they exist when we unequip our gun.

Well, we can now define our two view models to avoid having to use find first child constantly.

Since we are in first person, we check if there is already an existing first person view model. If not, if that's not the case, we create one. And if it is, we move on with our script and also check if there's a third-person view model to delete it since we are in first person. We now need to attach the

first-person view model to the camera of the player. We would we use functions like to object space or to orientation to apply the same rotation and location of the view model to the camera. For this way, we just use Lerp, which delays the execution of the following script. So, the movement is delayed by this way

amount. We then move the primary part of the view model, which is the head, the location and the rotation we previously defined. Since the head is the primary part, everything will move along with it because we rigged it previously. And for when we're in third person, we just use the Transit function

and use Pivot To to move and rotate our view model along the player's head. All right, let's test it.

I mean, it's all right, but I will have to adjust the view model of the camera to be more upward. Also, you might notice that our arms doesn't match our skin and shirt, and we also have four arms in third person. This is a simple fix if you add a shirt inside the two

view models and add the two more function in the local script.

Our first function will be to match the view model's arms to the player's skin color and shirt. We are only able to match the shirt since there is a humanoid inside the view model. So, here we simply get the information we need like the skin color, the shirt template, and we apply those on the view

model right arm and left arm.

We also set the real player's arms to a transparency that depends on the prompt when calling the function. One being transparent and zero being visible.

Now, we apply those functions and it should work.

Since our local script works, we need to also make the view model in the server script, since we see nothing in the server. The reason why we need two third-person view models, one in the client and one in the server, is so that both camera views from server and client have no delays or desynchronization.

First, we set up our variables. You may notice that this time we use Run Service, since we can't use RenderStepped in server scripts. Copy the match arms functions and set transparency function from the local script and apply those into the server script.

And now, we just create a third-person view model like in the local script. With the difference being the name, which is View Model TPS, so no local.

We use a loop to move the arms onto the players when the equip variable is true on the execution of the remote event.

We also use Lerp when updating the CFrame, because for some reason there is no delay without it, which makes it look like the arm move before the body without it.

And eventually, when the tool is unequipped, it will close the connection and destroy the view model.

Go back to your local script and fire the events on equip and unequip. And make sure to delete the view model server version from the client side view model view so that the player doesn't see it.

When testing it, the view model should also appear in the server.

Before scripting, we will need a reference part for aiming in first person.

So duplicate the head of your view model.

And change its size to the smallest size.

Keep it anchored and name it aim part.

Once you place it Once you place it in on the location of aiming, you can set the transparency to of the aim part to one and put the V model back into the folder. We will first need some variables to define how much time it will take for to aim and un-aim depending on if you're in first person

or third person. On top of that, we will also need to aim a CFrame for the first person aiming. We'll also need a to get a variable to see if we're aiming or not and set it by default to false. We will build up the twin service as we are going to use it to smoothly aim in

the third person. For the first person, it's pretty easy. In our loop, we just have to add a few lines. First, define your aim part. Then, we check if we are aiming. If if we are, we just move the aim part, which will move the whole V model closer to the camera. And if not, we simply set

it the aim CFrame back to zero. We use lerp again for a smooth animation. For the third person, we're going to modify the player's FOV instead of changing the camera location. So, we create a zoom camera function that using twin services will set the player new FOV using the variable prompted when calling the function.

Create a handle aiming function which will later write in it. To know if we're aiming or not, we need the player user input service which will grant us access to the inputs of the player on his keyboard or mouse. In our input function, we first need to check if the player has his gun

equipped. What we can do for now is set back the FOV to a normal when the input stops.

We set the FOV to 70 within the aiming time of the third-person variable. Then, you can copy what we did in the input ended function into the handle aiming function and change the FOV to 45.

We need to make sure when we unequip our gun or when we we switch into first-person that our FOV reverts back to normal.

And it works.

This is the end of the first part of the series. I'm sorry to have kept you waiting with this tutorial, but I feel like focusing on quality rather than quantity is better. Next part will include the shooting, ray tracers, and recoil. A lot of effort went in making this video. So, if you could subscribe or like or

comment, I would really appreciate it. We are almost at 1K subscribers. Anyways, that's all for me. See you soon.

bluff