Satranç Tahtasında A* Algoritması İle En Kısa Yolu Bulma

Bu projede 12*12'lik satranç tahtasında başlangıç ve varış noktalarını kullanıcının seçtiği iki nokta arasındaki en kısa yolu özel bir at taşı(uzun ayağı 3 birim giden) ile A* algoritmasını kullanarak bulacağız.

Problemin çözümünde karşılaşılan zorluklar ve çözümleri:

Çözüm işlemlerini yaparken karşımıza çıkacak zorlukları ve bunlara karşı bulduğumuz çözümleri şu şekilde açıklayabiliriz:

1-Satranç tahtasında at için her zaman 8 alternatif olmayabilir. Bu sorunumuzu atın hareket için yelteneceği yerler arasından, tahtamızın içinde olanları seçerek bir yol izlemesini sağlayarak çözüyoruz.

2-Atın hareket edeceği yer önceden gittiği bir yer olabilir. Bu sorunu da gidilen yerleri bir dizide tutarak ve gidilebilecek yerler için önerilecek listeden çıkartarak çözüyoruz.

3-En son gidilen yerler listesinden; en kısa yol çıkarımını yapmak bu programın belki de en zor kısmıydı. Bu zorluğu da en son bulunduğumuz noktadan sırayla belli kontroller ile geri gelerek aştık. Geri gelme kısmında mantığımız yine oyunun başında kullandığımız “gidebileceği yerleri bulmak” oldu. Bu en zor kısmında biraz ayrıntıya girmek istersek:

Tabloda gittiğimiz her noktanın satır, sütun, F(x) ve derinlik sayılarını tuttuk. Arama işlemini dersteki A* algoritması örneğindeki gibi tree gibi düşünelim. Derinlik sayımız, satır ve sütun değerlerimi de biliyoruz dedik. En son işlemde hedefe ulaşmıştık. Bu hedeften gidilebilecek yerleri buluyoruz ve bu yerlerden hangisinin derinliğinin bizimkinden bir az olduğuna bakıyoruz. Bulduğumuz değer bizim bir önceki geldiğimiz değerdir. Bu değeri kaydetmemiz gerekiyor. Sırayla bu işlemi başlangıç noktasına kadar yapıyoruz ve programımızı bitiriyoruz.

NOT: Şunu söylemeliyiz ki A* arama algoritması bizim belirlediğimiz H(x) veya G(x) değerlerine bağlı olarak değişmektedir. Örneğin programımızda G(x) değerimizi 15 değil de 5 yaparsak herhangi bulduğu bir adımı daha uzun yoldan ya da daha efektif bir şekilde de bulabilir. Bu yüzden programımız her zaman en kısa yolu bulamayacaktır fakat genelleme yaparsak bu olasılığın düşük olduğunu da söyleyebiliriz.

Programın Kodu Şu Şekildedir:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
namespace yapayzeka
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
int isaretleme = 0;
int sat1, sut1, sat2, sut2;

int GX(int i)
{
return i * 15;
}

int mutlak(int h)
{
if (h < 0)
{
return (h * (-1));
}
else
{
if (h > 0)
{
return h;
}
else
{
return -1;
}
}
}

void Form1_Click(object sender, EventArgs e)
{
Label tiklananKare = sender as Label;
string kordinat = tiklananKare.Tag.ToString();
int x = Convert.ToInt32(kordinat.Split(';')[0]);
button1.Enabled = false;
int y = Convert.ToInt32(kordinat.Split(';')[1]);
//ilk işaretleme işlemi ise başlangıçı sececek
if (isaretleme == 0)
{
satrancKareleri[x, y].BackColor = Color.Green;
isaretleme++;
satrancKareleri[x, y].Font = new Font("Times New Roman", 9, FontStyle.Italic);
satrancKareleri[x, y].Text = "Bşlngç";
sat1 = x;
sut1 = y;
}
else
{
//ikinci işaretleme işlemi ise bitişi seçecek
if (isaretleme == 1)
{
if (satrancKareleri[x, y].Text == "Bşlngç")
{
MessageBox.Show("Bitiş için başka seçim yapmalısınız!!");
}
//ikinciden fazla işaretleme olduğu zaman hata verecek
else
{
satrancKareleri[x, y].BackColor = Color.Red;
satrancKareleri[x, y].Text = "Bitiş";
isaretleme++;
sat2 = x;
sut2 = y;
button1.Enabled = true;
}
}
else
{
button1.Enabled = true;
MessageBox.Show("Başka seçim yapamazsınız!!");
}
}
}

