Instruction: Kod örneğiyle göster: Unreal C++ ile Actor içinde rotating pickup yaz.

Answer:
Pickup için `AActor` türetip mesh'i root'a bağlayabilir ve Tick içinde döndürebilirsin.

```cpp
UCLASS()
class ARotatingPickup : public AActor
{
    GENERATED_BODY()

public:
    ARotatingPickup();
    virtual void Tick(float DeltaSeconds) override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(EditAnywhere, Category="Pickup")
    float RotationSpeed = 90.0f;
};
```

```cpp
ARotatingPickup::ARotatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ARotatingPickup::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaSeconds, 0.0f));
}
```


Instruction: Kısa açıkla: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kod örneğiyle göster: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kısa açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: En temiz mimariyle öner: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Yeni başlayan biri için anlat: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Unreal Engine'de can sistemi için UHealthComponent yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Yeni başlayan biri için anlat: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kod örneğiyle göster: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: UE C++ AddMovementInput örneği ver.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Yeni başlayan biri için anlat: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kod örneğiyle göster: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Yeni başlayan biri için anlat: UE C++ UActorComponent tabanlı health component örneği ver.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity için basit player movement yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Unity'de oyuncu hareket kodunu temiz şekilde göster.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: En temiz mimariyle öner: Unreal'da BlueprintCallable TakeDamage fonksiyonu olan health component oluştur.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kısa açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kısa açıkla: Unity için basit player movement yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kod örneğiyle göster: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: En temiz mimariyle öner: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Yeni başlayan biri için anlat: Unity'de null reference exception nasıl debug edilir?

Answer:
`NullReferenceException`, null olan bir değişkenin alanına veya metoduna eriştiğini gösterir. Inspector referansı atanmış mı, `GetComponent` sonucu null mı ve obje sahnede aktif mi kontrol et.

```csharp
[SerializeField] private Transform target;

private void Awake()
{
    if (target == null)
    {
        Debug.LogError("Target referansı Inspector'dan atanmadı.", this);
        enabled = false;
        return;
    }
}
```

Hata satırına çift tıkla, o satırdaki her referansı tek tek kontrol et.


Instruction: Yeni başlayan biri için anlat: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Yeni başlayan biri için anlat: Unity C# ile karakter hareketi örneği ver.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Actor içinde rotating pickup yaz.

Answer:
Pickup için `AActor` türetip mesh'i root'a bağlayabilir ve Tick içinde döndürebilirsin.

```cpp
UCLASS()
class ARotatingPickup : public AActor
{
    GENERATED_BODY()

public:
    ARotatingPickup();
    virtual void Tick(float DeltaSeconds) override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(EditAnywhere, Category="Pickup")
    float RotationSpeed = 90.0f;
};
```

```cpp
ARotatingPickup::ARotatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ARotatingPickup::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaSeconds, 0.0f));
}
```


Instruction: Kısa açıkla: Unity C# ile karakter hareketi örneği ver.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kısa açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kısa açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: En temiz mimariyle öner: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Unreal Engine Character class içinde hareket input'u bağla.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Hata ayıklama açısından açıkla: Unity için basit player movement yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kısa açıkla: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Yeni başlayan biri için anlat: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: Unity C# ile karakter hareketi örneği ver.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Hata ayıklama açısından açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile basit player movement yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kod örneğiyle göster: Unreal Blueprint ile kapı açma mantığını anlat.

Answer:
Kapı actor'ünde `Box Collision`, kapı mesh'i ve timeline bulunur. Player overlap olduğunda timeline çalışır, timeline değeriyle kapının rotation veya location değeri interpolate edilir.

Akış:

- `OnComponentBeginOverlap` tetiklenir.
- Overlap eden actor player mı kontrol edilir.
- Timeline `Play` çağrılır.
- Timeline update pin'inde `SetRelativeRotation` veya `SetRelativeLocation` kullanılır.
- Çıkışta `OnComponentEndOverlap` ile timeline reverse yapılabilir.

C++ gerekiyorsa aynı mantık `UBoxComponent` ve `FTimeline` ile kurulabilir.


Instruction: Kısa açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Unreal C++ ile Actor içinde rotating pickup yaz.

