praca_magisterska/games/unreal/tutorial/part-3-create-bullet.md

Part 3: Create the Bullet

← Previous: Part 2 - Create the Player | Back to Index | Next: Part 4 - Create the Enemy →

---

Step 3.1: Create Bullet Blueprint

1. In Content Browser → Blueprints folder

2. Right-click → Blueprint Class → Actor

3. Name it: BP_Bullet

4. Double-click to open

5. Add Components:

   • Paper Sprite → name BulletSprite
   • Sphere Collision → name BulletCollision
     • Radius: 8
     • Generate Overlap Events: CHECKED
     • Collision Preset: Custom → Query Only
   • Cube (Static Mesh) → name TempVisual
     • Scale: (0.1, 0.1, 0.05) - small bullet-sized cube
     • This provides visibility until proper visuals in Part 9

6. Create Variables:

Variable Name	Type	Default Value
TravelDirection	Vector	(0, 1, 0)
TravelSpeed	Float	1200.0
RemainingLifetime	Float	4.0
IsEnemyProjectile	Boolean	false
Damage	Integer	1

Expected Result after Compile:

• Compile button shows GREEN checkmark
• Components panel shows: DefaultSceneRoot → BulletSprite, BulletCollision, TempVisual
• Variables panel shows all 5 variables with correct types

Expected Result in Viewport (Blueprint Editor):

• Small cube visible (the TempVisual placeholder)
• Sphere collision visible (radius 8)

---

Step 3.2: Bullet Movement Logic

1. In Event Graph, from Event Tick:

a) Calculate movement:

1. Right-click → Get TravelDirection

2. Right-click → Get TravelSpeed

3. Right-click → search Multiply (Vector * Float) → add it

   • Connect TravelDirection to the Vector input
   • Connect TravelSpeed to the Float input
   • Result: a vector representing full speed in travel direction

4. Right-click → Get World Delta Seconds

5. Right-click → search Multiply (Vector * Float) → add another one

   • Connect the RESULT from step 3 to the Vector input
   • Connect World Delta Seconds to the Float input
   • Result: movement delta for this frame (frame-rate independent)

6. Right-click → Get Actor Location

7. Right-click → search Add (Vector + Vector) → add it

   • Connect Actor Location to first input
   • Connect the movement delta (from step 5) to second input

8. Right-click → Set Actor Location

   • Connect the Add result to "New Location"
   • Connect execution wire from Event Tick to Set Actor Location

b) Check lifetime and destroy when expired:

9. Right-click → Get RemainingLifetime

10. Right-click → Get World Delta Seconds

11. Right-click → search Subtract (Float) → add it

    • Connect RemainingLifetime to the TOP input (A)
    • Connect World Delta Seconds to the BOTTOM input (B)
    • Result: RemainingLifetime minus DeltaSeconds

12. Right-click → Set RemainingLifetime

    • Connect the Subtract result to it
    • This ALWAYS stores the new decreased lifetime value

13. Connect execution wire:

    • From Set Actor Location (from step 8) → Set RemainingLifetime

14. Right-click → search <= (Float) (less than or equal) → add it

    • Connect RemainingLifetime (from Set node output, or Get again) to TOP input
    • Type 0 in BOTTOM input
    • Result: true if lifetime has expired

15. From Set RemainingLifetime, drag execution → Branch

    • Connect the <= result to Branch's "Condition" input

16. On TRUE (lifetime expired):

    • From Branch's "True" pin, drag → Destroy Actor
    • Target: leave as "Self" (destroys this bullet)

17. On FALSE (still alive):

    • Leave unconnected (bullet continues to exist, will check again next frame)

Visual:

Event Tick ──► Set Actor Location ──► Set RemainingLifetime ──► Branch
               (movement)              = Remaining - Delta      (Remaining <= 0?)
                                                                     │
                                                          TRUE ──────┴────── FALSE
                                                            │                  │
                                                            ▼                  ▼
                                                      Destroy Actor        (nothing)