private void Form1_Load(object sender, EventArgs e)
{
//satranç tahtasını oluşturyoruz
textBox1.ReadOnly = true;
int kareler_en = 41;
int kareler_boy = 41;
int yukseklik = 50;
for (int satir = 0; satir < 12; satir++)
{
int sol = 50;
for (int sutun = 0; sutun < 12; sutun++)
{
satrancKareleri[satir, sutun] = new Label();
satrancKareleri[satir, sutun].Size = new Size(kareler_en, kareler_boy);
satrancKareleri[satir, sutun].Left = sol;
satrancKareleri[satir, sutun].Top = yukseklik;
satrancKareleri[satir, sutun].BorderStyle = BorderStyle.FixedSingle;
satrancKareleri[satir, sutun].AutoSize = false;
satrancKareleri[satir, sutun].Tag = satir + ";" + sutun;
if ((satir + sutun) % 2 == 0)
{
satrancKareleri[satir, sutun].BackColor = Color.White;
}
else
{
satrancKareleri[satir, sutun].BackColor = Color.Black;
}
satrancKareleri[satir, sutun].Font = new Font("Times New Roman", 10, FontStyle.Italic);
this.Controls.Add(satrancKareleri[satir, sutun]);
satrancKareleri[satir, sutun].Click += new EventHandler(Form1_Click);
sol += kareler_en;
}
yukseklik += kareler_boy;
}
}
Label[,] satrancKareleri = new Label[12, 12];