Answer:
Pickup için `AActor` türetip mesh'i root'a bağlayabilir ve Tick içinde döndürebilirsin.

```cpp
UCLASS()
class ARotatingPickup : public AActor
{
    GENERATED_BODY()

public:
    ARotatingPickup();
    virtual void Tick(float DeltaSeconds) override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(EditAnywhere, Category="Pickup")
    float RotationSpeed = 90.0f;
};
```

```cpp
ARotatingPickup::ARotatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ARotatingPickup::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaSeconds, 0.0f));
}
```


Instruction: Hata ayıklama açısından açıkla: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Yeni başlayan biri için anlat: Unreal C++ ile Actor içinde rotating pickup yaz.

Answer:
Pickup için `AActor` türetip mesh'i root'a bağlayabilir ve Tick içinde döndürebilirsin.

```cpp
UCLASS()
class ARotatingPickup : public AActor
{
    GENERATED_BODY()

public:
    ARotatingPickup();
    virtual void Tick(float DeltaSeconds) override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(EditAnywhere, Category="Pickup")
    float RotationSpeed = 90.0f;
};
```

```cpp
ARotatingPickup::ARotatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ARotatingPickup::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaSeconds, 0.0f));
}
```


Instruction: En temiz mimariyle öner: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Yeni başlayan biri için anlat: Unreal C++ derleme hatalarında nasıl debug yapılır?

Answer:
Önce derleyicinin verdiği ilk hataya bak. Unreal build çıktısında sonraki hatalar çoğu zaman ilk hatanın sonucudur.

Kontrol listesi:

- Header dosyasında `GENERATED_BODY()` doğru yerde mi?
- `.generated.h` include'u en son include mu?
- Sınıf adı dosya ve constructor adıyla uyumlu mu?
- Eksik module dependency var mı?
- Pointer tipleri forward declaration ile yetiyor mu, yoksa include gerekli mi?

Reflection hatalarında Unreal Editor'ü kapatıp temiz build almak da gerekebilir.


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Yeni başlayan biri için anlat: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: En temiz mimariyle öner: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Hata ayıklama açısından açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Yeni başlayan biri için anlat: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kod örneğiyle göster: UE C++ AddMovementInput örneği ver.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kod örneğiyle göster: Unreal C++ ile Actor içinde rotating pickup yaz.

Answer:
Pickup için `AActor` türetip mesh'i root'a bağlayabilir ve Tick içinde döndürebilirsin.

```cpp
UCLASS()
class ARotatingPickup : public AActor
{
    GENERATED_BODY()

public:
    ARotatingPickup();
    virtual void Tick(float DeltaSeconds) override;

protected:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;

    UPROPERTY(EditAnywhere, Category="Pickup")
    float RotationSpeed = 90.0f;
};
```

```cpp
ARotatingPickup::ARotatingPickup()
{
    PrimaryActorTick.bCanEverTick = true;
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ARotatingPickup::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaSeconds, 0.0f));
}
```


Instruction: Unreal'da BlueprintCallable TakeDamage fonksiyonu olan health component oluştur.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kod örneğiyle göster: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Kod örneğiyle göster: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kısa açıkla: UE C++ UActorComponent tabanlı health component örneği ver.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kod örneğiyle göster: MonoBehaviour içinde WASD movement nasıl yazılır?

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kod örneğiyle göster: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Yeni başlayan biri için anlat: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kısa açıkla: Unity'de oyuncu hareket kodunu temiz şekilde göster.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kod örneğiyle göster: Unreal Blueprint ile kapı açma mantığını anlat.

Answer:
Kapı actor'ünde `Box Collision`, kapı mesh'i ve timeline bulunur. Player overlap olduğunda timeline çalışır, timeline değeriyle kapının rotation veya location değeri interpolate edilir.

Akış:

- `OnComponentBeginOverlap` tetiklenir.
- Overlap eden actor player mı kontrol edilir.
- Timeline `Play` çağrılır.
- Timeline update pin'inde `SetRelativeRotation` veya `SetRelativeLocation` kullanılır.
- Çıkışta `OnComponentEndOverlap` ile timeline reverse yapılabilir.

C++ gerekiyorsa aynı mantık `UBoxComponent` ve `FTimeline` ile kurulabilir.