2. CREATE "Initialize" FUNCTION:

a) Create the function:

1. In "My Blueprint" panel (left side), find "Functions" section
2. Click the "+" button next to Functions
3. Name the new function Initialize
4. Double-click to open the function graph

b) Add input parameters:

1. In the function graph, you should see a purple "Initialize" entry node
2. With the entry node selected, look at the Details panel (right side)
3. Find "Inputs" section and click "+" to add parameters:

Parameter	Type	Default
Direction	Vector	-
Speed	Float	-
bIsEnemy	Boolean	-
Lifetime	Float	-
DamageValue	Integer	1

The entry node should now show 5 input pins.

c) Build the function logic:

1. Normalize and set direction:

   • Drag from Direction parameter (yellow pin) → search Normalize → add it
   • Right-click → Set TravelDirection
   • Connect Normalize's "Return Value" → Set TravelDirection input

2. Set travel speed:

   • Right-click → Set TravelSpeed
   • Drag from Speed parameter → Set TravelSpeed input

3. Set enemy projectile flag:

   • Right-click → Set IsEnemyProjectile
   • Drag from bIsEnemy parameter → Set IsEnemyProjectile input

4. Set remaining lifetime:

   • Right-click → Set RemainingLifetime
   • Drag from Lifetime parameter → Set RemainingLifetime input

5. Set damage:

   • Right-click → Set Damage
   • Drag from DamageValue parameter → Set Damage input

d) CRITICAL - Connect execution wires:

IMPORTANT: Without execution wires, the SET nodes will NEVER run! You must chain them together.

6. From Initialize entry node (white triangle on right), drag execution → Set TravelDirection
7. From Set TravelDirection (white triangle), drag execution → Set TravelSpeed
8. From Set TravelSpeed, drag execution → Set IsEnemyProjectile
9. From Set IsEnemyProjectile, drag execution → Set RemainingLifetime
10. From Set RemainingLifetime, drag execution → Set Damage

Visual:

┌─────────────────────────┐
│ Initialize              │
│ Direction ○─────────────┼──► Normalize ──► Set TravelDirection
│ Speed ○─────────────────┼──────────────────► Set TravelSpeed
│ bIsEnemy ○──────────────┼──────────────────► Set IsEnemyProjectile
│ Lifetime ○──────────────┼──────────────────► Set RemainingLifetime
│ DamageValue ○───────────┼──────────────────► Set Damage
└──────────┬──────────────┘
           │ (white execution wire)
           ▼
    Set TravelDirection ──► Set TravelSpeed ──► Set IsEnemyProjectile
                                                         │
                                                         ▼
                              Set Damage ◄── Set RemainingLifetime

3. Compile and Save

Expected Result after Compile:

• Compile button shows GREEN checkmark
• "Initialize" function appears under Functions with 5 input parameters

NOTE: Bullet testing is possible after completing Step 3.4.

---

Step 3.3: Bullet Collision Logic

1. ADD THE OVERLAP EVENT:

1. In the Components panel (top-left), click on "BulletCollision" to select it

2. In the Details panel (right side), scroll down to find the "Events" section

   • Look for "On Component Begin Overlap"
   • Click the green "+" button next to it
   • This creates an event node in the Event Graph

3. The Event Graph now shows a red node: "On Component Begin Overlap (BulletCollision)"

   • This fires whenever another actor overlaps with the bullet's collision sphere

2. CHECK IF THIS IS AN ENEMY PROJECTILE:

4. Right-click → Get IsEnemyProjectile

   • This gets your boolean variable

5. From "On Component Begin Overlap", drag execution → Branch

   • Connect IsEnemyProjectile to Branch's "Condition" input
   • TRUE = this is an enemy bullet (should damage player)
   • FALSE = this is a player bullet (should damage enemies)

3. TRUE BRANCH - Enemy Bullet Hits Player:

6. From the "On Component Begin Overlap" node, look for the "Other Actor" output pin

   • This is the actor that overlapped with the bullet
   • Drag from "Other Actor" → search Cast to BP_Player

