diff --git a/installer/examples/othello/menu_tr.kojo.installed b/installer/examples/othello/menu_tr.kojo.installed new file mode 100644 index 00000000..bf015cf1 --- /dev/null +++ b/installer/examples/othello/menu_tr.kojo.installed @@ -0,0 +1,78 @@ +//#include tr/anaTanimlar +//#include tr/eTahta +//#include tr/araYuz +//#include tr/alfabeta + +val açıklama = + KojOtello'ya hoşgeldin! Bu güzel oyun hakkında bilgi edinmek için +
+ internette "wiki reversi" diye arama yapabilirsin. + .toString + +val ay_çeşniler = ay.Salındıraç("geleneksel", "bir çeşni") +val ay_tahta = ay.Salındıraç(8, 4, 5, 6, 7, 8, 9, 10, 11, 12) +val ay_tahta2 = ay.Salındıraç(7, 8, 9, 10, 11, 12) // todo +val ay_ilk = ay.Salındıraç("Siyah", "Beyaz") +val ay_düzey = ay.Salındıraç("Er", "Çırak", "Kalfa", "Usta", "Doktor", "Deha") +val ay_bilgisayar = ay.Salındıraç( + "Oynamasın", + "Siyahları oynasın", + "Beyazları oynasın" +) + +def menu: Birim = { + silVeSakla + çizMerkezde(büyüt(1.8) -> + Resim.arayüz( + ay.Sütun( + ay.Sıra(ay.Tanıt(açıklama)), + ay.Sıra(ay.Tanıt("Başlangıç taşları:"), ay_çeşniler), + ay.Sıra(ay.Tanıt("Tahta:"), ay_tahta), + ay.Sıra(ay.Tanıt("Kim başlar:"), ay_ilk), + ay.Sıra(ay.Tanıt("Düzey:"), ay_düzey), + ay.Sıra(ay.Tanıt("Bilgisayar:"), ay_bilgisayar), + ay.Sıra(ay.Düğme("Oyna!") { + val odaSayısı = ay_tahta.value + val çeşni = ay_çeşniler.value match { + case "geleneksel" => 0 + case _ => 1 + } + var sorunYok = doğru + if (çeşni != 0) { + if (odaSayısı < 7) { + satıryaz("Çeşnili başlangıç taşları için 7x7 ya da daha iri bir tahta seç!") + sorunYok = yanlış + } + } + val kimBaşlar = ay_ilk.value match { + case "Siyah" => Siyah + case _ => Beyaz + } + val düzey = ay_düzey.value match { + case "Er" => Er + case "Çırak" => Çırak + case "Kalfa" => Kalfa + case "Usta" => Usta + case "Doktor" => Doktor + case "Deha" => Deha + case _ => Kalfa + } + val bilgisayar = ay_bilgisayar.value match { + case "Siyahları oynasın" => Siyah + case "Beyazları oynasın" => Beyaz + case "Oynamasın" => Yok + case _ => Yok + } + if (sorunYok) { + val tahta = new ETahta(odaSayısı, kimBaşlar, çeşni) + val bellek = new Bellek(tahta) + çıktıyıSil + ABa.ustalık(düzey) + new Arayüz(tahta, bellek, bilgisayar) + } + }) + ) + ) + ) +} +menu diff --git a/installer/examples/othello/tr/alfabeta.kojo b/installer/examples/othello/tr/alfabeta.kojo new file mode 100644 index 00000000..325a3f72 --- /dev/null +++ b/installer/examples/othello/tr/alfabeta.kojo @@ -0,0 +1,318 @@ +//#include tr/anaTanimlar + +object ABa { // alfa-beta arama + def hamleYap(durum: Durum): Belki[Oda] = { + var çıktı: Belki[Oda] = Hiçbiri + zamanTut(s"Alfa-beta ${düzeydenUstalığa} arama") { + çıktı = alfaBetaHamle(durum) + }("sürdü") + çıktı + } + + def alfaBetaHamle(durum: Durum): Belki[Oda] = + if (durum.seçenekler.isEmpty) Hiçbiri + else // todo: karşı oyuncunun skorunu azaltan birden çok hamle varsa rastgele seç + Biri((for (hamle <- durum.seçenekler) yield hamle -> + abHamle(durum.oyna(hamle), aramaDerinliğiSınırı) + ).minBy(_._2)._1) + + // todo: yasal hamle olmadığı zaman arama kısa kesilmemeli! + def abHamle(durum: Durum, derinlik: Sayı): Sayı = + if (durum.bitti || derinlik == 0 || durum.seçenekler.isEmpty) durum.skor + else azalt(durum, derinlik, Int.MinValue, Int.MaxValue) // todo + + def azalt(durum: Durum, derinlik: Sayı, alfa: Sayı, beta: Sayı): Sayı = + if (durum.bitti || derinlik == 0 || durum.seçenekler.isEmpty) durum.skor + else { + var yeniBeta = beta + durum.seçenekler.foreach { hamle => // onun hamleleri + val yeniDurum = durum.oyna(hamle) + yeniBeta = enUfağı(yeniBeta, artır(yeniDurum, derinlik - 1, alfa, yeniBeta)) + if (alfa >= yeniBeta) return alfa + } + yeniBeta + } + def artır(durum: Durum, derinlik: Sayı, alfa: Sayı, beta: Sayı): Sayı = + if (durum.bitti || derinlik == 0 || durum.seçenekler.isEmpty) durum.skor + else { + var yeniAlfa = alfa + durum.seçenekler.foreach { hamle => + val yeniDurum = durum.oyna(hamle) + yeniAlfa = enİrisi(yeniAlfa, azalt(yeniDurum, derinlik - 1, yeniAlfa, beta)) + if (yeniAlfa >= beta) return beta + } + yeniAlfa + } + + def ustalık(derece: Ustalık) = { + aramaDerinliğiSınırı = derece match { + case Er => 3 + case Çırak => 4 + case Kalfa => 5 + case Usta => 6 + case Doktor => 7 + case Aheste => 7 + case Deha => 8 + case ÇokSabır => 8 + case _ => 5 + } + } + def düzeydenUstalığa: Ustalık = + if (aramaDerinliğiSınırı < 3) ErdenAz + else if (aramaDerinliğiSınırı > 8) DehadanÇok + else { + aramaDerinliğiSınırı match { + case 3 => Er + case 4 => Çırak + case 5 => Kalfa + case 6 => Usta + case 7 => Doktor + case 8 => Deha + } + } + var aramaDerinliğiSınırı = 3 + +} + +class Durum(val tahta: Tahta, val sıra: Taş) { + val karşıTaş = if (sıra == Beyaz) Siyah else Beyaz + def skor = tahta.durum(sıra) - tahta.durum(karşıTaş) + def bitti = oyunBittiMi + def oyunBittiMi = { + if (yasallar.size > 0) yanlış else { + val yeni = new Durum(tahta, karşıTaş) + yeni.yasallar.size == 0 + } + } + def seçenekler = yasallar + def yasallar = tahta.yasallar(sıra) + def oyna(oda: Oda) = { + val yTahta = tahta.oyna(sıra, oda) + new Durum(yTahta, karşıTaş) + } +} + +class Tahta(val tane: Sayı, val tahta: Sayılar) { + def durum(t: Taş) = { + say(t) // + 4 * isay(t)(köşeMi) + 2 * isay(t)(köşeyeİkiUzakMı) + // + isay(t)(içKöşeMi) + // - 2 * isay(t)(tuzakKöşeMi) - isay(t)(tuzakKenarMı) + // + } + def yaz(msj: Yazı = "", tab: Yazı = "") = { + for (y <- satırAralığıSondan) { + val satır = for (x <- satırAralığı) yield s2t(tahta(y * tane + x)) + satıryaz(satır.mkString(s"$tab", " ", "")) + } + if (msj.size > 0) satıryaz(msj) + satıryaz(s"$tab Beyazlar: ${say(Beyaz)} durum: ${durum(Beyaz)}") + satıryaz(s"$tab Siyahlar: ${say(Siyah)} durum: ${durum(Siyah)}") + } + def koy(oda: Oda, taş: Taş) = { + new Tahta(tane, tahta.updated(oda.y * tane + oda.x, t2s(taş))) + } + def koy(odalar: Dizi[Oda], taş: Taş) = { + var yeni = tahta + for (o <- odalar) { yeni = yeni.updated(o.y * tane + o.x, t2s(taş)) } + new Tahta(tane, yeni) + } + def taş(o: Oda): Taş = s2t(tahta(o.y * tane + o.x)) + def oyunVarMı(oyuncu: Taş) = yasallar(oyuncu).size > 0 + def yasallar(oyuncu: Taş) = { + (for (y <- satırAralığı; x <- satırAralığı if taş(Oda(y, x)) == Yok) + yield Oda(y, x)) filter { çevirilecekKomşuDiziler(oyuncu, _).size > 0 } + } + def oyna(oyuncu: Taş, oda: Oda) = { + val odalar = EsnekDizim(oda) + val karşı = if (oyuncu == Beyaz) Siyah else Beyaz + çevirilecekKomşuDiziler(oyuncu, oda).foreach { komşu => + odalar += komşu.oda + gerisi(komşu).takeWhile(taş(_) == karşı).foreach { o => odalar += o } + } + koy(odalar.dizi, oyuncu) + } + + private def çevirilecekKomşuDiziler(oyuncu: Taş, oda: Oda): Dizi[Komşu] = + komşularıBul(oda) filter { komşu => + val karşı = if (oyuncu == Beyaz) Siyah else Beyaz + taş(komşu.oda) == karşı && sonuDaYasalMı(komşu, oyuncu)._1 + } + + private def komşularıBul(o: Oda): Dizi[Komşu] = Dizi( + Komşu(D, Oda(o.y, o.x + 1)), Komşu(B, Oda(o.y, o.x - 1)), + Komşu(K, Oda(o.y + 1, o.x)), Komşu(G, Oda(o.y - 1, o.x)), + Komşu(KD, Oda(o.y + 1, o.x + 1)), Komşu(KB, Oda(o.y + 1, o.x - 1)), + Komşu(GD, Oda(o.y - 1, o.x + 1)), Komşu(GB, Oda(o.y - 1, o.x - 1))) filter { + k => odaMı(k.oda) + } + + private def sonuDaYasalMı(k: Komşu, oyuncu: Taş): (İkil, Sayı) = { + val diziTaşlar = gerisi(k) + val sıraTaşlar = diziTaşlar.dropWhile { o => + taş(o) != oyuncu && taş(o) != Yok + } + if (sıraTaşlar.isEmpty) (yanlış, 0) else { + val oda = sıraTaşlar.head + (taş(oda) == oyuncu, 1 + diziTaşlar.size - sıraTaşlar.size) + } + } + private def gerisi(k: Komşu): Dizi[Oda] = { + val sıra = EsnekDizim.boş[Oda] + val (x, y) = (k.oda.x, k.oda.y) + k.yön match { + case D => for (i <- x + 1 to sonOda) /* */ sıra += Oda(y, i) + case B => for (i <- x - 1 to 0 by -1) /**/ sıra += Oda(y, i) + case K => for (i <- y + 1 to sonOda) /* */ sıra += Oda(i, x) + case G => for (i <- y - 1 to 0 by -1) /**/ sıra += Oda(i, x) + case KD => // hem y hem x artacak + if (x >= y) for (i <- x + 1 to sonOda) /* */ sıra += Oda(y + i - x, i) + else for (i <- y + 1 to sonOda) /* */ sıra += Oda(i, x + i - y) + case GB => // hem y hem x azalacak + if (x >= y) for (i <- y - 1 to 0 by -1) /* */ sıra += Oda(i, x - y + i) + else for (i <- x - 1 to 0 by -1) /* */ sıra += Oda(y - x + i, i) + case KB => // y artacak x azalacak + if (x + y >= sonOda) for (i <- y + 1 to sonOda) /**/ sıra += Oda(i, x + y - i) + else for (i <- x - 1 to 0 by -1) /* */ sıra += Oda(y + x - i, i) + case GD => // y azalacak x artacak + if (x + y >= sonOda) for (i <- x + 1 to sonOda) /**/ sıra += Oda(y + x - i, i) + else for (i <- y - 1 to 0 by -1) /* */ sıra += Oda(i, x + y - i) + } + sıra.dizi + } + + val sonOda = tane - 1; val son = sonOda + val satırAralığı = 0 to sonOda + val satırAralığıSondan = sonOda to 0 by -1 + + def tuzakKenarMı: Oda => İkil = { + case Oda(str, stn) => str == 1 || stn == 1 || str == sonOda - 1 || stn == sonOda - 1 + } + def tuzakKöşeMi: Oda => İkil = { + case Oda(y, x) => (x == 1 && (y == 1 || y == sonOda - 1)) || + (x == sonOda - 1 && (y == 1 || y == sonOda - 1)) + } + def köşeMi: Oda => İkil = { + case Oda(str, stn) => if (str == 0) stn == 0 || stn == sonOda else + str == sonOda && (stn == 0 || stn == sonOda) + } + def köşeyeİkiUzakMı: Oda => İkil = { + case Oda(y, x) => + ((y == 0 || y == son) && (x == 2 || x == son - 2)) || + ((y == 2 || y == son - 2) && + (x == 0 || x == 2 || x == son - 2 || x == son)) + } + def içKöşeMi: Oda => İkil = { + case Oda(y, x) => (x == 2 && (y == 2 || y == sonOda - 2)) || + (x == sonOda - 2 && (y == 2 || y == sonOda - 2)) + } + def odaMı: Oda => İkil = { + case Oda(y, x) => 0 <= y && y < tane && 0 <= x && x < tane + } + def isay(t: Taş)(iş: Oda => İkil) = (for (x <- satırAralığı; y <- satırAralığı; if taş(Oda(y, x)) == t && iş(Oda(y, x))) yield 1).size + def say(t: Taş) = isay(t) { o => doğru } + + private def t2s(t: Taş) = t match { + case Beyaz => 1 + case Siyah => 2 + case _ => 0 + } + private def s2t(s: Sayı) = s match { + case 1 => Beyaz + case 2 => Siyah + case _ => Yok + } +} + +def yeniTahta(tane: Sayı, çeşni: Sayı = 0): Tahta = { + var t = new Tahta(tane, Vector.fill(tane * tane)(0)) + + def diziden(dizi: Dizi[(Sayı, Sayı)])(taş: Taş) = t = t.koy(dizi.map(p => Oda(p._1, p._2)), taş) + def dörtTane: Oda => Birim = { + case Oda(y, x) => + diziden(Dizi((y, x), (y + 1, x + 1)))(Beyaz) + diziden(Dizi((y + 1, x), (y, x + 1)))(Siyah) + } + val orta: Sayı = tane / 2 + val son = tane - 1 + çeşni match { + case 2 => // boş tahtayla oyun başlayamıyor + case 1 => + gerekli((tane > 6), "Bu çeşni için 7x7 ya da daha iri bir tahta gerekli") + dörtTane(Oda(1, 1)) + dörtTane(Oda(son - 2, son - 2)) + dörtTane(Oda(1, son - 2)) + dörtTane(Oda(son - 2, 1)) + case _ => + val çiftse = tane % 2 == 0 + if (çiftse) dörtTane(Oda(orta - 1, orta - 1)) + else { + val (a, b) = (orta - 1, orta + 1) + diziden(Dizi(a -> a, b -> b))(Beyaz) + diziden(Dizi((a, b), (b, a)))(Siyah) + if (yanlış) { // (a, b) odaları boş kalıyor her a ve b çift sayısı için + diziden(Dizi(a + 1 -> a, (b - 1, b)))(Beyaz) + diziden(Dizi((a, b - 1), (b, a + 1)))(Siyah) + } + else { + diziden(Dizi((a + 1, a), (a + 1, b), (b + 1, b - 1), (a - 1, b - 1)))(Beyaz) + diziden(Dizi((a, a + 1), (b, a + 1), (a + 1, a - 1), (a + 1, b + 1)))(Siyah) + } + } + } + t +} + +var i = 0 +class Oyun(tane: Sayı) { + val t = yeniTahta(tane) + val durum = new Durum(t, Siyah) + + def oyna: Durum = döngü(durum) + + import scala.annotation.tailrec + @tailrec + private def döngü(durum: Durum): Durum = { + durum.tahta.yaz("döngü") + i += 1 + if (durum.oyunBittiMi) return durum + if (i > tane * tane) { satıryaz("çok uzadı!"); return durum } + val hamle = ABa.hamleYap(durum) match { + case Biri(oda) => oda + case _ => ABa.hamleYap(new Durum(durum.tahta, durum.karşıTaş)) match { + case Biri(oda) => oda + case _ => throw new Exception("Burada olmamalı") + } + } + val yeni = durum.oyna(hamle) + satıryaz(s"$i. hamle ${durum.sıra} $hamle:") + döngü(yeni) + } +} + +def dene1 = { + val tane = 4 + var t = new Tahta(tane, Vector.fill(tane * tane)(0)) + satıryaz("t"); t.yaz() + val foo = t.koy(Oda(1, 1), Beyaz) + t = t.koy(Dizi(Oda(2, 2), Oda(3, 3)), Beyaz) + t = t.koy(Dizi(Oda(2, 3), Oda(3, 2)), Siyah) + val t2 = t.oyna(Siyah, Oda(1, 2)) + satıryaz("t2"); t2.yaz() + val t3 = t2.oyna(Beyaz, Oda(1, 3)) + satıryaz("t3"); t3.yaz() + satıryaz("t"); t.yaz() + foo.yaz() +} + +def dene2 = { + çıktıyıSil + val o = new Oyun(4) + //ABa.ustalık(Çırak) + ABa.aramaDerinliğiSınırı = 2 + o.oyna +} +//dene1 +/* Bu yazılımcığı otello.kojo ve menu.kojo kullanıyor. + Onun için denemeleri artık çalıştırmıyoruz */ +//dene2 +satıryaz("arama motoru hazır") diff --git a/installer/examples/othello/tr/anaTanimlar.kojo b/installer/examples/othello/tr/anaTanimlar.kojo new file mode 100644 index 00000000..a2c91782 --- /dev/null +++ b/installer/examples/othello/tr/anaTanimlar.kojo @@ -0,0 +1,57 @@ +// temel türleri tanımlayalım burada +trait Taş { + val adı = "taş" +} +case object Beyaz extends Taş { + override val adı = "beyaz" + override def toString() = "B" +} +case object Siyah extends Taş { + override val adı = "siyah" + override def toString() = "S" +} +case object Yok extends Taş { + override val adı = "boş" + override def toString() = "." +} +case class Oda(str: Sayı, stn: Sayı) { + val y = str + val x = stn + override def toString() = s"${stn + 1}x${str + 1}" // satır ve sütün sırası yazılımda ters! +} +trait Yön +case object K extends Yön; case object KD extends Yön +case object D extends Yön; case object GD extends Yön +case object G extends Yön; case object GB extends Yön +case object B extends Yön; case object KB extends Yön +case class Komşu(yön: Yön, oda: Oda) +trait Ustalık +case object ErdenAz extends Ustalık +case object Er extends Ustalık +case object Çırak extends Ustalık +case object Kalfa extends Ustalık +case object Usta extends Ustalık +case object Doktor extends Ustalık +case object Aheste extends Ustalık +case object Deha extends Ustalık +case object DehadanÇok extends Ustalık +case object ÇokSabır extends Ustalık + +class HamleSayısı { + // bir sonraki hamle kaçıncı hamle olacak? 1, 2, 3, ... + def apply() = say + def başaAl() = say = 1 + def artır() = say += 1 + def azalt() = say -= 1 + private var say: Sayı = _ + başaAl() +} +class Oyuncu(val kimBaşlar: Taş) { + def apply() = oyuncu + def karşı: Taş = if (oyuncu == Beyaz) Siyah else Beyaz + def başaAl() = oyuncu = kimBaşlar + def değiştir() = oyuncu = karşı + def kur(o: Taş) = oyuncu = o + private var oyuncu: Taş = _ + başaAl() +} diff --git a/installer/examples/othello/tr/araYuz.kojo b/installer/examples/othello/tr/araYuz.kojo new file mode 100644 index 00000000..6ce0bd94 --- /dev/null +++ b/installer/examples/othello/tr/araYuz.kojo @@ -0,0 +1,414 @@ +//#include tr/anaTanimlar +//#include tr/eTahta +//#include tr/bellek +//#include tr/alfabeta + +class Arayüz( // tahtayı ve taşları çizelim ve canlandıralım + tahta: ETahta, + bellek: Bellek, + bilgisayar: Taş) { + private def tahtayıKur = { + silVeSakla; /* tümEkranTuval; */ artalanıKur(koyuGri) + val içKöşeler = EsnekDizim.boş[Resim] + val içKöşeKalemRengi = Renk(255, 215, 85, 101) // soluk sarımsı bir renk + for (x <- tahta.satırAralığı; y <- tahta.satırAralığı) { + val oda = Oda(y, x) + val kRenk = if (tahta.içKöşeMi(oda)) içKöşeKalemRengi else mor + val r = kalemRengi(kRenk) * boyaRengi(taşınRengi(tahta.taş(y, x))) * + götür(odanınNoktası(oda)) -> Resim.dikdörtgen(boy, boy) + r.çiz() + kareninOdası += (r -> oda) + odanınKaresi += (oda -> r) + if (kRenk == içKöşeKalemRengi) içKöşeler += r + kareyiTanımla(r) + } + içKöşeler.dizi.map(_.öneAl()) + } + val odaSayısı = tahta.odaSayısı + // karelerin boyu inç başına nokta sayısı. 64 => 1cm'de yaklaşık 25 nokta var (/ 64 2.54) + val boy = 50 + val (köşeX, köşeY) = (-odaSayısı / 2 * boy, -odaSayısı / 2 * boy) // tahtayı ortalamak için sol alt köşesini belirle + val (b2, b3, b4) = (boy / 2, boy / 3, boy / 4) + val kareninOdası = Eşlem.boş[Resim, Oda] + val odanınKaresi = Eşlem.boş[Oda, Resim] + + def boya(hane: Oda, taş: Taş) = odanınKaresi(hane).boyamaRenginiKur(taşınRengi(taş)) + + private def odanınNoktası(oda: Oda, solAltKöşe: İkil = doğru) = + if (solAltKöşe) Nokta(köşeX + oda.stn * boy, köşeY + oda.str * boy) + else Nokta(köşeX + oda.stn * boy + b2, köşeY + oda.str * boy + b2) + + private def kareyiTanımla(k: Resim) = { + val oda = kareninOdası(k) + k.fareyeTıklayınca { (_, _) => + tahta.taş(oda) match { + case Yok => + val yasal = tahta.hamleyiDene(oda) + if (yasal.size > 0) { + hamleyiYap(yasal, oda) + if (bittiMi) bittiKaçKaç(tahta) + else if (tahta.hamleYoksa) { + sırayıÖbürOyuncuyaGeçir + satıryaz(s"Yasal hamle yok. Sıra yine ${tahta.oyuncu().adı}ın") + skoruGüncelle + } + else { + if (tahta.oyuncu() == bilgisayar && !tahta.hamleYoksa) { + skorBilgisayarHamleArıyor + /* burada yaparsak abArama sırasında herşey donuyor ve bizim + aldığımız taşlar abArama hamlesini yapana kadar dönmüyor */ + // öneri // todo + } + } + } + case _ => + } + } + def odaRengi = taşınRengi(tahta.taş(oda)) + def renk = taşınRengi(tahta.oyuncu()) + k.fareGirince { (x, y) => + ipucu.konumuKur(odanınNoktası(oda, yanlış) - Nokta(b2, -b2)) + tahta.taş(oda) match { + case Yok => if (tahta.hamleyiDene(oda).size > 0) { + k.boyamaRenginiKur(renk) + ipucu.güncelle(s"${tahta.hamleGetirisi(oda)}") + } + else { + ipucu.güncelle(s"$oda") + } + case _ => ipucu.güncelle(s"$oda") + } + ipucu.göster() + ipucu.öneAl() + ipucu.girdiyiAktar(k) + } + k.fareÇıkınca { (_, _) => + k.boyamaRenginiKur(odaRengi) + ipucu.gizle() + // todo: çıkmadan, ya da tekrar tıklamadan çalışmıyor! + if (tahta.oyuncu() == bilgisayar && !tahta.hamleYoksa) öneri + } + } + private val boşOdaRengi = Renk(10, 111, 23) // koyuYeşil + private def taşınRengi(t: Taş) = t match { + case Yok => boşOdaRengi + case Beyaz => beyaz + case Siyah => siyah + } + + tahtayıKur + + def bittiKaçKaç(tahta: ETahta) = if (!tahta.oyunBitti) { + tahta.oyunBitti = doğru + skorBitiş + satıryaz(s"Oyun bitti.\n${tahta.kaçkaç()}") + } + + def hamleyiGöster(oda: Oda) = { + hamleResminiSil + if (hamleResmiAçık) { + hamleResmi = götür(odanınNoktası(oda, yanlış)) * kalemRengi(mavi) * kalemBoyu(3) * + boyaRengi(renksiz) -> Resim.daire(b4) + hamleResmi.girdiyiAktar(odanınKaresi(oda)) + hamleResmi.çiz() + } + } + def hamleResminiSil = hamleResmi.sil() + private var hamleResmi: Resim = Resim.daire(b4) + private var hamleResmiAçık = yanlış + def hamleyiAçKapa(d: Resim) = { + hamleResmiAçık = !hamleResmiAçık + if (hamleResmiAçık) düğmeSeçili(d) else düğmeTepkisi(d) + tahta.sonHamle match { + case Biri(hane) => hamleyiGöster(hane) + case _ => + } + } + + def seçenekleriGöster = { + seçenekResimleri.foreach { r => r.sil() } + if (seçeneklerAçık) { + val sıralı = tahta.yasallar.map { oda => (oda, tahta.hamleGetirisi(oda)) }.sortBy { p => p._2 }.reverse + if (sıralı.size > 0) { + val enİriGetiri = sıralı.head._2 + seçenekResimleri = sıralı map { + case (oda, getirisi) => + val renk = if (getirisi == enİriGetiri) sarı else turuncu + val göster = götür(odanınNoktası(oda, yanlış)) * kalemRengi(renk) * kalemBoyu(3) * + boyaRengi(renksiz) -> Resim.daire(b4) + göster.girdiyiAktar(odanınKaresi(oda)) + göster.çiz() + göster + } + } + } + } + private var seçenekResimleri: Dizi[Resim] = Dizi() + private var seçeneklerAçık = yanlış + private def seçenekleriAçKapa(d: Resim) = { + seçeneklerAçık = !seçeneklerAçık + seçenekleriGöster + if (seçeneklerAçık) düğmeSeçili(d) else düğmeTepkisi(d) + if (!seçeneklerAçık) seçenekleriKapa(d) + } + private def seçenekleriKapa(d: Resim) = { + seçeneklerAçık = yanlış + seçenekResimleri.foreach { r => r.sil() } + düğmeTepkisi(d) + d.kalemRenginiKur(renksiz) + } + + def ileri = { + bellek.ileriGit + taşlarıGüncelle + bittiMi + } + def geri = { + bellek.geriAl + taşlarıGüncelle + } + def taşlarıGüncelle = { + for (y <- tahta.satırAralığı; x <- tahta.satırAralığı) + boya(Oda(y, x), tahta.taş(y, x)) + skoruGüncelle + tahta.sonHamle match { + case Biri(hane) => hamleyiGöster(hane) + case _ => hamleResminiSil + } + seçenekleriGöster + } + def bittiMi = + if (tahta.hamleYoksa) { + sırayıÖbürOyuncuyaGeçir + if (tahta.hamleYoksa) { + skorBitiş + doğru + } + else { + sırayıÖbürOyuncuyaGeçir + yanlış + } + } + else yanlış + + def yeniOyun = if (tahta.hamleSayısı() != 1) { + tahta.başaAl("Yeni oyun:") + for (x <- tahta.satırAralığı; y <- tahta.satırAralığı) + boya(Oda(y, x), tahta.taş(y, x)) + bellek.başaAl() + skorBaşlangıç + hamleResminiSil + if (tahta.oyuncu() == bilgisayar && !tahta.hamleYoksa) öneri + } + + def hamleyiYap(yasal: Dizi[Komşu], hane: Oda, duraklamaSüresi: Kesir = 0.0): Birim = { + // todo: iyileştirmek için eTahta'da tanımla: def hamleYap(hane: Oda): Dizi[Oda] çıktı olarak boyanması gereken odaları sun. İngilizce'ye tercüme ederken de öyle yaptım. + def bütünTaşlarıÇevir = yasal.foreach { komşu => + val komşuTaş = tahta.taş(komşu.oda) + tahta.gerisi(komşu).takeWhile { oda => + tahta.taş(oda) != Yok && tahta.taş(oda) != tahta.oyuncu() + }.foreach(taşıAltÜstYap(_)) + taşıAltÜstYap(komşu.oda) + } + def taşıAltÜstYap(oda: Oda): Birim = { + tahta.taşıKur(oda)(tahta.oyuncu()) + boya(oda, tahta.oyuncu()) + } + bellek.saklaTahtayı(doğru, tahta.sonHamle) + tahta.sonHamle = Biri(hane) + bütünTaşlarıÇevir + tahta.taşıKur(hane)(tahta.oyuncu()) + boya(hane, tahta.oyuncu()) + satıryaz(s"Hamle ${tahta.hamleSayısı()} ${tahta.oyuncu()} $hane:") + tahta.yaz + sırayıÖbürOyuncuyaGeçir + tahta.hamleSayısı.artır() + bellek.yeniHamleYapıldı + skoruGüncelle + hamleyiGöster(hane) + if (duraklamaSüresi > 0) durakla(duraklamaSüresi) + } + + def sırayıÖbürOyuncuyaGeçir = { + tahta.oyuncu.değiştir() + seçenekleriGöster + } + + def özdevin(süre: Kesir = 0.0) = zamanTut("Özdevinimli oyun") { + özdevinimliOyun( + // abArama, // yavaş! bütün Kojo'yu donduruyor! + köşeYaklaşımı, + süre) + }("sürdü") + def özdevinimliOyun( // özdevinim ve bir kaç hamle seçme yöntemi/yaklaşımı (heuristic) + yaklaşım: İşlev1[Dizi[Oda], Belki[Oda]], + duraklamaSüresi: Kesir /*saniye*/ + ) = { + val dallanma = EsnekDizim.boş[Sayı] + var oyna = doğru + while (oyna) yaklaşım(tahta.yasallar) match { + case Biri(oda) => + dallanma += tahta.yasallar.size + hamleyiYap(tahta.hamleyiDene(oda), oda, duraklamaSüresi) + case _ => + sırayıÖbürOyuncuyaGeçir + yaklaşım(tahta.yasallar) match { + case Biri(oda) => + satıryaz(s"Yasal hamle yok. Sıra yine ${tahta.oyuncu().adı}ın") + dallanma += tahta.yasallar.size + hamleyiYap(tahta.hamleyiDene(oda), oda, duraklamaSüresi) + case _ => + bittiKaçKaç(tahta) + if (dallanma.sayı > 0) { + val d = dallanma.dizi + satıryaz(s"Oyun ${d.size} kere dallandı. Dal sayıları: ${d.mkString(",")}") + satıryaz(s"Ortalama dal sayısı: ${yuvarla(d.sum / (1.0 * d.size), 1)}") + satıryaz(s"En iri dal sayısı: ${d.max}") + } + oyna = yanlış + } + } + } + + def abArama(yasallar: Dizi[Oda]): Belki[Oda] = // yasallar yerine tahtadanTahta işlevini girdi olarak kullanıyor + ABa.hamleYap(new Durum(tahtadanTahta, tahta.oyuncu())) + def öneri: Birim = { + val aTahta = tahtadanTahta + val durum = new Durum(aTahta, tahta.oyuncu()) + if (durum.bitti) bittiKaçKaç(tahta) + else { + val hamle = ABa.hamleYap(durum) match { + case Biri(oda) => oda + case _ => + sırayıÖbürOyuncuyaGeçir + ABa.hamleYap(new Durum(durum.tahta, durum.karşıTaş)) match { + case Biri(oda) => oda + case _ => throw new Exception("Burada olmamalı") + } + + } + hamleyiYap(tahta.hamleyiDene(hamle), hamle) + bittiMi + } + } + def tahtadanTahta: Tahta = { // elektronik tahtadan arama tahtası oluşturalım + val tane = odaSayısı + var t = new Tahta(tane, Vector.fill(tane * tane)(0)) + def diziden(dizi: Dizi[(Sayı, Sayı)])(taş: Taş) = t = t.koy(dizi.map(p => Oda(p._1, p._2)), taş) + for (t <- Dizi(Beyaz, Siyah)) + diziden(for (y <- 0 until tane; x <- 0 until tane; if (t == tahta.taş(y, x))) yield (y, x))(t) + t + } + def köşeYaklaşımı(yasallar: Dizi[Oda]): Belki[Oda] = rastgeleSeç(yasallar.filter(tahta.köşeMi(_))) match { + case Biri(oda) => Biri(oda) // köşe bulduk! + case _ => rastgeleSeç(yasallar.filter(tahta.içKöşeMi(_))) match { + case Biri(oda) => Biri(oda) + case _ => { // tuzakKenarlar tuzakKöşeleri içeriyor + val tuzakKenarOlmayanlar = yasallar.filterNot(tahta.tuzakKenarMı(_)) + enİriGetirililerArasındanRastgele( + if (!tuzakKenarOlmayanlar.isEmpty) tuzakKenarOlmayanlar + else { // tuzak kenarlardan getirisi en iri olanlardan seçiyoruz + val tuzakKöşeOlmayanlar = yasallar.filterNot(tahta.tuzakKöşeMi(_)) + if (tuzakKöşeOlmayanlar.isEmpty) yasallar else tuzakKöşeOlmayanlar + } + ) + } + } + } + def rastgeleSeç[T](dizi: Dizi[T]): Belki[T] = if (dizi.isEmpty) Hiçbiri else + Biri(dizi.drop(rastgele(dizi.size)).head) + def enİriGetirililerArasındanRastgele(yasallar: Dizi[Oda]): Belki[Oda] = + rastgeleSeç(enGetirililer(yasallar)) + def enGetirililer(yasallar: Dizi[Oda]): Dizi[Oda] = { + def bütünEnİriler[A, B: Ordering](d: Dizin[A])(iş: A => B): Dizin[A] = { + d.sortBy(iş).reverse match { + case Dizin() => Dizin() + case baş :: kuyruk => baş :: kuyruk.takeWhile { oda => iş(oda) == iş(baş) } + } + } + bütünEnİriler(yasallar.toList) { tahta.hamleGetirisi(_) } + } + + private def düğme(x: Kesir, y: Kesir, boya: Renk, mesaj: Yazı) = { + val d = götür(x, y) * kalemRengi(renksiz) * boyaRengi(boya) -> Resim.dizi( + götür(boy / 5, b2 + b4 / 3) -> Resim.yazıRenkli(mesaj, 10, beyaz), + kalemBoyu(3) -> Resim.daire(boy * 9 / 20)) + düğmeTepkisi(d) + d.çiz() + d + } + private def düğmeTepkisi(d: Resim, rFareGirince: Renk = beyaz, rFareÇıkınca: Renk = renksiz) = { + d.fareGirince { (_, _) => d.kalemRenginiKur(rFareGirince) } + d.fareÇıkınca { (_, _) => d.kalemRenginiKur(rFareÇıkınca) } + } + private def düğmeSeçili(d: Resim) = düğmeTepkisi(d, renksiz, beyaz) + + private val (dx, dy) = ((0.8 + odaSayısı) * boy + köşeX, köşeY + b2) + private val d0 = { + val d = düğme(dx, dy + 2 * boy, pembe, "öneri") + d.fareGirince { (_, _) => + d.kalemRenginiKur(if (tahta.yasallar.isEmpty) kırmızı else beyaz) + } + /* todo: çalışmadı + var running = yanlış + def run(flag: => İkil) = flag + d.fareyeTıklayınca { (_, _) => running = doğru; skorBilgisayarHamleArıyor } + d.fareÇıkınca { (_, _) => if (run(running)) öneri; running = yanlış; düğmeTepkisi(d) } */ + // todo: skor ne yazık ki güncellenmiyor arama sırasında bütün arayüz donuyor + d.fareyeTıklayınca { (_, _) => skorBilgisayarHamleArıyor; öneri } + } + private val d1 = { + val d = düğme(dx, dy + boy, sarı, "seçenekler") + d.fareyeTıklayınca { (_, _) => seçenekleriAçKapa(d) } + d + } + private val d2 = { + val d = düğme(dx + boy, dy + boy, mavi, "son hamle aç/kapa") + d.kalemRenginiKur(renksiz) // başlangıçta son hamleyi görmeyelim + d.fareyeTıklayınca { (_, _) => hamleyiAçKapa(d) } + d + } + düğme(dx + boy, dy + 2 * boy, turuncu, "tüm ekran aç/kapa").fareyeTıklayınca { (_, _) => tümEkranTuval() } + düğme(dx, dy, kırmızı, "özdevin").fareyeTıklayınca { (_, _) => özdevin() } + düğme(dx + boy, dy, yeşil, "yeni oyun").fareyeTıklayınca { (_, _) => yeniOyun; seçenekleriGöster } + düğme(dx, dy + 3 * boy, açıkGri, "geri").fareyeTıklayınca { (_, _) => geri } + düğme(dx + boy, dy + 3 * boy, renkler.blanchedAlmond, "ileri").fareyeTıklayınca { (_, _) => ileri } + private val skorYazısı = { + val y = { + val tahtaTavanı = dy + (odaSayısı - 0.75) * boy + val düğmelerinTavanı = dy + 5 * boy + enİrisi(tahtaTavanı, düğmelerinTavanı) + } + val yazı = götür(dx - b3, y) -> Resim.yazıRenkli(s"", 20, sarı) + yazı.çiz(); yazı + } + def skorBitiş = { + val fark = tahta.say(Beyaz) - tahta.say(Siyah) + val msj = + if (fark > 0) + s"Beyaz $fark taşla kazandı" + else if (fark < 0) + s"Siyah ${-fark} taşla kazandı" + else "Berabere!" + skorYazısı.güncelle(s"$msj\n${tahta.kaçkaç(doğru)}") + } + def skorBaşlangıç = skorYazısı.güncelle(s"${tahta.oyuncu().adı.capitalize} başlar") + def skoruGüncelle = skorYazısı.güncelle(s"${tahta.hamleSayısı()}. hamle${if (bellek.sıraGeriDöndüMü) " yine " else " "}${tahta.oyuncu().adı}ın\n${tahta.kaçkaç(doğru)}") + def skorBilgisayarHamleArıyor = skorYazısı.güncelle(s"${tahta.hamleSayısı()}. hamle. Bilgisayar arıyor...\n${tahta.kaçkaç(doğru)}") + skorBaşlangıç + + private val ipucu = Resim.yazıRenkli("", 20, kırmızı) + ipucu.çiz() + + tuşaBasınca { t => + t match { + case tuşlar.VK_RIGHT => ileri + case tuşlar.VK_LEFT => geri + case tuşlar.VK_UP => öneri + case _ => + } + } + + if (tahta.oyuncu() == bilgisayar && !tahta.hamleYoksa) öneri + +} diff --git a/installer/examples/othello/tr/bellek.kojo b/installer/examples/othello/tr/bellek.kojo new file mode 100644 index 00000000..d350ee6e --- /dev/null +++ b/installer/examples/othello/tr/bellek.kojo @@ -0,0 +1,59 @@ +//#include tr/anaTanimlar +//#include tr/eTahta + +class Bellek(tahta: ETahta) { + val odaSayısı = tahta.odaSayısı + // ileri geri gidiş için gerekli bellek + private val eskiTahtalar = EsnekDizim.boş[Dizim[Array[Taş]]] // todo + private val oyuncular = EsnekDizim.boş[Taş] + private val hamleler = EsnekDizim.boş[Belki[Oda]] + def saklaTahtayı(yeniHamleMi: İkil, hane: Belki[Oda]) = { + if (yeniHamleMi) while (tahta.hamleSayısı() <= eskiTahtalar.sayı) { + eskiTahtalar.çıkar(eskiTahtalar.sayı - 1) + oyuncular.çıkar(oyuncular.sayı - 1) + hamleler.çıkar(hamleler.sayı - 1) + } + val yeni = Dizim.boş[Taş](odaSayısı, odaSayısı) + for (x <- tahta.satırAralığı; y <- tahta.satırAralığı) + yeni(y)(x) = tahta.taş(y, x) + eskiTahtalar += yeni + oyuncular += tahta.oyuncu() + hamleler += hane + } + def verilenHamleTahtasınaGeç(hamle: Sayı) = { + val eski = eskiTahtalar(hamle) + for (x <- tahta.satırAralığı; y <- tahta.satırAralığı) + tahta.taşıKur(y)(x)(eski(y)(x)) + tahta.oyuncu.kur(oyuncular(hamle)) + tahta.sonHamle = hamleler(hamle) + } + def yeniHamleYapıldı = { + yeniHamleEnYeniGeriAlKomutundanDahaGüncel = doğru + } + // yeni bir hamleden önce geri/ileri çalışmaz ki + private var yeniHamleEnYeniGeriAlKomutundanDahaGüncel = doğru + def geriAl = if (tahta.hamleSayısı() > 1) { + if (yeniHamleEnYeniGeriAlKomutundanDahaGüncel) { + yeniHamleEnYeniGeriAlKomutundanDahaGüncel = yanlış + saklaTahtayı(yanlış, tahta.sonHamle) + } + tahta.oyunBitti = yanlış + tahta.hamleSayısı.azalt() + verilenHamleTahtasınaGeç(tahta.hamleSayısı() - 1) + } + def ileriGit = if (tahta.hamleSayısı() < eskiTahtalar.sayı) { + verilenHamleTahtasınaGeç(tahta.hamleSayısı()) + tahta.hamleSayısı.artır() + } + + def başaAl() = { + eskiTahtalar.sil() + oyuncular.sil() + hamleler.sil() + } + + def sıraGeriDöndüMü = + if (tahta.hamleSayısı() == 1) yanlış + else tahta.oyuncu() == oyuncular(tahta.hamleSayısı() - 2) + +} diff --git a/installer/examples/othello/tr/eTahta.kojo b/installer/examples/othello/tr/eTahta.kojo new file mode 100644 index 00000000..3d66ce5d --- /dev/null +++ b/installer/examples/othello/tr/eTahta.kojo @@ -0,0 +1,150 @@ +//#include tr/anaTanimlar + +// elektronik tahta +class ETahta( + val odaSayısı: Sayı, // satır ve sütunların oda sayısı + val kimBaşlar: Taş, + val çeşni: Sayı) { + gerekli(3 < odaSayısı, "En küçük tahtamız 4x4lük. odaSayısı değerini artırın") // başlangıç taşları sığmıyor + gerekli(20 > odaSayısı, "En büyük tahtamız 19x19luk. odaSayısı değerini azaltın") // çok yavaşlıyor + gerekli(kimBaşlar != Yok, "Beyaz ya da Siyah başlamalı") + def yaz = for (y <- satırAralığıSondan) satıryaz(tahta(y).mkString(" ")) + def say(t: Taş) = (for (x <- satırAralığı; y <- satırAralığı; if tahta(y)(x) == t) yield 1).size + val hamleSayısı = new HamleSayısı + var oyunBitti = yanlış + var sonHamle: Belki[Oda] = _ // son hamleyi tuvalde göstermek ve geri/ileri için gerekli + def yasallar = (for { + x <- satırAralığı; y <- satırAralığı; if tahta(y)(x) == Yok + } yield Oda(y, x)) filter { hamleyiDene(_).size > 0 } + def hamleYoksa = yasallar.size == 0 + def taş(oda: Oda): Taş = tahta(oda.str)(oda.stn) + def taş(y: Sayı, x: Sayı): Taş = tahta(y)(x) + def taşıKur(y: Sayı)(x: Sayı)(taş: Taş): Birim = tahta(y)(x) = taş + def taşıKur(oda: Oda)(taş: Taş): Birim = tahta(oda.str)(oda.stn) = taş + private val tahta = Dizim.doldur[Taş](odaSayısı, odaSayısı)(Yok) + val oyuncu = new Oyuncu(kimBaşlar) + def kaçkaç(kısa: İkil = yanlış) = + if (kısa) s"B: ${say(Beyaz)}\nS: ${say(Siyah)}" + else s"Beyazlar: ${say(Beyaz)}\nSiyahlar: ${say(Siyah)}" + def başaAl(başlık: Yazı = "") = { + for (x <- satırAralığı; y <- satırAralığı) taşıKur(Oda(y, x))(Yok) + başlangıçTaşlarınıKur + oyuncu.başaAl() // todo: new tahta? + hamleSayısı.başaAl() + oyunBitti = yanlış + sonHamle = Hiçbiri + if (başlık.size > 0) satıryaz(başlık) + yaz + } + def başlangıçTaşlarınıKur = { + def diziden(dizi: Dizi[(Sayı, Sayı)])(taş: Taş) = for { (y, x) <- dizi } taşıKur(Oda(y, x))(taş) + def dörtTane: Oda => Birim = { + case Oda(y, x) => + diziden(Dizi((y, x), (y + 1, x + 1)))(Beyaz) + diziden(Dizi((y + 1, x), (y, x + 1)))(Siyah) + } + val orta: Sayı = odaSayısı / 2 + çeşni match { + case 2 => // boş tahtayla oyun başlayamıyor + case 1 => + gerekli((odaSayısı > 6), "Bu çeşni için 7x7 ya da daha iri bir tahta gerekli") + dörtTane(Oda(1, 1)) + dörtTane(Oda(sonOda - 2, sonOda - 2)) + dörtTane(Oda(1, sonOda - 2)) + dörtTane(Oda(sonOda - 2, 1)) + case _ => + val çiftse = odaSayısı % 2 == 0 + if (çiftse) dörtTane(Oda(orta - 1, orta - 1)) else { + val (a, b) = (orta - 1, orta + 1) + diziden(Dizi(a -> a, b -> b))(Beyaz) + diziden(Dizi((a, b), (b, a)))(Siyah) + if (yanlış) { // (a, b) odaları boş kalıyor her a ve b çift sayısı için + diziden(Dizi(a + 1 -> a, (b - 1, b)))(Beyaz) + diziden(Dizi((a, b - 1), (b, a + 1)))(Siyah) + } + else { + diziden(Dizi((a + 1, a), (a + 1, b), (b + 1, b - 1), (a - 1, b - 1)))(Beyaz) + diziden(Dizi((a, a + 1), (b, a + 1), (a + 1, a - 1), (a + 1, b + 1)))(Siyah) + } + } + } + } + + val sonOda = odaSayısı - 1 + val satırAralığı = 0 to sonOda + val satırAralığıSondan = sonOda to 0 by -1 + + def tuzakKenarMı: Oda => İkil = { + case Oda(str, stn) => str == 1 || stn == 1 || str == sonOda - 1 || stn == sonOda - 1 + } + def tuzakKöşeMi: Oda => İkil = { + case Oda(y, x) => (x == 1 && (y == 1 || y == sonOda - 1)) || + (x == sonOda - 1 && (y == 1 || y == sonOda - 1)) + } + def köşeMi: Oda => İkil = { + case Oda(str, stn) => if (str == 0) stn == 0 || stn == sonOda else + str == sonOda && (stn == 0 || stn == sonOda) + } + def içKöşeMi: Oda => İkil = { + case Oda(y, x) => (x == 2 && (y == 2 || y == sonOda - 2)) || + (x == sonOda - 2 && (y == 2 || y == sonOda - 2)) + } + def odaMı: Oda => İkil = { + case Oda(y, x) => 0 <= y && y < odaSayısı && 0 <= x && x < odaSayısı + } + + def hamleyiDene(oda: Oda): Dizi[Komşu] = komşularıBul(oda).filter { komşu => + val komşuTaş = taş(komşu.oda) + komşuTaş != Yok && komşuTaş != oyuncu() && sonuDaYasalMı(komşu, oyuncu())._1 + } + def hamleGetirisi(oda: Oda): Sayı = komşularıBul(oda).map { komşu => + val komşuTaş = taş(komşu.oda) + val sonunaKadar = sonuDaYasalMı(komşu, oyuncu()) + if (komşuTaş != Yok && komşuTaş != oyuncu() && sonunaKadar._1) sonunaKadar._2 else 0 + }.sum + + def komşularıBul(o: Oda): Dizi[Komşu] = Dizi( + Komşu(D, Oda(o.str, o.stn + 1)), Komşu(B, Oda(o.str, o.stn - 1)), + Komşu(K, Oda(o.str + 1, o.stn)), Komşu(G, Oda(o.str - 1, o.stn)), + Komşu(KD, Oda(o.str + 1, o.stn + 1)), Komşu(KB, Oda(o.str + 1, o.stn - 1)), + Komşu(GD, Oda(o.str - 1, o.stn + 1)), Komşu(GB, Oda(o.str - 1, o.stn - 1))) filter { + k => odaMı(k.oda) + } + + def sonuDaYasalMı(k: Komşu, oyuncu: Taş): (İkil, Sayı) = { + val diziTaşlar = gerisi(k) + val sıraTaşlar = diziTaşlar.dropWhile { o => + taş(o) != oyuncu && taş(o) != Yok + } + if (sıraTaşlar.isEmpty) (yanlış, 0) else { + val oda = sıraTaşlar.head + (taş(oda) == oyuncu, 1 + diziTaşlar.size - sıraTaşlar.size) + } + } + def gerisi(k: Komşu): Dizi[Oda] = { + val son = sonOda + val sıra = EsnekDizim.boş[Oda] + val (x, y) = (k.oda.stn, k.oda.str) + k.yön match { + case D => for (i <- x + 1 to son) /* */ sıra += Oda(y, i) + case B => for (i <- x - 1 to 0 by -1) /**/ sıra += Oda(y, i) + case K => for (i <- y + 1 to son) /* */ sıra += Oda(i, x) + case G => for (i <- y - 1 to 0 by -1) /**/ sıra += Oda(i, x) + case KD => // hem str hem stn artacak + if (x >= y) for (i <- x + 1 to son) /* */ sıra += Oda(y + i - x, i) + else for (i <- y + 1 to son) /* */ sıra += Oda(i, x + i - y) + case GB => // hem str hem stn azalacak + if (x >= y) for (i <- y - 1 to 0 by -1) /* */ sıra += Oda(i, x - y + i) + else for (i <- x - 1 to 0 by -1) /* */ sıra += Oda(y - x + i, i) + case KB => // str artacak stn azalacak + if (x + y >= son) for (i <- y + 1 to son) /**/ sıra += Oda(i, x + y - i) + else for (i <- x - 1 to 0 by -1) /* */ sıra += Oda(y + x - i, i) + case GD => // str azalacak stn artacak + if (x + y >= son) for (i <- x + 1 to son) /**/ sıra += Oda(y + x - i, i) + else for (i <- y - 1 to 0 by -1) /* */ sıra += Oda(i, x + y - i) + } + sıra.dizi + } + + başaAl() +} diff --git a/installer/examples/othello/tr/otello.kojo b/installer/examples/othello/tr/otello.kojo new file mode 100644 index 00000000..63b6ba79 --- /dev/null +++ b/installer/examples/othello/tr/otello.kojo @@ -0,0 +1,27 @@ +//#include tr/anaTanimlar +//#include tr/eTahta +//#include tr/araYuz +//#include tr/alfabeta + +çıktıyıSil +val çeşni = 0 // ya da 1 +val odaSayısı = 8 +val kimBaşlar = Siyah // Beyaz ya da Siyah başlayabilir. Seç :-) +val bilgisayar = Siyah // Siyah ya da Beyaz oynar ya da Yok (yani oynamaz) + +val tahta = new ETahta(odaSayısı, kimBaşlar, çeşni) +val bellek = new Bellek(tahta) +val düzey = Usta +ABa.ustalık(düzey) +val araYüz = new Arayüz(tahta, bellek, bilgisayar) +// 1) istersen bilgisayar çabucak bir oyunla başlayabilir +// araYüz.özdevin(0.02) + +// 2) Burada ise daha ciddi bir bilgisayar motorunu kullanıyoruz. +// Epey çok zaman alıyor. Hamle başına 1, 3, 5 hatta 10 saniyeden çok bile +// sürebilir. Hızlandırmak için Usta yerine Er, Çırak ya da Kalfa kurabilirsin: +/* +zamanTut(s"$odaSayısı x $odaSayısı ustalık: $düzey") { + araYüz.özdevinimliOyun(araYüz.abArama, 0.1) +}("sürdü") +*/ diff --git a/src/main/resources/mathgames/tr/counting.kojo b/src/main/resources/mathgames/tr/counting.kojo index ae029f61..ff43193a 100644 --- a/src/main/resources/mathgames/tr/counting.kojo +++ b/src/main/resources/mathgames/tr/counting.kojo @@ -163,9 +163,9 @@ def yeterinceZamanVarMı() = { else yanlış } +import ay.olay.TuşaBasmaOlayı val s = yeniSoru(0, 0) -import java.awt.event.{ KeyAdapter, KeyEvent } -yanıtPenceresi.addKeyListener(new KeyAdapter { +yanıtPenceresi.addKeyListener(new ay.olay.TuşUyarlayıcısı { // yanıt penceresine tuş dinleyicisi ekliyoruz var sayılarAnımsa = s // yanlış yanıt verince arayüzü baştan kuruyoruz. Soruyu hatırlayalım ki oyuncu tekrar deneyebilsin def yanıtıDenetle(x: Sayı) { if (x == yanıt) { @@ -191,14 +191,15 @@ yanıtPenceresi.addKeyListener(new KeyAdapter { } } - def yanıtHazırMı(e: KeyEvent) = { + def yanıtHazırMı(olay: TuşaBasmaOlayı) = { + // penceredeki yazıyı al ve uzunluğunu bul yanıtPenceresi.getText.length >= yanıtUzunluğu } // escape tuşuna basınca oyuna son verelim: - override def keyPressed(e: KeyEvent) { - if (e.getKeyCode == tuşlar.VK_ESCAPE) { - e.consume() + override def keyPressed(olay: TuşaBasmaOlayı) { + if (olay.getKeyCode == tuşlar.VK_ESCAPE) { + olay.consume() if (!oyunBitti) { oyunSüresineBak(doğru) } @@ -207,33 +208,33 @@ yanıtPenceresi.addKeyListener(new KeyAdapter { tümEkranTuval(); tümEkran = yanlış // tüm ekran modunu kapatalım } } // d tuşu yazılımcığımızı test etmek için: - else if (e.getKeyCode == tuşlar.VK_D) { + else if (olay.getKeyCode == tuşlar.VK_D) { val sayılar = (enÇokKaçSatır, enÇokKaçSütun, enÇokKaçSütun) sayılarAnımsa = sayılar yanıtıKur(sayılar) yeniArayüz(sayılar) } // büyük boşluk tuşuna basarak soruyu değiştirebiliriz: - else if (e.getKeyCode == tuşlar.VK_SPACE) { + else if (olay.getKeyCode == tuşlar.VK_SPACE) { değiştirmeSayısı += 1 val sayılar = yeniSoru(0, 0) sayılarAnımsa = sayılar yeniArayüz(sayılar) } - else if (e.getKeyCode == tuşlar.VK_ENTER) { + else if (olay.getKeyCode == tuşlar.VK_ENTER) { tümEkran = !tümEkran tümEkranTuval() // tüm ekran modunu aç/kapat } } // sayı dışındaki girdileri yok sayalım - override def keyTyped(e: KeyEvent) { - if (!e.getKeyChar.isDigit) { - e.consume() + override def keyTyped(olay: TuşaBasmaOlayı) { + if (!olay.getKeyChar.isDigit) { + olay.consume() } } - override def keyReleased(e: KeyEvent) { - if (yanıtHazırMı(e)) { + override def keyReleased(olay: TuşaBasmaOlayı) { + if (yanıtHazırMı(olay)) { val x = yanıtPenceresi.value yanıtıDenetle(x) } diff --git a/src/main/scala/net/kogics/kojo/lite/i18n/tr/data.scala b/src/main/scala/net/kogics/kojo/lite/i18n/tr/data.scala new file mode 100644 index 00000000..d18724cc --- /dev/null +++ b/src/main/scala/net/kogics/kojo/lite/i18n/tr/data.scala @@ -0,0 +1,372 @@ +/* + * Copyright (C) 2022 June + * Bulent Basaran https://github.com/bulent2k2 + * Lalit Pant + * + * The contents of this file are subject to the GNU General Public License + * Version 3 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.gnu.org/copyleft/gpl.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + */ + +trait Ne +case object KW extends Ne +case object JKW extends Ne +case object Type extends Ne +case object Val extends Ne +case object Def extends Ne +case object Method extends Ne + +case class Name(tr: String, en: String, ne: Ne) + +object Data { + def nType(tr: String, en: String) = Name(tr, en, Type) + def nVal(tr: String, en: String) = Name(tr, en, Val) + def nDef(tr: String, en: String) = Name(tr, en, Def) + def nMet(tr: String, en: String) = Name(tr, en, Method) + val data = List( + // type defs, (case) classes + nType("Nesne", "Object"), + nType("Birim", "Unit"), + nType("Her", "Any"), + nType("HerDeğer", "AnyVal"), + nType("HerGönder", "AnyRef"), + nType("Yok", "Null"), + nType("Hiç", "Nothing"), + nType("Renk", "Color"), + nType("Boya", "Paint"), + nType("Hız", "Speed"), + nType("Nokta", "Point"), + nType("Dikdörtgen", "Rectangle"), + nType("Üçgen", "Triangle2D"), + nType("İkil", "Boolean"), + nType("Seçim", "Boolean"), + nType("Lokma", "Byte"), + nType("Kısa", "Short"), + nType("Sayı", "Int"), + nType("Uzun", "Long"), + nType("İriSayı", "BigInt"), + nType("UfakKesir", "Float"), + nType("Kesir", "Double"), + nType("İriKesir", "BigDecimal"), + nType("Harf", "Char"), + nType("Yazı", "String"), + nType("EsnekYazı", "collection.mutable.StringBuilder"), + nType("Belki", "Option"), + nType("Biri", "Some"), + nType("Dizi", "collection.Seq"), + nType("Dizim", "Array"), + nType("EsnekDizim", "collection.mutable.ArrayBuffer"), + nType("Dizin", "List"), + nType("MiskinDizin", "LazyList"), + nType("Yöney", "Vector"), + nType("Küme", "Set"), + nType("Sayılar", "Vector[Sayı]"), + nType("UzunlukBirimi", "UnitLen"), + nType("GeoYol", "java.awt.geom.GeneralPath"), + nType("GeoNokta", "VertexShape"), + nType("Grafik2B", "scala.swing.Graphics2D"), + nType("İmge", "Image"), + nType("Bellekteİmge", "BufferedImage"), + nType("Bellekteİmgeİşlemi", "java.awt.image.BufferedImageOp"), + nType("İşlev1", "Function1"), + nType("İşlev2", "Function2"), + nType("İşlev3", "Function3"), + nType("Bölümselİşlev", "PartialFunction"), + // class defs + nType("Mp3Çalar", "net.kogics.kojo.music.KMp3"), + nType("Aralık", "Range"), + nType("ÇiniDünyası", "net.kogics.kojo.tiles.TileWorld"), + nType("ÇiniXY", "net.kogics.kojo.tiles.TileXY"), + nType("BirSayfaKostüm", "net.kogics.kojo.tiles.SpriteSheet"), + nType("Yöney2B", "Vector2D"), + nType("Resim", "Picture"), + nType("İmge", "Image"), + // defs + nDef("varMı", "isDefined"), + nDef("yokMu", "isEmpty"), + nDef("belirt", "assert"), + nDef("gerekli", "require"), + nDef("yeniMp3Çalar", "newMp3Player"), + nDef("sil", "clear"), + nDef("silVeSakla", "cleari"), + nDef("çizimiSil", "clearStepDrawing"), + nDef("çıktıyıSil", "clearOutput"), + nDef("silVeÇizimBiriminiKur", "clearWithUL"), + // val defs, objects, packages + nVal("yok", "null"), + nVal("doğru", "true"), + nVal("yanlış", "false"), + nVal("yavaş", "slow"), + nVal("orta", "medium"), + nVal("hızlı", "fast"), + nVal("çokHızlı", "superFast"), + nVal("noktaSayısı", "Pixel"), + nVal("santim", "Cm"), + nVal("inç", "Inch"), + nVal("Boş", "collection.immutable.Nil"), + nVal("Hiçbiri", "None"), + + nVal("mavi", "blue"), + nVal("kırmızı", "red"), + nVal("sarı", "yellow"), + nVal("yeşil", "green"), + nVal("mor", "purple"), + nVal("pembe", "pink"), + nVal("kahverengi", "brown"), + nVal("siyah", "black"), + nVal("beyaz", "white"), + nVal("renksiz", "noColor"), + nVal("gri", "gray"), + nVal("koyuGri", "darkGray"), + nVal("açıkGri", "lightGray"), + nVal("turuncu", "orange"), + nVal("morumsu", "magenta"), + nVal("camgöbeği", "cyan"), + // cm + nVal("renkler", "ColorMaker"), + // Key Codes + nVal("tuşlar", "Kc"), + + nDef("Renk", "Color"), + nDef("artalanıKur", "setBackground"), + nDef("artalanıKurDik", "setBackgroundV"), + nDef("artalanıKurYatay", "setBackgroundH"), + + nDef("buAn", "epochTimeMillis"), + nDef("buSaniye", "epochTime"), + + nDef("yinele", "repeat"), + nDef("yineleDizinli", "repeati"), + nDef("yineleDoğruysa", "repeatWhile"), + nDef("yineleOlanaKadar", "repeatUntil"), + nDef("yineleKere", "repeatFor"), + nDef("yineleİçin", "repeatFor"), + nDef("yineleİlktenSonra", "repeatFor"), + + nDef("satıroku", "readln"), + nDef("satıryaz", "println"), + nDef("yaz", "print"), + + nVal("matematik", "math"), + nDef("piSayısı", "Pi"), + nDef("eSayısı", "E"), + nDef("gücü", "pow"), + nDef("kuvveti", "pow"), + nDef("karesi", "pow"), + nDef("karekökü", "sqrt"), + nDef("onlukTabandaLogu", "log10"), + nDef("doğalLogu", "log"), + nDef("logaritması", "log"), + nDef("sinüs", "sin"), + nDef("kosinüs", "cos"), + nDef("tanjant", "tan"), + nDef("sinüsünAçısı", "asin"), + nDef("kosinüsünAçısı", "acos"), + nDef("tanjantınAçısı", "atan"), + + nDef("eüssü", "exp"), + nDef("radyana", "toRadians"), + nDef("dereceye", "toDegrees"), + nDef("taban", "floor"), + nDef("tavan", "ceil"), + nDef("yakını", "rint"), + nDef("işareti", "sign"), + nDef("sayıya", "toInt"), + nDef("logTabanlı", "log"), + + nDef("rastgele", "random"), + nDef("yuvarla", "round"), + nDef("mutlakDeğer", "abs"), + nDef("yakın", "round"), + nDef("enUfağı", "min"), + nDef("enİrisi", "max"), + nDef("rastgele", "random"), + nDef("rastgeleSayı", "randomInt"), + nDef("rastgeleUzun", "randomLong"), + nDef("rastgeleKesir", "randomDouble"), + nDef("rastgeleÇanEğrisinden", "randomNormalDouble"), + nDef("rastgeleNormalKesir", "randomNormalDouble"), + nDef("rastgeleDoğalKesir", "randomNormalDouble"), + nDef("rastgeleTohumunuKur", "initRandomGenerator"), + nDef("rastgeleİkil", "randomBoolean"), + nDef("rastgeleSeçim", "randomBoolean"), + nDef("rastgeleRenk", "randomColor"), + nDef("rastgeleŞeffafRenk", "randomTransparentColor"), + nDef("rastgeleDiziden", "randomFrom"), + nDef("rastgeleKarıştır", "util.Random.shuffle"), + + nDef("evDizini", "homeDir"), + nDef("buDizin", "currentDir"), + nDef("kurulumDizini", "installDir"), + nDef("yazıyüzleri", "availableFontNames"), + nDef("yazıyüzü", "Font"), + nDef("yazıÇerçevesi", "textExtent"), + nDef("kaplumbağa0", "turtle0"), + nDef("yeniKaplumbağa", "newTurtle"), + nDef("buradaDur", ""), + nDef("burdaDur", ""), + nDef("sayıOku", ""), + nDef("kesirOku", ""), + nDef("resimİndir", ""), + nDef("müzikİndir", ""), + nDef("müzikMp3üÇal", ""), + nDef("sesMp3üÇal", ""), + nDef("müzikMp3üÇalDöngülü", ""), + nDef("Mp3ÇalıyorMu", ""), + nDef("Mp3üDurdur", ""), + nDef("Mp3DöngüsünüDurdur", ""), + nDef("müzikMp3üÇalıyorMu", ""), + nDef("müzikÇalıyorMu", ""), + nDef("müzikMp3üKapat", ""), + nDef("müzikMp3DöngüsünüKapat", ""), + nDef("müziğiDurdur", ""), + nDef("müziğiKapat", ""), + nDef("kojoVarsayılanBakışaçısınıKur", ""), + nDef("kojoVarsayılanİkinciBakışaçısınıKur", ""), + nDef("kojoYazılımcıkBakışaçısınıKur", ""), + nDef("kojoÇalışmaSayfalıBakışaçısınıKur", ""), + nDef("kojoÖyküBakışaçısınıKur", ""), + nDef("kojoGeçmişBakışaçısınıKur", ""), + nDef("kojoÇıktılıÖyküBakışaçısınıKur", ""), + nDef("tümEkranÇıktı", ""), + nDef("tümEkranTuval", ""), + nDef("tümEkran", ""), + nDef("tuvalAlanı", "canvasBounds"), + nDef("eni", ""), + nDef("boyu", ""), + nDef("en", ""), + nDef("boy", ""), + nDef("yatayMerkezKonumu", ""), + nDef("dikeyMerkezKonumu", ""), + nDef("ekranTazelemeHızınıKur", ""), + nDef("ekranTazelemeHızınıGöster", ""), + nDef("yaklaş", ""), + nDef("yaklaşXY", ""), + nDef("yaklaşmayıSil", ""), + nDef("yaklaşmayaİzinVerme", ""), + nDef("tuvaliKaydır", ""), + nDef("tuvaliDöndür", ""), + nDef("tuşaBasılıMı", ""), + nDef("tuşaBasınca", ""), + nDef("tuşuBırakınca", ""), + nDef("fareyeTıklıyınca", ""), + nDef("fareyiSürükleyince", ""), + nDef("fareKımıldayınca", ""), + nDef("gridiGöster", ""), + nDef("gridiGizle", ""), + nDef("eksenleriGöster", ""), + nDef("eksenleriGizle", ""), + nDef("açıÖlçeriGöster", ""), + nDef("açıÖlçeriGöster", ""), + nDef("cetveliGöster", ""), + nDef("çizimiKaydet", ""), + nDef("çizimiKaydetBoy", ""), + nDef("çizimiKaydetEn", ""), + nDef("çizimiPulBoyundaKaydet", ""), + nDef("artalandaOynat", ""), + nDef("fareKonumu", ""), + nDef("yorumla", ""), + nDef("yineleSayaçla", ""), + nDef("canlandır", ""), + nDef("durdur", ""), + nDef("canlandırmaBaşlayınca", ""), + nDef("canlandırmaBitince", ""), + nDef("tuvaliEtkinleştir", ""), + nDef("yazılımcıkDüzenleyicisiniEtkinleştir", ""), + nDef("çıktıArtalanınıKur", ""), + nDef("çıktıYazıRenginiKur", ""), + nDef("çıktıYazıYüzüBoyunuKur", ""), + nDef("tuvalBoyutOranınınKur", ""), + nDef("tuvalBoyutlarınıKur", ""), + nDef("süreTut", ""), + nDef("oyunSüresiniGöster", ""), + nDef("sırayaSok", ""), + nDef("döndür", "rot"), + nDef("döndürMerkezli", ""), + nDef("filtre", ""), + nDef("gürültü", ""), + nDef("örgü", ""), + nDef("büyütXY", ""), + nDef("saydamlık", ""), + nDef("ton", ""), + nDef("parlaklık", ""), + nDef("aydınlık", ""), + nDef("yansıtY", ""), + nDef("yansıtX", ""), + nDef("eksenler", ""), + nDef("boyaRengi", ""), + nDef("kalemRengi", ""), + nDef("kalemBoyu", ""), + nDef("çizimÖncesiİşlev", ""), + nDef("çizimSonrasıİşlev", ""), + nDef("çevir", ""), + nDef("yansıt", ""), + nDef("soluk", ""), + nDef("bulanık", ""), + nDef("noktaIşık", ""), + nDef("sahneIşığı", ""), + nDef("götür", ""), + nDef("kaydır", ""), + nDef("büyüt", ""), + nDef("ışıklar", ""), + nDef("birEfekt", ""), + nDef("NoktaIşık", ""), + nDef("SahneIşığı", ""), + nDef("çiz", ""), + nDef("çizVeSakla", ""), + nDef("çizMerkezde", ""), + nDef("çizSahne", ""), + nDef("çizMerkezdeYazı", ""), + nDef("merkezeTaşı", ""), + nDef("sahneKenarındanYansıtma", ""), + nDef("engeldeYansıtma", ""), + nDef("imge", ""), + nDef("imgeNoktası", ""), + nDef("imgeNoktasınıKur", ""), + nDef("arayüz", ""), + nDef("zamanTut", "timeit"), + nDef("DokumaBoya", "TexturePaint"), + nDef("boş", "empty"), + nDef("doldur", "tabulate"), + nDef("sayalım", "from"), + nDef("sayıMı", "isDigit"), + nDef("harfMi", "isLetter"), + nDef("yazıya", "toString"), + ) + +/* + def dump = { + // https://docs.scala-lang.org/overviews/reflection/overview.html + import scala.reflect.runtime.{ universe => ru } + // https://www.scala-lang.org/api/2.13.6/scala/util/Try.html + import scala.util.{ Try, Success, Failure } + // from: https://stackoverflow.com/questions/33975029/using-scala-reflection-to-check-for-a-method-on-an-object-or-to-find-key-type-on + def lookUp[T: ru.TypeTag](obj: T, key: String): Option[Any] = ru.typeTag[T].tpe match { + case ru.TypeRef(a, m, l) if (m.name.toString == "Map" && l.head =:= ru.typeOf[java.lang.String]) => obj.asInstanceOf[Map[String, _]].get(key) + case ru.TypeRef(a, m, l) if (m.name.toString == "Map" && l.head =:= ru.typeOf[Symbol]) => obj.asInstanceOf[Map[Symbol, _]].get(scala.Symbol(key)) + case _ => Try(obj.getClass.getDeclaredMethod(key).invoke(obj)) match { + case Success(x) => Some(x) + case Failure(_) => None + } + } + + val hepsi = (for (n <- Data.data) yield n.tr).sorted + val türler = (for (n <- Data.data if n.ne == Type) yield n.tr).sorted + + çıktıyıSil() + satıryaz(s"${türler.size} tane Türkçe türümüz var:") + türler.foreach(satıryaz) + satıryaz(s"${hepsi.size} tane Türkçe ad var:") + hepsi.foreach(satıryaz) + } +*/ +} + +// Data.dump diff --git a/src/main/scala/net/kogics/kojo/lite/i18n/tr/dict.scala b/src/main/scala/net/kogics/kojo/lite/i18n/tr/dict.scala index eda029c4..932e7db0 100644 --- a/src/main/scala/net/kogics/kojo/lite/i18n/tr/dict.scala +++ b/src/main/scala/net/kogics/kojo/lite/i18n/tr/dict.scala @@ -90,71 +90,9 @@ object dict { "void" -> "türsüz", "volatile" -> "uçucu" ) - val type2en = Map( - // type defs - "Nesne" -> "Object", - "Birim" -> "Unit", - "Her" -> "Any", - "HerDeğer" -> "AnyVal", - "HerGönder" -> "AnyRef", - "Yok" -> "Null", - "Hiç" -> "Nothing", - "Renk" -> "Color", - "Boya" -> "Paint", - "Hız" -> "Speed", - "Nokta" -> "Point", - "Dikdörtgen" -> "Rectangle", - "Üçgen" -> "Triangle2D", - "İkil" -> "Boolean", - "Seçim" -> "Boolean", - "Lokma" -> "Byte", - "Kısa" -> "Short", - "Sayı" -> "Int", - "Uzun" -> "Long", - "İriSayı" -> "BigInt", - "UfakKesir" -> "Float", - "Kesir" -> "Double", - "İriKesir" -> "BigDecimal", - "Harf" -> "Char", - "Yazı" -> "String", - "EsnekYazı" -> "collection.mutable.StringBuilder", - "Belki" -> "Option", - "Biri" -> "Some", - "Dizi" -> "collection.Seq", - "Dizin" -> "List", - "MiskinDizin" -> "LazyList", - "Yöney" -> "Vector", - "Küme" -> "Set", - "Sayılar" -> "Vector[Sayı]", - "UzunlukBirimi" -> "UnitLen", - "GeoYol" -> "java.awt.geom.GeneralPath", - "GeoNokta" -> "VertexShape", - "Grafik2B" -> "scala.swing.Graphics2D", - "İmge" -> "Image", - "Bellekteİmge" -> "BufferedImage", - "Bellekteİmgeİşlemi" -> "java.awt.image.BufferedImageOp", - "İşlev1" -> "Function1", - "İşlev2" -> "Function2", - "İşlev3" -> "Function3", - "Bölümselİşlev" -> "PartialFunction", - // class defs - "Mp3Çalar" -> "net.kogics.kojo.music.KMp3", - ) - val val2en = Map ( - // val defs - "yok" -> "null", - "Hiçbiri" -> "None", - "doğru" -> "true", - "yanlış" -> "false", - "yavaş" -> "slow", - "orta" -> "medium", - "hızlı" -> "fast", - "çokHızlı" -> "superFast", - "noktaSayısı" -> "Pixel", - "santim" -> "Cm", - "inç" -> "Inch", - "Boş" -> "collection.immutable.Nil", - ) + val type2en = Map() + val def2en = Map () + val val2en = Map () val method2en = Map ( "Yöney.boş" -> "Vector.empty", "Küme.boş" -> "Set.empty", @@ -171,5 +109,62 @@ object dict { "Harf.ufakkesire" -> "Char.char2float", "Harf.enUfağı" -> "Char.MaxValue", "Harf.enİrisi" -> "Char.MinValue", + "Aralık.başı" -> "Range.head", + "Aralık.sonu" -> "Range.last", + "Aralık.uzunluğu" -> "Range.size", + "Aralık.dizin" -> "Range.toList", + "Aralık.yazı" -> "Range.toString", + "Aralık.herÖgeİçin" -> "Range.foreach", + "ay.BölmeÇizgisi" -> "javax.swing.JSeparator", + "ay.Parça" -> "javax.swing.JComponent", + "ay.Satır" -> "javax.swing.RowPanel", + "ay.Sıra" -> "javax.swing.RowPanel", + "ay.Sütun" -> "javax.swing.ColPanel", + "ay.Yazıgirdisi" -> "javax.swing.TextField", + "ay.Yazıalanı" -> "javax.swing.TextArea", + "ay.Tanıt" -> "javax.swing.Label", + "ay.Düğme" -> "javax.swing.Button", + "ay.Açkapa" -> "javax.swing.ToggleButton", + "ay.Salındıraç" -> "javax.swing.DropDown", + "ay.Kaydıraç" -> "javax.swing.Slider", + "ay.çerçeveci.çizgiKenar" -> "javax.swing.BorderFactory.createLineBorder", + "ay.çerçeveci.boşKenar" -> "javax.swing.BorderFactory.createEmptyBorder", + ) + val altkumeler = Map ( + "ay" -> List("olay", "değişmez", "çerçeveci") ) + val packageName2en = Map ( + "ay" -> List("java.awt", "javax.swing"), + ) + // todo: ./cinidunyasi.scala + /* (sub)types: + "ay.olay.TuşUyarlayıcısı" -> "java.awt.event.KeyAdapter", + "ay.olay.TuşaBasmaOlayı" -> "java.awt.event.KeyEvent", + */ + /* (sub)packages + "ay.değişmez" -> "javax.swing.SwingConstants", + "ay.çerçeveci" -> "javax.swing.BorderFactory", + */ + /* values + "ay.değişmez.merkez" -> "javax.swing.SwingConstants.CENTER", + "ay.değişmez.taban" -> "javax.swing.SwingConstants.BOTTOM", + "ay.değişmez.tavan" -> "javax.swing.SwingConstants.TOP", + "ay.değişmez.sol" -> "javax.swing.SwingConstants.LEFT", + "ay.değişmez.sağ" -> "javax.swing.SwingConstants.RIGHT", + "ay.değişmez.doğu" -> "javax.swing.SwingConstants.EAST", + "ay.değişmez.batı" -> "javax.swing.SwingConstants.WEST", + "ay.değişmez.kuzey" -> "javax.swing.SwingConstants.NORTH", + "ay.değişmez.güney" -> "javax.swing.SwingConstants.SOUTH", + "ay.değişmez.kuzeydoğu" -> "javax.swing.SwingConstants.NORTH_EAST", + "ay.değişmez.kuzeybatı" -> "javax.swing.SwingConstants.NORTH_WEST", + "ay.değişmez.güneydoğu" -> "javax.swing.SwingConstants.SOUTH_EAST", + "ay.değişmez.güneybatı" -> "javax.swing.SwingConstants.SOUTH_WEST", + "ay.değişmez.yatay" -> "javax.swing.SwingConstants.HORIZONTAL", + "ay.değişmez.dikey" -> "javax.swing.SwingConstants.VERTICAL", + "ay.değişmez.önceki" -> "javax.swing.SwingConstants.PREVIOUS", + "ay.değişmez.sonraki" -> "javax.swing.SwingConstants.NEXT", + "ay.değişmez.önder" -> "javax.swing.SwingConstants.LEADING", + "ay.değişmez.izler" -> "javax.swing.SwingConstants.TRAILING", + */ + } diff --git a/src/main/scala/net/kogics/kojo/lite/i18n/tr/dizim.scala b/src/main/scala/net/kogics/kojo/lite/i18n/tr/dizim.scala index 64ce80e7..50f71ea6 100644 --- a/src/main/scala/net/kogics/kojo/lite/i18n/tr/dizim.scala +++ b/src/main/scala/net/kogics/kojo/lite/i18n/tr/dizim.scala @@ -16,7 +16,7 @@ */ package net.kogics.kojo.lite.i18n.tr -import collection.mutable.{ArrayBuffer} +import collection.mutable.ArrayBuffer import scala.reflect.ClassTag // todo: this has only the bare essentials for Array and ArrayBuffer. Add more to the interface.. diff --git a/src/main/scala/net/kogics/kojo/lite/i18n/tr/help.scala b/src/main/scala/net/kogics/kojo/lite/i18n/tr/help.scala index 74eb8f55..470b8f4e 100644 --- a/src/main/scala/net/kogics/kojo/lite/i18n/tr/help.scala +++ b/src/main/scala/net/kogics/kojo/lite/i18n/tr/help.scala @@ -83,6 +83,7 @@ object help { "buSaniye" -> "buSaniye()", "hızıKur" -> "hızıKur(${hız})", "def2" -> "def2()", + "eksenler" -> "eksenler", ) val content = Map( @@ -192,7 +193,7 @@ x.metod "buAn" ->
buAn() - Bu komut evrensel zamana (UTC) göre 1 Ocak 1970 tam geceyarısından bu ana kadar geçen zamanı kesirsiz milisaniye olarak verir.
.toString, "buSaniye" ->
buSaniye() - Bu komut evrensel zamana (UTC) göre 1 Ocak 1970 tam geceyarısından bu ana kadar geçen zamanı kesirli saniye olarak verir.
.toString, "hızıKur" ->
hızıKur(hız) - Kaplumbağacığın hızını belirler. yavaş, orta, hızlı ve çokHızlı değerlerinden birini dene.
.toString, - "def2" ->
def2 - Kıvrık parantez içindeki bir dizi komuta ya da deyişe bir ad takar. Bu yöntemle yeni bir işlev ya da komut tanımlamış olursun.
+ "def_türkçe" ->
def - Kıvrık parantez içindeki bir dizi komuta ya da deyişe bir ad takar. Bu yöntemle yeni bir işlev ya da komut tanımlamış olursun.