Instruction: Yeni başlayan biri için anlat: Unreal C++ derleme hatalarında nasıl debug yapılır?

Answer:
Önce derleyicinin verdiği ilk hataya bak. Unreal build çıktısında sonraki hatalar çoğu zaman ilk hatanın sonucudur.

Kontrol listesi:

- Header dosyasında `GENERATED_BODY()` doğru yerde mi?
- `.generated.h` include'u en son include mu?
- Sınıf adı dosya ve constructor adıyla uyumlu mu?
- Eksik module dependency var mı?
- Pointer tipleri forward declaration ile yetiyor mu, yoksa include gerekli mi?

Reflection hatalarında Unreal Editor'ü kapatıp temiz build almak da gerekebilir.


Instruction: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kod örneğiyle göster: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: Kısa açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Yeni başlayan biri için anlat: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: En temiz mimariyle öner: Unity 2D'de Rigidbody2D ile oyuncu hareketi yaz.

Answer:
Bu örnek top-down 2D hareket içindir. Player objesinde `Rigidbody2D` olmalı ve gravity scale genelde 0 yapılır.

```csharp
using UnityEngine;

[RequireComponent(typeof(Rigidbody2D))]
public class PlayerMovement2D : MonoBehaviour
{
    [SerializeField] private float speed = 6f;

    private Rigidbody2D rb;
    private Vector2 input;

    private void Awake()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    private void Update()
    {
        input.x = Input.GetAxisRaw("Horizontal");
        input.y = Input.GetAxisRaw("Vertical");
        input = input.normalized;
    }

    private void FixedUpdate()
    {
        rb.linearVelocity = input * speed;
    }
}
```

Eski Unity sürümlerinde `linearVelocity` yerine `velocity` kullanılır.


Instruction: Hata ayıklama açısından açıkla: Unreal Engine'de UPROPERTY ve UFUNCTION ne işe yarar?

Answer:
`UPROPERTY`, değişkeni Unreal reflection sistemine tanıtır. Böylece garbage collector, Blueprint, editor ve serialization sistemi değişkeni görebilir.

`UFUNCTION`, C++ fonksiyonunu reflection sistemine açar. Blueprint'ten çağırmak veya event olarak kullanmak için gerekir.

```cpp
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats")
float MaxHealth = 100.0f;

UFUNCTION(BlueprintCallable, Category="Stats")
void TakeDamageAmount(float Amount);
```

Unreal'da UObject referanslarını çoğu zaman `UPROPERTY` ile tutmak önemlidir; aksi halde GC davranışı sorun çıkarabilir.


Instruction: En temiz mimariyle öner: Unreal'da Character hareket kodunu temiz şekilde göster.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: En temiz mimariyle öner: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Kısa açıkla: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Yeni başlayan biri için anlat: MonoBehaviour içinde WASD movement nasıl yazılır?

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.


Instruction: En temiz mimariyle öner: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kısa açıkla: Unreal Engine C++ ile basit Character hareket sınıfı yaz.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kod örneğiyle göster: Unity'de null reference exception nasıl debug edilir?

Answer:
`NullReferenceException`, null olan bir değişkenin alanına veya metoduna eriştiğini gösterir. Inspector referansı atanmış mı, `GetComponent` sonucu null mı ve obje sahnede aktif mi kontrol et.

```csharp
[SerializeField] private Transform target;

private void Awake()
{
    if (target == null)
    {
        Debug.LogError("Target referansı Inspector'dan atanmadı.", this);
        enabled = false;
        return;
    }
}
```

Hata satırına çift tıkla, o satırdaki her referansı tek tek kontrol et.


Instruction: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: En temiz mimariyle öner: Unreal Engine'de can sistemi için UHealthComponent yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: Hata ayıklama açısından açıkla: Unity'de coin toplama sistemi C# ile nasıl yapılır?

Answer:
Coin objesinde trigger collider olmalı. Player objesini tag veya component ile ayırt edebilirsin.

```csharp
using UnityEngine;

public class Coin : MonoBehaviour
{
    [SerializeField] private int value = 1;

    private void OnTriggerEnter(Collider other)
    {
        if (!other.TryGetComponent<PlayerWallet>(out var wallet))
            return;

        wallet.AddCoins(value);
        Destroy(gameObject);
    }
}

public class PlayerWallet : MonoBehaviour
{
    public int Coins { get; private set; }

    public void AddCoins(int amount)
    {
        Coins += amount;
    }
}
```