7. Connect execution wire:

   • From Branch TRUE pin → Cast to BP_Player

8. The cast has two execution outputs:

   • "Cast Succeeded" (top) - the other actor IS a player
   • "Cast Failed" (bottom) - the other actor is NOT a player

9. From "Cast Succeeded", we need to damage the player:

   • From the cast's "As BP Player" output pin, drag → search TakeHit
   • This calls the TakeHit function you created in Part 2
   • IMPORTANT: The "Target" pin on TakeHit should now be connected to "As BP Player" (this happened automatically when you dragged from that pin)
   • If Target shows "self", you must manually connect "As BP Player" to the "Target" pin - TakeHit must be called ON the player, not on the bullet!

10. Connect the Damage parameter:

    • Right-click → Get Damage (your bullet's damage variable)
    • Connect to TakeHit's "DamageAmount" input

11. After damaging the player, destroy the bullet:

    • From TakeHit, drag execution → Destroy Actor
    • Leave "Target" as "Self" (destroys this bullet)

12. Connect execution wire:

    • Cast to BP_Player → TakeHit → Destroy Actor

4. FALSE BRANCH - Player Bullet Hits Enemy (PLACEHOLDER):

NOTE: BP_Enemy doesn't exist yet, so we'll add a placeholder. You'll complete this logic in Part 4, Step 4.7.

13. From Branch FALSE pin, drag execution → Print String
    • In the "In String" field, type: TODO: Damage enemy
    • This is temporary - we'll replace it with real enemy damage logic in Part 4

Visual:

┌──────────────────────────────────────┐
│ On Component Begin Overlap           │
│ (BulletCollision)                    │
│                          Other Actor ○─────────────────────┐
└──────────────┬───────────────────────┘                     │
               │                                             │
               ▼                                             ▼
        ┌─────────────────┐                       ┌──────────────────┐
        │ Branch          │                       │ Cast to BP_Player│
        │ IsEnemyProjectile                       └────────┬─────────┘
        └───────┬───┬─────┘                                │
                │   │                             Cast Succeeded
          TRUE ─┘   └─ FALSE                               │
                │         │                                ▼
                ▼         │                       ┌──────────────────┐
     Cast to BP_Player    │                       │ TakeHit          │
     (see above)          │                       │ Damage: Damage   │
                          │                       └────────┬─────────┘
                          ▼                                │
               ┌──────────────────┐                        ▼
               │ Print String     │               ┌──────────────────┐
               │ "TODO: Damage    │               │ Destroy Actor    │
               │  enemy"          │               │ (Self)           │
               └──────────────────┘               └──────────────────┘

4. Compile and Save

Expected Result after Compile:

• Compile button shows GREEN checkmark
• Event Graph shows "On Component Begin Overlap" event connected to Branch

NOTE: Collision testing requires player firing (Step 3.4) and enemies (Part 4). Full collision behavior is testable after completing Part 4.

---

Step 3.4: Complete Player Firing Logic (BP_Player)

Now that BP_Bullet exists, we can complete the player's firing functions.

1. Open BP_Player Blueprint:

• In Content Drawer, navigate to Content → Blueprints
• Double-click "BP_Player" to open the Blueprint Editor

2. SET THE BULLET CLASS VARIABLE:

1. In My Blueprint panel, find the BulletClass variable
2. Click on it to select it
3. In Details panel, find "Default Value"
4. Click the dropdown and select BP_Bullet
5. Compile to save the change

3. CREATE SPAWN BULLET FUNCTION:

a) In "My Blueprint" panel, under "Functions", click "+"

b) Name the function SpawnBullet

c) Double-click to open function graph

d) Add input parameters to the function:

• In the function graph, look at the purple "SpawnBullet" entry node
• In Details panel (right side), find "Inputs" section
• Click "+" to add a new input parameter

Parameter	Type
SpawnLocation	Vector
Direction	Vector