private void button1_Click(object sender, EventArgs e)
{
try
{
if (isaretleme == 2)
{
Stopwatch sw = Stopwatch.StartNew();
int donguden_cik = 0;//hedefe ulaşıldığında while döngüsünden çıkmak için tanımlandı
int min;//gidilebilecek yerler arasında f(x) fonksiyonun en küçük elemanını bulurken kullandık
int indis = 0;//minimumu bulduğumuz elenın indisini tutacak
int dizi_sonu;//gidilecek yerlerin tutulduğu dizinin sonunu gösterecek
int[,] gidilebilecek_yerler = new int[144, 4];//gidilebilecek yerin tutulduğu dizi
//gidilebilecek_yerler dizisinin 1. sütunu gidilebilecek yerin satır sayısını;
//gidilebilecek_yerler dizisinin 2. sütunu gidilebilecek yerin sütun sayısını;
//gidilebilecek_yerler dizisinin 3. sütunu gidilebilecek yerin F(x) değerini;
//gidilebilecek_yerler dizisinin 4. sütunu gidilebilecek yerin kaçıncı derecede olduğunu göstermektedir;
int[,] HX = new int[12, 12];//H(x) fonksiyonun değerlerinin tutulduğu dizi
int[,] gidilen_yerler = new int[144, 3];//seçilen her node'un tutulduğu dizi
int tmp = 0, sayac, dongu, dongu2;//döngülerde kullanıyoruz
int i, j, m;//döngülerde kullanıyoruz
int liste = 0;//kaç adım ilerlediğimizi tuttuğumuz değişken
int bul;//döngüde kullanıyoruz
int agac_derecesi = 1;//her açtığımız yolun kaçıncı yol olduğunu tutacak değişken
int[,] gercek_yol = new int[144, 2];//en son gidilen yolu atadığımız dizi
//başlangıç yerini gidilen yerlere kaydediyoruz
gidilen_yerler[0, 0] = sat1;
gidilen_yerler[0, 1] = sut1;
gidilen_yerler[0, 2] = 0;
//H(x) fonksiyonunu oluşturuyoruz
for (i = 0; i < 12; i++)
{
for (j = 0; j < 12; j++)
{
if (i == sat2 || j == sut2)
{
HX[i, j] = (mutlak(sat2 - i) + mutlak(sut2 - j) + 1) * 10;
}
else
{
HX[i, j] = (mutlak(sat2 - i) + mutlak(sut2 - j)) * 10;
}
HX[sat2, sut2] = 0;
}
}
dizi_sonu = -1;
//Gidilebilecek yerleri buluyoruz
//Bunu yaparken tablo dışına çıkmayı ve gidilen yerlere gitmeyi engellemeliyiz
while (donguden_cik == 0)
{
if ((sat1 + 3) < 12 && (sut1 - 1) < 12 && (sat1 + 3) >= 0 && (sut1 - 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 3 && gidilen_yerler[m, 1] == sut1 - 1)
{
bul = 1;
}//gidilen yerlerde varsa o noktaya gitmeye gerek yoktur
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 3 && gidilebilecek_yerler[i, 1] == sut1 - 1)
{
bul = 1;
}//gidilebilecek yerlere önceden eklenmişse gitmemeliyiz
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 3, sut1 - 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}//yeni noktayı gidilebilecek yerlere ekliyoruz
bul = 0;
}
if ((sat1 + 3) < 12 && (sut1 + 1) < 12 && (sat1 + 3) >= 0 && (sut1 + 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 3 && gidilen_yerler[m, 1] == sut1 + 1)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 3 && gidilebilecek_yerler[i, 1] == sut1 + 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 3, sut1 + 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 3) < 12 && (sut1 - 1) < 12 && (sat1 - 3) >= 0 && (sut1 - 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if ((gidilen_yerler[m, 0] == sat1 - 3) && (gidilen_yerler[m, 1] == sut1 - 1))
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 3 && gidilebilecek_yerler[i, 1] == sut1 - 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 3, sut1 - 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 3) < 12 && (sut1 + 1) < 12 && (sat1 - 3) >= 0 && (sut1 + 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if ((gidilen_yerler[m, 0] == sat1 - 3) && (gidilen_yerler[m, 1] == sut1 + 1))
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 3 && gidilebilecek_yerler[i, 1] == sut1 + 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 3, sut1 + 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 1) < 12 && (sut1 - 3) < 12 && (sat1 - 1) >= 0 && (sut1 - 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 - 1 && gidilen_yerler[m, 1] == sut1 - 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 1 && gidilebilecek_yerler[i, 1] == sut1 - 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 1, sut1 - 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 1) < 12 && (sut1 + 3) < 12 && (sat1 - 1) >= 0 && (sut1 + 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 - 1 && gidilen_yerler[m, 1] == sut1 + 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 1 && gidilebilecek_yerler[i, 1] == sut1 + 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 1, sut1 + 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 + 1) < 12 && (sut1 - 3) < 12 && (sat1 + 1) >= 0 && (sut1 - 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 1 && gidilen_yerler[m, 1] == sut1 - 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 1 && gidilebilecek_yerler[i, 1] == sut1 - 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 1, sut1 - 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 + 1) < 12 && (sut1 + 3) < 12 && (sat1 + 1) >= 0 && (sut1 + 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 1 && gidilen_yerler[m, 1] == sut1 + 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 1 && gidilebilecek_yerler[i, 1] == sut1 + 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 1, sut1 + 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
//gidilebilecek yerlerin F(x)'i gidilebilecek_yerler dizisinin 2.satırında tutuluyor
//F(x)=G(x)+H(x) işlemini yapıp 2 satırlara kaydediyoruz
for (i = tmp; i <= dizi_sonu; i++)
{
gidilebilecek_yerler[i, 2] = GX(liste) + gidilebilecek_yerler[i, 2];
}
tmp = dizi_sonu;//
min = gidilebilecek_yerler[0, 2];//minimum için ilk atama
indis = 0;//indis için ilk atama
//minimum F(x) değerini buluyoruz ve indisini kaydediyoruz
for (i = 1; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 2] < min)
{
min = gidilebilecek_yerler[i, 2];
indis = i;
}
}
liste++;
//bulduğumuz yeri gidilen yerlere ekliyoruz
gidilen_yerler[liste, 0] = gidilebilecek_yerler[indis, 0];
gidilen_yerler[liste, 1] = gidilebilecek_yerler[indis, 1];
gidilen_yerler[liste, 2] = gidilebilecek_yerler[indis, 3];
agac_derecesi = gidilebilecek_yerler[indis, 3] + 1;
sat1 = gidilebilecek_yerler[indis, 0];//en son satır değerini yine satır değerine atıyoruz
sut1 = gidilebilecek_yerler[indis, 1];//en son sutun değerini yine sutun değerine atıyoruz
//eklediğimiz değerleri gidilebilecek yerler dizisinden çıkartmamız gerekiyor,çıkartıyoruz
for (i = indis; i < dizi_sonu; i++)
{
gidilebilecek_yerler[i, 0] = gidilebilecek_yerler[i + 1, 0];
gidilebilecek_yerler[i, 1] = gidilebilecek_yerler[i + 1, 1];
gidilebilecek_yerler[i, 2] = gidilebilecek_yerler[i + 1, 2];
gidilebilecek_yerler[i, 3] = gidilebilecek_yerler[i + 1, 3];
}
dizi_sonu--;
//hedef yere veya ulaşılamayacağını anladığımız yere gelip gelmediğimizin kontrolü
if (HX[sat1, sut1] == 10)
{
textBox1.Text = "Maksimum yakınlık sağlandı fakat çözüm yok!!";
donguden_cik = 2;
}
if (sat1 == sat2 && sut1 == sut2)
{
textBox1.Text = "Hedefe ulaşıldı!!";
donguden_cik = 3;
}
}
sayac = 0;
dongu2 = gidilen_yerler[liste, 2] - 1;
agac_derecesi = agac_derecesi - 2;//ağaç derecesini istediğimiz başlangıç derecesine getiriyoruz
dongu = agac_derecesi;//en son gidilen adımları yazdırırken kullanacağız
gercek_yol[sayac, 0] = sat1;//ulaşılan sonuç yerinin satırını gerçek yol dizisie atıyoruz
gercek_yol[sayac, 1] = sut1;//ulaşılan sonuç yerinin sutununu gerçek yol dizisie atıyoruz
//kaç adımda gittiğimiz bellidir,dongu2 kadar while yapıyoruz
//son ulaştıgımız yerden geriye doğru gelerek yolu buluyoruz
while (dongu2 > 0)
{
sayac++;
//son bulunduğumuz yerden gidilebilecek yerleri buluyoruz, tahtadan dışarı çıkıp çıkmadığına bakıyoruz
if ((sat1 + 3) < 12 && (sut1 - 1) < 12 && (sat1 + 3) >= 0 && (sut1 - 1) >= 0)
{
//dışarı çıkmıyorsa bir önceki geldiği yerin burası olup olmadığına bakıyoruz
//eğer burasıysa gerçek yol dizimize eklemeliyiz
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 3 && gidilen_yerler[i, 1] == sut1 - 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 3;
gercek_yol[sayac, 1] = sut1 - 1;
sat1 = sat1 + 3;
sut1 = sut1 - 1;
}
}
}
if ((sat1 + 3) < 12 && (sut1 + 1) < 12 && (sat1 + 3) >= 0 && (sut1 + 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 3 && gidilen_yerler[i, 1] == sut1 + 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 3;
gercek_yol[sayac, 1] = sut1 + 1;
sat1 = sat1 + 3;
sut1 = sut1 + 1;
}
}
}
if ((sat1 - 3) < 12 && (sut1 - 1) < 12 && (sat1 - 3) >= 0 && (sut1 - 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 3 && gidilen_yerler[i, 1] == sut1 - 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 3;
gercek_yol[sayac, 1] = sut1 - 1;
sat1 = sat1 - 3;
sut1 = sut1 - 1;
}
}
}
if ((sat1 - 3) < 12 && (sut1 + 1) < 12 && (sat1 - 3) >= 0 && (sut1 + 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 3 && gidilen_yerler[i, 1] == sut1 + 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 3;
gercek_yol[sayac, 1] = sut1 + 1;
sat1 = sat1 - 3;
sut1 = sut1 + 1;
}
}
}
if ((sat1 - 1) < 12 && (sut1 - 3) < 12 && (sat1 - 1) >= 0 && (sut1 - 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 1 && gidilen_yerler[i, 1] == sut1 - 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 1;
gercek_yol[sayac, 1] = sut1 - 3;
sat1 = sat1 - 1;
sut1 = sut1 - 3;
}
}
}
if ((sat1 - 1) < 12 && (sut1 + 3) < 12 && (sat1 - 1) >= 0 && (sut1 + 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 1 && gidilen_yerler[i, 1] == sut1 + 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 1;
gercek_yol[sayac, 1] = sut1 + 3;
sat1 = sat1 - 1;
sut1 = sut1 + 3;
}
}
}
if ((sat1 + 1) < 12 && (sut1 - 3) < 12 && (sat1 + 1) >= 0 && (sut1 - 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 1 && gidilen_yerler[i, 1] == sut1 - 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 1;
gercek_yol[sayac, 1] = sut1 - 3;
sat1 = sat1 + 1;
sut1 = sut1 - 3;
}
}
}
if ((sat1 + 1) < 12 && (sut1 + 3) < 12 && (sat1 + 1) >= 0 && (sut1 + 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 1 && gidilen_yerler[i, 1] == sut1 + 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 1;
gercek_yol[sayac, 1] = sut1 + 3;
sat1 = sat1 + 1;
sut1 = sut1 + 3;
}
}
}
dongu2--;
agac_derecesi--;//bir öncekini bulmuşuzdur artık , bir daha geriye gidiyoruz
}
//artık gidilen yolu bulduk
//yollara adımları teker teker yazıyoruz ve tablonun renklerini değiştiriyoruz
for (i = dongu; i >= 0; i--)
{
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].Font = new Font("Times New Roman", 15, FontStyle.Italic);
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].Text = (dongu - i + 1).ToString();
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].BackColor = Color.Aqua;
}
int hafiza = liste + dizi_sonu + sayac + 2;//dizilerde toplam kullanılan hafızayı buluyoruz
label5.Text = (hafiza * 8).ToString();//toplam hafızayı ekrana yazdırıyoruz
sw.Stop();//sayaçı durdurmamız gerekiyor
String metin;
metin = (sw.Elapsed).ToString();//sayaç değerinin döndürdüğü sayıyı stringe çeviriyoruz
metin = metin.Remove(0, 9);//sayaç değerinin döndürdüğü metni kesiyoruz
label3.Text = metin;//süreyi ekrana yazdırıyoruz
isaretleme = 0;
}
else{
MessageBox.Show("Yeni tablo açıp tekrar deneyiniz!!");
}
}
catch (Exception)
{
MessageBox.Show("Hata Oluştu !!");
}
}

