Orvix Engine

Bölüm 1: Oyun Geliştirmeye Başlangıç | Temel Kavramlara Derin Dalış

Oyun geliştirme maceranıza hoş geldiniz! Orvix Engine, Düğümler (Nodes) ve Sahneler (Scenes) etrafında dönen modüler bir mimariye sahiptir. Bu bölüm, bu temel yapı taşlarını ve editör arayüzünü derinlemesine anlamanızı sağlayacak.

1.1 Proje Yönetimi ve Yapılandırma Stratejileri

Orvix Engine'i ilk başlattığınızda, sizi güçlü bir Proje Yöneticisi karşılar. Burası, tüm oyun projelerinizin merkezi komuta odasıdır. Projelerinizi verimli bir şekilde düzenlemek, farklı versiyonlar arasında geçiş yapmak ve yeni fikirler için alan açmak için Proje Yöneticisi'ni ustaca kullanmak, geliştirme sürecinizin temelini oluşturur.

Yeni Bir Proje Oluşturma: İlk Adımınız

Proje Yöneticisi'ndeki parlak "Oluştur Yeni Proje" (Create New Project) butonuna tıklayarak yeni bir maceraya atılabilirsiniz. Bu aşamada, projenize sadece akılda kalıcı bir isim vermekle kalmayacak, aynı zamanda tüm oyun varlıklarınızın, kod dosyalarınızın ve sahne tanımlarınızın güvenle saklanacağı stratejik bir disk konumu seçmelisiniz. Projenin adını belirlerken, gelecekteki genişlemeleri ve olası modüler yapıları düşünerek kısa, açıklayıcı ve benzersiz bir isim seçmek akıllıca olacaktır.

Orvix Proje Dosya Yapısı: Bir Mimarın Gözünden

Her Orvix projesi, titizlikle organize edilmiş, mantıksal bir dosya yapısına sahiptir. Bu yapı, hem küçük prototipler hem de milyonlarca satır kodu barındıran devasa AAA oyunları için ölçeklenebilirliği sağlar. En kritik ve sıkça karşılaşacağınız dosya türleri şunlardır:

• `.tscn` (Sahne Dosyaları): Bunlar, oyun dünyanızın ve içindeki tüm interaktif objelerinizin (düğümlerin) hiyerarşik yapısını, pozisyonlarını, ayarlarını ve ilişkilerini içeren omurgalardır. Her seviye, her karakter, her menü kendi `.tscn` dosyasında bir sahne olarak kaydedilir. Bu, oyunun modülerliğini sağlar.
• `.ovx` (OrvixScript Kod Dosyaları): Oyununuzun kalbi ve beyni! GDScript'e benzeyen, Orvix Engine'e özel bu güçlü betik dili, oyununuzun tüm mantığını, karakter davranışlarını, düşman yapay zekasını, kullanıcı etkileşimlerini ve özel mekaniklerini bu `.ovx` uzantılı dosyalarda barındırır. Okunabilirliği ve esnekliği sayesinde hızlı prototipleme ve karmaşık sistem geliştirme için idealdir.
• `project.orvix` (Proje Konfigürasyon Dosyası): Oyun motorunun projenizi tanımasını sağlayan, tüm global ayarların (başlangıç sahnesi, giriş haritaları, fizik katmanları, otomatik yüklemeler vb.) saklandığı ana konfigürasyon dosyasıdır. Bu dosyayı düzenlerken dikkatli olmalısınız.
• Görsel Varlıklar (`.png`, `.jpg`, `.tga`): Karakterler, arka planlar, arayüz elementleri, efektler... Oyununuzun görsel kimliğini oluşturan tüm dokular ve Spriteler.
• Ses Varlıkları (`.ogg`, `.wav`, `.mp3`): Oyun müziği, ses efektleri, diyaloglar... Oyunun işitsel atmosferini zenginleştiren tüm ses dosyaları.

1.2 Oyun Dünyasının Temel Bileşenleri: Düğümler (Nodes) ve Sahneler (Scenes)

Orvix Engine'in temel felsefesi, her şeyin küçük, yeniden kullanılabilir ve hiyerarşik nesneler etrafında dönmesidir. Bu nesneleri "Düğüm" (Node), bu düğümlerin mantıksal olarak bir araya gelmiş halini ise "Sahne" (Scene) olarak adlandırırız. Bu yapı, oyununuzun karmaşıklığını yönetmek için inanılmaz bir esneklik sunar.

Düğüm (Node) Nedir? Detaylı Bakış

Düğüm, Orvix Engine'deki en küçük, atomik yapı taşıdır. Ancak bu basit tanım, onun ne kadar güçlü olduğunu tam olarak yansıtmaz. Bir düğüm, oyununuzdaki belirli bir görevi veya işlevi yerine getiren herhangi bir objedir. Örneğin:

• Bir `Camera2D` düğümü, oyunun görsel penceresini kontrol eder.
• Bir `PointLight2D` düğümü, oyun dünyasına ışık saçar.
• Bir `Sprite2D` düğümü, ekranda bir 2D görseli (karakter, arka plan elemanı vb.) gösterir.
• Bir `AudioStreamPlayer2D` düğümü, oyun içi sesleri veya müziği çalar.
• Bir `CharacterBody2D` düğümü, hareket eden bir karakterin fiziksel davranışını yönetir.

Her düğüm, kendi benzersiz özellik setine (konum, rotasyon, boyut, renk vb.) ve kendi özel davranışlarını tanımlayabileceğiniz bir betiğe (`.ovx` dosyası) sahip olabilir. Düğümler, birbiriyle ilişkili bir "ağaç" yapısında düzenlenir. Bir düğümün altına başka düğümler ekleyerek hiyerarşiler oluşturursunuz. Örneğin, bir karakter düğümünün altına bir kamera düğümü eklediğinizde, kamera karakterle birlikte hareket eder.

Sahne (Scene) Nedir? Modüler Geliştirmenin Kalbi

Bir sahne, bir veya daha fazla düğümün mantıksal olarak bir araya getirilmiş, hiyerarşik bir koleksiyonudur. Bir sahne, oyununuzun belirli bir "parçasını" temsil eder:

• Oyunun bir seviyesi (level) bir sahne olabilir.
• Ana oynanabilir karakteriniz bir sahne olabilir.
• Bir düşman tipi bir sahne olabilir.
• Oyunun ana menüsü veya ayarlar ekranı bir sahne olabilir.

Sahnelerin gücü, onların "yeniden kullanılabilir" olmasında yatar. Bir karakter sahnesi tasarladınız ve test ettiniz. Şimdi bu karakteri oyununuzun farklı seviyelerine veya birden fazla düşman olarak farklı sahnelerde kolayca örnekleyerek ekleyebilirsiniz. Bu modüler yapı, kod tekrarını azaltır, hata ayıklamayı kolaylaştırır ve büyük oyunları daha yönetilebilir hale getirir.