The entry node should now show two input pins: SpawnLocation and Direction

e) Build the spawning logic:

1. Right-click → search Spawn Actor from Class → add it

2. For the "Class" input:

   • Right-click → Get BulletClass (your variable)
   • Connect BulletClass output (blue pin) to SpawnActor's "Class" input (purple pin)

3. For the "Spawn Transform Location" input:

   • On the SpawnActor node, look for "Spawn Transform Location" (orange pin)
   • If you only see "Spawn Transform", right-click on it → "Split Struct Pin" to expand it
   • Drag a wire from the SpawnLocation parameter (on the SpawnBullet entry node) to "Spawn Transform Location"
   • Leave Rotation and Scale at defaults (0,0,0 and 1,1,1)

4. Connect execution wire:

   • Drag from SpawnBullet entry node (white triangle) → SpawnActor (white triangle)

f) Initialize the spawned bullet:

5. Add the Cast node:

   • From SpawnActor's "Return Value" output (blue pin on right side), drag → search Cast to BP_Bullet
   • Connect "Return Value" to the Cast's "Object" input

6. Connect execution wire:

   • From SpawnActor (white triangle output) → Cast to BP_Bullet (white triangle input)

7. Add the Initialize call:

   • From the Cast's "As BP Bullet" output (blue pin), drag → search Initialize
   • This calls the Initialize function you created in Step 3.2
   • IMPORTANT: The "Target" pin should automatically connect to "As BP Bullet"

8. Connect Initialize parameters:

   • Direction: Drag from the Direction parameter (on SpawnBullet entry node, yellow pin) → Initialize's "Direction" input
   • Speed: Right-click → Get BulletSpeed → connect to Initialize's "Speed" input
   • bIsEnemy: Leave unchecked (false) - player bullets aren't enemy projectiles
   • Lifetime: Type 4.0 in the input field (or leave default)
   • DamageValue: Leave at default 1

9. Connect execution wire:

   • From Cast to BP_Bullet → Initialize

Visual:

┌───────────────────────┐      ┌─────────────────────────────────┐
│ SpawnBullet           │─────►│ Spawn Actor from Class          │
│ SpawnLocation ○───────┼─────►│   Class: BulletClass            │
│ Direction ○           │      │   Spawn Transform Location ○◄───┘
└───────────────────────┘      │   Return Value ○────────────────┐
                               └─────────────────────────────────┘
                                                                 │
                                           ┌─────────────────────┘
                                           ▼
                               ┌─────────────────────────┐
                               │ Cast to BP_Bullet       │
                               │   Object ○◄─────────────┘
                               │   As BP Bullet ○────────┐
                               └─────────────────────────┘
                                                         │
                                           ┌─────────────┘
                                           ▼
                               ┌─────────────────────────┐
                               │ Initialize              │
                               │   Target ○◄─────────────┘
                               │   Direction ○◄──────────── (from entry node)
                               │   Speed ○◄────────────── BulletSpeed
                               │   bIsEnemy: false       │
                               │   Lifetime: 4.0         │
                               └─────────────────────────┘

g) Compile (should have no errors now)

4. CREATE FIRE VOLLEY FUNCTION:

a) In "My Blueprint" panel, under "Functions", click "+"

b) Name the function FireVolley

c) Double-click to open function graph

d) Inside FireVolley function graph, build this logic step by step:

---

STEP 1 - Get the volley size and check for single bullet case:

1. You should see a purple "FireVolley" entry node on the left

   • This is where execution starts when the function is called

2. Right-click → search Get VolleySize → add it

   • This gets your variable value (default 3)

3. Right-click → search Equal (Integer) or == → add it

   • Connect VolleySize output to the TOP input (A)
   • Type 1 in the BOTTOM input (B)
   • This checks: is VolleySize exactly 1?

4. From FireVolley entry node, drag execution → Branch

   • Connect the == result to Branch's "Condition" input
   • TRUE = single bullet, FALSE = multiple bullets in spread