private void button2_Click(object sender, EventArgs e)
{
isaretleme = 0;
Form1 yeni = new Form1();//yeni tahta formu oluşturuyoruz
yeni.Show();
}
}
}

Ekran Çıktıları:

Not: Başlangıç noktası yeşil , bitiş noktası kırmızı ile işaretlenmiştir. Karelerdeki sayılar da adım sayılarını göstermektedir. Hedefe ulaşıldığında son kare de işaretlendiği için kırmızı renk de kaybolmaktadır. 

Program Setup Dosyası aşağıdaki linktedir:

Buraya Tıklayın

C# : Metoda Diziden Veri Alma

          Metotlarda dışarıdan dizi alınarak işlem yapılması gerekebilir. Fakat gerek metot yazımında gerekse bu metodun kullanımında kullanılacak dizinin yazımı normal veri türlerinin yazımına göre farklılık gösterecektir.

         Öncelikle metot üzerinde dizinin kullanımına bakacak olursak metotta kullanılacak diziyi normalde kod kısmında hangi veri türünde olacağını belirterek tanımlıyorsak aynısını burada da yapacağız.

          İçinde dizi içeren metotların kullanımında da sadece dışarıdan alınacak dizinin ismi yazılır.

          Örnek üzerinde bunu göstermemiz anlaşılması bakımında daha verimli olacaktır.

          Öncelikle bir dizinin içerisindeki elemanları karıştıran yani yer değiştiren bir metot yazıyoruz.

