C# : Resim Üzerindeki Renkleri Kullanma

     Kimi  zaman Visual Studio'nun bize uygulamalarımızda sundu Color Dialog seçeneği uygulamalarımızda yetmeyebilir. Bir resim düzenleme programı yapacaksınız diyelim. Hazırladığınız uygulamayı diğer resim düzenleme uygulamalarından farklı olmasını küçük değişikliklerle sağlayabilirsiniz. En basitinden kendi renk panelinizi oluşturup kullanıcılarınızın bunu kullanmasını sağlayabilirsiniz. Belki de kullanıcının seçtiği resim üzerindeki renkleri kullanmasını ya da resminin üzerindeki renklerle oynamasa fırsat tanıyan uygulamalar geliştirebilirsiniz.

          Bunları nasıl yapabiliriz şimdi ona bakalım biraz. Bir PictureBox nesnesi içerisinde aşağıda yer alan resmin renklerini kullanacağımızı varsayalım.

          Öncelikli yapmamız gereken PictureBox içerisinde resmi Bitmap değişkeni oluşturup onun üzerinde Bitmap olarak işlem yapacağız. Bunun için gerekli kodumuz şu şekildedir. (Aşağıdaki kodu formun Load olayında kullanabilirsiniz):

Bitmap bmp = (Bitmap)PictureBox.Image.Clone();

          Renk panelinin üzerinde olduğu PictureBox nesnesinin Click olayına aşağıdaki kodu yazarak o an resmin üzerinde hangi noktasındaysanız o rengi color değişkenine alarak bir renk olarak kullanabilirsiniz. 

Color renk = bmp.GetPixel(e.X, e.Y);

          Şimdide seçtiğimiz rengin Click olayından hemen sonra başka bir picturebox nesnesine aktarılmasını istiyoruz diyelim. Bunun için ColorShow adında bir picturebox nesnemizin olduğunu varsayalım. Bunun için ColorShow nesnemizin BackColor özelliğini kullanarak rengin değişmesini sağlayacağız. Bu kodu da hemen color olarak tanımladığımız renk değişkeninden sonra kullanabiliriz.

ColorShow.BackColor = renk;

         Bu üç adımı uygulayarak istediğiniz resimler üerindeki renkleri kullanabilir veya bu renkler üzerinde oynayabilirsiniz. 

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#: String Sınıfı(Trim, Substring, Split )

          String sınıfı karakter işlemlerini baz alınarak oluşturmuş bir sınıftır. Karakterler üzerinde sık yapılan işlemler için geliştirilmiş metotlar oluşturulmuştur. Biz Trim, Substring ve Split metotlarından bahsedeceğiz.

Trim

         Trim metodu karakterin başındaki ve sonundaki boşlukları atmak için kullanılır. Eğer ki sadece kelimelerin başındaki ya da sonundaki boşlukları aşmak istiyorsak TrimEnd ve TrimStart metotlarını da kullanabiliriz.

Kullanılabilecek Yer

          Bu metotların yapmış olduğu işlemlere örnek verecek olursak hazırladığımız programda kullanıcının mailden gelen güvenlik kodunu gireceği bir alan var. Genelde mailimizden direkt kopyala yapıştır yaparız ve kimi zaman karakter topluluğunun başında veya sonundaki fazladan boşlukları da alırız. Bu da programın güvenlik kodunu yanlış algılamasına neden olacaktır. Bu gibi durumları engellemek için Trim metotunu kullanabiliriz.

Kod

Substring

         Kelime ve kelime gruplarından istenilen karakter sırasından sonraki belirlediğimiz kadar karakteri alan  metottur.Kullanımı şu şekildedir:

Substring(başlangıç karakter sırası, gözükecek karakter sayısı)

         Örneğin "isimiz yazilim" alanında "imiz ya" kısmını almak istiyoruz. Öncelikle ilk karakterin başlangıç noktası 0 baz alınır. Bunun için biz almak isteğimiz alanının başlangıç sırasını 2 olarak alacağız. bitiş sırasında da boşluğu da saymamız gerekmektedir. Şimdi ise başlangıç sırasından itibaren gözükmesini isteğimiz kelime sayısını gireceğiz. i harfinden a harfine kadar boşluk da dahil olmak üzere 7 karakter olduğu için 7 yazacağız.

Substring(başlangıç karakter sırası)

          Gözükecek karakter sayısı belirtilmediğinde belirtilmediğinde başlangıç sırası belirtilen karakterden sonraki tüm karakterler alınacaktır.

Kullanılabilecek Yer

        Hazırladığımız programda bir metin içerisinde kelime aramak için kullanılabilecek bir kod parçasıdır. 

Kod

Split

          Kelime veya kelime gruplarında belirlenen karakterden sonrasını bölmek için kullanılır. Bu işlem sırasında belirlenen karakteri kaldıracaktır.

Kullanılabilecek Yer

          Çeviri programlarında girilen metinler split komutu sayesinde boşluklardan sonrasında kelime kelime ayrılması sağlanarak bir dizide tutulup var olan kelime veri tabanındakiler ile eşleştirilip ufak çaplı bir çeviri yapılması sağlanan programların yapımında kullanılabilecek bir komuttur.


Uyarı: Split ile böldüğünüz kelime gruplarını bir yerde tutmanız gerekmektedir. Bunun için en uygun yer diziler olacaktır.

Kod