You want a shield that blocks enemy bullets. But you also want to fire your own bullets outward from inside it. Being able to vary how the same shield collides depending on the other party is what makes mechanisms like this possible.
UE's collision has a table deciding "block, check for overlap, or ignore" per kind of other party. Start by reading that table and saving frequently used combinations under a name.
This article organizes the roles of channels and profiles and builds a shield that stops only enemy bullets. At the end we actually fire two kinds of bullet and map the settings table to what we see.
What You'll Learn
- How to read the "name tag" of Object Type and the per-target Response
- When to use an Object Channel versus a Trace Channel
- How Block, Overlap, and Ignore are decided from both sides' settings
- A shield that stops only enemy bullets, and switching profiles
Channels and profiles: the name tag and the settings set
A Static Mesh Component for a rock's collision, a CapsuleComponent for the player's body. Open "Collision Presets" in the details panel of such a collision-bearing part and you can see the Object Type and Responses.
The Object Type is a name tag saying what that part is. The player's capsule is Pawn, an immovable wall is WorldStatic, and so on. Create your own Object Channels and you can add kinds such as EnemyProjectile.
The Response is how it reacts to a target of that kind. An enemy bullet, for example, is configured per name tag: "Block against PlayerShield, Overlap against Pawn."
Bundling that Object Type, the per-target Responses, and settings like Collision Enabled that decide the query purpose gives you a collision profile. Name that settings set Enemy_Bullet and you can apply the same settings to several bullets.
For a quick test, setting a part's Collision Presets to "Custom..." and configuring directly works too. The reason to make a profile is to avoid rewriting the same table by hand repeatedly and to be able to reselect it by name later.
Creating a channel does not automatically distinguish friend from foe. You also configure which part claims that kind and how the other party reacts.
Object Channels and Trace Channels
Channels come in two kinds: classifying parts, and separating query purposes.
| Kind | What it separates | Examples |
|---|---|---|
| Object Channel | The kind of a collision-bearing part | Pawn, WorldStatic, your own EnemyProjectile |
| Trace Channel | The purpose of a query | Visibility, Camera, your own Interact |
Object Channels apply to invisible trigger parts too. Rather than whether it is drawn on screen, think in terms of what you classify a collision-bearing part as.
A trace, meanwhile, extends a line or shape to inspect what lies along it. Use a Trace Channel when you want different targets to respond to "what is beyond the crosshair" versus "is there a wall in front of the camera."
Line Trace by Channel's Trace Channel takes the latter. Line-based queries can also select targets by Object Type, so there is no need to memorize "lines always mean Trace Channels." Line Trace Basics covers when each is used.
Create new kinds under "Edit" → "Project Settings" → "Engine" → "Collision." For our bullets and shield, we use Object Channels.
Reading Ignore, Overlap, and Block from both tables
There are three basic Responses. Start by comparing what happens in game.
| Response | How it collides | When you use the notification |
|---|---|---|
| Ignore | Ignores queries against that target | You do not even need to know it passed |
| Overlap | Checks the overlap. Does not stop movement | Touching an item, entering a volume |
| Block | Treated as contact that obstructs movement | Walls, or a shield that stops bullets |
Overlap is the entry point for writing what happens when things overlap. To receive notifications, turn on Generate Overlap Events on both Components and connect logic to events such as On Component Begin Overlap. Setting Overlap alone does not reduce HP.
Block, too, does not by itself decide bouncing. When moving a bullet with Projectile Movement, whether it bounces is chosen by Should Bounce. Hit notifications also have conditions, so start by separating "obstructing motion" from "calling logic from a notification."
Block on one side alone cannot stop anything
Even if the shield Blocks enemy bullets, an enemy bullet that Ignores the shield passes through. Reading your own table together with the other party's is what matters.
| You → them | Them → you | Result |
|---|---|---|
| Block | Block | Block |
| Block | Overlap | Overlap |
| Block | Ignore | Ignore |
| Overlap | Overlap | Overlap |
| Overlap | Ignore | Ignore |
Swapping left and right gives the same result. If either side is Ignore it is ignored; with no Ignore and one side Overlap it overlaps; with both Block it obstructs. Of course, when collision itself is disabled or movement is not checking for collisions, this table alone will not stop anything.
Hands-On: building a shield that blocks only enemy bullets
We use BP_InputPractice from Enhanced Input Basics. We put a spherical shield around the white character, with enemy bullets flying in from outside and friendly bullets from inside.
First, compare the shield enabled and disabled by restarting Play. After confirming the basic responses, we add toggling with the Q key.
1. Create three name tags
Press "New Object Channel..." under Object Channels in "Project Settings" → "Engine" → "Collision" and create these three.
| Name | Default Response |
|---|---|
| PlayerShield | Ignore |
| EnemyProjectile | Ignore |
| PlayerProjectile | Ignore |
Default Response is the starting point for how existing settings react to a newly added kind. Since we specify only the targets we need, we start from Ignore. If the new entries do not appear in a part's details, close and reopen the Blueprint.
2. Save three profiles
Open Presets on the same screen and create these three from "New...". Each column of the table is one profile.
| Item | Shield_Active | Enemy_Bullet | Player_Bullet |
|---|---|---|---|
| Collision Enabled | Query Only | Query Only | Query Only |
| Object Type | PlayerShield | EnemyProjectile | PlayerProjectile |
| Response to PlayerShield | Ignore | Block | Ignore |
| Response to EnemyProjectile | Block | Ignore | Ignore |
| Response to PlayerProjectile | Ignore | Ignore | Ignore |
| Response to Pawn | Ignore | Overlap | Ignore |
| Response to everything else | Ignore | Ignore | Ignore |
Query Only participates in overlap and destination queries. Here we do not drop bullets with rigid-body physics simulation; we move them straight with Projectile Movement.
Since these bullets exist to observe the shield-body relationship, we Ignore walls and floors too. To stop them at walls like a normal bullet, set the bullet's WorldStatic to Block later and configure the wall side as well.
3. Attach the shield to the character
Add a Sphere Collision as a child of BP_InputPractice's CapsuleComponent and name it ShieldCollision. Set Relative Location all to 0, Scale all to 1, and Sphere Radius to 150.
Set ShieldCollision's Collision Presets to Shield_Active and turn Generate Overlap Events off. We do not use the shield's overlap notifications here; it only stops bullets.
If you want to see the sphere's extent during practice, turn off ShieldCollision's Hidden in Game. That outline is a debug display and separate from the finished shield's appearance.
Next select the body's CapsuleComponent. Set Collision Presets to "Custom..." and change only the Response to EnemyProjectile to Overlap, leaving Object Type as Pawn. Turn on Generate Overlap Events too. Leave the original responses such as WorldStatic for walking on floors.
Since we made the new channels' Default Response Ignore, without this change the body would ignore enemy bullets too. The shield and the body are parts of the same Actor, but their response tables are separate.
4. Build a flying enemy bullet
Create a Blueprint with Actor as parent and name it BP_EnemyBullet. First add a Sphere Collision named BulletCollision, drag it onto DefaultSceneRoot, and make it the Root.
Add a Static Mesh Component BulletMesh as its child and choose a Sphere for the visual. With the Sphere from the engine's BasicShapes, setting Scale to 0.2 on all axes gives a diameter of about 20. If you cannot find it, turn on "Show Engine Content" in the asset picker's settings. BulletMesh's Collision Presets is NoCollision.
| Part | Setting |
|---|---|
| BulletCollision | Sphere Radius = 10, Scale = 1, Collision Presets = Enemy_Bullet |
| BulletCollision | Generate Overlap Events on, Simulate Physics off |
| BulletMesh | Relative Location 0, visual only. Collision Presets = NoCollision |
Also add a Projectile Movement with these values.
| Item | Value |
|---|---|
| Initial Speed / Max Speed | 200 for both |
| Velocity | X=200, Y=0, Z=0 |
| Initial Velocity in Local Space | On |
| Projectile Gravity Scale | 0 |
| Should Bounce | Off |
| Sweep Collision | On |
| Auto Activate | On |
Now, once Play starts, it travels 200 cm per second along its own local X, which is forward for the bullet. Change the placed bullet's rotation and its travel direction changes too. Gravity is 0, so it does not drop along the way.
Sweep means checking whether anything is hit between the pre-move and post-move positions. Projectile Movement normally moves the Root, so we put the collision-bearing BulletCollision at the Root. Whether you are moving a visual-only part is the thing to check when things pass through.
Sweep can also be specified when you use Set Actor Location yourself. Here we leave bullet movement to Projectile Movement. Spawning bullets during the game is covered in the Spawn Actor and Projectile article.
5. Display where it stopped and when it reached the body
Select Projectile Movement in BP_EnemyBullet and add On Projectile Stop from the events in the details. Connect it to a Print String showing Enemy bullet stopped for 5 seconds. Leave the stopped sphere in place so you can see its position.
Next select BulletCollision and add On Component Begin Overlap. Connect Other Actor to Cast To BP_InputPractice's Object, and the white line from the event to the Cast.
From the Cast's success side, Print String Enemy bullet reached the body for 5 seconds, then call Destroy Actor (Target = self). Leave the Cast Failed side unconnected.
The Cast here confirms whether the overlapped party is the practice character. It distinguishes the case where the shield did not stop it and it reached the body. Here we stop at confirming arrival; combine it with the health and damage article for HP reduction.
6. Place the enemy bullet and compare the two states
Use a spot with a flat floor at height 0 and place the PlayerStart at Location = (0, 0, 100), Rotation = (0, 0, 0). The GameMode is BP_InputPracticeGameMode from Enhanced Input Basics. The character spawns from the PlayerStart, so do not add one by hand.
Place BP_EnemyBullet at Location = (800, 0, 88) with Rotation Yaw = 180 and Pitch and Roll = 0. That puts it 8 m in front of the character, flying toward you. Leave no obstacles between the bullet and the PlayerStart, and observe without moving or jumping during Play.
First, with Shield_Active still set, compile, save, and Play. If the enemy bullet approaches and stops on the sphere in front of the character's body, "Enemy bullet stopped" appears.
Next stop Play, change only BP_InputPractice's ShieldCollision to NoCollision, and Play again. This time it does not stop at the sphere; it reaches the character, "Enemy bullet reached the body" appears, and the bullet vanishes.
If you turned off Hidden in Game, the debug outline remains even with NoCollision. Outline display and collision being enabled are separate, so compare the results by the bullet's position and the notification.
We restart Play each time to test the same conditions with a fresh bullet. A bullet that stopped once does not fly again automatically when you disable the shield.
7. Confirm friendly bullets can leave from inside
Stop Play and set ShieldCollision back to Shield_Active. Duplicate BP_EnemyBullet as BP_PlayerBullet and change BulletCollision's Collision Presets to Player_Bullet.
Delete the copied On Projectile Stop and On Component Begin Overlap events, and the Print, Cast, and Destroy logic from them, on the BP_PlayerBullet side. That keeps enemy-bullet notifications from firing on the friendly bullet. Leave the movement settings as they are.
Place BP_PlayerBullet in the level at Location = (80, 60, 88), Rotation = (0, 0, 0). That puts it inside the shield, flying forward.
Save, Play, and watch whether the inner friendly bullet travels outward while the incoming enemy bullet stops on the sphere. Even with identical collision shapes, the per-target Response changed the result.
8. Toggle the shield with Q
Once that is confirmed, add runtime toggling. Create a Digital (Bool) IA_Shield in the InputPractice folder with Modifiers and Triggers empty. Add a Q key binding to IMC_Common.
Create a Boolean variable bShieldOn in BP_InputPractice with initial value true. Align ShieldCollision's initial profile to Shield_Active as well.
Connect IA_Shield's Started to a Branch with Get bShieldOn on the Condition.
- True side: Set Collision Profile Name to NoCollision → Set bShieldOn = false → Print String "Shield OFF"
- False side: Set Collision Profile Name to Shield_Active → Set bShieldOn = true → Print String "Shield ON"
Both Set Collision Profile Name nodes have Get ShieldCollision as Target. Enter the name in In Collision Profile Name and turn Update Overlaps on. The Print Duration is 2.
Reselecting a profile switches that part's whole settings set. It is not an operation that changes the sphere's size or the settings of the body, which is a different part.
Click the Play view and press Q before the enemy bullet arrives. Turn it OFF and you can confirm arrival at the body; leave it ON and you confirm the stop at the sphere. Restart Play when repeating.
Common Pitfalls
| Symptom | Where to check |
|---|---|
| The enemy bullet passes through the shield | Whether Shield_Active and Enemy_Bullet Block each other's Object Type. Whether ShieldCollision is still NoCollision |
| Disabling the shield gives no arrival message | Whether the Capsule's EnemyProjectile is Overlap. Whether Generate Overlap Events is on for both the Capsule and BulletCollision |
| The bullet doesn't move | Check Projectile Movement's Auto Activate, Velocity, and Initial Speed |
| The bullet flies elsewhere or drops | Check the bullet's Yaw, Initial Velocity in Local Space, and Gravity Scale = 0 |
| It's Block but movement passes through | Whether Sweep Collision is on, whether BulletCollision is the Root, whether Simulate Physics is off |
| Friendly bullets stop too | Whether BP_PlayerBullet's Object Type is PlayerProjectile. Whether BulletMesh has its own collision |
| Q doesn't toggle | Check IMC_Common's Q binding, Started, bShieldOn's initial value, and the Set's Target and name |
| The bullet passes somewhere other than the body | The PlayerStart's position and rotation, the bullet's height, the floor height, and whether you moved the character during Play |
If the shape itself does not fit, also check choosing between Simple and Complex. Looking at shape, response to targets, and movement method in order lets you find the cause without changing settings all at once.
Bonus: organizing query purpose and classification
Query Only can still stop movement
Collision Enabled chooses what the collision is used for. Start by distinguishing these four common kinds.
| Setting | How it is used |
|---|---|
| No Collision | Disables collision |
| Query Only | Traces, overlaps, and destination checks via Sweep |
| Physics Only | Rigid-body physics simulation |
| Collision Enabled (Query and Physics) | Both queries and physics simulation |
A query asks whether a specified position and shape hits something. Character Movement and Projectile Movement check their destinations, so they can be stopped by a Query Only target that Blocks.
Some versions also have entries such as Probe Only, but we do not use them here. To roll a dropped box with physics, consider a setting including Physics and Simulate Physics separately from the bullets here.
Also confirm Hit notifications alongside the movement method. Beyond hitting during a Sweep, contact during physics simulation can also notify. For the latter, enable that Component's Simulation Generates Hit Events.
Separate before the hit, or after the hit
Channels are for separating "targets to block" from "targets to ignore" at the query stage. When you only want to branch post-contact logic — "if the enemy hit is fire-attributed, change the effect" — you can classify with Gameplay Tags instead.
Before adding lots of channels, consider whether the kinds actually collide differently. Rather than a name tag per enemy, grouping what can be handled as a shared "enemy bullet" kind makes the response table easier to follow. Adding Gameplay Tags does not change collision responses.
Confirm settings after changing a profile
Set Collision Profile Name is not merely storing a name in a variable; it changes the Component's collision behavior. Responses you had adjusted with Custom also switch to the chosen profile's contents.
When the result is not what you intended, check the name's spelling and the Target. Reading the applied name with Get Collision Profile Name and comparing against the running Component's details lets you investigate at which stage the settings changed.
Summary
Object Type decides a target's kind, Response writes the reaction per kind, and a profile saves the settings set. When something does not stop, check both your table and the other party's.
For the shield: enemy bullets stop, disabling it lets them reach the body, and friendly bullets get through. Comparing those three in the same place connects the setting names to what happens in game.
References: Collision Response Reference, Collision Enabled types, Projectile Movement, Overlap events, Hit events, Set Collision Profile Name.