1.3 Editör Arayüzü ve 2D/3D Görünüm Alanı (Viewport)

Orvix Engine'in sezgisel editörü, oyununuzu görsel olarak inşa etmeniz ve test etmeniz için tasarlanmış, güçlü bir iş istasyonudur. Editörü açtığınızda, oyununuzun kalbi olan Görünüm Alanı (Viewport) ile karşılaşırsınız.

2D Görünüm Alanı (Canvas): Piksel Sanatçısının Tuvali

Özellikle 2D oyun geliştirme modunda çalışırken, bu alana "Canvas" (Tuval) denir. Canvas, oyunun tüm 2D objelerinin yerleştirildiği, sınırsız ve esnek bir çalışma alanı gibidir. Karakterlerinizi, dinamik arka planlarınızı, etkileşimli nesnelerinizi ve kullanıcı arayüzü elementlerinizi bu tuval üzerine sürükleyip bırakarak oyun dünyanızı titizlikle görsel olarak oluşturursunuz. Burada, piksel hassasiyetinde konumlandırma ve ölçekleme yaparak oyununuzun estetiğini mükemmelleştirebilirsiniz.

3D Görünüm Alanı (Spatial View): Sanal Gerçekliğin Mimarisi

3D oyun geliştirme modunda ise, Görünüm Alanı "Spatial View" (Uzamsal Görünüm) olarak işlev görür. Burada, objeleri üç boyutlu uzayda konumlandırır, ışık kaynaklarını yerleştirir, kameraları ayarlar ve oyun dünyanızın derinliğini inşa edersiniz. 3D Viewport, gerçek zamanlı gölgeler, yansımalar ve post-processing efektleriyle oyununuzun nasıl görüneceğini anında gösterir.

Kilit Paneller: İş Akışınızın Anahtarları

Orvix Editör'ü, verimli bir iş akışı için tasarlanmış bir dizi hayati panelle çevrilidir:

• İnceleyici (Inspector) Paneli: Editörün genellikle sağ üst köşesinde konumlanır. Sahne ağacında seçtiğiniz herhangi bir düğümün tüm ayarlarını, özelliklerini (pozisyon, rotasyon, boyut vb.) ve betiğe bağlı özel değişkenlerini buradan anlık olarak değiştirebilirsiniz. Bu, objelerinizi ince ayar yapmak ve davranışlarını özelleştirmek için vazgeçilmez bir araçtır.
• Dosya Sistemi (FileSystem) Paneli: Genellikle sol altta yer alır. Projenizin tüm varlıklarını (görseller, ses dosyaları, fontlar, 3D modeller, scriptler vb.) yönettiğiniz merkezi bir depolama alanıdır. Varlıkları içe aktarabilir, klasörler halinde düzenleyebilir ve sahnelerinize sürükleyerek kolayca kullanabilirsiniz.
• Sahne (Scene) Paneli: Editörün sol üstünde bulunur. Açık olan sahnenin düğüm hiyerarşisini gösterir. Düğümleri ekleyebilir, silebilir, yeniden adlandırabilir ve ebeveyn-çocuk ilişkilerini bu panel üzerinden düzenleyebilirsiniz. Oyununuzun yapısını görsel olarak buradan takip edersiniz.
• Çıktı (Output) Paneli: Genellikle alt kısımda yer alır. Oyun çalışırken `print()` komutlarıyla gönderdiğiniz mesajları, hata ayıklama bilgilerini ve uyarıları gösterir. Hata ayıklama sürecinde vazgeçilmezdir.

1.4 İlk Oyununu Yarat: Klavyeyle Hareket Eden Bir Karakter

Şimdiye kadar öğrendiğimiz tüm temel bilgileri bir araya getirerek, klavye girdileriyle kontrol edebileceğiniz, etkileşimli bir karakter oluşturalım. Bu basit proje, Orvix Engine'deki oyun geliştirme döngüsünün ilk pratik uygulaması olacak.

Adım 1: Oyuncu Karakteri Sahnesini Oluşturma (Modüler Yaklaşım)

Yeni bir sahne başlatın ve kök düğüm olarak `CharacterBody2D` (2D oyunlar için fiziksel karakterler) ekleyin. Bu düğüm, fizik motorunun algılamasını ve çarpışmalarını yönetmek için temeldir. Düğümün adını "Oyuncu" olarak değiştirin ve bu sahneyi `Oyuncu.tscn` adıyla projenizin `res://oyuncular/` klasörüne (eğer yoksa oluşturun) kaydedin.

• `Sprite2D` Ekleme: "Oyuncu" düğümünün altına bir `Sprite2D` düğümü ekleyin. Bu düğüm, karakterinizin görsel temsilini sağlar. İnceleyici panelinde, `Texture` (Doku) özelliğine karakterinize ait bir görsel (örneğin bir `player.png` dosyası) sürükleyip bırakarak karakterinizin ekranda görünmesini sağlayın.
• `CollisionShape2D` Ekleme: `Sprite2D` düğümünün altına bir `CollisionShape2D` düğümü ekleyin. Bu düğüm, karakterinizin fiziksel çarpışma alanını tanımlar. İnceleyici panelinden, `Shape` (Şekil) özelliğine bir `RectangleShape2D` (kutu şekli) veya `CapsuleShape2D` (kapsül şekli) atayın ve boyutunu karakter görselinize uyacak şekilde ayarlayın. Bu, karakterinizin oyun dünyasındaki fiziksel etkileşimlerini sağlar.