---

STEP 2 - TRUE branch: Fire single bullet straight up:

5. From Branch TRUE pin, drag execution → right-click → search SpawnBullet (the function you created in step 3 above)

6. For SpawnBullet's "Spawn Location" input:

   • Right-click → Get Actor Location
   • Connect the output to Spawn Location

7. For SpawnBullet's "Direction" input (fire straight UP):

   • Right-click → Make Vector
   • Set X = 1 (up in top-down view)
   • Set Y = 0
   • Set Z = 0
   • Connect to Direction input

8. After SpawnBullet, drag execution → Return Node

   • This exits the function early (don't continue to the loop)

Visual so far:

┌─────────────┐      ┌────────────────────┐
│ FireVolley  │─────►│ Branch             │
│ (entry)     │      │ VolleySize == 1    │
└─────────────┘      └─────────┬──────────┘
                               │ TRUE
                               ▼
                     ┌─────────────────────┐
                     │ SpawnBullet         │
                     │ Location: ActorLoc  │───► Return
                     │ Direction: (1,0,0)  │
                     └─────────────────────┘

---

STEP 3 - FALSE branch: Fire multiple bullets in a spread pattern:

9. From Branch FALSE pin, we need to loop through each bullet. First, calculate the starting angle:

   The spread is CENTERED on "straight up". For 3 bullets with 12° spread:

   • Bullet 0: -12° (left of center)
   • Bullet 1: 0° (center, straight up)
   • Bullet 2: +12° (right of center)

   Formula: StartAngle = -(VolleySpread * (VolleySize - 1)) / 2

10. Calculate StartAngle:

    • Right-click → Get VolleySize

    • Right-click → Subtract (Integer) → connect VolleySize, type 1

      • Result: (VolleySize - 1) = 2 for default

    • Right-click → Get VolleySpread

    • Right-click → Multiply (float) → connect VolleySpread and (VolleySize-1)

      • NOTE: The integer will auto-convert to float
      • Result: VolleySpread * (VolleySize - 1) = 12 * 2 = 24

    • Right-click → Divide (float) → connect the multiply result, type 2

      • Result: 24 / 2 = 12

    • Right-click → Negate (float) or "Multiply by -1"

      • Result: -12 (this is StartAngle)

    • Right-click → Set → create a LOCAL variable "StartAngle" (Float)

      • OR just keep the wire connected (we'll use it in the loop)

11. Set up the FOR loop:

    • From Branch FALSE pin, drag → right-click → search For Loop
    • "First Index": type 0
    • "Last Index": connect (VolleySize - 1)
      • You already calculated this in step 10, reuse it or calculate again:
      • Get VolleySize → Subtract 1 → connect to Last Index

    The loop will run with Index = 0, 1, 2 for VolleySize=3

12. Inside the loop (from "Loop Body" execution pin):

    Calculate angle for THIS bullet:

    • Right-click → Multiply (float)

      • Connect loop "Index" to first input (auto-converts int to float)
      • Connect VolleySpread to second input
      • Result: Index * VolleySpread (0, 12, 24 for indices 0, 1, 2)

    • Right-click → Add (float)

      • Connect StartAngle (the -12 from step 10) to first input
      • Connect (Index * VolleySpread) to second input
      • Result: StartAngle + (Index * VolleySpread) = -12, 0, +12 degrees

    This is the angle in DEGREES. Store or continue with this value.

13. Convert angle from degrees to a direction vector:

    In Unreal's top-down view (looking down Z axis):

    • X axis = up/down on screen (vertical)
    • Y axis = left/right on screen (horizontal)
    • Angle 0° = straight up = direction (1, 0, 0)
    • Angle 90° = right = direction (0, 1, 0)

    Direction.X = Cos(angle)   // Cos for vertical (forward/up)
    Direction.Y = Sin(angle)   // Sin for horizontal offset
    Direction.Z = 0
    

    BUT Unreal's Sin/Cos use RADIANS, not degrees!

    a) Convert degrees to radians:

    • Right-click → search Degrees To Radians → add it
    • Connect your angle (from step 12) to the input
    • Output is angle in radians

    b) Calculate X component (Cos - forward/up direction):

    • Right-click → Cos (Radians) → add it
    • Connect the Degrees To Radians output to Cos input

    c) Calculate Y component (Sin - horizontal offset):

    • Right-click → Sin (Radians) → add it
    • To connect the SAME radians value to Sin (without losing the Cos connection):
      • Option 1: Ctrl+drag from "Degrees To Radians" output to Sin input (creates second wire)
      • Option 2: Drag directly from "Degrees To Radians" output again - UE5 allows multiple wires from one output pin
    • Both Cos and Sin should now be connected to the same radians value

    d) Make the direction vector:

    • Right-click → Make Vector
    • Connect Cos result to X (forward/up direction)
    • Connect Sin result to Y (horizontal spread)
    • Set Z = 0