İpucu: Dizilerimizi metot içerisinde yer alan for döngüsündeki kullanımı ile karıştırabiliriz. Öncelikle dizi içerisinde var olan değerimizi bir a değişkende tutuyoruz. Ardından bu değişkenimize dizi boyutu neyse o sayıya göre rastgele bir indeks seçecek ve dizimiz o indeksteki diziyi öncesinde atama yaptığımız belirli indeksteki aynı diziye atıyoruz. Tabi seçilen bu rastgele sayımızı da farklı bir b değişkeninde tutuyoruz. b değişkenimize atadığımız sayıyı dizimizin indeksi olarak kullanacağız ve b indeksli dizimize a değişkenimizdeki değeri atayarak takas işlemi yani belirli aynı iki dizin değerinin yer değiştirmesi sağlanacaktır.

          Daha sonra konsol ile kullanıcının 5 tane sayı girmesini istiyoruz ve bu sayıları oluşturduğumuz int türünde bir diziye aktarıyoruz.. Oluşturduğumuz metodu yazarak bu metodun parametresini de girdiğimiz sayıların dizisinin adını kullanacağız. foreach döngüsü ile de karıştırdığımız dizideki değerleri görmek için konsol ekranına yazdırıyoruz.

Kodun Tamamı

Ekran Çıktısı