Adım 2: GDScript ile Karakter Hareketi Programlama (GDScript'in İlk Temelleri)

"Oyuncu" düğümüne sağ tıklayarak veya düğümü seçip üst menüden "Attach Script" (Betiği Bağla) seçeneğiyle yeni bir GDScript dosyası (`Oyuncu.ovx`) oluşturun ve aşağıdaki kodu içine yazın. Bu kod, klavye yön tuşlarından gelen girdiyi okuyacak ve `CharacterBody2D`'nin `velocity` (hız) özelliğini kullanarak karakteri fizik motoruyla hareket ettirecektir.

# Oyuncu.cs - Bu script, bir CharacterBody2D düğümüne eklendi.
extends CharacterBody2D

# Karakterin hareket hızını bir değişken olarak tanımlıyoruz.
# '@export' anahtar kelimesi, bu değişkeni İnceleyici panelinde düzenlenebilir yapar.
@export var hiz = 250.0 # Piksel/saniye cinsinden hız

# '_physics_process' fizik motoru tarafından kare başına sabit bir zamanda çağrılır.
# Bu, tutarlı fizik hareketleri için önemlidir.
func _physics_process(delta: float):
    # Klavyeden yön girdisini alalım.
    # 'Vector2.ZERO' boş bir 2D vektördür (0,0).
    var yon_girisi = Vector2.ZERO

    # Her bir yön tuşu için girdiyi kontrol et.
    # 'ui_right', 'ui_left', 'ui_down', 'ui_up' varsayılan giriş eylemleridir.
    if Input.is_action_pressed("ui_right"):
        yon_girisi.x += 1.0
    if Input.is_action_pressed("ui_left"):
        yon_girisi.x -= 1.0
    if Input.is_action_pressed("ui_down"):
        yon_girisi.y += 1.0
    if Input.is_action_pressed("ui_up"):
        yon_girisi.y -= 1.0

    # Yön girdisi normalize edilir (büyüklüğü 1 olur) ve hız ile çarpılır.
    # Bu, çapraz hareketlerin daha hızlı olmamasını sağlar.
    # 'velocity' CharacterBody2D'nin dahili bir değişkenidir.
    velocity = yon_girisi.normalized() * hiz
    
    # Karakteri fizik motoruyla hareket ettir ve çarpışmaları algıla.
    # 'move_and_slide()' yöntemi, karakteri hızına göre hareket ettirir
    # ve yüzeyler boyunca kaydırır.
    move_and_slide()

Adım 3: Oyunu Oynatma ve İlk Zaferin!

Yeni bir ana sahne oluşturun (örneğin `MainGame.tscn`). Bu sahne, oyununuzun genel çerçevesini oluşturacaktır. `Oyuncu.tscn` sahnesini, Dosya Sistemi panelinden sürükleyip ana sahnenizin Sahne paneline bırakarak "Oyuncu" karakterinizi ana oyuna ekleyin. Şimdi, editörün üst kısmındaki "Oynat" (Play) butonuna basarak veya `F5` tuşuna basarak oyununuzu çalıştırın. Klavyenizdeki yön tuşlarını kullanarak karakterinizi Canvas üzerinde sorunsuz bir şekilde hareket ettirebileceksiniz. Tebrikler! Oyun geliştirme yolculuğunuzda ilk büyük adımı attın ve kendi ilk etkileşimli oyun mekaniğini tamamladın!

Bölüm 2: Dinamik Etkileşimler | Sinyallerin Gücü ve Kullanıcı Arayüzü

Oyunlar sadece hareketli görsellerden ibaret değildir; aynı zamanda etkileşimlerden ibarettir. Orvix Engine'in temelinde yatan **Sinyal (Signal) Sistemi** ve **Kullanıcı Arayüzü (GUI)** mimarisi, oyun dünyanızdaki dinamik tepkileri ve oyuncu etkileşimlerini yönetmenizi sağlar. Bu bölümde, bu güçlü mekanizmaları nasıl kullanacağınızı detaylıca inceleyeceğiz.

2.1 Çarpışma Sinyalleri ile Gelişmiş Etkileşimler

Sinyaller, Orvix'teki düğümler arası iletişimin omurgasıdır. Bir düğüm belirli bir olay gerçekleştirdiğinde bir sinyal yayar, diğer düğümler ise bu sinyali dinleyerek (bağlayarak) o olaya göre tepki verir. Bu, kodu daha temiz, daha modüler ve daha az bağımlı hale getirir. En yaygın sinyallerden biri, fiziksel çarpışmalardan tetiklenen sinyallerdir.

Adım 1: "Para" Toplanabilir Nesnesini Oluşturma Sahnesi

Yeni bir sahne başlatın ve kök düğüm olarak `Area2D` ekleyin. `Area2D` düğümü, fiziksel kurallara göre hareket etmeyen, ancak diğer fiziksel nesnelerle çarpışmaları (veya onlara giriş/çıkışları) algılayabilen alanlar oluşturmak için idealdir. Bu düğüme "Para" adını verin ve sahneyi `Para.tscn` olarak `res://varliklar/` klasörüne (oluşturun) kaydedin.

• `Sprite2D` Ekleme: "Para" düğümünün altına bir `Sprite2D` düğümü ekleyin ve İnceleyici panelinde `Texture` (Doku) özelliğine bir para görseli (`coin.png`) atayın.
• `CollisionShape2D` Ekleme: `Sprite2D` altına bir `CollisionShape2D` düğümü ekleyin ve para görselinizin boyutuna uygun bir şekil (örneğin `CircleShape2D` veya `RectangleShape2D`) atayarak paraya bir çarpışma alanı tanımlayın. Bu alan, başka bir fiziksel nesne bu alana girdiğinde `Area2D`'nin sinyal yaymasını sağlayacaktır.

Adım 2: Para Sinyali ve GDScript Kod Mantığı

"Para" düğümüne bir GDScript (`Para.ovx`) ekleyin. Bu script, bir oyuncuyla çarpıştığında özel bir sinyal yayacak ve ardından kendini sahneden kaldırarak "toplandı" efektini verecektir. Bu, nesne tabanlı programlamanın ve sinyal/slot mekaniğinin güzel bir örneğidir.

# Para.ovx - Bu script, bir Area2D düğümüne eklendi.
extends Area2D

# "para_alindi" adında, 'puan' adında bir argüman taşıyan özel bir sinyal tanımla.
signal para_alindi(puan: int)

# '_on_body_entered' fonksiyonu, bu Area2D'ye fiziksel bir 'body' (CharacterBody2D veya RigidBody2D gibi)
# girdiğinde otomatik olarak çağrılır. Editörden sinyali bağlayarak oluşturulabilir.
func _on_body_entered(body: Node2D):
    # Çarpışan nesnenin 'Oyuncu' karakterimiz olup olmadığını kontrol ediyoruz.
    # 'body.name' yerine gruplar kullanmak daha sağlam bir yöntemdir.
    if body.name == "Oyuncu":
        # "para_alindi" sinyalini yayıyoruz ve 100 puan değerini argüman olarak gönderiyoruz.
        # Bu sinyali dinleyen tüm düğümler bu olayı alacaktır.
        emit_signal("para_alindi", 100)
        # Parayı sahneden güvenli bir şekilde sil (sonraki fizik adımında silinir).
        queue_free()

Bu kodu yazdıktan sonra, editörde "Para" düğümünü seçin. Sağdaki **"Düğüm"** panelini (Inspector'ın yanında) açın, `Area2D` altındaki "body_entered" sinyaline çift tıklayın. Açılan pencerede, script'inizin bağlı olduğu düğümü (Para) ve metodu seçerek `_on_body_entered` fonksiyonunu otomatik olarak oluşturabilir ve sinyali bağlayabilirsiniz.

Adım 3: Oyuncu Scriptinde Sinyali Dinleme ve Puan Entegrasyonu

Ana sahnede (veya `Oyuncu.tscn` içindeki "Oyuncu" düğümüne bağlı olan) `Oyuncu.ovx` script'inizi açın. Şimdi, "para_alindi" sinyalini dinlemek ve toplanan paralarla oyuncunun puanını güncellemek için aşağıdaki kodu script'inize ekleyin. Ayrıca, bu puanı oyun boyunca erişilebilir kılmak için global bir "OyunYönetimi" (Globals) singleton'ı kullanacağız.

# Oyuncu.ovx - Oyuncu karakterinin script'ine eklenir.
extends CharacterBody2D

# ... (Önceki hareket kodu burada kalır) ...

# '_ready' fonksiyonu düğüm sahne ağacına girdiğinde bir kez çağrılır.
func _ready():
    # 'Para' sahnelerinin nerede olduğunu varsayıyoruz (örneğin ana sahnede örneklenmişlerse).
    # Tüm 'Para' düğümlerini bulup onların 'para_alindi' sinyallerini bu oyuncuya bağlıyoruz.
    # Alternatif olarak, 'Para' düğümü oluşturulduğunda bu bağlantıyı yapabilirsiniz.
    # Bu, sinyalleri dinamik olarak bağlamanın bir yoludur.
    get_tree().get_nodes_in_group("toplanabilir_objeler").for_each(
        func(toplanabilir): 
            if toplanabilir is Area2D and toplanabilir.has_signal("para_alindi"):
                toplanabilir.para_alindi.connect(_on_Para_para_alindi)
    )
    # Önemli: 'Para' düğümlerinizi editörde bir gruba eklemeyi unutmayın (örn. "toplanabilir_objeler")!

# 'Para' düğümünün 'para_alindi' sinyali yayıldığında bu fonksiyon çağrılır.
func _on_Para_para_alindi(puan: int):
    # Global singleton'daki puanı güncelleyin.
    GlobalGameManager.artir_puan(puan) # GlobalGameManager, Project Settings -> AutoLoad'a eklenmeli.
    print("Toplanan Puan: ", GlobalGameManager.puan)
    # Oyuncuya ses veya görsel geribildirim ekleyebilirsiniz.

Bu kodla, oyuncu bir parayla çarpıştığında, para kendini yok edecek ve `GlobalGameManager` adlı global bir singleton'daki (projenizin herhangi bir yerinden erişilebilir) `puan` değişkenini güncelleyecektir. Konsolda puanınızın arttığını göreceksiniz. Bu, sinyal sisteminin temel gücüdür!

2.2 Kullanıcı Arayüzü (GUI) ve Akış Yönetimi

Oyunun menüleri, skoru, envanteri, diyalog kutuları ve diğer tüm etkileşimli elemanları kullanıcı arayüzü (GUI) ile oluşturulur. Orvix Engine, bu amaçla özel **Kontrol (Control)** düğümleri ve düzenleyiciler sunar. GUI, oyunun çekirdek mekaniklerinden ayrı bir katmanda çalışarak esneklik ve performans sağlar.

Adım 1: Basit Bir Başlangıç Menüsü Sahnesini Oluşturma

Yeni bir sahne başlatın ve kök düğüm olarak bir `Control` düğümü ekleyin. Bu, tüm UI elementleri için temel bir kapsayıcıdır. Bu sahneyi `MainMenu.tscn` olarak `res://ui/` klasörüne kaydedin. Ardından, bu `Control` düğümünün altına bir `CanvasLayer` düğümü ekleyin. `CanvasLayer`, GUI elemanlarının her zaman 2D veya 3D oyun dünyasının üzerinde, kendi bağımsız render katmanında çizilmesini sağlar, bu da ölçekleme ve görünürlük sorunlarını önler. `CanvasLayer`'ın altına sırasıyla şu UI düğümlerini ekleyin:

• `Panel` veya `ColorRect`: Menü için basit bir arka plan oluşturur. İnceleyici panelinden rengini ve boyutunu ayarlayabilirsiniz. Genellikle ekranı kaplaması için `Layout -> Full Rect` seçeneği kullanılır.
• `Label`: Menü başlık metnini (örneğin "Orvix Macerası" veya "Oyun Adınız") gösterir. Fontunu, boyutunu, rengini ve hizalamasını İnceleyici'den özelleştirebilirsiniz.
• `Button`: Oyunu başlatmak için bir "Başla" veya "Oyna" butonu oluşturur. Butonun metnini ve görsel stilini (normal, hover, basılı durum) `Theme` kaynakları ile detaylıca özelleştirebilirsiniz.
• (İsteğe Bağlı) `OptionButton` / `CheckButton`: Oyun ayarları veya seçenekleri için karmaşık arayüz elemanları ekleyebilirsiniz.

Bu düğümleri Canvas'ın (2D Viewport) tam ortasına yerleştirmek için, kapsayıcı `Control` düğümünün `Layout` özelliğini `Center Container` veya ilgili `Anchor` ve `Margin` ayarlarını kullanabilirsiniz.

Adım 2: Butona İşlev Kazandırma ve Sahne Geçişleri

Butonun "pressed" sinyaline tıklayarak (Düğüm panelinden veya scriptten bağlayarak), butona basıldığında çalışacak bir fonksiyon oluşturun. Bu fonksiyonu kullanarak oyun akışını ana oyun sahnesine geçirebiliriz. Sahne geçişleri, oyunun farklı bölümleri arasında sorunsuz bir deneyim sunmak için kritik öneme sahiptir.

# MainMenu.ovx - Bu script, ana menü sahnesindeki ana Control düğümüne eklendi.
extends Control

# `@onready` ile düğümlere daha güvenli referanslar alınır.
# '$' işareti, Sahne ağacında bir düğüm yolu anlamına gelir.
@onready var basla_butonu = $"VBoxContainer/BaslaButonu" # Butonunuzun Sahne yolunu doğru ayarlayın.

# '_ready' fonksiyonu, düğüm sahne ağacına girdiğinde bir kez çağrılır.
func _ready():
    # Butonun 'pressed' sinyalini bu scriptteki bir fonksiyona bağlıyoruz.
    basla_butonu.pressed.connect(_on_BaslaButonu_pressed)

# '_on_BaslaButonu_pressed' fonksiyonu, "Başla" butonuna basıldığında tetiklenir.
func _on_BaslaButonu_pressed():
    print("Oyun başlatılıyor! Ana Oyun Sahnesi'ne geçiliyor...")
    # 'get_tree().change_scene_to_file()' ile mevcut sahneyi değiştiriyoruz.
    # 'res://' prefix'i projenin kök dizinini ifade eder.
    get_tree().change_scene_to_file("res://AnaOyunSahnesi.tscn")

Bu kodla, "Başla" butonuna tıklandığında oyunun akışı "AnaOyunSahnesi" adlı sahneye sorunsuz bir şekilde geçiş yapacaktır. Bu, bir ana menüden oyuna veya bir seviyeden diğerine geçiş yapmanın en temel ve yaygın yoludur. Gelecekte, sahne geçişlerine animasyonlar veya yükleme ekranları da ekleyebilirsiniz.

2.3 Giriş Haritalaması ve Dinamik Kontroller

Oyuncu girdileri (klavye, fare, gamepad) oyununuzla etkileşimin temelidir. Orvix Engine'in **Giriş Haritalaması (Input Map)** sistemi, bu girdileri daha soyut ve yönetilebilir "Aksiyonlar"a dönüştürmenizi sağlar. Bu, farklı cihazlar için kontrol şemalarını kolayca özelleştirebileceğiniz anlamına gelir.

Giriş Haritalaması Kurulumu

Orvix Editör'de: **Proje > Proje Ayarları > Giriş Haritası (Input Map)** sekmesine gidin. Burada yeni aksiyonlar (örneğin "ates_et", "zipla", "envanter_ac") tanımlayabilir ve bu aksiyonlara farklı tuşları veya fare düğmelerini atayabilirsiniz. Örneğin, "ates_et" aksiyonuna hem fare sol tuşunu hem de klavyeden `Space` tuşunu atayabilirsiniz. Bu, kontrol esnekliği sağlar.

Girdiyi Kodda Kullanma

Oyun içinde bu aksiyonları kontrol etmek için `Input` singleton'ını kullanırsınız. Önceki `Oyuncu.ovx` script'imizdeki hareket kontrolünü bu sisteme uyarlayabiliriz:

# Oyuncu.ovx - Geliştirilmiş Giriş Yönetimi
extends CharacterBody2D

@export var hiz = 250.0

func _physics_process(delta: float):
    var yon_girisi = Vector2.ZERO

    # Giriş eylemlerini kullanarak daha temiz ve esnek kod.
    # Kullanıcı bu aksiyonlara dilediği tuşu atayabilir.
    if Input.is_action_pressed("move_right"): # "move_right" gibi yeni aksiyonlar tanımlayın.
        yon_girisi.x += 1.0
    if Input.is_action_pressed("move_left"):
        yon_girisi.x -= 1.0
    if Input.is_action_pressed("move_down"):
        yon_girisi.y += 1.0
    if Input.is_action_pressed("move_up"):
        yon_girisi.y -= 1.0

    velocity = yon_girisi.normalized() * hiz
    move_and_slide()

    # Bir aksiyonun yalnızca bir kez basılmasını kontrol etme (örneğin zıplama veya ateş etme)
    if Input.is_action_just_pressed("ates_et"): # "ates_et" aksiyonu tanımlanmış olmalı
        print("Ateş edildi!")
        # Mermi oluşturma fonksiyonunu burada çağırabilirsiniz.

Bu yöntem, oyuncuların kendi kontrol şemalarını özelleştirmelerine olanak tanır ve gelecekte farklı platformlara (gamepad gibi) uyum sağlamayı kolaylaştırır.

Bölüm 3: Oyununu Geliştir | Seviye Tasarımı, Kamera ve Temel Yapay Zeka

Oyunun temel etkileşimlerini sinyaller ve GUI ile kurduktan sonra, sıra oyun dünyasını inşa etmeye geliyor. Bu bölümde, hızlı ve verimli seviye tasarımı için **TileMap** düğümünü, oyuncu hareketini takip eden bir **Kamera** sistemini ve oyununuza meydan okuma ekleyecek basit bir **Düşman Yapay Zekası** geliştirmeyi öğreneceksin.

3.1 Hızlı Seviye Oluşturma: TileMap (Döşeme Haritası)

TileMap, 2D oyunlarda seviye tasarlamanın en güçlü, en hızlı ve en verimli yoludur. Tek tek Sprite'ları manuel olarak yerleştirmek yerine, önceden hazırlanmış bir **TileSet** (döşeme kümesi) kullanarak haritanı sanki bir ressamın fırçasıyla boyar gibi oluşturabilirsin. Bu, büyük ve karmaşık seviyeleri inanılmaz bir hızla inşa etmene olanak tanır.

Adım 1: TileMap Düğümünü Kurma ve TileSet Oluşturma

Ana oyun sahnene (`AnaOyunSahnesi.tscn`) bir `TileMap` düğümü ekle. Bu düğüm, tüm harita döşemelerini içerecektir. Ardından, İnceleyici panelinde (Inspector) `TileMap` düğümünü seçiliyken, `Tile Set` özelliğine tıklayarak yeni bir `TileSet` kaynağı oluştur. Bu `TileSet`'e, haritanı oluşturan tüm görsel dosyalarını (örneğin zemin, duvar, platform görselleri) sürükleyip bırakarak döşemelerini (Tiles) tanımlayabilirsin. Her bir döşeme için çarpışma şekillerini, yansımaları veya özel verileri de ayarlayabilirsin.

Adım 2: Seviyeyi Tasarlama: Sanal Bir Ressam Gibi

`TileMap` düğümünü seçtiğinde, editörün üst kısmında özel TileMap düzenleme araçları belirecektir. Buradan farklı fırça araçlarını (tekli fırça, dikdörtgen, çizgi vb.) seçerek veya kütüphanendeki döşemeleri tek tek seçerek oyun haritanı Canvas (2D Görünüm Alanı) üzerine özgürce çizebilirsin. Fiziksel objeler (duvarlar, zeminler) için `Collision` (Çarpışma) katmanlarını da bu aşamada tanımlayabilirsin, böylece karakterlerin bu objelerle doğru bir şekilde etkileşim kurar.

3.2 Dinamik Kamera Takibi ve Viewport Yönetimi

Oyun dünyası genellikle oyuncu karakterinin hareketine göre kaymalıdır, böylece oyuncu her zaman ekranın merkezinde kalır ve çevresini görebilir. Bunu sağlamak için `Camera2D` düğümünü kullanacağız. `Camera2D`, oyun dünyasının belirli bir kısmını "görüntüleyen" ve bu görüntüyü oyuncunun ekranına yansıtan bir objektif gibidir.

Adım 1: Kamera Düğümünü Ekleme ve İlişkilendirme

Ana sahnedeki "Oyuncu" düğümünün (veya takip etmek istediğin herhangi bir düğümün) altına bir `Camera2D` düğümü ekle. Bu, kameranın her zaman karakterle aynı konumda olmasını, yani karakteri otomatik olarak takip etmesini sağlayacaktır. Bu hiyerarşik ilişki, kamera kodunu yazma ihtiyacını ortadan kaldırır.

Adım 2: Kamera Ayarları ve Optimizasyonlar

`Camera2D` düğümünü seç ve İnceleyici panelinden **"Current"** (Aktif) özelliğini işaretle. Bu, Orvix Engine'e oyun başlarken bu kamerayı kullanmasını söyler. Ayrıca, kameranın davranışını özelleştirmek için birçok ayar bulunur:

• Limitler (Limit): Kameranın belirli bir alanın dışına çıkmasını engellemek için sol, sağ, üst ve alt limitleri ayarlayabilirsin. Bu, seviyenin kenarlarını gizlemek için kullanışlıdır.
• Zoom (Yakınlaştırma): Kameranın yakınlaştırma seviyesini (`Zoom` özelliği) değiştirerek farklı oyun anları için görsel dinamizm sağlayabilirsin.
• Sürtünme (Drag Margin): Karakterin hareket ettiği yönde kameranın ne kadar gecikmeli takip edeceğini belirleyebilirsin. Bu, daha yumuşak ve akıcı kamera hareketleri için önemlidir.
• Vibra (Vibration): Oyun içindeki olaylara (patlamalar, hasar alma) tepki olarak kamerayı titretebilirsin, bu da oyunun etkisini artırır.

3.3 Basit Bir Düşman Yapay Zekası: Oyuncu Takibi

Oyununa biraz daha meydan okuma ve dinamizm eklemek için, oyuncuyu takip eden basit bir düşman oluşturalım. Bu, oyununuzda temel bir yapay zeka davranışının nasıl programlanacağını anlamanızı sağlayacak.

Adım 1: Düşman Karakteri Sahnesini Oluşturma

Yeni bir sahne oluştur ve ana düğüm olarak `CharacterBody2D` ekle. Adını "Düşman" olarak değiştir ve bu sahneyi `Düşman.tscn` olarak `res://dusmanlar/` klasörüne (oluşturun) kaydet. Karakterin görseli ve çarpışma şekli için bir `Sprite2D` ve `CollisionShape2D` eklemeyi unutma, tıpkı oyuncu karakterinde yaptığın gibi.

Adım 2: Düşman Yapay Zekası Kodu: Oyuncu Peşinde!

"Düşman" düğümüne bir GDScript (`Düşman.ovx`) ekle ve aşağıdaki kodu yaz. Bu kod, düşmanın her fizik adımında oyuncunun konumunu tespit etmesini ve ona doğru hareket etmesini sağlar. Ayrıca, düşmanı bir "düşmanlar" grubuna ekleyerek daha sonra mermilerle veya diğer etkileşimlerle kolayca hedef alabileceğiz.

# Düşman.ovx - Bu script, bir CharacterBody2D düğümüne eklendi.
extends CharacterBody2D

@export var hiz = 120.0 # Düşmanın hareket hızı
var oyuncu: CharacterBody2D = null # Oyuncu düğümünü tutacak değişken (tip ipucu)

# _ready fonksiyonu, düğüm sahne ağacına girdiğinde bir kez çağrılır.
func _ready():
    # Oyuncu düğümünü sahne ağacında "oyuncular" grubundan buluyoruz.
    # Oyuncuyu sahneye eklediğinizde bu gruba eklemeyi unutmayın!
    oyuncu = get_tree().get_first_node_in_group("oyuncular")
    if oyuncu is null:
        print("Hata: 'oyuncular' grubunda oyuncu bulunamadı!")
        queue_free() # Oyuncu yoksa düşmanı sil

# _physics_process, fiziksel hesaplamalar için sabit aralıklarla çağrılır.
func _physics_process(delta: float):
    if oyuncu:
        # Oyuncunun global pozisyonunu al ve ona doğru bir yön vektörü oluştur.
        # 'normalized()' vektörün büyüklüğünü 1 yapar, sadece yönü korur.
        var yon = (oyuncu.global_position - global_position).normalized()
        
        # Hız vektörünü ayarla (yön x hız).
        velocity = yon * hiz
        
        # Düşmanı hareket ettir ve çarpışmaları yönet.
        move_and_slide()
    else:
        # Oyuncu yoksa veya henüz bulunamadıysa düşmanı durdur.
        velocity = Vector2.ZERO
        move_and_slide()

# Oyuncuyu düşman grubuna eklemeyi unutma: Oyuncu düğümünü seç > Inspector > Node tab > Groups > "oyuncular" grubunu ekle.
# Ayrıca, düşmanı da "düşmanlar" grubuna ekleyebilirsin.

Önemli Not: Bu kodun doğru çalışması için, ana sahnenize eklediğiniz "Oyuncu" düğümüne **"oyuncular"** adında bir grup atamanız gerekir. Bunu, "Oyuncu" düğümünü editörde seçip, İnceleyici panelindeki "Düğüm" (Node) sekmesine giderek "Gruplar" (Groups) bölümünden yapabilirsiniz. Aynı şekilde, "Düşman" düğümlerinizi de "düşmanlar" adında bir gruba eklemek, gelecekteki mermi isabetleri gibi etkileşimleri kolaylaştıracaktır.

Bölüm 4: Profesyonel Dokunuşlar | Silah Mekanikleri, Efektler ve Ses Yönetimi

Oyunun temel seviye tasarımını ve yapay zekayı öğrendikten sonra, sıra onu aksiyon ve duyusal geri bildirimlerle doldurmaya geldi. Bu rehber sayfasında, oyununu daha çekici ve dinamik hale getirmek için mermi sistemleri, etkileyici partikül efektleri ve sürükleyici bir ses yönetimi gibi önemli konuları ele alacağız.

4.1 Mermi Sistemi Oluşturma ve Çarpışma Yönetimi

Oyuncunun düşmanlara veya diğer etkileşimli nesnelere saldırmasını sağlamak, birçok oyun türünün en temel mekaniklerinden biridir. Orvix Engine'de güçlü ve esnek bir mermi sistemi oluşturmak oldukça basittir, çünkü fizik motoru ve sinyal sistemi bunu destekler.

Adım 1: "Mermi" Sahnesini Oluşturma (Yeniden Kullanılabilir Obje)

Yeni bir sahne başlatın ve kök düğüm olarak `RigidBody2D` ekleyin. `RigidBody2D` düğümü, fizik kurallarına (yerçekimi, kuvvetler vb.) göre hareket eden nesneler için idealdir, ancak mermilerde genellikle yerçekimini kapatırız. Adını "Mermi" olarak değiştirin ve sahneyi `Mermi.tscn` olarak `res://savunma/mermiler/` klasörüne (oluşturun) kaydedin.

• `Sprite2D` Ekleme: Merminizin görseli için (örneğin `bullet.png`) bir `Sprite2D` düğümü ekleyin. Merminin ucunun sağa baktığından emin olun, çünkü başlangıç yönünü `Vector2.RIGHT` olarak ayarlayacağız.
• `CollisionShape2D` Ekleme: Merminin çarpışma alanını tanımlayan bir şekil (örneğin `RectangleShape2D` veya `CapsuleShape2D`) atayın. Mermiye uygun küçük bir çarpışma alanı olmalı.
• `Area2D` Ekleme (İsteğe Bağlı ama Önerilir): Eğer merminin sadece hasar vermekle kalmayıp, belirli alanlara girdiğinde de sinyal yaymasını istiyorsanız (örneğin, bir patlayıcı mermi), merminin altına bir `Area2D` düğümü ekleyebilirsiniz.

Merminin `RigidBody2D` düğümünü seçiliyken, İnceleyici panelinde `Mode` özelliğini `Character` veya `Kinematic` yerine `Rigid` olarak bırakın, ancak `Gravity Scale` (Yerçekimi Ölçeği) değerini `0` olarak ayarlayın. Ayrıca, `Physics Material` (Fizik Materyali) ayarlarını kontrol edin ve `Friction` (Sürtünme) ile `Bounce` (Sekme) değerlerini `0` olarak ayarlayarak merminin düz bir çizgide hareket etmesini sağlayın.

Mermi Kodu: Ateşleme ve Hasar Mekaniği

"Mermi" düğümüne bir GDScript (`Mermi.ovx`) ekleyin. Bu kod, merminin bir kez oluşturulduğunda kendi başına hareket etmesini ve bir nesneye çarptığında (özellikle bir düşmana) ne olacağını belirler. Hasar verme ve kendini silme mekanizmalarını içerecektir.

# Mermi.ovx - Bu script, bir RigidBody2D düğümüne eklendi.
extends RigidBody2D

@export var hiz = 800.0 # Merminin hızı (piksel/saniye)
@export var hasar_miktari = 10 # Merminin verdiği hasar
@export var yasam_suresi = 3.0 # Merminin ne kadar süre sonra kendiliğinden silineceği (saniye)

# '_ready' fonksiyonu, düğüm sahne ağacına girdiğinde bir kez çağrılır.
func _ready():
    # Mermiyi 'mermiler' grubuna ekleyin, böylece düşmanlar tarafından algılanabilir.
    add_to_group("mermiler")
    
    # Mermiye hareket yönünde (düğümün rotasyonu) bir başlangıç hızı ver.
    # 'linear_velocity' bir RigidBody2D'nin dahili bir özelliğidir.
    linear_velocity = Vector2.RIGHT.rotated(rotation) * hiz
    
    # Merminin belirli bir süre sonra kendini yok etmesini sağlayan bir zamanlayıcı başlat.
    var timer = get_tree().create_timer(yasam_suresi)
    timer.timeout.connect(queue_free) # Zamanlayıcı bittiğinde mermiyi sil.

# '_on_body_entered' sinyali, mermi başka bir fiziksel nesneye çarptığında tetiklenir.
# Bu sinyali Editörden, Mermi düğümünün CollisionShape2D'sinden veya RigidBody2D'sinden bağlayabilirsiniz.
func _on_body_entered(body: Node):
    # Çarpışılan nesnenin 'hasar_al' adında bir metodu olup olmadığını kontrol et.
    # Bu, düşmanlar, kırılabilir objeler vb. için geçerli olacaktır.
    if body.has_method("hasar_al"):
        body.hasar_al(hasar_miktari) # Hasar ver.
        
    # Çarptıktan sonra mermiyi sahneden sil.
    queue_free()

# Editörde mermi düğümünü seçin ve RigidBody2D panelindeki 'body_entered' sinyalini script'e bağlayın.
# Eğer Area2D eklediyseniz, Area2D'nin 'body_entered' veya 'area_entered' sinyallerini de kullanabilirsiniz.

Önemli Notlar:

• Mermi, başlangıçta döndüğü yöne doğru hareket edecektir. Oyuncu scriptinde mermi oluştururken `mermi_örneği.rotation = global_rotation` yaparak oyuncunun baktığı yöne doğru ateş etmesini sağlayabilirsiniz.
• Düşman karakterinizin scriptinde `hasar_al(miktari: int)` adında bir metod oluşturmanız gerekmektedir, böylece mermiden hasar alabilir.

Oyuncu Scriptinde Mermi Ateşleme Fonksiyonu

Şimdi, `Oyuncu.ovx` script'inize geri dönün ve oyuncunun bir tuşa bastığında (örneğin "ates_et" aksiyonu) mermi oluşturup fırlatmasını sağlayan kodu ekleyin. Bu, dinamik sahne oluşturma ve örnekleme kavramını da içerir.

# Oyuncu.ovx - Mermi ateşleme özelliği eklendi
extends CharacterBody2D

# ... (Önceki hareket ve puanlama kodu burada kalır) ...

# Mermi sahnesinin ön yüklemesi (pre-load). Bu, mermiyi hafızaya alır ve hızlıca örneklemeyi sağlar.
const MermiSahnesi = preload("res://savunma/mermiler/Mermi.tscn") # Kendi mermi sahnenizin yolunu girin!

# Merminin ortaya çıkacağı konum (örneğin, silahın ucu).
# Editörde Oyuncu düğümünün altına bir Marker2D düğümü ekleyip adını "MermiCikisNoktasi" yapın.
@onready var mermi_cikis_noktasi = $"MermiCikisNoktasi" 

func _physics_process(delta: float):
    # ... (Hareket kodu) ...

    # "ates_et" aksiyonuna basıldığında mermi ateşle.
    if Input.is_action_just_pressed("ates_et"):
        ates_et()

# 'ates_et' fonksiyonu, bir mermi örneği oluşturur ve onu sahneye ekler.
func ates_et():
    # Mermi sahnesinden yeni bir örnek oluştur.
    var yeni_mermi = MermiSahnesi.instantiate()
    
    # Merminin global pozisyonunu ve rotasyonunu oyuncunun mermi çıkış noktasına ayarla.
    yeni_mermi.global_position = mermi_cikis_noktasi.global_position
    yeni_mermi.rotation = global_rotation # Oyuncunun baktığı yöne doğru ateş etmesini sağlar.
    
    # Mermiyi ana sahnenin bir çocuğuna ekle (örn. get_parent() veya get_tree().current_scene).
    get_parent().add_child(yeni_mermi)
    # Oyunun ana Node'una eklemek daha iyi bir yöntem olabilir:
    # get_tree().get_current_scene().add_child(yeni_mermi)

Bu kodla, `ates_et` aksiyonuna basıldığında, oyuncunun konumunda yeni bir mermi oluşacak ve ateşleme sesini çalacak (eğer eklediysen). Bu, dinamik olarak nesne oluşturmanın ve sahne ağacına eklemenin temel yoludur.

4.2 Görsel Şölen: Partikül Sistemleri (CPUParticles2D / GPUParticles2D)

Görsel efektler (FX), oyunun canlı, tepkisel ve sürükleyici hissetmesini sağlayan en önemli unsurlardan biridir. Bir patlama, duman bulutu, karakterin ayak izi tozu veya sihirli parıltılar gibi efektler için Orvix Engine'in güçlü **Partikül Sistemlerini** kullanacağız. 2D için `CPUParticles2D` (CPU tabanlı, daha basit) veya `GPUParticles2D` (GPU tabanlı, daha performanslı ve karmaşık efektler için) düğümlerini kullanabiliriz.

Adım 1: Partikül Efekti Düğümünü Ekleme ve Temel Ayarlar

Merminin çarpışma noktasında bir patlama efekti veya oyuncunun ateş ettiğinde namludan çıkan duman efekti yaratmak için, ilgili sahnelerinize (örneğin "Mermi" sahnesine veya "Oyuncu" sahnesindeki mermi çıkış noktasına) bir `CPUParticles2D` düğümü ekle. Ardından, İnceleyici panelinde, partikül sisteminin özelliklerini kapsamlı bir şekilde özelleştirebilirsin:

• `Amount` (Miktar): Aynı anda ekranda bulunacak partikül sayısı. Performans ve görsel kalite arasında denge kurmak önemlidir.
• `Texture` (Doku): Partiküllerin görseli (örneğin küçük bir parıltı, duman resmi).
• `Emission Shape` (Yayılım Şekli): Partiküllerin hangi şekilden (örneğin, daire, küre, kutu, tek nokta) yayılacağını belirler. Patlama için daire, duman için tek nokta idealdir.
• `Lifetime` (Yaşam Süresi): Her bir partikülün ekranda ne kadar süre kalacağı (saniye). Efektin ne kadar kalıcı olacağını belirler.
• `Direction` (Yön) & `Spread` (Yayılma): Partiküllerin hangi yöne ve ne kadar açıyla yayılacağını belirler.
• `Speed` (Hız), `Gravity` (Yerçekimi), `Linear Accel` (Doğrusal Hızlanma): Partiküllerin hareket dinamiklerini kontrol eder.
• `Color` (Renk) ve `Scale` (Boyut) Rampaları: Partiküllerin yaşam süreleri boyunca renklerini ve boyutlarını animasyonlu olarak değiştirebilirsin. Örneğin, bir patlama partikülü başlangıçta sarıdan kırmızıya dönüp küçülerek kaybolabilir.

Partikül sistemleri oldukça esnektir ve sadece birkaç ayar değişikliğiyle alevden suya, sihirli parıltılardan yoğun dumana kadar her türlü efekti yaratabilirsin. **`One Shot`** özelliğini açarak, sistemin sadece bir kez tetiklenmesini (örneğin bir patlama için) ve ardından durmasını sağlayabilirsin.

Partikül Efektini Kodla Tetikleme

Partikül sistemini bir olayla (örneğin mermi çarpışması) tetiklemek için, genellikle `emitting` (yayılım) özelliğini `true` yaparak başlar ve ardından kısa bir süre sonra kendini silmesini sağlarsın. Partikül sistemlerini sahneye dinamik olarak ekleyip silmek daha verimlidir.

# Mermi.ovx - Partikül efekti tetikleme örneği
extends RigidBody2D

# ... (Diğer değişkenler ve fonksiyonlar) ...

# Patlama partikül sahnesinin ön yüklemesi.
const PatlamaEfektiSahnesi = preload("res://efektler/PatlamaEfekti.tscn") # Kendi patlama sahnenizin yolu

func _on_body_entered(body: Node):
    # Hasar verme kodu...
    
    # Patlama efektini oluştur ve oyna.
    var patlama_efekti = PatlamaEfektiSahnesi.instantiate()
    patlama_efekti.global_position = global_position # Merminin pozisyonunda oluşur
    get_tree().get_current_scene().add_child(patlama_efekti)
    
    # Eğer partikül sistemi 'One Shot' değilse, manuel olarak başlat.
    if !patlama_efekti.one_shot:
        patlama_efekti.emitting = true

    # Partikül efekti bittiğinde kendini silmesi için bir zamanlayıcı ayarla (eğer 'One Shot' değilse ve 'Autostart' kapalıysa)
    # Genellikle partikül efekti sahneleri 'One Shot' açık ve 'Autostart' açık olarak ayarlanır
    # ve 'Lifetime' süresinden sonra otomatik silinmeleri için bir 'Timer' eklenir.
    var efekti_sil_timer = get_tree().create_timer(patlama_efekti.lifetime + 0.5) # Küçük bir gecikme ekleyerek bitmesini bekle
    efekti_sil_timer.timeout.connect(patlama_efekti.queue_free)

    queue_free() # Mermiyi sil

Bu kodla, mermi herhangi bir şeye çarptığında dinamik bir patlama efekti oluşacak ve ardından hem mermi hem de efekt sahneden silinecektir.

4.3 Oyun Sesleri: Atmosferi Yaratma ve Duyusal Geri Bildirim

Ses, oyunun atmosferini güçlendiren, oyuncuya önemli geri bildirimler sağlayan ve genel deneyimi inanılmaz derecede zenginleştiren, genellikle göz ardı edilen ama en önemli unsurlardan biridir. Orvix Engine, ses dosyalarını yönetmek ve çalmak için güçlü **AudioStreamPlayer** düğümleri ve Audio Bus sistemi sunar.

Adım 1: Ses Düğümlerini Ekleme (2D, 3D ve Global)

Orvix'te üç ana ses düğümü vardır:

• `AudioStreamPlayer`: Genel sesler veya GUI sesleri gibi, 2D veya 3D uzayda belirli bir konuma bağlı olmayan sesler için kullanılır (örneğin ana menü müziği, buton tıklamaları).
• `AudioStreamPlayer2D`: 2D oyun dünyasındaki belirli bir konuma bağlı sesler için kullanılır (örneğin düşmanın adımları, merminin çarpması). Kamera uzaklaştıkça sesin şiddeti azalır.
• `AudioStreamPlayer3D`: 3D oyun dünyasındaki belirli bir konuma bağlı sesler için kullanılır. Uzamsal ses efektleri yaratır.

Oyununuzun arka plan müziği için ana sahnenize bir `AudioStreamPlayer` düğümü ekle ve ses dosyanı (örneğin `.ogg`, `.wav` veya `.mp3`) İnceleyici panelindeki "Stream" özelliğine sürükle. `Autoplay` özelliğini aktif ederek oyun başladığında müziğin otomatik olarak çalmasını sağlayabilirsin. Ses efektleri (örneğin mermi sesi, patlama sesi) için ise her etkileşimli objeye (oyuncu, düşman, mermi) veya efekt sahnesine birer `AudioStreamPlayer2D` düğümü eklemelisin.

Adım 2: Koduyla Ses Oynatma ve Yönetimi

Bir sesi kod ile oynatmak oldukça basittir. Genellikle ilgili `AudioStreamPlayer` düğümüne bir referans alırsın ve ardından `play()` metodunu çağırırsın:

# Oyuncu.ovx - Ateş sesi örneği
extends CharacterBody2D

# ... (Önceki kodlar) ...

# Ateş sesi için AudioStreamPlayer2D düğümüne referans al.
# Bu düğümü Oyuncu sahnesinin altına eklemeyi unutmayın!
@onready var ates_sesi = $"AtesSesiPlayer" # Düğüm yolunuza göre ayarlayın.

# 'ates_et' fonksiyonu içindeki ses çalma.
func ates_et():
    # ... mermi oluşturma kodları ...
    
    # Sesi baştan başlat ve çal.
    ates_sesi.play()