Instruction: En temiz mimariyle öner: Unity'de Health component yaz.

Answer:
Health'i ayrı component yapmak Player, enemy ve kırılabilir objelerde yeniden kullanımı kolaylaştırır.

```csharp
using System;
using UnityEngine;

public class Health : MonoBehaviour
{
    [SerializeField] private int maxHealth = 100;

    public int Current { get; private set; }
    public event Action<int, int> Changed;
    public event Action Died;

    private void Awake()
    {
        Current = maxHealth;
    }

    public void TakeDamage(int amount)
    {
        Current = Mathf.Max(Current - amount, 0);
        Changed?.Invoke(Current, maxHealth);

        if (Current == 0)
            Died?.Invoke();
    }
}
```


Instruction: Kısa açıkla: Unreal Blueprint ile kapı açma mantığını anlat.

Answer:
Kapı actor'ünde `Box Collision`, kapı mesh'i ve timeline bulunur. Player overlap olduğunda timeline çalışır, timeline değeriyle kapının rotation veya location değeri interpolate edilir.

Akış:

- `OnComponentBeginOverlap` tetiklenir.
- Overlap eden actor player mı kontrol edilir.
- Timeline `Play` çağrılır.
- Timeline update pin'inde `SetRelativeRotation` veya `SetRelativeLocation` kullanılır.
- Çıkışta `OnComponentEndOverlap` ile timeline reverse yapılabilir.

C++ gerekiyorsa aynı mantık `UBoxComponent` ve `FTimeline` ile kurulabilir.


Instruction: Kısa açıkla: UE C++ AddMovementInput örneği ver.

Answer:
Enhanced Input kurulu projelerde input binding genelde Character içinde yapılır. Aşağıdaki iskelet hareket fonksiyonlarını gösterir.

```cpp
// MyPlayerCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyPlayerCharacter.generated.h"

UCLASS()
class AMyPlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyPlayerCharacter();

protected:
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

    void MoveForward(float Value);
    void MoveRight(float Value);
};
```

```cpp
// MyPlayerCharacter.cpp
#include "MyPlayerCharacter.h"

AMyPlayerCharacter::AMyPlayerCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AMyPlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    PlayerInputComponent->BindAxis("MoveForward", this, &AMyPlayerCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyPlayerCharacter::MoveRight);
}

void AMyPlayerCharacter::MoveForward(float Value)
{
    AddMovementInput(GetActorForwardVector(), Value);
}

void AMyPlayerCharacter::MoveRight(float Value)
{
    AddMovementInput(GetActorRightVector(), Value);
}
```


Instruction: Kısa açıkla: Unreal C++ ile Health component yaz.

Answer:
Reusable health için `UActorComponent` uygundur.

```cpp
UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class UHealthComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Health")
    float MaxHealth = 100.0f;

    UPROPERTY(BlueprintReadOnly, Category="Health")
    float CurrentHealth = 100.0f;

    UFUNCTION(BlueprintCallable, Category="Health")
    void ApplyDamage(float Amount)
    {
        CurrentHealth = FMath::Clamp(CurrentHealth - Amount, 0.0f, MaxHealth);
        if (CurrentHealth <= 0.0f)
        {
            // Death event veya BlueprintImplementableEvent çağrılabilir.
        }
    }
};
```

Daha gelişmiş sürümde multicast delegate ile UI ve gameplay sistemlerine haber verilir.


Instruction: En temiz mimariyle öner: Unity'de WASD ile CharacterController kullanan FPS hareket kodu yaz.

Answer:
Bu script Player objesine eklenir. Objede `CharacterController` component'i olmalı.

```csharp
using UnityEngine;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -9.81f;

    private CharacterController controller;
    private Vector3 velocity;

    private void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    private void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move.normalized * speed * Time.deltaTime);

        if (controller.isGrounded && velocity.y < 0f)
            velocity.y = -2f;

        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
```

Yeni Input System kullanıyorsan `Input.GetAxisRaw` yerine input action callback'leriyle vektör okuyabilirsin.