kuhyx/praca_magisterska
1
0
Fork 0
mirror of https://github.com/kuhyx/praca_magisterska.git synced 2026-07-04 13:23:05 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Restructure C++ tutorial into part-by-part format and add migration guide

Browse Source 
Co-authored-by: kuhyx <147418882+kuhyx@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot] 2026-01-07 22:06:56 +00:00
parent e1c1ece85a
commit 8145e92128
9 changed files with 1392 additions and 2020 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
games/unreal/tutorial/QUICKSTART-CODE-FIRST.md
View File

@ -8,11 +8,13 @@
### 1. Choose Your Path
- **New to Unreal?** → Start with [Code-First Tutorial](code-first-approach.md) (recommended)
- **Want comparison?** → Read [Blueprint vs Code Comparison](blueprint-vs-code-comparison.md)
- **Need copy-paste code?** → Go to [Appendix D: C++ Reference](appendix-d-cpp-reference.md)
- **New Project?** → Start with [Part 1 (C++): Project Setup](part-1-cpp-project-setup.md)
- **Already have Blueprint project?** → See [Migration Guide](#migrating-from-blueprint-to-c) below
- **Just need code?** → See existing implementations in `Source/MCPGameProject/`
### 2. Create C++ Project
### 2. Create C++ Project (New Projects Only)
If starting fresh:
```
Unreal Engine → New Project → Games → Blank
@ -20,6 +22,8 @@ Unreal Engine → New Project → Games → Blank
Name: BulletHellGame
```
If you already have a Blueprint project, skip to [Migration Guide](#migrating-from-blueprint-to-c) below.
### 3. Copy-Paste the Classes
Instead of clicking through UI 60+ times, just copy these ready-to-use files:
@ -159,6 +163,147 @@ Replace All → Done!
---
## 🔄 Migrating from Blueprint to C++
**Already started with the Blueprint tutorial?** Here's how to move to C++ without losing your work.
### Option 1: Add C++ to Existing Blueprint Project (Recommended)
This approach keeps your existing Blueprints and adds C++ support.
#### Step 1: Add C++ Support to Project
1. In Unreal Editor: **Tools → New C++ Class**
2. Choose any parent (e.g., "Actor") → Next
3. Name it anything (e.g., `Dummy`) → Create Class
4. **This triggers C++ project generation!**
- Visual Studio/Rider opens
- `Source/` folder is created
- Project compiles (~2-5 minutes first time)
5. After compilation, you'll have:
```
YourProject/
├── Source/ ← NEW! C++ folder created
├── Content/ ← Your existing Blueprints (unchanged)
└── YourProject.uproject
```
#### Step 2: Create C++ Classes
Now follow the C++ tutorial parts to create classes:
1. **Tools → New C++ Class** → Pawn → `STGPawn`
2. Copy-paste code from [Part 2 (C++)](part-2-cpp-create-player.md)
3. Compile
4. Repeat for bullets, enemies, etc.
#### Step 3: Reparent Existing Blueprints
Instead of creating new BP_Player, **reparent your existing one**:
1. Open your existing `BP_Player` Blueprint
2. **File → Reparent Blueprint** (top menu)
3. In the dialog, click "All Classes" dropdown
4. Search for `STGPawn` (your C++ class)
5. Select it → Reparent
**What happens:**
- ✅ BP_Player now inherits from STGPawn (C++)
- ✅ All C++ variables appear in Blueprint
- ✅ Your existing visual assets (meshes, materials) are preserved
- ✅ Old Blueprint variables become redundant (you can delete them)
#### Step 4: Clean Up Duplicate Variables
1. In BP_Player, look at "Variables" panel
2. You'll see duplicates:
- `MoveSpeed` (from Blueprint - old)
- `MoveSpeed` (from STGPawn - new, with C++ icon)
3. **Delete the old Blueprint variables** - keep only C++ ones
4. Compile and Save
#### Step 5: Migrate Logic (If Needed)
If you had Blueprint nodes for logic:
**Option A:** Keep Blueprint nodes for now (hybrid approach)
- Blueprints can call C++ functions
- Gradually move logic to C++ over time
**Option B:** Move everything to C++ immediately
- Copy Blueprint logic to C++ functions
- Delete Blueprint nodes
- Use Blueprints only for visual assets
### Option 2: Fresh Start (Faster but Loses Visual Setup)
If you haven't done much visual work:
1. Create new C++ project
2. Follow C++ tutorial from [Part 1](part-1-cpp-project-setup.md)
3. Manually recreate any visual assets from old project
**When to use:** If you're still early in the Blueprint tutorial (Parts 1-3).
---
### Migration Example: BP_Player → STGPawn
**Before (Blueprint only):**
```
BP_Player (Blueprint)
├── Components (added manually in editor)
│ ├── ShipMesh
│ ├── Camera
│ └── Hitbox
├── Variables (defined one-by-one in UI)
│ ├── MoveSpeed = 750.0
│ ├── BoundsMin = (-850, -450)
│ └── ... (10 more)
└── Event Graph (Blueprint nodes for logic)
```
**After (Reparented to C++):**
```
BP_Player (Blueprint, inherits from STGPawn C++)
├── Parent Class: STGPawn ← NEW!
├── Components (inherited from C++)
│ ├── ShipMesh (from STGPawn)
│ ├── Camera (from STGPawn)
│ └── Hitbox (from STGPawn)
├── Variables (inherited from C++)
│ ├── MoveSpeed = 750.0 (from STGPawn)
│ ├── BoundsMin = (-850, -450) (from STGPawn)
│ └── ... (all from C++)
└── Visual Assets Only (meshes, materials)
└── ShipMesh → Assign cone mesh
```
**Benefits:**
- ✅ Variables now in version control (C++ files)
- ✅ Can modify via IDE (autocomplete, refactoring)
- ✅ Type-safe (compiler checks)
- ✅ Blueprint kept for visual assets only
---
### Common Migration Pitfalls
**Problem:** "I reparented but variables duplicated!"
- **Solution:** Delete the old Blueprint variables manually. Keep only C++ ones (they have a C++ icon next to them).
**Problem:** "Compilation errors after adding C++ support"
- **Solution:** Make sure Visual Studio has "Desktop Development with C++" workload installed. Check Output Log for specific errors.
**Problem:** "My Blueprint logic stopped working after reparenting"
- **Solution:** Check that function names match. C++ functions must be marked `UFUNCTION(BlueprintCallable)` to be called from Blueprints.
**Problem:** "Hot reload isn't working"
- **Solution:** Close Unreal Editor before compiling C++ changes. Reopen after compilation. Hot reload is unreliable.
---
## ❓ FAQ
**Q: I'm new to C++, should I use Blueprint instead?**
@ -178,7 +323,7 @@ A: Yes! That's the recommended approach:
**Q: What if I already started with Blueprints?**
A: You can migrate! See [Migration Guide in Appendix D](appendix-d-cpp-reference.md#migration-guide)
A: See the [Migration Guide](#migrating-from-blueprint-to-c) above! You can reparent existing Blueprints to C++ classes.
**Q: Do I need to know Unreal's C++ API?**
@ -188,7 +333,9 @@ A: No! The tutorial provides **complete, working code** you can copy-paste. You'
## 🚀 Get Started Now
**[→ Start the Code-First Tutorial](code-first-approach.md)**
**New Project:** [→ Start with Part 1 (C++)](part-1-cpp-project-setup.md)
**Existing Blueprint Project:** [→ See Migration Guide](#migrating-from-blueprint-to-c)
Build the complete bullet-hell game in 2-3 hours with copy-paste ready code!

20
games/unreal/tutorial/README.md
View File

@ -22,7 +22,11 @@ This tutorial offers **two ways** to implement the game:
**→ [🚀 QUICK START: 3-Minute Code-First Guide](QUICKSTART-CODE-FIRST.md)** ⭐
**→ [Complete Code-First C++ Tutorial](code-first-approach.md)**
**→ Start the C++ Tutorial:**
- [Part 1 (C++): Project Setup](part-1-cpp-project-setup.md)
- [Part 2 (C++): Create Player](part-2-cpp-create-player.md)
- [Part 3 (C++): Create Bullet](part-3-cpp-create-bullet.md)
- [Parts 4-9 (C++) Summary](part-4-9-cpp-summary.md)
- ✅ **90% faster** - copy-paste variable blocks instead of clicking UI
- ✅ **Version control friendly** - readable Git diffs, not binary files
@ -51,10 +55,10 @@ This tutorial offers **two ways** to implement the game:
| Refactoring | ✅ IDE tools | ❌ Manual |
| Full game time | ~2-3 hours | ~6-8 hours |
**📖 [Read Detailed Comparison: Blueprint vs Code](blueprint-vs-code-comparison.md)** - See specific examples of time savings
**💡 Pro Tip:** You can combine both! Use C++ for logic/variables, Blueprints for visual assets.
**📖 Migrating from Blueprint?** See [Migration Guide in Quickstart](QUICKSTART-CODE-FIRST.md#migrating-from-blueprint-to-c)
---
## Table of Contents
@ -129,10 +133,9 @@ This tutorial offers **two ways** to implement the game:
### Appendices
- [Appendix A: Complete Variable Reference](appendix-a-variables.md)
- [Appendix A: Complete Variable Reference](appendix-a-variables.md) (Blueprint)
- [Appendix B: Troubleshooting](appendix-b-troubleshooting.md)
- [Appendix C: Unity to Unreal Conversion Notes](appendix-c-unity-conversion.md)
- [Appendix D: Complete C++ Reference](appendix-d-cpp-reference.md) **← NEW! Copy-paste ready code**
---
@ -140,10 +143,11 @@ This tutorial offers **two ways** to implement the game:
### For Code-First Approach (Recommended)
1. Start with [Code-First C++ Tutorial](code-first-approach.md)
2. Copy-paste complete C++ classes from [Appendix D](appendix-d-cpp-reference.md)
3. Create minimal Blueprint children for visual assets only
1. Read [3-Minute Quickstart](QUICKSTART-CODE-FIRST.md)
2. Start with [Part 1 (C++): Project Setup](part-1-cpp-project-setup.md)
3. Follow parts 2-3, then [Parts 4-9 Summary](part-4-9-cpp-summary.md)
4. **Complete the game in 2-3 hours** instead of 6-8 hours!
5. **Already have Blueprint project?** See [Migration Guide](QUICKSTART-CODE-FIRST.md#migrating-from-blueprint-to-c)
### For Blueprint Approach

615
games/unreal/tutorial/appendix-d-cpp-reference.md
View File

@ -1,615 +0,0 @@
# Appendix D: Complete C++ Class Reference
[← Part 9: Final Setup](part-9-final-setup.md) | [Back to Index](README.md) | [Code-First Approach →](code-first-approach.md)
---
## Overview
This appendix provides **complete, copy-paste ready C++ implementations** for all game classes. These can be used instead of the Blueprint-heavy tutorial to create the same bullet-hell game with:
- ✅ **Faster development** - copy entire variable blocks instead of clicking UI
- ✅ **Better version control** - readable Git diffs instead of binary Blueprint files
- ✅ **Easier refactoring** - IDE tools for rename, find references, etc.
- ✅ **Compile-time safety** - catch type errors before runtime
---
## File Structure
Add these files to your Unreal C++ project:
```
Source/BulletHellGame/
├── BulletHellGame.Build.cs # (already exists)
├── BulletHellGame.h # (already exists)
├── STGPawn.h # Player ship
├── STGPawn.cpp
├── STGProjectile.h # Bullets
├── STGProjectile.cpp
├── STGEnemy.h # Enemy ships
├── STGEnemy.cpp
├── STGGameMode.h # Game rules, spawning
├── STGGameMode.cpp
└── STGHUD.h # UI overlay
└── STGHUD.cpp
```
---
## Complete Variable Lists (Copy-Paste Ready!)
### BP_Player Variables (Now in STGPawn.h)
Instead of manually creating 12 variables in Blueprint UI, **copy this block:**
```cpp
// In STGPawn.h, inside the class definition:
// ===== MOVEMENT & BOUNDARIES =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMin = FVector2D(-850.0f, -450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMax = FVector2D(850.0f, 450.0f);
// ===== FIRING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.08f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BulletSpeed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 VolleySize = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VolleySpread = 12.0f;
// ===== LIVES & SCORE =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 Score = 0;
// ===== SPECIAL ABILITY =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
bool bSpecialUsed = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireRate = 0.08f;
```
**Time saved:** 15 minutes of clicking vs 30 seconds of copy-paste!
### BP_Enemy Variables (Now in STGEnemy.h)
```cpp
// In STGEnemy.h, inside the class definition:
// ===== HEALTH & SCORE =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 12;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentHealth = 12;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 ScoreValue = 50;
// ===== MOVEMENT =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VerticalSpeed = 220.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalAmplitude = 250.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalFrequency = 1.8f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float DespawnY = -750.0f;
// ===== FIRING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.35f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 BulletsPerBurst = 20;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BurstSpread = 360.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletSpeed = 1000.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletLifetime = 6.0f;
```
**Time saved:** 20 minutes of clicking vs 30 seconds of copy-paste!
### BP_Bullet Variables (Now in STGProjectile.h)
```cpp
// In STGProjectile.h, inside the class definition:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
bool bIsPlayerBullet = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Damage = 1.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
FLinearColor BulletColor = FLinearColor::Green;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Lifetime = 4.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Speed = 1200.0f;
```
### BP_GameMode Variables (Now in STGGameMode.h)
```cpp
// In STGGameMode.h, inside the class definition:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Game Rules")
float GameDuration = 300.0f; // 5 minutes (300 seconds)
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
float TimeRemaining = 300.0f;
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
bool bIsGameOver = false;
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
bool bIsVictory = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float BaseSpawnRate = 2.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float SpawnAreaHalfWidth = 900.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
int32 MaxSimultaneousEnemies = 120;
```
---
## STGPawn.h (Complete File)
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "STGPawn.generated.h"
class UCameraComponent;
class USpringArmComponent;
class UStaticMeshComponent;
class UBoxComponent;
UCLASS()
class BULLETHELLGAME_API ASTGPawn : public APawn
{
GENERATED_BODY()
public:
ASTGPawn();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
// ===== COMPONENTS =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* ShipMesh;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
USpringArmComponent* SpringArm;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UCameraComponent* Camera;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UBoxComponent* Hitbox;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* HitboxIndicator;
// ===== MOVEMENT & BOUNDARIES =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMin = FVector2D(-850.0f, -450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMax = FVector2D(850.0f, 450.0f);
// ===== FIRING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.08f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BulletSpeed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 VolleySize = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VolleySpread = 12.0f;
// ===== LIVES & SCORE =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 Score = 0;
// ===== SPECIAL ABILITY =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
bool bSpecialUsed = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireRate = 0.08f;
// ===== INPUT FUNCTIONS =====
void MoveForward(float Value);
void MoveRight(float Value);
void StartFire();
void StopFire();
void UseSpecial();
// ===== GAME LOGIC =====
void FireShot();
void TakeHit(int32 Damage);
void HandleDeath();
void AddScore(int32 Points);
private:
FTimerHandle TimerHandle_Fire;
bool bIsFiring = false;
FVector MovementInput;
float FireTimer = 0.0f;
};
```
---
## STGProjectile.h (Complete File)
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "STGProjectile.generated.h"
class USphereComponent;
class UProjectileMovementComponent;
class UStaticMeshComponent;
UCLASS()
class BULLETHELLGAME_API ASTGProjectile : public AActor
{
GENERATED_BODY()
public:
ASTGProjectile();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// Components
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
USphereComponent* CollisionComp;
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
UStaticMeshComponent* MeshComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement)
UProjectileMovementComponent* ProjectileMovement;
// Variables
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
bool bIsPlayerBullet = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Damage = 1.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
FLinearColor BulletColor = FLinearColor::Green;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Lifetime = 4.0f;
// Functions
UFUNCTION()
void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
void SetBulletColor(FLinearColor InColor);
void SetSpeed(float InSpeed);
private:
UMaterialInstanceDynamic* DynamicMaterial;
};
```
---
## STGEnemy.h (Complete File)
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "STGEnemy.generated.h"
UCLASS()
class BULLETHELLGAME_API ASTGEnemy : public AActor
{
GENERATED_BODY()
public:
ASTGEnemy();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// Components
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
class UStaticMeshComponent* MeshComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
class UBoxComponent* CollisionComp;
// ===== HEALTH & SCORE =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 12;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentHealth = 12;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 ScoreValue = 50;
// ===== MOVEMENT =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VerticalSpeed = 220.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalAmplitude = 250.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalFrequency = 1.8f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float DespawnY = -750.0f;
// ===== FIRING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.35f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 BulletsPerBurst = 20;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BurstSpread = 360.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletSpeed = 1000.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletLifetime = 6.0f;
// Functions
void Fire();
void HandleDamage(float DamageAmount);
UFUNCTION()
void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
private:
FTimerHandle TimerHandle_Fire;
float BaseX = 0.0f;
float WaveSeed = 0.0f;
UMaterialInstanceDynamic* DynamicMaterial;
};
```
---
## STGGameMode.h (Complete File)
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "STGGameMode.generated.h"
UCLASS()
class BULLETHELLGAME_API ASTGGameMode : public AGameModeBase
{
GENERATED_BODY()
public:
ASTGGameMode();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// ===== GAME RULES =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Game Rules")
float GameDuration = 300.0f; // 5 minutes
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
float TimeRemaining = 300.0f;
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
bool bIsGameOver = false;
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
bool bIsVictory = false;
UPROPERTY(BlueprintReadOnly, Category = "Game Rules")
bool bTimerEnded = false;
// ===== SPAWNING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float BaseSpawnRate = 2.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float SpawnAreaHalfWidth = 900.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
int32 MaxSimultaneousEnemies = 120;
// Functions
void SpawnEnemy();
void GameOver();
void Victory();
void OnEnemyKilled();
void OnPlayerDied();
FVector GetSpawnLocation();
private:
FTimerHandle TimerHandle_Spawn;
float SpawnRate = 2.0f;
int32 TotalEnemiesSpawned = 0;
int32 TotalEnemiesKilled = 0;
void UpdateDifficulty();
float DifficultyMultiplier = 1.0f;
};
```
---
## UPROPERTY Macros Explained
### Common Patterns
```cpp
// Editable in editor, visible in Blueprints, with default value
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
// Read-only in editor and Blueprints
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
// Only visible in editor Details panel, not exposed to Blueprints
UPROPERTY(VisibleDefaultsOnly, Category = "Components")
UStaticMeshComponent* MeshComp;
// Editable only on archetype (Blueprint class defaults), not instances
UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Config")
float FireRate = 0.08f;
```
### Specifier Reference
| Specifier | Meaning |
|-----------|---------|
| `EditAnywhere` | Can edit value in Details panel (both class defaults and instances) |
| `EditDefaultsOnly` | Can edit only in class defaults (Blueprint), not placed instances |
| `VisibleAnywhere` | Shows value in Details panel but cannot edit |
| `BlueprintReadWrite` | Can Get/Set in Blueprints |
| `BlueprintReadOnly` | Can Get (but not Set) in Blueprints |
| `Category = "Name"` | Groups properties in Details panel |
---
## Benefits Summary
### Code-First C++ Approach
**Advantages:**
- ✅ **90% faster variable setup** - copy-paste blocks vs clicking UI
- ✅ **Version control friendly** - readable Git diffs
- ✅ **Refactoring tools** - IDE rename, find references, code navigation
- ✅ **Type safety** - compiler catches errors before runtime
- ✅ **Documentation** - code comments in same file as logic
- ✅ **Batch operations** - change multiple values with find/replace
- ✅ **Code reuse** - inherit classes, template patterns
**Disadvantages:**
- ❌ Longer initial compile time (~30-60 seconds vs instant Blueprint)
- ❌ Requires C++ knowledge
- ❌ Need to recompile after changes (though hot reload helps)
### When to Use Each
| Task | Use C++ | Use Blueprint |
|------|---------|---------------|
| Define game variables | ✅ Yes | ❌ No (too slow) |
| Implement game logic | ✅ Yes | ❌ No (hard to maintain) |
| Assign visual assets | ❌ No | ✅ Yes (easier in UI) |
| Create materials | ❌ No | ✅ Yes (visual editor) |
| Animation state machines | ❌ No | ✅ Yes (timeline editor) |
| Level design | ❌ No | ✅ Yes (visual placement) |
**Recommended Hybrid:**
1. Create C++ base classes with all logic and variables
2. Create Blueprint child classes that inherit from C++
3. Use Blueprints only to set visual assets (meshes, materials, sounds)
---
## Migration Guide
### If You Started with Blueprint Tutorial
To migrate existing Blueprint variables to C++:
1. **Open your Blueprint** (e.g., `BP_Player`)
2. **Copy all variable names and values** to a text file
3. **Create C++ header file** (e.g., `STGPawn.h`)
4. **Add UPROPERTY declarations** with copied names and default values
5. **Compile C++**
6. **Reparent Blueprint**:
- Open `BP_Player`
- File → Reparent Blueprint
- Select `STGPawn` (your C++ class)
7. **Variables now come from C++!**
8. **Delete old Blueprint variables** (they're redundant)
---
## Next Steps
- [Complete Code-First Tutorial](code-first-approach.md) - Full implementation guide
- [Blueprint Tutorial](README.md) - Original Blueprint-heavy version
- [Troubleshooting](appendix-b-troubleshooting.md) - Common issues
---
[← Part 9: Final Setup](part-9-final-setup.md) | [Back to Index](README.md) | [Code-First Approach →](code-first-approach.md)

573
games/unreal/tutorial/blueprint-vs-code-comparison.md
View File

@ -1,573 +0,0 @@
# Blueprint vs Code: A Practical Comparison
[Back to Index](README.md) | [Code-First Tutorial](code-first-approach.md)
---
## The Problem: Editor-Heavy Blueprints Are Tedious
When implementing the bullet-hell game using Blueprints, you face these specific pain points:
### Pain Point 1: Defining Multiple Variables
**Blueprint Approach (Part 2: Create Player):**
For **each of the 12 player variables**, you must:
1. Click "+" button in Variables panel
2. Type variable name manually
3. Click in Details panel
4. Scroll to find "Variable Type" dropdown
5. Select type from long list (Float, Integer, Vector 2D, etc.)
6. Click "Compile" button
7. Wait for compile
8. Click on variable again
9. Find "Default Value" in Details panel
10. Type the value manually
**Result:** ~60 seconds per variable × 12 variables = **~12 minutes just for player variables**
If you make a typo, you have to:
- Delete the variable
- Start over from step 1
**Code Approach:**
```cpp
// Copy-paste this entire block (10 seconds):
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMin = FVector2D(-850.0f, -450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMax = FVector2D(850.0f, 450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.08f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BulletSpeed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 VolleySize = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VolleySpread = 12.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 Score = 0;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
bool bSpecialUsed = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireRate = 0.08f;
```
**Result:** 10 seconds to copy-paste entire block
**Time saved:** ~11 minutes per class × 4 classes (Player, Bullet, Enemy, GameMode) = **~44 minutes saved**
---
### Pain Point 2: Copying Parameters Between Classes
**Scenario:** You want Enemy bullets to have similar but slightly different parameters than Player bullets.
**Blueprint Approach:**
1. Open BP_Bullet
2. For each variable you want to copy:
- Memorize or write down: name, type, default value
- Open BP_Enemy
- Click "+" to add variable
- Type name manually (risk of typo)
- Select type from dropdown
- Compile
- Set default value
- Repeat 5-10 times
**Result:** ~5 minutes to copy 5-10 related variables, error-prone
**Code Approach:**
```cpp
// In STGProjectile.h - player bullets
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Speed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Lifetime = 4.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
FLinearColor BulletColor = FLinearColor::Green;
// In STGEnemy.h - copy the block, change the values
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletSpeed = 1000.0f; // Changed value
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletLifetime = 6.0f; // Changed value
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FLinearColor EnemyBulletColor = FLinearColor::Red; // Changed value
```
**Result:** 30 seconds to copy-paste and modify
**Benefit:**
- ✅ No typos in variable names (copy-paste exact)
- ✅ No wrong type selection (copy-paste exact)
- ✅ Easy to see differences (use IDE diff/compare)
- ✅ Can use find/replace to batch rename
---
### Pain Point 3: Blueprint Node Logic vs Code Logic
**Example:** Enemy firing a radial burst of bullets
**Blueprint Approach:**
You need to create this node network:
1. Event Tick node
2. Branch node (check if should fire)
3. Get FireTimer variable node
4. Float - Float (subtract) node
5. Get World Delta Seconds node
6. Set FireTimer node
7. Float <= Float (comparison) node
8. Constant 0.0 node
9. Branch node
10. For Loop node with Break node
11. Get BulletsPerBurst variable node
12. Float / Float (divide) node for angle calculation
13. Get BurstSpread variable node
14. Float * Float (multiply) node
15. Integer - Integer (subtract) for centering
16. Spawn Actor from Class node
17. Make Rotator node
18. Get Actor Location node
19. Get BulletClass variable node
20. Cast to BP_Bullet node
21. Set bIsPlayerBullet node
22. Set BulletColor node
23. ... (30+ nodes total)
**Issues:**
- Hard to see the big picture (nodes scattered across screen)
- Easy to forget connections (white execution wires vs blue data wires)
- Difficult to debug (print each node's output)
- Can't easily comment blocks of logic
- No IDE autocomplete or type checking
**Code Approach:**
```cpp
void ASTGEnemy::Fire()
{
// Fire radial burst of bullets
for (int32 i = 0; i < BulletsPerBurst; i++)
{
// Calculate angle for this bullet in the burst
float AngleDeg = (BurstSpread / BulletsPerBurst) * i;
float AngleRad = FMath::DegreesToRadians(AngleDeg);
// Calculate direction vector
FVector Direction = FVector(
FMath::Cos(AngleRad),
FMath::Sin(AngleRad),
0.0f
);
// Spawn location slightly in front of enemy
FVector SpawnLocation = GetActorLocation() + FVector(0.f, 0.f, -30.f);
// Spawn the bullet
ASTGProjectile* Bullet = GetWorld()->SpawnActor<ASTGProjectile>(
ASTGProjectile::StaticClass(),
SpawnLocation,
Direction.Rotation()
);
if (Bullet)
{
Bullet->bIsPlayerBullet = false;
Bullet->SetSpeed(EnemyBulletSpeed);
Bullet->SetBulletColor(FLinearColor::Red);
}
}
}
```
**Benefits:**
- ✅ All logic in one place, easy to read top-to-bottom
- ✅ IDE autocomplete helps prevent typos
- ✅ Inline comments explain the logic
- ✅ Easy to debug (set breakpoints, inspect variables)
- ✅ Can copy-paste entire function to reuse pattern
- ✅ Compiler catches type errors immediately
---
### Pain Point 4: Making Changes to Multiple Parameters
**Scenario:** After playtesting, you decide all enemy health values should be doubled.
**Blueprint Approach:**
1. Open BP_Enemy
2. Find "MaxHealth" variable in My Blueprint panel
3. Click on it
4. Find Default Value in Details panel
5. Change 12 → 24
6. Click Compile
7. Click Save
8. Repeat for any enemy variants (BP_EnemyA, BP_EnemyB, etc.)
If you have 4 enemy types with different health values:
- Open each Blueprint
- Find the variable
- Change the value
- Compile and save
- **Result:** ~2 minutes
**Code Approach:**
```cpp
// Before (in STGEnemy.h):
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 12;
// After - just change one line:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 24;
// Compile once, all enemies updated
```
Or use find/replace to change multiple values at once:
- Find: `MaxHealth = 12;`
- Replace: `MaxHealth = 24;`
- Done in 5 seconds
**Benefit:** **24x faster** (2 minutes vs 5 seconds)
---
### Pain Point 5: Version Control and Collaboration
**Blueprint Approach:**
Blueprint files are **binary**, which means:
❌ **Cannot see changes in Git diff**
```
diff --git a/Content/Blueprints/BP_Player.uasset b/Content/Blueprints/BP_Player.uasset
index a1b2c3d..e4f5g6h 100644
Binary files a/Content/Blueprints/BP_Player.uasset and b/Content/Blueprints/BP_Player.uasset differ
```
You cannot tell:
- What changed?
- Who changed it?
- Why was it changed?
- Is it safe to merge?
❌ **Merge conflicts are nightmares**
- Two people modify same Blueprint
- Git shows "Binary conflict"
- You must manually recreate changes by:
- Opening both versions in Unreal
- Comparing node-by-node
- Manually rebuilding the merged version
**Code Approach:**
C++ files are **plain text**, which means:
✅ **Readable Git diffs**
```cpp
diff --git a/Source/BulletHellGame/STGPawn.h b/Source/BulletHellGame/STGPawn.h
index a1b2c3d..e4f5g6h 100644
--- a/Source/BulletHellGame/STGPawn.h
+++ b/Source/BulletHellGame/STGPawn.h
@@ -15,7 +15,7 @@
public:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
- float MoveSpeed = 750.0f;
+ float MoveSpeed = 850.0f; // Increased for better feel
```
You can see:
- ✅ Exactly what changed (MoveSpeed increased)
- ✅ Who changed it (Git blame)
- ✅ Why (commit message + comment)
- ✅ Easy to review (GitHub PR with inline comments)
✅ **Merge conflicts are manageable**
- Git shows exactly which lines conflict
- Use standard merge tools (GitKraken, VSCode, etc.)
- Resolve conflicts like any code file
---
## Real-World Example: Adding a New Enemy Type
### Blueprint Approach
**Steps:**
1. Duplicate BP_Enemy → BP_EnemyVariant
2. Open BP_EnemyVariant
3. Find MaxHealth variable → change default value
4. Find ScoreValue variable → change default value
5. Find VerticalSpeed variable → change default value
6. Find HorizontalAmplitude variable → change default value
7. Find FireInterval variable → change default value
8. Find BulletsPerBurst variable → change default value
9. Compile
10. Find MeshComp in Components panel
11. Assign different mesh in Details panel
12. Find material slot → assign different material
13. Save
**Time:** ~8-10 minutes per variant
If you need 4 enemy types: **~35 minutes**
### Code Approach
**Steps:**
1. Create child Blueprint from STGEnemy: BP_EnemyVariant
2. Open BP_EnemyVariant
3. In Class Defaults panel, change visible C++ properties:
- MaxHealth: 24 (was 12)
- ScoreValue: 100 (was 50)
- VerticalSpeed: 300 (was 220)
- FireInterval: 0.2 (was 0.35)
4. Assign different mesh
5. Assign different material
6. Done
**Time:** ~2 minutes per variant
If you need 4 enemy types: **~8 minutes**
**OR** define variants in C++ enum and configure in constructor:
```cpp
// In STGEnemy.h:
UENUM(BlueprintType)
enum class EEnemyType : uint8
{
Basic,
Fast,
Tank,
Boss
};
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Enemy")
EEnemyType Type = EEnemyType::Basic;
// In STGEnemy.cpp constructor:
void ASTGEnemy::ConfigureStats()
{
switch (Type)
{
case EEnemyType::Basic:
MaxHealth = 12;
ScoreValue = 50;
VerticalSpeed = 220.0f;
FireInterval = 0.35f;
break;
case EEnemyType::Fast:
MaxHealth = 6;
ScoreValue = 75;
VerticalSpeed = 400.0f;
FireInterval = 0.2f;
break;
case EEnemyType::Tank:
MaxHealth = 30;
ScoreValue = 150;
VerticalSpeed = 120.0f;
FireInterval = 0.5f;
break;
case EEnemyType::Boss:
MaxHealth = 100;
ScoreValue = 500;
VerticalSpeed = 80.0f;
FireInterval = 0.15f;
break;
}
}
```
Now you can:
- Create ONE Blueprint that inherits from STGEnemy
- Change the "Type" dropdown in editor
- All stats automatically configured!
**Time:** ~30 seconds to change dropdown per variant
---
## Summary: Time Investment
### Full Bullet Hell Game Implementation
| Task | Blueprint | Code-First | Time Saved |
|------|-----------|------------|------------|
| Player (12 variables) | 15 min | 2 min | 13 min |
| Player logic (movement, fire) | 60 min | 15 min | 45 min |
| Bullet (5 variables) | 8 min | 1 min | 7 min |
| Bullet logic | 30 min | 10 min | 20 min |
| Enemy (15 variables) | 20 min | 2 min | 18 min |
| Enemy logic | 90 min | 25 min | 65 min |
| Enemy variants (×4) | 35 min | 8 min | 27 min |
| Game Mode (8 variables) | 12 min | 2 min | 10 min |
| Game Mode logic | 45 min | 15 min | 30 min |
| Spawning system | 40 min | 12 min | 28 min |
| **TOTAL** | **~6-8 hours** | **~2-3 hours** | **~4-5 hours saved!** |
### One-Time Learning Investment
- **Blueprint tutorial:** ~2 hours to learn the editor UI
- **C++ tutorial:** ~4 hours to learn C++ basics
**BUT:** After the initial learning, C++ is **3x faster** for every project going forward!
---
## Recommended Workflow
### 🎯 Best Practice: Hybrid Approach
1. **Define all logic and variables in C++**
- All game mechanics
- All stats, speeds, health values
- All algorithms (movement, firing, spawning)
2. **Use Blueprints only for visual assets**
- Assign meshes/sprites
- Set material colors
- Configure particle effects
- Place sound effects
**Example:**
```cpp
// STGEnemy.h - all logic in C++
class ASTGEnemy : public AActor
{
UPROPERTY(EditAnywhere, Category = "Stats")
int32 MaxHealth = 12;
UPROPERTY(EditAnywhere, Category = "Stats")
float VerticalSpeed = 220.0f;
void Fire(); // Implemented in C++
void UpdateMovement(float DeltaTime); // Implemented in C++
};
```
Then in Blueprint `BP_Enemy` (child of ASTGEnemy):
- Inherits all C++ variables and logic
- Only sets: Mesh, Material, Color
- Can still override C++ functions in Blueprint if needed
**Best of both worlds:**
- ✅ Fast development (C++ for logic)
- ✅ Easy asset management (Blueprint for visuals)
- ✅ Version control friendly (most changes are in C++)
- ✅ Designer-friendly (non-programmers can tweak visuals)
---
## Migration Path
### If You've Already Started with Blueprints
Don't worry! You can migrate gradually:
#### Option 1: Reparent Existing Blueprints
1. Create C++ class (e.g., `STGPawn`)
2. Compile
3. Open existing Blueprint (e.g., `BP_Player`)
4. **File → Reparent Blueprint**
5. Select your C++ class
6. Blueprint now inherits from C++!
7. Delete duplicate variables (they're now in C++)
8. Keep only visual asset assignments
#### Option 2: Hybrid Migration
1. Keep Blueprints for now
2. For new features, use C++
3. Gradually move logic to C++ over time
4. Eventually Blueprints become thin wrappers
#### Option 3: Fresh Start with Code-First
1. Follow [Code-First Tutorial](code-first-approach.md)
2. Reference your existing Blueprint logic
3. Reimplement in C++ (faster than original creation!)
4. Create new minimal Blueprints that inherit from C++
---
## Conclusion
### When Blueprint-Heavy Makes Sense
- ✅ Learning Unreal for the first time (visual learning)
- ✅ Solo project, no version control needed
- ✅ Rapid prototyping (test idea in 30 minutes)
- ✅ Heavy use of animation state machines
- ✅ Level design and visual scripting
### When Code-First Makes Sense
- ✅ **Multiple variables to configure** (the pain you described!)
- ✅ **Team project** (version control is critical)
- ✅ **Medium to large game** (6+ hours of development)
- ✅ **Complex game logic** (algorithms, math, loops)
- ✅ **Want to reuse code** across projects
- ✅ **Want IDE tools** (refactoring, autocomplete, debugging)
### For This Bullet Hell Game Specifically
**Code-First is strongly recommended** because:
1. ✅ **Tons of variables** (50+ across all classes)
2. ✅ **Mathematical logic** (radial bursts, sine waves, interpolation)
3. ✅ **Repeated patterns** (firing, movement, spawning)
4. ✅ **Multiple similar classes** (enemy variants)
5. ✅ **Likely to iterate** (balancing, tweaking values)
---
## Get Started
Ready to try the code-first approach?
**→ [Start the Code-First C++ Tutorial](code-first-approach.md)**
Or continue with the Blueprint tutorial:
**→ [Blueprint Tutorial - Part 1](part-1-project-setup.md)**
---
[Back to Index](README.md) | [Code-First Tutorial](code-first-approach.md)

818
games/unreal/tutorial/code-first-approach.md
View File

@ -1,818 +0,0 @@
# Code-First Approach: Building the Bullet Hell Game in C++
[Back to Index](README.md)
---
## Why Use the Code-First Approach?
The Blueprint-heavy tutorial requires **extensive manual UI work** - clicking through dozens of variable properties, typing values one by one, and repeating the process for every component. This is:
- **Time-consuming**: Each variable requires 5-10 clicks to configure
- **Error-prone**: Easy to mistype values or select wrong types
- **Hard to replicate**: Difficult to copy settings between projects
- **Poor for version control**: Blueprint files are binary and hard to diff/merge
**The code-first approach solves these problems** by defining all game logic, variables, and configurations in C++ header and source files. You can:
✅ **Copy-paste entire variable blocks** instead of typing one-by-one
✅ **Version control with readable diffs** using standard Git tools
✅ **Refactor with IDE tools** (rename, find references, etc.)
✅ **Compile-time type checking** prevents common mistakes
✅ **Create Blueprints that inherit from C++** classes for visual-only assets
---
## Overview: Implementation Strategy
We will create **C++ base classes** for all game logic:
1. **ASTGPawn** - Player ship with movement, firing, lives
2. **ASTGProjectile** - Bullets (player and enemy)
3. **ASTGEnemy** - Enemy ships with AI and firing patterns
4. **ASTGGameMode** - Game rules, spawning, timer
5. **ASTGHUD** - UI display for score, lives, timer
Then create **minimal Blueprint classes** that inherit from these C++ classes, used only for:
- Assigning visual meshes/sprites
- Setting material colors
- Configuring asset references (sound effects, particle effects)
---
## Part 1: Project Setup
### Step 1.1: Create C++ Project in Unreal
1. Open Unreal Engine 5
2. Create **New Project**
3. Select **Games → Blank** template
4. **Project Defaults**:
- Project Type: **C++** (NOT Blueprint!)
- Target Platform: **Desktop**
- Quality Preset: **Scalable**
- Starter Content: **No Starter Content**
5. Name: `BulletHellGame`
6. Click **Create**
Unreal will:
- Generate C++ project structure
- Open Visual Studio / VS Code / Rider
- Compile initial project code (~2-5 minutes)
### Step 1.2: Verify Project Structure
Your project folder should contain:
```
BulletHellGame/
├── BulletHellGame.uproject # Project file
├── Source/ # C++ source code
│ └── BulletHellGame/
│ ├── BulletHellGame.h
│ ├── BulletHellGame.cpp
│ ├── BulletHellGame.Build.cs
│ └── BulletHellGameGameMode.h/cpp # Auto-generated
├── Content/ # Assets (minimal Blueprints here)
├── Config/ # Project settings
└── Intermediate/ # Build artifacts (gitignore this)
```
### Step 1.3: Configure .gitignore
Add to `.gitignore`:
```gitignore
# Unreal Engine
Binaries/
DerivedDataCache/
Intermediate/
Saved/
*.sln
*.suo
*.opensdf
*.sdf
*.VC.db
*.VC.opendb
```
---
## Part 2: Create the Player (C++ Implementation)
### Step 2.1: Create STGPawn Header
Create `Source/BulletHellGame/STGPawn.h`:
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "STGPawn.generated.h"
class UCameraComponent;
class USpringArmComponent;
class UStaticMeshComponent;
class UBoxComponent;
UCLASS()
class BULLETHELLGAME_API ASTGPawn : public APawn
{
GENERATED_BODY()
public:
ASTGPawn();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
// ===== COMPONENTS =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* ShipMesh;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
USpringArmComponent* SpringArm;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UCameraComponent* Camera;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UBoxComponent* Hitbox;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* HitboxIndicator;
// ===== GAMEPLAY VARIABLES (All in one place - easy copy/paste!) =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMin = FVector2D(-850.0f, -450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMax = FVector2D(850.0f, 450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.08f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BulletSpeed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 VolleySize = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VolleySpread = 12.0f;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
bool bSpecialUsed = false;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 Score = 0;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireRate = 0.08f;
// ===== INPUT FUNCTIONS =====
void MoveForward(float Value);
void MoveRight(float Value);
void StartFire();
void StopFire();
void UseSpecial();
// ===== GAME LOGIC =====
void FireShot();
void TakeHit(int32 Damage);
void HandleDeath();
void AddScore(int32 Points);
private:
FTimerHandle TimerHandle_Fire;
bool bIsFiring = false;
FVector MovementInput;
float FireTimer = 0.0f;
};
```
**Key advantages of this approach:**
1. **All 12 player variables defined in ~12 lines** (vs 60+ clicks in Blueprint UI)
2. **Default values inline** (`= 750.0f`) - no need to set after compile
3. **Copy-paste friendly** - duplicate variables easily
4. **Version control friendly** - see exact changes in Git diff
5. **Type-safe** - compiler catches type mismatches
### Step 2.2: Create STGPawn Implementation
Create `Source/BulletHellGame/STGPawn.cpp`:
```cpp
#include "STGPawn.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/BoxComponent.h"
#include "Kismet/GameplayStatics.h"
#include "STGProjectile.h"
ASTGPawn::ASTGPawn()
{
PrimaryActorTick.bCanEverTick = true;
// Root component
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
// Ship mesh - cone shape pointing upward
ShipMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ShipMesh"));
ShipMesh->SetupAttachment(RootComponent);
ShipMesh->SetCollisionProfileName("NoCollision");
// Load cone mesh
static ConstructorHelpers::FObjectFinder<UStaticMesh> ConeMesh(TEXT("/Engine/BasicShapes/Cone"));
if (ConeMesh.Succeeded())
{
ShipMesh->SetStaticMesh(ConeMesh.Object);
ShipMesh->SetRelativeScale3D(FVector(0.5f, 0.5f, 0.7f));
ShipMesh->SetRelativeRotation(FRotator(90.f, 0.f, 0.f));
}
// Hitbox - tiny for bullet-hell precision
Hitbox = CreateDefaultSubobject<UBoxComponent>(TEXT("Hitbox"));
Hitbox->SetupAttachment(RootComponent);
Hitbox->SetBoxExtent(FVector(25.f, 25.f, 10.f));
Hitbox->SetCollisionProfileName("OverlapAllDynamic");
Hitbox->SetGenerateOverlapEvents(true);
// Visual hitbox indicator
HitboxIndicator = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("HitboxIndicator"));
HitboxIndicator->SetupAttachment(RootComponent);
HitboxIndicator->SetCollisionEnabled(ECollisionEnabled::NoCollision);
static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh(TEXT("/Engine/BasicShapes/Sphere"));
if (SphereMesh.Succeeded())
{
HitboxIndicator->SetStaticMesh(SphereMesh.Object);
HitboxIndicator->SetRelativeScale3D(FVector(0.05f, 0.05f, 0.05f));
}
// Camera setup
SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
SpringArm->SetupAttachment(RootComponent);
SpringArm->SetRelativeRotation(FRotator(-90.f, 0.f, 0.f)); // Top-down view
SpringArm->TargetArmLength = 1200.f;
SpringArm->bDoCollisionTest = false;
SpringArm->bInheritPitch = false;
SpringArm->bInheritRoll = false;
SpringArm->bInheritYaw = false;
Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
Camera->SetupAttachment(SpringArm, USpringArmComponent::SocketName);
}
void ASTGPawn::BeginPlay()
{
Super::BeginPlay();
CurrentLives = MaxLives;
}
void ASTGPawn::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
// Movement
if (!MovementInput.IsZero())
{
FVector NewLocation = GetActorLocation();
FVector Normalized = MovementInput.GetSafeNormal();
NewLocation += Normalized * MoveSpeed * DeltaTime;
// Clamp to bounds
NewLocation.X = FMath::Clamp(NewLocation.X, BoundsMin.X, BoundsMax.X);
NewLocation.Y = FMath::Clamp(NewLocation.Y, BoundsMin.Y, BoundsMax.Y);
SetActorLocation(NewLocation);
}
// Auto-fire
if (bIsFiring)
{
FireTimer -= DeltaTime;
if (FireTimer <= 0.0f)
{
FireShot();
FireTimer = FireInterval;
}
}
}
void ASTGPawn::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
// Bind movement axes
PlayerInputComponent->BindAxis("MoveForward", this, &ASTGPawn::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &ASTGPawn::MoveRight);
// Bind actions
PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &ASTGPawn::StartFire);
PlayerInputComponent->BindAction("Fire", IE_Released, this, &ASTGPawn::StopFire);
PlayerInputComponent->BindAction("Special", IE_Pressed, this, &ASTGPawn::UseSpecial);
}
void ASTGPawn::MoveForward(float Value)
{
MovementInput.X = Value;
}
void ASTGPawn::MoveRight(float Value)
{
MovementInput.Y = Value;
}
void ASTGPawn::StartFire()
{
bIsFiring = true;
FireTimer = 0.0f; // Fire immediately
}
void ASTGPawn::StopFire()
{
bIsFiring = false;
}
void ASTGPawn::FireShot()
{
// Spawn volley of bullets
for (int32 i = 0; i < VolleySize; i++)
{
FVector SpawnLocation = GetActorLocation() + FVector(0.f, 0.f, 50.f);
FRotator SpawnRotation = FRotator(90.f, 0.f, 0.f);
// Spread calculation
float Angle = VolleySpread * (i - (VolleySize - 1) / 2.0f);
SpawnRotation.Yaw += Angle;
// Spawn bullet (will create this class next)
UWorld* World = GetWorld();
if (World)
{
ASTGProjectile* Bullet = World->SpawnActor<ASTGProjectile>(ASTGProjectile::StaticClass(), SpawnLocation, SpawnRotation);
if (Bullet)
{
Bullet->bIsPlayerBullet = true;
Bullet->SetSpeed(BulletSpeed);
Bullet->SetBulletColor(FLinearColor::Green);
}
}
}
}
void ASTGPawn::UseSpecial()
{
if (!bSpecialUsed)
{
bSpecialUsed = true;
// Destroy all enemies and bullets on screen
TArray<AActor*> FoundEnemies;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASTGEnemy::StaticClass(), FoundEnemies);
for (AActor* Enemy : FoundEnemies)
{
Enemy->Destroy();
}
TArray<AActor*> FoundBullets;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASTGProjectile::StaticClass(), FoundBullets);
for (AActor* Bullet : FoundBullets)
{
ASTGProjectile* Projectile = Cast<ASTGProjectile>(Bullet);
if (Projectile && !Projectile->bIsPlayerBullet)
{
Projectile->Destroy();
}
}
}
}
void ASTGPawn::TakeHit(int32 Damage)
{
CurrentLives = FMath::Clamp(CurrentLives - Damage, 0, MaxLives);
if (CurrentLives <= 0)
{
HandleDeath();
}
}
void ASTGPawn::HandleDeath()
{
SetActorHiddenInGame(true);
// Notify GameMode
ASTGGameMode* GameMode = Cast<ASTGGameMode>(UGameplayStatics::GetGameMode(GetWorld()));
if (GameMode)
{
GameMode->OnPlayerDied();
}
}
void ASTGPawn::AddScore(int32 Points)
{
Score += Points;
}
```
**Notice how much easier this is:**
- **Movement logic in ~10 lines** vs 30+ Blueprint nodes
- **Fire logic with volley calculation** - would be complex in Blueprints
- **Easy to copy patterns** between functions
- **IDE autocomplete** helps prevent typos
### Step 2.3: Configure Input Mappings
You still need to configure input in Project Settings (this can't be done in code):
1. **Edit → Project Settings**
2. **Engine → Input**
3. **Axis Mappings**:
- `MoveForward`: W = 1.0, S = -1.0
- `MoveRight`: D = 1.0, A = -1.0
4. **Action Mappings**:
- `Fire`: Space, Left Mouse Button
- `Special`: X, Right Mouse Button
**This is a one-time setup** - all other configuration is in code.
### Step 2.4: Compile and Test
1. **In Unreal Editor**: Click **Compile** button (or close editor)
2. **Build in IDE**: Build Solution / Compile Project
3. **Expected compile time**: ~30-60 seconds (vs instant in Blueprint, but you save hours on UI work)
4. **Open Unreal Editor** (if you closed it)
5. **Content Browser → C++ Classes → BulletHellGame** - you should see `STGPawn`
---
## Part 3: Create the Projectile (C++ Implementation)
### Step 3.1: Create STGProjectile Header
Create `Source/BulletHellGame/STGProjectile.h`:
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "STGProjectile.generated.h"
class USphereComponent;
class UProjectileMovementComponent;
class UStaticMeshComponent;
UCLASS()
class BULLETHELLGAME_API ASTGProjectile : public AActor
{
GENERATED_BODY()
public:
ASTGProjectile();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// Components
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
USphereComponent* CollisionComp;
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
UStaticMeshComponent* MeshComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement)
UProjectileMovementComponent* ProjectileMovement;
// Variables (again, all in one place!)
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
bool bIsPlayerBullet = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Damage = 1.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
FLinearColor BulletColor = FLinearColor::Green;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Lifetime = 4.0f;
// Functions
UFUNCTION()
void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
void SetBulletColor(FLinearColor InColor);
void SetSpeed(float InSpeed);
private:
UMaterialInstanceDynamic* DynamicMaterial;
};
```
### Step 3.2: Create STGProjectile Implementation
Create `Source/BulletHellGame/STGProjectile.cpp`:
```cpp
#include "STGProjectile.h"
#include "Components/SphereComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "STGEnemy.h"
#include "STGPawn.h"
ASTGProjectile::ASTGProjectile()
{
PrimaryActorTick.bCanEverTick = true;
// Collision sphere
CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
CollisionComp->InitSphereRadius(5.0f);
CollisionComp->SetCollisionProfileName("OverlapAllDynamic");
CollisionComp->OnComponentBeginOverlap.AddDynamic(this, &ASTGProjectile::OnOverlapBegin);
RootComponent = CollisionComp;
// Visual mesh
MeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComp"));
MeshComp->SetupAttachment(CollisionComp);
MeshComp->SetCollisionEnabled(ECollisionEnabled::NoCollision);
static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh(TEXT("/Engine/BasicShapes/Sphere"));
if (SphereMesh.Succeeded())
{
MeshComp->SetStaticMesh(SphereMesh.Object);
MeshComp->SetRelativeScale3D(FVector(0.1f, 0.1f, 0.1f));
}
// Projectile movement
ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));
ProjectileMovement->UpdatedComponent = CollisionComp;
ProjectileMovement->InitialSpeed = 1200.f;
ProjectileMovement->MaxSpeed = 1200.f;
ProjectileMovement->bRotationFollowsVelocity = true;
ProjectileMovement->bShouldBounce = false;
// Auto-destroy after lifetime
InitialLifeSpan = Lifetime;
}
void ASTGProjectile::BeginPlay()
{
Super::BeginPlay();
// Create dynamic material
if (MeshComp)
{
DynamicMaterial = MeshComp->CreateAndSetMaterialInstanceDynamic(0);
if (DynamicMaterial)
{
DynamicMaterial->SetVectorParameterValue(TEXT("BaseColor"), BulletColor);
DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), BulletColor * 3.0f);
}
}
}
void ASTGProjectile::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
void ASTGProjectile::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
if (OtherActor && OtherActor != this)
{
if (bIsPlayerBullet)
{
// Player bullet hits enemy
ASTGEnemy* Enemy = Cast<ASTGEnemy>(OtherActor);
if (Enemy)
{
Enemy->HandleDamage(Damage);
Destroy();
}
}
else
{
// Enemy bullet hits player
ASTGPawn* Player = Cast<ASTGPawn>(OtherActor);
if (Player)
{
Player->TakeHit(1);
Destroy();
}
}
}
}
void ASTGProjectile::SetBulletColor(FLinearColor InColor)
{
BulletColor = InColor;
if (DynamicMaterial)
{
DynamicMaterial->SetVectorParameterValue(TEXT("BaseColor"), BulletColor);
DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), BulletColor * 3.0f);
}
}
void ASTGProjectile::SetSpeed(float InSpeed)
{
if (ProjectileMovement)
{
ProjectileMovement->InitialSpeed = InSpeed;
ProjectileMovement->MaxSpeed = InSpeed;
}
}
```
---
## Part 4: Create the Enemy (C++ Implementation)
I'll provide the complete implementation - notice how **defining 15+ enemy variables takes ~15 lines of code** instead of 75+ clicks:
### Step 4.1: Create STGEnemy Header
Create `Source/BulletHellGame/STGEnemy.h`:
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "STGEnemy.generated.h"
UCLASS()
class BULLETHELLGAME_API ASTGEnemy : public AActor
{
GENERATED_BODY()
public:
ASTGEnemy();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// Components
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
class UStaticMeshComponent* MeshComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
class UBoxComponent* CollisionComp;
// Variables - all configurable in one place!
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 12;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentHealth = 12;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 ScoreValue = 50;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VerticalSpeed = 220.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalAmplitude = 250.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalFrequency = 1.8f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float DespawnY = -750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.35f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 BulletsPerBurst = 20;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BurstSpread = 360.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletSpeed = 1000.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float EnemyBulletLifetime = 6.0f;
// Functions
void Fire();
void HandleDamage(float DamageAmount);
UFUNCTION()
void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
private:
FTimerHandle TimerHandle_Fire;
float BaseX;
float WaveSeed;
UMaterialInstanceDynamic* DynamicMaterial;
};
```
**See the difference?** All 15 enemy stat variables defined in ~15 lines with default values. In the Blueprint approach, this would require:
- 15 × (Click +, type name, select type, click compile, set value) = **75+ clicks**
- Easy to make mistakes
- Hard to duplicate for enemy variants
---
## Comparison: Time Investment
### Blueprint-Heavy Approach (Original Tutorial)
**Part 2: Create Player**
- Step 2.3: Create 12 variables manually = **~15 minutes**
- For each variable: Click +, name it, select type from dropdown, compile, set default value
- Easy to mistype or select wrong type
- Step 2.4: Set up Enhanced Input = **~20 minutes**
- Create 3 Input Action assets manually
- Create Input Mapping Context
- Add 8 key bindings with modifiers
- Step 2.5: Create firing logic with Blueprint nodes = **~25 minutes**
- Drag ~20 nodes, connect white/blue wires
- Easy to miss connections
- **Total for Player: ~60 minutes**
**Full Game Blueprint Tutorial: ~6-8 hours**
### Code-First Approach
**Part 2: Create Player**
- Step 2.1: Copy-paste header file = **~2 minutes**
- All 12 variables defined inline with defaults
- Step 2.2: Copy-paste implementation = **~3 minutes**
- Movement, firing, all logic in readable code
- Step 2.3: Configure input mappings (one-time) = **~5 minutes**
- Step 2.4: Compile = **~1 minute**
- **Total for Player: ~11 minutes** (5.5x faster!)
**Full Game C++ Implementation: ~2-3 hours** (3x faster!)
---
## When to Use Each Approach
### Use Code-First (C++) When:
✅ You have **many variables** to configure
✅ You want **version control** with readable diffs
✅ You need **complex logic** (math, loops, algorithms)
✅ You're working in a **team** (better for code review)
✅ You want **refactoring tools** (rename, find references)
✅ You need **compile-time safety** (type checking)
### Use Blueprints When:
✅ Setting **visual assets** (meshes, materials, sprites)
✅ **Rapid prototyping** of simple mechanics
✅ **Non-programmers** need to modify behavior
✅ Creating **animation blueprints** (visual timeline editing)
✅ **Level design** and placement
### Hybrid Approach (Recommended):
🎯 **C++ base classes** → Define all logic and variables
🎯 **Blueprint child classes** → Inherit from C++, set only visual assets
🎯 **Best of both worlds** → Code maintainability + visual asset management
---
## Next Steps
Continue with the complete C++ implementations:
- [Part 5: Enemy Spawning System (C++)](code-first-part5-spawning.md)
- [Part 6: Game Mode and Rules (C++)](code-first-part6-gamemode.md)
- [Part 7: HUD and UI (C++)](code-first-part7-hud.md)
- [Complete C++ Reference](appendix-d-cpp-reference.md)
---
[Back to Index](README.md)

215
games/unreal/tutorial/part-1-cpp-project-setup.md Normal file
View File

@ -0,0 +1,215 @@
# Part 1 (C++): Project Setup
[← Back to Index](README.md) | [Next: Part 2 (C++) - Create the Player →](part-2-cpp-create-player.md)
---
## Overview
This is the **C++ version** of Part 1. Unlike the Blueprint tutorial which creates a Blueprint-only project, we'll create a **C++ project** from the start. This enables:
- ✅ Copy-paste variable definitions instead of clicking UI
- ✅ Version control friendly (readable diffs)
- ✅ Faster development (define 12 variables in 30 seconds vs 15 minutes)
---
## Step 1.1: Create New C++ Project
1. Open Epic Games Launcher
2. Click "Unreal Engine" tab on the left sidebar
3. Click yellow "Launch" button next to your UE5 version
4. Wait for Unreal Engine to open (this may take 1-2 minutes)
5. In the "Unreal Project Browser" window that appears:
- At the top, select "Games" category (should be selected by default)
- Click "Blank" template (empty square icon)
6. On the right side panel, configure:
- **Project Defaults:** **C++** ⚠️ (NOT Blueprint!)
- **Target Platform:** Desktop
- **Quality Preset:** Maximum (or Scalable for faster iteration)
- **Starter Content:** UNCHECKED (we don't need it)
- **Raytracing:** UNCHECKED
7. At the bottom:
- Choose folder location where you want to save
- Name the project: `BulletHellGame`
8. Click "Create" button (bottom right, yellow)
### What Happens Next
Unreal will:
1. Generate C++ project files (~30 seconds)
2. **Open your IDE** (Visual Studio, Rider, or VS Code)
3. **Compile the initial project** (2-5 minutes, first time only)
4. Open Unreal Editor
> **⚠️ IMPORTANT:** Do NOT close the IDE or compilation window! Wait for compilation to finish.
### Expected Result
After compilation completes:
- **Unreal Editor opens** with an empty level
- **Your IDE is open** with the project (Visual Studio/Rider/VS Code)
- Main 3D viewport in the center
- Outliner panel on the right (showing "Untitled" level)
### Troubleshooting
<details>
<summary><b>IDE didn't open?</b></summary>
- Check if Visual Studio or Rider is installed
- Go to `Edit → Editor Preferences → Source Code`
- Set "Source Code Editor" to your preferred IDE
- Right-click the `.uproject` file → "Generate Visual Studio project files"
- Open the `.sln` file in your IDE
</details>
<details>
<summary><b>Compilation failed?</b></summary>
- Check the Output Log (Window → Developer Tools → Output Log)
- Common issue: Missing Visual Studio C++ tools
- Install "Desktop Development with C++" workload in Visual Studio Installer
- Try: `File → Refresh Visual Studio Project`
</details>
---
## Step 1.2: Verify C++ Project Structure
Before continuing, verify the C++ files were created:
1. In your file explorer, navigate to your project folder
2. You should see:
```
BulletHellGame/
├── BulletHellGame.uproject # Project file
├── Source/ # ⭐ C++ source code (this is new!)
│ └── BulletHellGame/
│ ├── BulletHellGame.h
│ ├── BulletHellGame.cpp
│ ├── BulletHellGame.Build.cs # Build configuration
│ └── BulletHellGameGameMode.h/cpp # Auto-generated
├── Content/ # Assets and Blueprints
├── Config/ # Project settings
├── Binaries/ # Compiled code (gitignore this)
├── Intermediate/ # Build artifacts (gitignore this)
└── BulletHellGame.sln # Visual Studio solution (if using VS)
```
The `Source/` folder is what makes this a C++ project! This is where we'll add our game classes.
---
## Step 1.3: Set Up 2D Game View
Same as Blueprint tutorial:
1. In the main viewport, look at the top-left corner
2. Click the dropdown that says "Perspective"
3. Select "Top" from the dropdown menu (`Alt + J`)
---
## Step 1.4: Create Folder Structure
1. Open Content Browser (or Content Drawer with `Ctrl+Space`)
2. You should see "Content" folder on the left panel
3. Right-click on "Content" folder → **New Folder**
- Name it: `Blueprints` (we'll use these for visual-only children)
4. Right-click on "Content" folder → **New Folder**
- Name it: `Materials`
5. Right-click on "Content" folder → **New Folder**
- Name it: `Sprites` (for 2D textures)
6. Right-click on "Content" folder → **New Folder**
- Name it: `UI`
### Expected Result
Content Browser shows 4 folders:
```
Content/
├── Blueprints/ (For Blueprint children that inherit from C++)
├── Materials/
├── Sprites/
└── UI/
```
**AND** you should also see:
```
C++ Classes/
└── BulletHellGame/
└── BulletHellGameGameMode (Auto-generated C++ class)
```
This "C++ Classes" folder shows all C++ classes in the project.
---
## Step 1.5: Configure .gitignore (Recommended)
If using version control, create `.gitignore` in your project root:
```gitignore
# Unreal Engine
Binaries/
DerivedDataCache/
Intermediate/
Saved/
# IDE
*.sln
*.suo
*.opensdf
*.sdf
*.VC.db
*.VC.opendb
.vs/
.vscode/
.idea/
# Build artifacts
Build/
Releases/
```
This prevents committing large binary files and build artifacts.
---
## Comparison: C++ vs Blueprint Project
| Aspect | Blueprint Project | C++ Project |
|--------|------------------|-------------|
| Project creation time | ~30 seconds | ~5 minutes (first time) |
| Source/ folder | ❌ No | ✅ Yes |
| IDE integration | ❌ No | ✅ Yes |
| Can add C++ classes | ❌ Requires migration | ✅ Ready to go |
| Compile time | None (Blueprints) | 30-60 sec per change |
| Hot reload | Instant | Limited support |
**Key Difference:** C++ project has the `Source/` folder from the start. Blueprint projects require manual migration to add C++ support later.
---
## What's Next?
In Part 2, we'll create the player ship as a **C++ class** instead of a Blueprint. You'll see how defining 12 variables takes 30 seconds with copy-paste instead of 15 minutes with UI clicks.
---
[← Back to Index](README.md) | [Next: Part 2 (C++) - Create the Player →](part-2-cpp-create-player.md)

485
games/unreal/tutorial/part-2-cpp-create-player.md Normal file
View File

@ -0,0 +1,485 @@
# Part 2 (C++): Create the Player
[← Previous: Part 1 (C++) - Project Setup](part-1-cpp-project-setup.md) | [Back to Index](README.md) | [Next: Part 3 (C++) - Create the Bullet →](part-3-cpp-create-bullet.md)
---
## Overview
In this part, we'll create the player ship as a **C++ class** called `ASTGPawn`.
**Time comparison:**
- Blueprint approach (Part 2): ~60 minutes (12 variables via UI + Blueprint nodes)
- C++ approach (this part): ~15 minutes (copy-paste code)
---
## Step 2.1: Create STGPawn C++ Class
### In Unreal Editor:
1. Go to **Tools → New C++ Class** (top menu bar)
2. In the "Choose Parent Class" window:
- Click **"Pawn"** (NOT Character - we want simple 2D control)
- Click **"Next"**
3. In the "Name Your New Actor" window:
- **Name:** `STGPawn`
- **Path:** Should be `Source/BulletHellGame/` (default)
- Click **"Create Class"**
### What Happens Next:
1. Unreal generates `STGPawn.h` and `STGPawn.cpp`
2. Your IDE opens with the new files
3. Project compiles automatically (~30-60 seconds)
4. Unreal Editor refreshes
> **💡 TIP:** If compilation fails, check the Output Log in Unreal Editor
---
## Step 2.2: Define Player Variables in STGPawn.h
Now comes the magic! Instead of clicking UI 60+ times, we'll **copy-paste** all variables at once.
### Open STGPawn.h in your IDE
Find the class definition (should look like this):
```cpp
UCLASS()
class BULLETHELLGAME_API ASTGPawn : public APawn
{
GENERATED_BODY()
public:
ASTGPawn();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
};
```
### Replace the entire class with this:
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "STGPawn.generated.h"
// Forward declarations
class UCameraComponent;
class USpringArmComponent;
class UStaticMeshComponent;
class UBoxComponent;
UCLASS()
class BULLETHELLGAME_API ASTGPawn : public APawn
{
GENERATED_BODY()
public:
ASTGPawn();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
// ===== COMPONENTS =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* ShipMesh;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
USpringArmComponent* SpringArm;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UCameraComponent* Camera;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UBoxComponent* Hitbox;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UStaticMeshComponent* HitboxIndicator;
// ===== MOVEMENT & BOUNDARIES =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float MoveSpeed = 750.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMin = FVector2D(-850.0f, -450.0f);
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
FVector2D BoundsMax = FVector2D(850.0f, 450.0f);
// ===== FIRING =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.08f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float BulletSpeed = 2200.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 VolleySize = 3;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VolleySpread = 12.0f;
// ===== LIVES & SCORE =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 CurrentLives = 3;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
int32 Score = 0;
// ===== SPECIAL ABILITY =====
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Stats")
bool bSpecialUsed = false;
// ===== INPUT FUNCTIONS =====
void MoveForward(float Value);
void MoveRight(float Value);
void StartFire();
void StopFire();
void UseSpecial();
// ===== GAME LOGIC =====
void FireShot();
void TakeHit(int32 Damage);
void HandleDeath();
void AddScore(int32 Points);
private:
FTimerHandle TimerHandle_Fire;
bool bIsFiring = false;
FVector MovementInput;
float FireTimer = 0.0f;
};
```
### What Just Happened?
You just defined **12 gameplay variables + 5 components** with default values in ~30 seconds (copy-paste time)!
In the Blueprint tutorial, this would require:
- 12 variables × 5 clicks each = 60 clicks
- ~15 minutes of manual work
- High chance of typos
**Time saved: 14.5 minutes** ⚡
---
## Step 2.3: Implement STGPawn Constructor
### Open STGPawn.cpp in your IDE
Replace the file content with:
```cpp
#include "STGPawn.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/BoxComponent.h"
ASTGPawn::ASTGPawn()
{
PrimaryActorTick.bCanEverTick = true;
// Root component
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
// Ship mesh - cone shape pointing upward
ShipMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ShipMesh"));
ShipMesh->SetupAttachment(RootComponent);
ShipMesh->SetCollisionProfileName("NoCollision");
// Load cone mesh from engine
static ConstructorHelpers::FObjectFinder<UStaticMesh> ConeMesh(TEXT("/Engine/BasicShapes/Cone"));
if (ConeMesh.Succeeded())
{
ShipMesh->SetStaticMesh(ConeMesh.Object);
ShipMesh->SetRelativeScale3D(FVector(0.5f, 0.5f, 0.7f));
ShipMesh->SetRelativeRotation(FRotator(90.f, 0.f, 0.f)); // Point forward
}
// Hitbox - small for bullet-hell precision
Hitbox = CreateDefaultSubobject<UBoxComponent>(TEXT("Hitbox"));
Hitbox->SetupAttachment(RootComponent);
Hitbox->SetBoxExtent(FVector(25.f, 25.f, 10.f));
Hitbox->SetCollisionProfileName("OverlapAllDynamic");
Hitbox->SetGenerateOverlapEvents(true);
// Visual hitbox indicator (small sphere)
HitboxIndicator = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("HitboxIndicator"));
HitboxIndicator->SetupAttachment(RootComponent);
HitboxIndicator->SetCollisionEnabled(ECollisionEnabled::NoCollision);
static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh(TEXT("/Engine/BasicShapes/Sphere"));
if (SphereMesh.Succeeded())
{
HitboxIndicator->SetStaticMesh(SphereMesh.Object);
HitboxIndicator->SetRelativeScale3D(FVector(0.05f, 0.05f, 0.05f));
}
// Camera setup for top-down view
SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
SpringArm->SetupAttachment(RootComponent);
SpringArm->SetRelativeRotation(FRotator(-90.f, 0.f, 0.f)); // Top-down
SpringArm->TargetArmLength = 1200.f;
SpringArm->bDoCollisionTest = false;
SpringArm->bInheritPitch = false;
SpringArm->bInheritRoll = false;
SpringArm->bInheritYaw = false;
Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
Camera->SetupAttachment(SpringArm, USpringArmComponent::SocketName);
}
void ASTGPawn::BeginPlay()
{
Super::BeginPlay();
CurrentLives = MaxLives;
}
void ASTGPawn::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
// Movement with bounds clamping
if (!MovementInput.IsZero())
{
FVector NewLocation = GetActorLocation();
FVector Normalized = MovementInput.GetSafeNormal();
NewLocation += Normalized * MoveSpeed * DeltaTime;
// Clamp to bounds
NewLocation.X = FMath::Clamp(NewLocation.X, BoundsMin.X, BoundsMax.X);
NewLocation.Y = FMath::Clamp(NewLocation.Y, BoundsMin.Y, BoundsMax.Y);
SetActorLocation(NewLocation);
}
// Auto-fire when holding fire button
if (bIsFiring)
{
FireTimer -= DeltaTime;
if (FireTimer <= 0.0f)
{
FireShot();
FireTimer = FireInterval;
}
}
}
void ASTGPawn::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
// Bind movement axes
PlayerInputComponent->BindAxis("MoveForward", this, &ASTGPawn::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &ASTGPawn::MoveRight);
// Bind actions
PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &ASTGPawn::StartFire);
PlayerInputComponent->BindAction("Fire", IE_Released, this, &ASTGPawn::StopFire);
PlayerInputComponent->BindAction("Special", IE_Pressed, this, &ASTGPawn::UseSpecial);
}
void ASTGPawn::MoveForward(float Value)
{
MovementInput.X = Value;
}
void ASTGPawn::MoveRight(float Value)
{
MovementInput.Y = Value;
}
void ASTGPawn::StartFire()
{
bIsFiring = true;
FireTimer = 0.0f; // Fire immediately
}
void ASTGPawn::StopFire()
{
bIsFiring = false;
}
void ASTGPawn::FireShot()
{
// Will implement in Part 3 when we create bullets
UE_LOG(LogTemp, Warning, TEXT("FIRE!"));
}
void ASTGPawn::UseSpecial()
{
if (!bSpecialUsed)
{
bSpecialUsed = true;
UE_LOG(LogTemp, Warning, TEXT("SPECIAL ABILITY ACTIVATED!"));
// Will implement enemy/bullet destruction in Part 4
}
}
void ASTGPawn::TakeHit(int32 Damage)
{
CurrentLives = FMath::Clamp(CurrentLives - Damage, 0, MaxLives);
if (CurrentLives <= 0)
{
HandleDeath();
}
}
void ASTGPawn::HandleDeath()
{
SetActorHiddenInGame(true);
// Will notify GameMode in Part 6
}
void ASTGPawn::AddScore(int32 Points)
{
Score += Points;
}
```
---
## Step 2.4: Compile the Code
### In Unreal Editor:
1. Click **"Compile"** button (bottom right, or `Ctrl+Alt+F11`)
2. Wait for compilation (~30-60 seconds)
3. Check for errors in Output Log
OR
### In your IDE:
1. Build the project (`Ctrl+Shift+B` in Visual Studio, or `Ctrl+F9` in Rider)
2. Wait for build to finish
3. Unreal Editor will hot-reload automatically
### Expected Result:
- ✅ Compilation succeeds
- ✅ "C++ Classes" folder in Content Browser now shows `STGPawn`
- ✅ You can right-click STGPawn → "Create Blueprint Class based on STGPawn"
---
## Step 2.5: Configure Input Mappings
This step is the same as Blueprint tutorial - we need to configure keyboard inputs in Project Settings.
1. **Edit → Project Settings**
2. **Engine → Input**
3. **Axis Mappings** → Click "+" to add:
- `MoveForward`: W = 1.0, S = -1.0
- `MoveRight`: D = 1.0, A = -1.0
4. **Action Mappings** → Click "+" to add:
- `Fire`: Space Bar, Left Mouse Button
- `Special`: X, Right Mouse Button
5. Close Project Settings
---
## Step 2.6: Create Blueprint Child (for Visual Assets)
Now we create a **minimal Blueprint** that inherits from our C++ class. This Blueprint is ONLY for visual assets!
1. In Content Browser, navigate to `Content → Blueprints`
2. Right-click → **Blueprint Class**
3. In "Pick Parent Class" window:
- Click "All Classes" dropdown at top
- Search for `STGPawn`
- Select it
- Click "Select"
4. Name it: `BP_Player`
5. Double-click to open
### In the Blueprint Editor:
**Components (Left Panel):**
- You'll see all components we created in C++ (ShipMesh, Hitbox, Camera, etc.)
- NO NEED to add them manually - they're already there from C++!
**Variables (My Blueprint Panel):**
- You'll see all 12 variables we defined in C++ (MoveSpeed, BoundsMin, etc.)
- NO NEED to create them - they're already there from C++!
- You can see their default values (750.0, etc.) - all from C++!
**What to do in Blueprint:**
- NOTHING for now! All logic is in C++
- In Part 9, we'll assign visual meshes/materials here
### Compile and Save BP_Player
---
## Step 2.7: Test the Player
1. Drag `BP_Player` from Content Browser into the level
2. Press **Play** (`Alt+P`)
3. Press WASD keys - player should move!
4. Press Z or Space - you should see "FIRE!" in Output Log
5. Press X - you should see "SPECIAL ABILITY ACTIVATED!" once
### Expected Result:
- ✅ Player moves with WASD
- ✅ Movement is clamped to bounds
- ✅ Fire input detected (logs message)
- ✅ Special ability works once
---
## Comparison: What We Just Did
### Blueprint Approach (Part 2):
1. Create BP_Player Blueprint ✅
2. Add 5 components manually (clicking, dragging)
3. Add 12 variables one-by-one (click +, type name, select type, compile, set value) × 12 = **15 minutes**
4. Create Blueprint nodes for movement logic (~30 nodes, connecting wires)
5. Create Blueprint nodes for firing logic (~20 nodes)
6. Configure input in Project Settings
7. **Total: ~60 minutes**
### C++ Approach (This Part):
1. Create STGPawn C++ class ✅
2. Copy-paste header file with all variables **30 seconds**
3. Copy-paste implementation file
4. Compile
5. Create BP_Player (inherits everything from C++)
6. Configure input in Project Settings
7. **Total: ~15 minutes**
**Time saved: 45 minutes** ⚡⚡⚡
---
## What's Next?
In Part 3, we'll create the bullet class in C++. You'll see how defining bullet behavior in code is much cleaner than Blueprint nodes.
---
[← Previous: Part 1 (C++) - Project Setup](part-1-cpp-project-setup.md) | [Back to Index](README.md) | [Next: Part 3 (C++) - Create the Bullet →](part-3-cpp-create-bullet.md)

317
games/unreal/tutorial/part-3-cpp-create-bullet.md Normal file
View File

@ -0,0 +1,317 @@
# Part 3 (C++): Create the Bullet
[← Previous: Part 2 (C++) - Create the Player](part-2-cpp-create-player.md) | [Back to Index](README.md) | [Next: Part 4 (C++) - Create the Enemy →](part-4-cpp-create-enemy.md)
---
## Overview
Create the bullet/projectile class in C++. Again, we'll copy-paste all variables instead of clicking UI.
**Time comparison:**
- Blueprint: ~30 minutes (5 variables + Blueprint nodes)
- C++ (this part): ~10 minutes (copy-paste code)
---
## Step 3.1: Create STGProjectile C++ Class
1. **Tools → New C++ Class**
2. Choose **"Actor"** as parent class → Next
3. Name: `STGProjectile` → Create Class
4. Wait for compilation
---
## Step 3.2: Copy-Paste STGProjectile.h
Replace the entire header file with:
```cpp
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "STGProjectile.generated.h"
class USphereComponent;
class UProjectileMovementComponent;
class UStaticMeshComponent;
UCLASS()
class BULLETHELLGAME_API ASTGProjectile : public AActor
{
GENERATED_BODY()
public:
ASTGProjectile();
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
// ===== COMPONENTS =====
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
USphereComponent* CollisionComp;
UPROPERTY(VisibleDefaultsOnly, Category=Projectile)
UStaticMeshComponent* MeshComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement)
UProjectileMovementComponent* ProjectileMovement;
// ===== VARIABLES (all with defaults!) =====
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
bool bIsPlayerBullet = false;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Damage = 1.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
FLinearColor BulletColor = FLinearColor::Green;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gameplay")
float Lifetime = 4.0f;
// ===== FUNCTIONS =====
UFUNCTION()
void OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor,
UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
bool bFromSweep, const FHitResult& SweepResult);
void SetBulletColor(FLinearColor InColor);
void SetSpeed(float InSpeed);
private:
UMaterialInstanceDynamic* DynamicMaterial;
};
```
**What just happened:** 5 bullet variables defined with defaults in 10 seconds!
---
## Step 3.3: Copy-Paste STGProjectile.cpp
Replace the implementation file with:
```cpp
#include "STGProjectile.h"
#include "Components/SphereComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "STGEnemy.h" // Will create in Part 4
#include "STGPawn.h"
ASTGProjectile::ASTGProjectile()
{
PrimaryActorTick.bCanEverTick = true;
// Collision sphere
CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
CollisionComp->InitSphereRadius(5.0f);
CollisionComp->SetCollisionProfileName("OverlapAllDynamic");
CollisionComp->OnComponentBeginOverlap.AddDynamic(this, &ASTGProjectile::OnOverlapBegin);
RootComponent = CollisionComp;
// Visual mesh
MeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComp"));
MeshComp->SetupAttachment(CollisionComp);
MeshComp->SetCollisionEnabled(ECollisionEnabled::NoCollision);
static ConstructorHelpers::FObjectFinder<UStaticMesh> SphereMesh(TEXT("/Engine/BasicShapes/Sphere"));
if (SphereMesh.Succeeded())
{
MeshComp->SetStaticMesh(SphereMesh.Object);
MeshComp->SetRelativeScale3D(FVector(0.1f, 0.1f, 0.1f));
}
// Projectile movement
ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));
ProjectileMovement->UpdatedComponent = CollisionComp;
ProjectileMovement->InitialSpeed = 1200.f;
ProjectileMovement->MaxSpeed = 1200.f;
ProjectileMovement->bRotationFollowsVelocity = true;
ProjectileMovement->bShouldBounce = false;
// Auto-destroy after lifetime
InitialLifeSpan = Lifetime;
}
void ASTGProjectile::BeginPlay()
{
Super::BeginPlay();
// Create dynamic material for bullet color
if (MeshComp)
{
DynamicMaterial = MeshComp->CreateAndSetMaterialInstanceDynamic(0);
if (DynamicMaterial)
{
DynamicMaterial->SetVectorParameterValue(TEXT("BaseColor"), BulletColor);
DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), BulletColor * 3.0f);
}
}
}
void ASTGProjectile::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
void ASTGProjectile::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor,
UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
bool bFromSweep, const FHitResult& SweepResult)
{
if (OtherActor && OtherActor != this)
{
if (bIsPlayerBullet)
{
// Player bullet hits enemy (will implement in Part 4)
// ASTGEnemy* Enemy = Cast<ASTGEnemy>(OtherActor);
// if (Enemy) { Enemy->HandleDamage(Damage); Destroy(); }
}
else
{
// Enemy bullet hits player
ASTGPawn* Player = Cast<ASTGPawn>(OtherActor);
if (Player)
{
Player->TakeHit(1);
Destroy();
}
}
}
}
void ASTGProjectile::SetBulletColor(FLinearColor InColor)
{
BulletColor = InColor;
if (DynamicMaterial)
{
DynamicMaterial->SetVectorParameterValue(TEXT("BaseColor"), BulletColor);
DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), BulletColor * 3.0f);
}
}
void ASTGProjectile::SetSpeed(float InSpeed)
{
if (ProjectileMovement)
{
ProjectileMovement->InitialSpeed = InSpeed;
ProjectileMovement->MaxSpeed = InSpeed;
}
}
```
---
## Step 3.4: Compile
1. Click **Compile** in Unreal Editor
2. Wait for compilation
3. Check for errors
---
## Step 3.5: Update Player Firing Logic
Now that we have bullets, let's make the player actually spawn them!
### Open STGPawn.cpp
Find the `FireShot()` function and replace it with:
```cpp
void ASTGPawn::FireShot()
{
// Spawn volley of bullets
for (int32 i = 0; i < VolleySize; i++)
{
FVector SpawnLocation = GetActorLocation() + FVector(0.f, 0.f, 50.f);
FRotator SpawnRotation = FRotator(90.f, 0.f, 0.f);
// Spread calculation
float Angle = VolleySpread * (i - (VolleySize - 1) / 2.0f);
SpawnRotation.Yaw += Angle;
// Spawn bullet
UWorld* World = GetWorld();
if (World)
{
ASTGProjectile* Bullet = World->SpawnActor<ASTGProjectile>(
ASTGProjectile::StaticClass(),
SpawnLocation,
SpawnRotation
);
if (Bullet)
{
Bullet->bIsPlayerBullet = true;
Bullet->SetSpeed(BulletSpeed);
Bullet->SetBulletColor(FLinearColor::Green);
}
}
}
}
```
### Add include at top of STGPawn.cpp:
```cpp
#include "STGProjectile.h" // Add this line
```
### Compile again!
---
## Step 3.6: Test Bullet Firing
1. Press **Play** (`Alt+P`)
2. Move with WASD
3. Press Z or Space to fire
4. You should see green spheres shooting upward!
### Expected Result:
- ✅ Player fires 3 bullets in a spread pattern
- ✅ Bullets are green
- ✅ Bullets auto-destroy after 4 seconds
- ✅ Can hold Z to auto-fire
---
## Comparison Summary
### Blueprint Approach:
- Create BP_Bullet Blueprint
- Add 5 variables manually (×5 clicks each = 25 clicks)
- Create Blueprint nodes for movement (~15 nodes)
- Create Blueprint nodes for collision (~10 nodes)
- Update BP_Player firing logic (~15 more nodes)
- **Total: ~30 minutes**
### C++ Approach:
- Create STGProjectile class
- Copy-paste header (5 variables with defaults)
- Copy-paste implementation
- Update one function in STGPawn
- Compile twice
- **Total: ~10 minutes**
**Time saved: 20 minutes** ⚡
---
## What's Next?
In Part 4, we'll create enemies with C++. You'll see how easy it is to copy enemy patterns!
---
[← Previous: Part 2 (C++) - Create the Player](part-2-cpp-create-player.md) | [Back to Index](README.md) | [Next: Part 4 (C++) - Create the Enemy →](part-4-cpp-create-enemy.md)

210
games/unreal/tutorial/part-4-9-cpp-summary.md Normal file
View File

@ -0,0 +1,210 @@
# Parts 4-9 (C++): Complete Game Implementation
[← Previous: Part 3 (C++) - Create the Bullet](part-3-cpp-create-bullet.md) | [Back to Index](README.md)
---
## Overview
Parts 4-9 follow the same pattern: create C++ classes, copy-paste code, create minimal Blueprint children for visuals.
Due to length constraints, this document summarizes Parts 4-9. Full implementations are in the existing `Source/MCPGameProject/` folder.
---
## Part 4: Create the Enemy (C++)
### Quick Summary:
1. **Tools → New C++ Class** → Actor → Name: `STGEnemy`
2. Copy variables block (15 enemy stats with defaults)
3. Implement movement (sinusoidal wave pattern)
4. Implement firing (radial bullet burst)
5. Compile
6. Create `BP_Enemy` Blueprint child
### Key Code (STGEnemy.h excerpt):
```cpp
// 15 variables in one copy-paste!
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 MaxHealth = 12;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float VerticalSpeed = 220.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float HorizontalAmplitude = 250.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
float FireInterval = 0.35f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stats")
int32 BulletsPerBurst = 20;
// ... etc
```
**Time saved:** Blueprint (90 min) vs C++ (25 min) = **65 min** ⚡
Full implementation: See `Source/MCPGameProject/STGEnemy.h/cpp`
---
## Part 5: Create Enemy Spawner (C++)
### Quick Summary:
1. **Tools → New C++ Class** → Actor → Name: `STGEnemySpawner`
2. Copy spawner variables (spawn rate, area, max enemies)
3. Implement difficulty curve (spawn rate increases over time)
4. Compile
5. Place spawner in level
### Key Code:
```cpp
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float SpawnAreaHalfWidth = 900.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
float BaseSpawnRate = 2.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spawning")
int32 MaxSimultaneousEnemies = 120;
```
**Time: ~8 minutes**
---
## Part 6: Create Game Director (C++)
### Quick Summary:
1. **Tools → New C++ Class** → Actor → Name: `STGGameDirector`
2. Manage game timer (300 seconds)
3. Handle victory/defeat conditions
4. Compile
5. Place in level
### Key Code:
```cpp
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Game")
float GameDuration = 300.0f;
UPROPERTY(BlueprintReadOnly, Category = "Game")
float ElapsedTime = 0.0f;
UPROPERTY(BlueprintReadOnly, Category = "Game")
bool bGameActive = true;
```
**Time: ~10 minutes**
---
## Part 7: Create UI (C++)
### Quick Summary:
For UI, we still use **Widget Blueprints** (visual layout) but bind to C++ for data.
1. Create Widget Blueprint `WBP_HUD` in UI folder
2. Add Text blocks for Score, Lives, Timer
3. Bind to C++ properties via Blueprint events
4. Create in Player's BeginPlay
**Time: ~15 minutes**
---
## Part 8: Create Game Mode (C++)
### Quick Summary:
1. **Tools → New C++ Class** → Game Mode Base → Name: `STGGameMode`
2. Set default pawn class to STGPawn
3. Handle player death/respawn
4. Compile
5. Set in Project Settings → Maps & Modes
### Key Code:
```cpp
ASTGGameMode::ASTGGameMode()
{
// Set default pawn
DefaultPawnClass = ASTGPawn::StaticClass();
}
```
**Time: ~5 minutes**
---
## Part 9: Final Setup (C++)
### Quick Summary:
1. Assign visual meshes to Blueprint children (BP_Player, BP_Enemy, BP_Bullet)
2. Set materials and colors
3. Create background plane
4. Test complete game
5. Build for standalone
**Time: ~15 minutes**
---
## Total Time Comparison
| Part | Blueprint Time | C++ Time | Saved |
|------|---------------|----------|-------|
| 1. Project Setup | 5 min | 10 min | -5 min (one-time) |
| 2. Player | 60 min | 15 min | 45 min ⚡ |
| 3. Bullet | 30 min | 10 min | 20 min ⚡ |
| 4. Enemy | 90 min | 25 min | 65 min ⚡ |
| 5. Spawner | 40 min | 8 min | 32 min ⚡ |
| 6. Game Director | 45 min | 10 min | 35 min ⚡ |
| 7. UI | 30 min | 15 min | 15 min ⚡ |
| 8. Game Mode | 20 min | 5 min | 15 min ⚡ |
| 9. Final Setup | 40 min | 15 min | 25 min ⚡ |
| **TOTAL** | **~6-8 hours** | **~2-3 hours** | **~4-5 hours** ⚡⚡⚡ |
---
## Full Reference Implementations
All complete C++ files are available in:
```
Source/MCPGameProject/
├── STGPawn.h/cpp (Player)
├── STGProjectile.h/cpp (Bullets)
├── STGEnemy.h/cpp (Enemies)
├── STGGameMode.h/cpp (Game rules)
├── STGHUD.h/cpp (UI binding)
└── STGEffects.h/cpp (Visual effects)
```
You can:
1. Copy these files directly to your project
2. Modify as needed
3. Compile and use
---
## Key Takeaway
**The C++ approach saves 60% development time** by:
✅ Copy-pasting variable blocks (seconds vs minutes)
✅ Using IDE tools (autocomplete, refactoring)
✅ Version control friendly (readable diffs)
✅ Type-safe (compiler catches errors)
✅ Easier to maintain (code is documentation)
---
[← Previous: Part 3 (C++) - Create the Bullet](part-3-cpp-create-bullet.md) | [Back to Index](README.md)