[GDScript/tr-tr] translate (#5012)

2024-12-23 17:41:41 +00:00 · 2024-08-30 06:25:04 +03:00 · 2024-08-30 06:25:04 +03:00 · 6dc0d4c0ca
commit 6dc0d4c0ca
parent 065116cdd5
1 changed files with 372 additions and 0 deletions
--- a/tr-tr/gdscript-tr.html.markdown
+++ b/tr-tr/gdscript-tr.html.markdown
@ -0,0 +1,372 @@
+---
+language: GDScript
+contributors:
+    - ["Wichamir", "https://github.com/Wichamir/"]
+    - ["zacryol", "https://github.com/zacryol"]
+filename: learngdscript.gd
+translators:
+    - ["R1cHero", "https://github.com/R1cHero"]
+lang: tr-tr
+---
+
+GDScript, özgür ve açık kaynaklı oyun motoru olan Godot için dinamik ve statik olarak 
+yazılmış bir kodlama dilidir. Yazılış şekli Python'a biraz benzerdir. 
+Başlıca avantajları kullanım kolaylığı ve motorla olan uyumudur. 
+Oyun geliştirme için mükemmel bir uyum sağlar.
+
+## Temeller
+
+```gdscript
+# Tek satırlık yorumlar, '#' simgesi kullanılarak yazılır.
+"""
+  Çok 
+  satırlı
+  yorumlar
+  üç
+  tırnak
+  kullanılarak
+  yazılır
+"""
+
+# Belge yorumları (Doc Comments) sınıflara ve alanlara açıklama ekleyebilir.
+# bunlar, motor içi dokümanlarda görüntülenebilir.
+
+## Bu sınıf, GDScript'in bir gösterimidir
+
+# Komut dosyası kendi başına bir sınıftır ve isteğe bağlı olarak bunun için bir ad tanımlayabilirsiniz.
+class_name MyClass
+
+# Kalıtım (Inheritance) komut dosyasının bağlı olduğu Node'a göre 'Node2D' kısmı değişkenlik gösterir.
+extends Node2D
+
+# Değişken türleri
+var x = 8 # int
+var y = 1.2 # float
+var b = true # bool
+var s = "Merhaba Dünya!" # String
+var a = [1, false, "turuncu kedi"] # Array - Python'daki listeye benzer,
+                                # aynı anda farklı tipte 
+                                # değişkenleri tutabilir.
+var d = {
+  "key" : "value",
+  42 : true
+} # Sözlük anahtar-değer (key-value) çiftlerini tutar.
+var p_arr = PackedStringArray(["Hey", "selamlar", "!"]) # Paketlenmiş diziler yalnızca
+                                                    # belirli bir türü tutabilir.
+
+# Doküman yorumları, özelliklere uygulanabilir.
+
+## Bu değişken nesnenin kaç kez zıpladığını tutar.
+var jump_count = 0
+
+# Motorda bulunan yerleşik vektör türleri:
+var v2 = Vector2(1, 2)
+var v3 = Vector3(1, 2, 3)
+
+# Sabitler (Constants)
+const ANSWER_TO_EVERYTHING = 42
+const BREAKFAST = "Sucuklu yumurta!"
+
+# Enumlar
+enum { ZERO, ONE , TWO, THREE }
+enum NamedEnum { ONE = 1, TWO, THREE }
+
+# Dışa aktarılan değişkenler 'inspector' de görünür.
+#
+# Editörün hangi seçenekleri vereceğini bilmesi için bir tür ipucu (daha sonra açıklanacaktır) 
+# veya varsayılan bir değere ihtiyaç vardır.
+@export var age: int
+@export var height: float
+@export var person_name = "Ahmet"
+# Ama ikisi de kabul edilebilir.
+@export var favorite_color: String = "Kırmızı"
+@export var favorite_food := "Lahmacun"
+
+# Fonksiyonlar
+func foo():
+  pass # pass anahtar sözcüğü gelecekteki yazılacak olan kod için bir yer tutucudur. 
+       # Editörde hata olarak göstermesini engellemek için de kullanılır.
+
+func add(first, second):
+  return first + second
+
+# Fonksiyonlar üzerinde doküman yorumları yazma
+
+## Zıplama Sayısını Artırma
+func jump():
+  jump_count += 1
+
+# Değerleri yazdırma
+func printing():
+  print("GDScript ", "mükemmel.")
+  prints("Bu", "kelimeler", "boşluklarla", "ayrıldı.")
+  printt("Bu", "kelimeler", "tablarla", "ayrıldı.")
+  printraw("Bu sistem konsoluna yazdırılır.")
+  printerr("Bu konsolda hata olarak gösterilir.")
+
+  # İsimsiz fonksiyonlar (Lambdas)
+  var my_lambda = func(): print("lambda'dan merhaba!")
+
+  my_lambda.call()
+
+# Matematik
+func doing_math():
+  var first = 8
+  var second = 4
+  print(first + second) # 12
+  print(first - second) # 4
+  print(first * second) # 32
+  print(first / second) # 2
+  print(first % second) # 0
+  # Ayrıca bunlar var +=, -=, *=, /=, %= vb.,
+  # ++ veya -- operatörleri yok.
+  print(pow(first, 2)) # 64
+  print(sqrt(second)) # 2
+  printt(PI, TAU, INF, NAN) # Yerleşik (built-in) sabitler (constants)
+
+# Kontrol akışı
+func control_flow():
+  x = 8
+  y = 2 # y orjinalde float'dı,
+        # ancak "dynamic typing" gücünü kullanarak 
+        # tipini int'e değiştirebiliriz!
+
+  if x < y:
+    print("x, y'den küçüktür.")
+  elif x > y:
+    print("x, y'den büyüktür.")
+  else:
+    print("x ve y eşittir.")
+
+  var a = true
+  var b = false
+  var c = false
+  if a and b or not c: # alternatif olarak bunları kullanabilirsiniz: &&, || ve !
+    print("Değer: true")
+
+  for i in range(20): # GDScript'de "range" Python'dakine benzerdir.
+    print(i) # bu 0'dan 19'a kadar sayıları yazdıracaktır.
+
+  for i in 20: # Python'dan farklı olarak, doğrudan bir int üzerinde "range" kullanmadan döngüye girebilirsiniz.
+    print(i) # bu da 0'dan 19'a kadar olan sayıları da yazdıracaktır.
+
+  for i in ["two", 3, 1.0]: # Bir dizi üzerinde yineleme (iterasyon) yapma.
+    print(i)
+
+  while x > y:
+    printt(x, y)
+    y += 1
+
+  x = 2
+  y = 10
+  while x < y:
+    x += 1
+    if x == 6:
+      continue # 6, "continue" ifadesi nedeniyle yazdırılmayacak.
+    prints("x eşittir:", x)
+    if x == 7:
+      break # döngü 7'de duracak, bu yüzden 8, 9 ve 10 yazdırılmayacak.
+
+  match x:
+    1:
+      print("Match, switch'e benzerdir.")
+    2:
+      print("Ancak her değerden önce "case" koymanıza gerek yok.")
+    3:
+      print("Ayrıca her "case" varsayılan olarak durdurulur.")
+      break # HATA! "Break" ifadesi gereksiz!
+    4:
+      print("Eğer "fallthrough" kullanmaya ihtiyacınız varsa "continue" kullanın.")
+      continue
+    _:
+      print("Alt çizgi varsayılan bir "case"dir.")
+
+  # Üç terimli operatör (tek satırda yazılabilen if-else)
+  prints("x", "pozitif" if x >= 0 else "negatif")
+
+# Bir veri tipini başka bir veri tipine dönüştürme (Casting)
+func casting_examples():
+  var i = 42
+  var f = float(42) # Değişkenlerin kurucusunu (constructor) kullanarak
+  var b = i as bool # veya "as" anahtar kelimesini kullanarak tür dönüştürme (casting)
+
+# Override fonksiyonlar
+# Built-in kurallı "overridable functions" bir alt çizgi ile başlar
+# ama pratikte hemen hemen her fonksiyonu geçersiz kılabilirsiniz.
+
+# _init nesne başlatıldığında çağrılır.
+# Bu, nesnenin kurucusudur (constructor).
+func _init():
+  # Burada nesnenin iç öğelerini başlatın.
+  pass
+
+# _ready, komut dosyasında
+# node ve children node sahneye girdiğinde çağrılır.
+func _ready():
+  pass
+
+# _process her karede çağrılır.
+func _process(delta):
+  # Bu fonksiyona iletilen delta argümanı,
+  # son kare ile anlık kare arasında geçen saniye sayısıdır.
+  print("Delta zamanı: ", delta)
+
+# _physics_process her fizik karesinde çağrılır.
+# Deltanın sabit olması gerektiği anlamına gelir.
+func _physics_process(delta):
+  # Vektör toplama ve çarpma kullanarak hareket ettirme.
+  var direction = Vector2(1, 0) # ya da Vector2.RIGHT
+  var speed = 100.0
+  self.global_position += direction * speed * delta
+  # self geçerli sınıf örneğini belirtir.
+
+# Geçersiz kılma sırasında, buradaki gibi nokta operatörünü kullanarak 
+# parent işlevini çağırabilirsiniz:
+func get_children():
+  # Bazı ek şeyler ekleyebilirsiniz.
+  var r = super() # Parent implementasyonunu çağırma 
+  return r
+
+# Dahili sınıflar (Inner class)
+class InnerClass:
+  extends Object
+
+  func hello():
+    print("Dahili sınıftan merhabalar!")
+
+func use_inner_class():
+  var ic = InnerClass.new()
+  ic.hello()
+  ic.free() # Ramde yer açmak için "free" kullanın.
+```
+
+## Sahne ağacındaki (Scene Tree) diğer node'lara erişim
+
+```gdscript
+extends Node2D
+
+var sprite # Bu değişken referansı tutacak.
+
+# _ready'de diğer node'lara referanslar alabilirsiniz.
+func _ready() -> void:
+  # "NodePath" node'lara erişmek için kullanışlıdır.
+  var path1 = NodePath("path/to/something")
+  # Ya da böyle kullanabilirsiniz:
+  var path2 = ^"path/to/something"
+  # NodePath örnekleri:
+  var path3 = ^"Sprite" # geçerli node'un child node'u
+  var path4 = ^"Timers/Firerate" # child node'un child node'u
+  var path5 = ^".." # geçerli node'un parent node'u
+  var path6 = ^"../Enemy" # geçerli node'un kardeşi
+  var path7 = ^"/root" # ana yol, get_tree().get_root() ile eşdeğerdir.
+  var path8 = ^"/root/Main/Player/Sprite" # Player'ın Sprite'ına giden ana yol
+  var path9 = ^"Timers/Firerate:wait_time" # özelliklere erişme
+  var path10 = ^"Player:position:x" # alt özelliklere erişim
+
+  # Son olarak, referans almak için bunlardan birini kullanabilirsiniz:
+  sprite = get_node(^"Sprite") as Sprite # her zaman belirttiğiniz türü yazın
+  sprite = get_node("Sprite") as Sprite # burada String
+                                        # NodePath'e dönüştürülür
+  sprite = get_node(path3) as Sprite
+  sprite = get_node_or_null("Sprite") as Sprite
+  sprite = $Sprite as Sprite
+
+func _process(delta):
+  # Artık referansı başka yerlerde tekrar kullanabiliriz.
+  prints("Sprite has global_position of", sprite.global_position)
+
+# _ready çalıştırılmadan hemen önce 
+# bir değişkene değer atamak için @onready kullanın.
+@onready var other_sprite = $Sprite as Sprite
+
+# NodePath'i dışa aktarabilir, böylece onu "inspector" içinde atama yapabilirsiniz.
+@export var nodepath = ^""
+@onready var reference = get_node(nodepath) as Node
+
+# Veya Node'u doğrudan dışa aktarın
+@export var other_reference: Node
+```
+
+## Sinyaller (Signals)
+
+Sinyal sistemi Godot'nun gözlemci programlama modelinin uygulamasıdır. 
+İşte bir örnek:
+
+```gdscript
+class_name Player extends Node2D
+
+var hp = 10
+
+# Belge yorumları sinyallere de yansıyabilir
+
+## Oyuncu öldüğünde sinyal gönderir (emit).
+signal died() # sinyali tanımlama
+signal hurt(hp_old, hp_new) # sinyallere değişken tanımlanabilir.
+
+func apply_damage(dmg):
+  var hp_old = hp
+  hp -= dmg
+  hurt.emit(hp_old, hp) # sinyal gönderme ve değişkenleri iletme
+  if hp <= 0:
+    died.emit()
+
+func _ready():
+  # "died" sinyali kendi içinde tanımlanan "_on_death" fonksiyonuna bağlama 
+  died.connect(_on_death)
+  # Hedef nesne kendisi değilse 
+  # alternatif bir yol gerekir.
+  # died.connect(Callable(self, &"_on_death"))
+
+func _on_death():
+  queue_free() # oyuncu öldüğünde sahneden siler
+```
+
+## Faydalı İpuçları
+
+GDScript'te hem kod netliği hem de performans avantajları için
+opsiyonel olarak "static typing" kullanılabilir.
+
+```gdscript
+extends Node
+
+var x: int # değişkenin türünü belirtme
+var y: float = 4.2
+var z := 1.0 # ":=" operatörünü kullanmak üstteki tanımlama ile aynıdır.
+
+var a: Array[int] = [1, 2, 3] # Dizinin tür içeriğini belirtme
+
+enum NamedEnum { ONE = 1, TWO, THREE }
+var n: NamedEnum = NamedEnum.ONE # Enum da bir tür olarak kullanılabilir.
+
+@onready var node_ref_typed := $Child as Node
+
+@export var speed := 50.0
+
+const CONSTANT := "Bu bir sabit atamadır (constant)."
+
+signal example(arg: int)
+
+func _ready() -> void:
+  # fonksiyon hiçbir şey döndürmez
+  x = "string" # HATA! Tür değiştirilemez!
+  a.append("q") # HATA! Array[int] string tutamaz!
+  return
+
+func join(arg1: String, arg2: String) -> String:
+  # Fonksiyon iki tane string alır ve bir tane string döndürür.
+  return arg1 + arg2
+
+func get_child_at(index: int) -> Node:
+  # Fonksiyon int alır ve node döndürür.
+  return get_children()[index]
+```
+
+## Daha fazla bilgi almak için
+
+* [Godot's Website](https://godotengine.org/)
+* [Godot Docs](https://docs.godotengine.org/en/stable/)
+* [Getting started with GDScript](https://docs.godotengine.org/en/stable/getting_started/scripting/gdscript/index.html)
+* [NodePath](https://docs.godotengine.org/en/stable/classes/class_nodepath.html)
+* [Signals](https://docs.godotengine.org/en/stable/getting_started/step_by_step/signals.html)
+* [GDQuest](https://www.gdquest.com/)
+* [GDScript.com](https://gdscript.com/)