Örneğin:

@@ -210,7 +211,6 @@ x.metod kare(100) kare(200) - // Topla adında yeni bir işlev tanımlayalım // İki girdisi, bir çıktısı var def topla(a: Sayı, b: Sayı) = @@ -222,7 +222,40 @@ x.metod val toplam = topla(20, 7) satıryaz(toplam) -
.toString, +
.toString, + + "eksenler" -> +
+ eksenler -> resim - Verilen resmin yerel eksenlerini çizerek yeni bir resim oluşturur. +
+ Bu yöntem dönüştürücü bir yöntemdir ve resim oluşturmakta size yardımcı olur. +
Örnek:
+ 
+      def resim = Resim {{
+        yinele(2) {{
+          ileri(50); sağ()
+          ileri(100); sağ()
+        }}
+      }}
+      silVeSakla
+      çiz(
+        götür(-100, -50) * döndür(45) *
+          boyaRengi(mavi) * eksenler -> resim
+      )
+      eksenleriGöster()
+
+ Bu örnekte bir dikdörtgen çiziyor, onu (-100, -50) noktasına taşıyor, 45 derece döndürüyor ve içini maviye boyuyoruz. Bir de bu çizimin kendi eksenlerini yani yerel eksenlerini çiziyoruz. En sondaki eksenleriGöster komutuyla da genel ya da mutlak eksenleri gösteriyoruz. +
.toString, + + "eksenleriGöster" -> +
+ eksenleriGöster - Çizim tuvalinde yatay (X) ve dikey (Y) eksenlerini çizer. +
.toString, + + "eksenleriGizle" -> +
+ eksenleriGizle - Çizim tuvalindeki yatay (X) ve dikey (Y) eksenlerini siler. +
.toString, ) } diff --git a/src/main/scala/net/kogics/kojo/lite/i18n/trInit.scala b/src/main/scala/net/kogics/kojo/lite/i18n/trInit.scala index 5ee99228..42591f2c 100644 --- a/src/main/scala/net/kogics/kojo/lite/i18n/trInit.scala +++ b/src/main/scala/net/kogics/kojo/lite/i18n/trInit.scala @@ -350,6 +350,7 @@ object TurkishAPI { def üçgenDöşeme(noktalar: Dizi[Nokta]): Dizi[Üçgen] = builtins.triangulate(noktalar) + // todo: klasör? def evDizini = builtins.homeDir def buDizin = builtins.currentDir def kurulumDizini = builtins.installDir @@ -541,7 +542,7 @@ object TurkishAPI { def DokumaBoya(dosya: Yazı, x: Kesir, y: Kesir) = richBuiltins.TexturePaint(dosya, x, y) def a_kalıp() = println("Kalıbı kullan") // todo: geçici. Bakınız tr/help.scala - def def2() = println("def") + def def_türkçe() = println("def") // more to come (:-) }