C# : foreach Kullanımı

         Yazdığımız programlarda yaptırdığımız işlemlerden dolayı dizilerde tuttuğumuz verilerin tümünü kullanıcıya aktarma gereği duyabiliriz. Bu yüzden dizilerdeki tüm verileri sıralamak için foreach kullanılmaktadır. foreach komutu kullanmadan da verilerin ekrana ya da farklı nesnelere aktarılarak sıralanması da mümkündür. Çeşitli program dillerinde sık yapılan işlemler gerek metot gerekse farklı bir özellik olarak sınıflarına eklenmiştir. foreach ise dizelerdeki verilerin sıralanması için geliştirilmiş bir döngüdür.

         foreach yapısının karşımıza çıkan aşağıdaki şekilde bir yapısı vardır:

          var: Yazdıracağımız dizinin hangi veri türünde olursa olsun yazdırılması için kullanılır fakat kullandığımız dizinin türü biliniyorsa var yerine onu belirtmek daha doğru olacaktır.

          collection: Kullanacağımız dizinin adını yazarak kullanılacak dizi belirtilir.

          item: Kullanacağımız dizinin foreach döngüsü içerisinde kullanımında temsili bir isim vermemiz gerekmektedir. 

Örnek Kod Parçası:

          Bu örnek kullanımında string türünde sehir dizinindeki verilerin console üzerinde alt alta yazılmasını sağlayacaktır.

Örnek Kullanımı:

Ekran Çıktısı