
Unity'de ScriptableObject ve JSON ile AES Şifreli Kayıt Sistemi (Save/Load)
Oyun geliştirme sürecinde her geliştiricinin er ya da geç yüzleşmek zorunda olduğu en kritik konulardan biri kayıt (save/load) sistemidir. Küçük projelerde çoğumuz refleks olarak PlayerPrefs kullanmaya yöneliyoruz. Ancak proje büyüdükçe, envanter sistemleri, karmaşık oyuncu istatistikleri veya görev durumları devreye girdiğinde PlayerPrefs hem yetersiz kalır hem de projenin mimarisini kirletmeye başlar. Üstelik PlayerPrefs verileri işletim sisteminin kayıt defterinde (Registry) veya düz metin dosyalarında açıkça saklandığı için oyuncular tarafından saniyeler içinde değiştirilebilir.
Bu yazıda Unity projelerinde sürdürülebilir, modüler ve güvenli bir kayıt sistemi kuracağız. Mimarimizi kurarken ScriptableObject yapısından faydalanacak, verileri serileştirmek için JSON formatını kullanacak ve veri güvenliği için AES (Advanced Encryption Standard) şifrelemeyi entegre edeceğiz. Son olarak kayıt dosyasının yarıda kesilip bozulmasını engelleyen bir "atomik kayıt" ve yedekten kurtarma adımı ekleyeceğiz.
Neden PlayerPrefs Yetersiz? Mimarinin Temelleri
PlayerPrefs, adı üstünde oyuncu tercihlerini (ses seviyesi, grafik kalitesi vb.) saklamak için tasarlanmıştır. Yalnızca int, float ve string tutar; karmaşık nesne hiyerarşileri için uygun değildir. Onun yerine kuracağımız yapıda roller şöyle dağılıyor:
1. ScriptableObject (SO): Oyun çalışırken verinin bellekteki canlı halidir. Sahne geçişlerinde veri kaybolmaz, MonoBehaviour bağımlılıkları azalır ve Inspector üzerinden anlık izlenebilir.
2. JSON Serileştirme: C# nesnelerimizi depolanabilir bir metin formatına dönüştürür.
3. AES Şifreleme: Diske yazılan JSON metnini şifreli bir metne (ciphertext) çevirerek kayıt dosyasının elle kurcalanmasını zorlaştırır.
Kısacası ScriptableObject verinin RAM'deki canlı halini, JSON ve AES ise verinin diskteki güvenli halini temsil ediyor. UI veya oyuncu kontrolcüsü kayıt işlemiyle hiç uğraşmaz; sadece ScriptableObject üzerindeki veriyi okur ve değiştirir. Bu yaklaşımı daha önce envanter sistemi ve modüler diyalog sistemi yazılarında da kullanmıştık.
1. Veri Yapısını ve ScriptableObject'i Oluşturma
İlk adımda diske yazılacak ham veriyi temsil eden saf bir C# sınıfı (POCO) oluşturalım. JsonUtility ScriptableObject'leri doğrudan serileştirirken Unity'ye özel iç verileri de işin içine katabildiği için, kaydedilecek veriyi ayrı bir sınıfta tutmak en temiz yaklaşımdır. JSON serileştirmenin çalışabilmesi için sınıfın [System.Serializable] ile işaretlenmesi şarttır.
using System.Collections.Generic;
[System.Serializable]
public class PlayerData
{
public string playerName;
public int level;
public float health;
public int gold;
public List<string> inventoryItems = new List<string>();
}
Şimdi bu veriyi runtime boyunca tutacak PlayerStateSO sınıfını yazalım. ImportData içinde gelen listenin null olma ihtimaline karşı kontrol ekledik; eski bir kayıt dosyasında bu alan hiç yoksa oyun hata vermeden boş envanterle devam eder. Ayrıca "Yeni Oyun" ve kayıt bulunamayan durumlar için bir ResetToDefaults metodu ekledik.
using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "PlayerState", menuName = "SaveSystem/PlayerState")]
public class PlayerStateSO : ScriptableObject
{
public string playerName;
public int level;
public float health;
public int gold;
public List<string> inventoryItems = new List<string>();
// ScriptableObject verisini düz C# veri sınıfına dönüştürür
public PlayerData ExportData()
{
return new PlayerData
{
playerName = playerName,
level = level,
health = health,
gold = gold,
inventoryItems = new List<string>(inventoryItems)
};
}
// Diskten okunan veriyi ScriptableObject içine aktarır
public void ImportData(PlayerData data)
{
playerName = data.playerName;
level = data.level;
health = data.health;
gold = data.gold;
inventoryItems = data.inventoryItems != null
? new List<string>(data.inventoryItems)
: new List<string>();
}
// Yeni oyun başlatırken veya kayıt bulunamadığında çağrılır
public void ResetToDefaults()
{
playerName = "Oyuncu";
level = 1;
health = 100f;
gold = 0;
inventoryItems.Clear();
}
}
2. Güvenlik Katmanı: AES Şifreleme Sınıfı
Veriyi JSON'a çevirdiğimizde elimizde düz metin kalır; oyuncu dosyayı Not Defteri ile açıp altın miktarını 999999 yapabilir. Bunu zorlaştırmak için simetrik bir algoritma olan AES-256 kullanacağız.
Burada sık yapılan iki hataya dikkat çekmek istiyorum. Birincisi anahtar uzunluğu: AES anahtarı tam olarak 16, 24 veya 32 bayt olmalıdır. Elle yazılmış 30 karakterlik bir parolayı doğrudan aes.Key alanına verirseniz "Specified key is not a valid size" hatası alırsınız. Bu yüzden parolayı SHA-256 ile özetleyip her zaman 32 baytlık bir anahtar elde ediyoruz. İkincisi sabit IV (Initialization Vector): her kayıtta aynı IV kullanmak, aynı içeriğin her seferinde aynı şifreli metni üretmesine yol açar. Bunun yerine her kayıtta rastgele bir IV üretip şifreli verinin başına ekliyoruz. IV gizli bir bilgi değildir, sadece şifre çözerken gereklidir.
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
public static class EncryptionUtility
{
// Parola herhangi bir uzunlukta olabilir; SHA-256 ile her zaman 32 baytlık (256-bit) anahtara çevrilir.
private const string Passphrase = "mErTkIyAkUnItYsAvEsYsTeM2024!#";
private static byte[] GetKey()
{
using (SHA256 sha = SHA256.Create())
{
return sha.ComputeHash(Encoding.UTF8.GetBytes(Passphrase));
}
}
public static string Encrypt(string plainText)
{
using (Aes aes = Aes.Create())
{
aes.Key = GetKey();
aes.GenerateIV(); // Her kayıtta yeni, rastgele 16 baytlık IV
using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
using (MemoryStream ms = new MemoryStream())
{
// IV'yi verinin başına yazıyoruz, çözerken buradan okuyacağız
ms.Write(aes.IV, 0, aes.IV.Length);
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
using (StreamWriter sw = new StreamWriter(cs))
{
sw.Write(plainText);
}
return Convert.ToBase64String(ms.ToArray());
}
}
}
public static string Decrypt(string cipherText)
{
byte[] buffer = Convert.FromBase64String(cipherText);
using (Aes aes = Aes.Create())
{
aes.Key = GetKey();
byte[] iv = new byte[aes.BlockSize / 8]; // 16 bayt
if (buffer.Length <= iv.Length)
throw new CryptographicException("Kayıt verisi geçersiz ya da eksik.");
Array.Copy(buffer, iv, iv.Length);
aes.IV = iv;
using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
using (MemoryStream ms = new MemoryStream(buffer, iv.Length, buffer.Length - iv.Length))
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
using (StreamReader sr = new StreamReader(cs))
{
return sr.ReadToEnd();
}
}
}
}
3. Kayıt Yöneticisi (SaveManager): Atomik Kayıt ve Yedekten Kurtarma
Artık tüm parçalar hazır: canlı veriyi tutan ScriptableObject, veriyi temsil eden C# sınıfı ve şifreleme katmanı. Şimdi bunları birleştiren statik SaveManager sınıfını yazalım. Dosya yolu olarak Application.persistentDataPath kullanıyoruz; bu yol Windows, macOS, Android ve iOS'ta işletim sisteminin uygulamaya ayırdığı yazılabilir alanı gösterir.
Kayıt sırasında oyun çökerse veya cihazın şarjı biterse yarım yazılmış bir dosya, oyuncunun tüm ilerlemesini kaybetmesi demektir. Bunu önlemek için veriyi önce .tmp uzantılı geçici bir dosyaya yazıyor, yazma başarıyla bittiğinde asıl dosyayla değiştiriyoruz. File.Replace bu sırada eski kaydı .bak olarak saklar; asıl dosya bir şekilde okunamazsa yükleme sırasında yedeğe düşeriz.
using System;
using System.IO;
using UnityEngine;
public static class SaveManager
{
private static string SaveFilePath => Path.Combine(Application.persistentDataPath, "save_data.dat");
private static string TempFilePath => SaveFilePath + ".tmp";
private static string BackupFilePath => SaveFilePath + ".bak";
public static bool SaveGame(PlayerStateSO playerState)
{
if (playerState == null)
{
Debug.LogError("SaveGame: PlayerStateSO atanmamış.");
return false;
}
try
{
// 1. SO verisini POCO sınıfına aktar
PlayerData data = playerState.ExportData();
// 2. JSON'a çevir (şifreleneceği için okunaklı formata gerek yok)
string jsonText = JsonUtility.ToJson(data);
// 3. AES ile şifrele
string encryptedData = EncryptionUtility.Encrypt(jsonText);
// 4. Önce geçici dosyaya yaz, sonra asıl dosyayla değiştir (atomik kayıt)
File.WriteAllText(TempFilePath, encryptedData);
if (File.Exists(SaveFilePath))
File.Replace(TempFilePath, SaveFilePath, BackupFilePath);
else
File.Move(TempFilePath, SaveFilePath);
Debug.Log($"Oyun başarıyla kaydedildi: {SaveFilePath}");
return true;
}
catch (Exception e)
{
Debug.LogError($"Kayıt yapılırken bir hata oluştu: {e.Message}");
return false;
}
}
public static bool LoadGame(PlayerStateSO playerState)
{
if (playerState == null)
{
Debug.LogError("LoadGame: PlayerStateSO atanmamış.");
return false;
}
// Önce asıl dosyayı, okunamazsa yedeği dene
if (TryLoadFrom(SaveFilePath, playerState))
return true;
if (TryLoadFrom(BackupFilePath, playerState))
{
Debug.LogWarning("Asıl kayıt okunamadı, yedek kayıttan yüklendi.");
return true;
}
Debug.LogWarning("Geçerli bir kayıt dosyası bulunamadı.");
return false;
}
private static bool TryLoadFrom(string path, PlayerStateSO playerState)
{
if (!File.Exists(path))
return false;
try
{
string encryptedData = File.ReadAllText(path);
string jsonText = EncryptionUtility.Decrypt(encryptedData);
PlayerData data = JsonUtility.FromJson<PlayerData>(jsonText);
if (data == null)
return false;
playerState.ImportData(data);
return true;
}
catch (Exception e)
{
Debug.LogError($"{Path.GetFileName(path)} okunamadı (dosya bozulmuş olabilir): {e.Message}");
return false;
}
}
public static void DeleteSaveFile()
{
foreach (string path in new[] { SaveFilePath, BackupFilePath, TempFilePath })
{
if (File.Exists(path))
File.Delete(path);
}
Debug.Log("Kayıt dosyaları silindi.");
}
}
4. Sistemi Sahneye Bağlamak ve Test Etmek
Sistemi kullanmak oldukça basit. Sahnedeki bir objeye aşağıdaki bileşeni ekleyip PlayerStateSO asset'ini atamanız yeterli. Oyun açılırken kaydı yüklüyoruz; kayıt yoksa veya okunamadıysa ScriptableObject'i varsayılan değerlere sıfırlıyoruz. Mobil cihazlarda oyun arka plana alındığında işletim sistemi uygulamayı haber vermeden kapatabildiği için OnApplicationPause içinde de kayıt alıyoruz.
using UnityEngine;
public class SaveBootstrap : MonoBehaviour
{
[SerializeField] private PlayerStateSO playerState;
private void Awake()
{
// Kayıt yoksa ya da okunamadıysa temiz bir başlangıç yap
if (!SaveManager.LoadGame(playerState))
playerState.ResetToDefaults();
}
private void Update()
{
// Test kısayolları: K ile kaydet, L ile yükle
if (Input.GetKeyDown(KeyCode.K))
SaveManager.SaveGame(playerState);
if (Input.GetKeyDown(KeyCode.L))
SaveManager.LoadGame(playerState);
}
private void OnApplicationPause(bool paused)
{
if (paused)
SaveManager.SaveGame(playerState);
}
private void OnApplicationQuit()
{
SaveManager.SaveGame(playerState);
}
}
Oyun sırasında oyuncunun canı azaldığında veya envantere yeni bir eşya eklendiğinde doğrudan playerState ScriptableObject'ini güncellersiniz. Kayıt zamanı geldiğinde (örneğin bir checkpoint'e ulaşıldığında) tek yapmanız gereken SaveManager.SaveGame(playerState) çağırmaktır. Yeni Input System kullanıyorsanız Input.GetKeyDown satırlarını kendi input action'larınızla değiştirebilirsiniz.
Sık Yapılan Hatalar
• Editor ve Build farkını unutmak: ScriptableObject'ler Editor'da Play modundan çıktığınızda bile üzerlerindeki değişiklikleri korur, Build'de ise oyun her açıldığında asset'teki varsayılan değerlere döner. Editor'da "kayıt çalışıyor" sanıp aslında asset'in kendisini kirletiyor olabilirsiniz. Bu yüzden oyun açılışında her zaman diskten yükleme yapın, kayıt yoksa ResetToDefaults çağırın.
• Dictionary kaydetmeye çalışmak: JsonUtility Dictionary türünü desteklemez ve hata vermeden boş geçer. Eşya ID'si ve adedi gibi eşleşmeleri iki ayrı List (anahtarlar ve değerler) olarak ya da [Serializable] bir struct listesi olarak tutun. Alternatif olarak Newtonsoft.Json paketini kullanabilirsiniz.
• Kayıt formatını sürümlememek: Oyunu güncelleyip PlayerData içine yeni alanlar eklediğinizde eski kayıtlar o alanları içermez. PlayerData sınıfına bir saveVersion alanı ekleyip yüklerken eski sürümleri dönüştürmek, güncellemelerden sonra oyuncu kayıtlarının bozulmasını engeller.
Performans ve Güvenlik Notları
• Asenkron dosya işlemleri: Kaydedilecek veri çok büyükse (örneğin açık dünyada binlerce nesnenin konumu), File.WriteAllText ana thread'i bloklayıp anlık takılmalara yol açabilir. Bu durumda veriyi ana thread'de ExportData ile kopyalayıp şifreleme ve dosya yazma kısmını Task.Run veya File.WriteAllTextAsync ile arka plana taşıyabilirsiniz. ScriptableObject'e ve çoğu Unity API'sine arka plan thread'inden erişmeyin; kopyalanmış POCO veriyle çalışmak bu yüzden önemlidir.
• Anahtar güvenliği: C# kodu IL2CPP kullanılmadığında dnSpy veya ILSpy gibi araçlarla kolayca decompile edilebilir. Koda gömülü bir parola, kararlı bir oyuncuyu durdurmaz; sadece işini zorlaştırır. Tek oyunculu oyunlarda bu genellikle yeterlidir. Çok oyunculu ya da ekonomisi olan oyunlarda kritik veriyi her zaman sunucuda doğrulayın.
• Platform farkları: WebGL'de persistentDataPath tarayıcının IndexedDB alanına bağlanır ve dosya işlemleri sınırlıdır; bu platform için File.Replace yerine doğrudan yazma ve PlayerPrefs tabanlı bir yedek düşünmek daha güvenlidir.
Bu mimari sayesinde oyununuzdaki veri yönetimini tamamen modüler hale getirmiş oldunuz. ScriptableObject sahneler arası veri akışını çözerken, JSON ve AES kombinasyonu güvenli ve esnek bir depolama sağlıyor; atomik kayıt ve yedek dosyası da oyuncunun ilerlemesini beklenmedik kapanmalara karşı koruyor. Yeni bir sistem eklemek istediğinizde (örneğin görevler veya yetenek ağacı) tek yapmanız gereken yeni bir veri sınıfı ve ona uygun bir ScriptableObject tanımlamak.
Bir sonraki teknik yazıda görüşmek üzere!
— Mert Kıyak