14. Spawn the bullet:

    • From the loop body execution, drag → SpawnBullet (from step 3)
    • Spawn Location: Get Actor Location
    • Direction: Connect the Make Vector from step 13

15. Connect loop completion:

    • The For Loop has a "Completed" execution pin
    • This fires AFTER all iterations are done
    • Drag from "Completed" → Return Node (or leave unconnected)

Complete Visual:

┌─────────────┐      ┌────────────────────┐
│ FireVolley  │─────►│ Branch             │
│ (entry)     │      │ VolleySize == 1    │
└─────────────┘      └──────┬───────┬─────┘
                            │TRUE   │FALSE
                            ▼       ▼
                     ┌──────────┐  ┌─────────────────────────────┐
                     │SpawnBullet│  │ Calculate StartAngle        │
                     │Dir:(1,0,0)│  │ = -(Spread*(Size-1))/2      │
                     └─────┬────┘  └──────────────┬──────────────┘
                           │                      ▼
                           ▼              ┌─────────────────┐
                        Return            │ For Loop        │
                                          │ 0 to Size-1     │
                                          └───────┬─────────┘
                                                  │ Loop Body
                                                  ▼
                                   ┌──────────────────────────────┐
                                   │ Angle = Start + (i * Spread) │
                                   │ Radians = DegreesToRadians   │
                                   │ Dir.X = Cos(Radians)         │
                                   │ Dir.Y = Sin(Radians)         │
                                   │ SpawnBullet(Location, Dir)   │
                                   └──────────────────────────────┘

Test Values (VolleySize=3, VolleySpread=12):

• StartAngle = -(12 * 2) / 2 = -12°
• Bullet 0: -12 + (0 * 12) = -12° → slightly left
• Bullet 1: -12 + (1 * 12) = 0° → straight up
• Bullet 2: -12 + (2 * 12) = +12° → slightly right

5. CONNECT FIREVOLLEY TO THE FIRE RATE LIMITER:

1. Go back to the Event Graph tab
2. Find your IA_Fire logic from Step 2.5
3. Delete the Print String "FIRE!" placeholder
4. From the "Set FireTimer = FireInterval" node, drag execution → FireVolley

Updated Visual:

┌─────────────────┐    TRUE    ┌─────────────────────┐
│ Branch          │───────────►│ Set FireTimer       │──► FireVolley
│ FireTimer <= 0  │            │   = FireInterval    │
└─────────────────┘            └─────────────────────┘

6. Compile and Save

Expected Result after Compile:

• Compile button shows GREEN checkmark
• "FireVolley" and "SpawnBullet" functions appear under Functions in My Blueprint panel

Expected Result in Play mode:

• Pressing Z or Left Mouse Button spawns 3 bullets in a spread pattern
• Bullets travel upward from player position
• Rapid fire when holding the button (every 0.08 seconds)
• Bullets disappear after 4 seconds (RemainingLifetime)

---

← Previous: Part 2 - Create the Player | Back to Index | Next: Part 4 - Create the Enemy →