makalah tugas 1 puzzle

IMPLEMENTASI KECERDASAN BUATAN

PADA PUZZLE 8

Untuk memenuhi Tugas Matakuliah Kecerdasan Buatan

Oleh :

REZHA KHARISMA PUTRI 409312417680

INGE RATIH PUSPITASARI 409312417682

NINE WINDA YUNITA 409312419793

UNIVERSITAS NEGERI MALANG

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

JURUSAN MATEMATIKA

SEPTEMBER 2012

KATA PENGANTAR

Puji dan syukur dipanjatkan kepada Allah SWT karena berkat rahmat dan hidayah-Nya,

penulis dapat menyelesaikan tugas matakuliah Kecerdasan Buatan yang berjudul Implementasi

Kecerdasan Buatan Pada Puzzle 8.

Ucapan terima kasih kepada semua pihak yang telah memberikan bantuan secara langsung

maupun tidak langsung, sehingga penyusunan tugas ini dapat diselesaikan dengan baik.

Dalam kesempatan kali ini, ucapan terima kasih ditujukan kepada:

1. Allah SWT yang telah memberikan segalanya yang terbaik kepada penulis

2. Bapak Moh. Yasin selaku dosen Pengampu.

3. Kedua orang tua dan segenap keluarga yang selalu mendukung.

4. Seluruh teman mahasiswa Program Studi S1 Matematika Angkatan 2009.

Penulis menyadari bahwa masih banyak kekurangan dalam penulisan tugas ini, oleh karena

itu penulis mengharapkan kritik dan saran yang membangun untuk kesempurnaan tugas ini.

Malang, 25 September 2012

Penulis

DAFTAR ISI

KATA PENGANTAR ................................................................................ i

DAFTAR ISI ............................................................................................... ii

BAB I PENDAHULUAN............................................................................ 1

BAB II DASAR TEORI

2.1 Puzzle......................................................................................... 3

2.2 Algoritma .................................................................................. 4

2.3 Kecerdasan Buatan Pada Puzzle................................................ 7

BAB III DESAIN PROGRAM DAN IMPLEMENTASI............................ 9

BAB IV PENUTUP

4.1 Kesimpulan................................................................................ 11

4.2.Saran........................................................................................... 11

LAMPIRAN ...............................................................................................

BAB I

PENDAHULUAN

Program permainan (game) merupakan salah satu implementasi dari bidang ilmu

komputer. Perkembangan permainan pada masa kini sudah sangat besar dan telah menjadi mode

tersendiri di dunia karena mayoritas pengguna komputer menghabiskan sebagian besar waktu

mereka di depan komputer dalam program permainan. Salah satu game yang diminati yaitu slide

puzzle.

Puzzle adalah representasi permainan teka-teki yang dapat diselesaikan dengan men-

gurutkan atau menyusun komponen-komponen pembentuknya sesuai dengan kondisi yang di-

inginkan. 8-Puzzle adalah permainan teka-teki yang berukuran 3x3. Komponen pada 8-Puzzle

adalah berupa kotak-kotak bernomor atau bergambar (sesuai kebutuhan) yang dapat diacak

sedemikian hingga menjadi suatu pola random yang dapat dicari jalan penyelesaiannya. Sesuai

namanya, 8-Puzzle terdiri atas 8 kotak dan 1 tempat kosong yang dapat digerakkan dengan atu-

ran tertentu. Aturan pergerakannya hanya berupa empat (4) arah pergerakan, yaitu: atas, bawah,

kanan, dan kiri. Serta terlimitasi oleh ukuran dimensi papan yang ditempatinya. Pada 8-Puzzle,

batasannya adalah ukuran 3×3. Sehingga, 8 kotak yang dimiliki hanya dapat bergerak dalam

lingkup ukuran tersebut.

Permasalahan pada 8-puzzle berupa pencarian langkah-langkah konkret sesuai aturan,

sehingga menuju kondisi akhir yang diinginkan. Oleh karena itu, pada bidang Artificial

Intellegence, penyelesaian permasalahan 8-puzzle ini dapat dikategorikan ke dalam pencarian

atau searching.

Kecerdasan buatan atau Artificial Intellegence (AI) adalah salah satu bagian dari ilmu

komputer yang membuat agar mesin (komputer) dapat melakukan pekerjaan seperti dan sebaik

yang dilakukan oleh manusia. Kecerdasan buatan atau AI ini meliputi studi tentang

pemrograman simbolik, penyelesaian masalah (problem solving) dan pencarian (searching).

Penyelesaian 8-puzzle dapat menggunakan algoritma dalam kecerdasaan buatan yaitu

Algoritma A*, Algoritma Hill Climbing Search , Deph-Frist-Search dan masih banyak yang

lainnya. Dari uraian diatas penulis akan membahas sedikit tentang 8-puzzle dengan

menggunakan Algoritma A*.

BAB II

DASAR TEORI

2.1. Puzzle

Puzzle adalah representasi permainan teka-teki yang dapat diselesaikan dengan men-

gurutkan atau menyusun komponen-komponen pembentuknya sesuai dengan kondisi yang di-

inginkan. Puzzle merupakan permainan menyusun potongan hanya dapat dipindahkan dengan

menggesernya ke ruang kosong. Puzzle memiliki tingkat kesulitan yang sangat tinggi dalam

menyelesaikan masalah. Umumnya orang yang memainkan puzzle ini butuh waktu lama dalam

menyelesaikan permainannya. Hal ini disebabkan karena pada slide puzzle tidak ada informasi

tambahan yang dimiliki untuk membantu melakukan pencarian solusi, sehingga saat proses

penyusunan potongan-potongan puzzle terjadi susunan puzzle semula. Untuk menyelesaikan

persoalan pada permainan ini dibutuhkan suatu algoritma pencarian efektif yang dapat

diterapkan. 8-Puzzle adalah permainan teka-teki yang berukuran 3x3. Komponen pada 8-Puzzle

adalah berupa kotak-kotak bernomor atau bergambar (sesuai kebutuhan) yang dapat diacak

sedemikian hingga menjadi suatu pola random yang dapat dicari jalan penyelesaiannya. Sesuai

namanya, 8-Puzzle terdiri atas 8 kotak dan 1 tempat kosong yang dapat digerakkan dengan atu-

ran tertentu. Aturan pergerakannya hanya berupa empat (4) arah pergerakan, yaitu: atas, bawah,

kanan, dan kiri. Serta terlimitasi oleh ukuran dimensi papan yang ditempatinya. Pada 8-Puzzle,

batasannya adalah ukuran 3×3. Sehingga, 8 kotak yang dimiliki hanya dapat bergerak dalam

lingkup ukuran tersebut. Gambar 2.1.1 adalah contoh 8-puzzle.

Gambar 2.1.1

http://andiktaufiq.files.wordpress.com/2010/04/puzzlecase1.png

2.2. Algoritma

Algoritma heuristic

Teknik pencarian heuristic merupakan pencarian suatu strategi untuk melakukan proses

pencarian ruang keadaan suatu problema secara selektif, yang memandu proses

pencarian yang kita lakukan di sepanjang jalur yang memiliki kemungkinan sukses

paling besar, dan mengesampingkan usaha yg memboroskan waktu.

Penentuan Rumus Heuristik

Rumus heuristik yang digunakan pada kasus ini adalah |(AbsAwal – OrdAkhir)| + |

(OrdAwal – AbsAkhir)| (1). Rumus heuristik ini diterapkan pada kotak yang mungkin

untuk digerakkan. Kemudian dipilih heuristik yang paling besar diantara semua

kemungkinan tadi. Kotak yang terpilih, akan digerakkan ke kotak yang kosong, lalu

akan dibangkitkan lagi anak pohon dari status yang sekarang. Dan memulai lagi proses

penentuan heuristik untuk kemungkinan kotak yang baru.

Penerapan Algoritma A*

Setelah menentukan heuristik, kita menggerakkan kotak yang terpilih. Setiap

pergerakan yang dilakukan statusnya akan disimpan pada suatu list. List ini akan

digunakan untuk melakukan pengecekan apakah kita sudah pernah membangun status

tersebut atau belum agar kita tidak menggerakkan kotak yang sama berkali-kali ke

status yang sama. Dengan menerapkan strategi ini, selain menemukan solusi, algoritma

ini juga bisa menemukan langkah terpendek untuk mencapai solusi tersebut.

Algoritma A* untuk Persoalan 8 Puzzle

1. Jadikan status awal sebagai akar pohon persoalan.

2. Tentukan heuristik untuk tiap kotak yang mungkin untuk digerakkan.

3. Dari kemungkinan yang ada, lakukan perbandingan heuristiknya.

4. Bila ada nilai heuristik yang sama, maka yang digerakkan adalah kotak yang nilai

heuristiknya ditentukan pertama kali.

5. Bila tidak ada nilai yang sama, maka yang digerakkan adalah kotak yang nilai

heuristiknya yang terbesar

6. Bangkitkan anak pohon status dari simpul saat ini, dengan status baru adalah status

setelah kotak digerakkan

7. Ulangi prosedur 2-6 sampai ditemukan solusi yang paling optimum.

Fungsi heuristic ini digunakan untuk mengevaluasi keadaan-keadaan problema

individual dan menentukan seberapa jauh hal tersebut dapat digunakan untuk mendapatkan

solusi yang diinginkan.

Jenis-jenis pencarian heuristic:

1. Hill Climbing

Hill Climbing sering digunakan jika terdapat fungsi heuristic yang baik untuk

mengevaluasi keadaan (state).

2. Best First Search

Best First Search merupakan algoritma heuristic yang akan mencari rute melewati

keadaan dengan cost terendah menuju keadaan akhirnya.

Suatu keadaan n setidaknya mempunyai 3 macam cost seperti :

a. G(n) : Path Cost, jarak keadaan n dari keadaan awal. Cost ini

menunjukkan tingkat kedalaman pencarian.

b. H(n) : Cost Heuristic, jarak keadaan n ke keadaan akhir. Untuk 8puzzle,

jarak heuristic ini dapat dihitung menggunakan H1(jumlah tile yang

berbeda di keadaan n dan keadaan tujuan) dan H2(Manhattan Distance,

jumlah jarak tile-tile yang tidak bersesuaian antara keadaan n dan

keadaan tujuan).

c. F(n) : Cost Total,cost total ini yang digunakan algoritma untuk

menentukan keadaan mana yang akan diambil sebagai rute menuju

keadaan akhir. Cost mana saja yang akan digunakan untuk menghitung

cost total ini menunjukkan algoritma searching yang digunakan

misalnya:

1. Uniform-cost: f(n)=g(n); dengan kata lain h(n)=0

2. Greedy: f(n)=h(n); dengan kata lain g(n)=0

3. A*/star: f(n)=g(n)+h(n); g(n) dan h(n) keduanya

diperhitungkan.

Dengan nilai cost-nya masing-masing, suatu keadaan dapat

dinyatakan sebagai n(g,h). Satu keadaan diwakili oleh satu node.

Algoritma Best-First mengambil keunggulan dari Breath-First dari

sisi completeness, namun tidak semua node atau keadaan yang akan

dibangkitkan node successornya untuk mencapai solusi yang mungkin.

Hanya node yang memiliki cost terendah (sebagai node terbaik) yang

akan di ekspan.

Perbedaan antara Uniform Cost, Greedy dan A* terletak di penentuan

node terbaik ini :

1. Uniform Cost memilih node dengan path cost, g(n), yang terkecil.

Algoritma ini akan menjamin jalur yang dipilih optimal, namun

memiliki kelemahan terhadap efisiensi karena hampir semua node

dengan level sama akan mempunyai g(n) yang unniform, sehingga

bisa jadi semua node akan diekspan dan ini akan menyerupai

Breadth-First –Search.

2. Greedy memilih node dengan cost heuristic, h(n), terkecil.

Algoritma ini mengejar efisiensi dengan memilih node yang lebih

dekat ke node tujuan. Harga yang harus dibayar adalah adanya

kemungkinan jalur yang dipilih tidak optimal, ada jalur yang

dipilih tidak optimal, ada jalur lain yang lebih pendek yang bisa

ditempuh tapi terlewatkan (algoritma tidak komplit dalam

mengevaluasi node-node).

3. A* memilih node dengan jumlah path cost dan heuristic cost,

f(n)=g(n)+h(n), yang terkecil. A* menggabungkan keunggulan

dari uniform-cost dan greedy, dengan trade-off antara tingkat

optimalitas jalur dan efisiensi yang didapatkan. Dalam

implementasinya, Algoritma A* dapat dibedakan menjadi 4 tipe

sebagai berikut :

a. A* standart

b. A* with guaranteed minimum pathcost

c. Conditional A* with g(n) (optimal greedy)

d. Conditional A* with h(n) (efficient A*)

3. Simulated Annealing (SA)

Simulated Annealing biasanya digunakan untuk penyelesaian masalah yang mana

perubahan keadaan dari suatu kondisi ke kondisi yang lainnya membutuhkan

ruang yang sangat luas, misalkan perubahan gerakan dengan menggunakan

permutasi pada masalah Traveling Salesman Problem.

Algoritma Simulated Annealing (SA)

1. Evaluasi keadaan awal. Jika tujuan maka keluar. Jika tidak lanjutkan dengan

keadaan awwal sebagai keadaan sekarang.

2. Inisialisasi BEST_SO_FAR untuk keadaan sekarang.

3. Inisialisasi T sesuai dengan annealing shedule

4. Kerjakan hingga solusi ditemukan atau sudah tidak ada operator baru lagi akan

diaplikasikan ke kondisi sekarang.

a. Gunakan operator yang belum pernah digunakan untuk menghasilkan

keadaan baru.

b. Evaluasi kondisi baru dengan menghitung:

i. Jika kondisi baru tujuan maka KELUAR.

ii. Jika bukan tujuan, namun nilainya lebih baik dari sekarang, maka

jadikan keadaan tersebut sebagai keadaan sekarang.

iii.Jika nilai kondisi baru tidak lebih baik dari keadaan sekarang, maka

tetapkan kondisi baru sebagai keadaan sekarang dengan probabilitas:

c. Perbaiki T sesuai dengan annealing scheduling

5. BEST_SO_FAR adalah jawaban yang dimaksud.

2.3. Kecerdasan Buatan Pada Puzzle

Kecerdasan buatan merupakan cabang ilmu pengetahuan pada komputer yang dapat

melakukan pekerjaan seperti dan sebaik manusia. Dalam kecerdasan buatan ada beberapa teknik

dalam pemecahan masalah, salah satu yang sering digunakan yaitu teknik pencarian. Salah satu

pencarian yaitu menggunakan fungsi heuristic.

Fungsi heuristic yang dipelajari menggunakan puzzle angka yaitu dengan menghitung

jumlah posisi paling banyak benar, jumlah yang paling tinggi diharapkan paling baik, dan

menghitung jumlah posisi sedikit salah, jumlah yang paling sedikit diharapkan paling baik.

Proses pembelajaran yang pertama yaitu melakukan acak angka puzzle yang telah ditentukan

fungsi heuristicnya. Setelah itu dilakukan tes geser ubin kosong pada setiap operator yang

memungkinkan,setelah dapat nilai yang dicari maka ubin kosong pada puzzle digeser ke arah

yang diharapkan paling baik. Pada penelitian ini proses sekali random yaitu dengan 5 kali geser

ini merupakan kondisi stabil.

BAB III

DESAIN PROGRAM DAN IMPLEMENTASI

Gerakkan f(n) terkecil

Gerakkan f(n) yang pertama kali dicari

Terdapat lebih dari satu nilai terkecil

Dapatkan langkah susun

puzzle

Hitung f(n)=g(n)+h(n)

end

start

Inisialisasi kotak-kotak yang

mungkin untuk digerakkan

Posisi berurut?

ya

tidak

ya

tidak

Kondisi GoaL State

Kondisi Acak

Kondisi acak dengan pengecekan

Kondisi acak dengan pengecekan setelah dipindahkan

BAB IV

PENUTUP

4.1. Kesimpulan

Salah satu implementasi kecerdasan buatan adalah pada 8-puzzle. Permasalahan pada 8-

puzzle berupa pencarian langkah-langkah konkret sesuai aturan, sehingga menuju kondisi akhir

yang diinginkan. Pada kecerdasan buatan, penyelesaian permasalahan 8-puzzle ini dapat

dikategorikan ke dalam pencarian atau searching. Salah satu algoritma yang dapat digunakan

untuk menyelesaikan permasalahan pada 8-puzzle adalah algoritma Astar, dengan perhitungan

heuristic manhattan distance.

4.2 Saran

Saran yang dapat diberikan dari penulis adalah dalam program ini, masih banyak kekurangan

yakni belum dapat mencapai goal state. Maka untuk pembaca disarankan untuk menyelasaikan program

ini agar dapat mencapai goal state.

LAMPIRAN

Listing Program

unit puzzle;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, ExtCtrls, StdCtrls, Math, XPMan, ShellAPI;

type

TForm17 = class(TForm)

Panel1: TPanel;

Panel2: TPanel;

Panel3: TPanel;

Panel4: TPanel;

Panel6: TPanel;

Panel7: TPanel;

Panel8: TPanel;

Panel5: TPanel;

Bevel1: TBevel;

Button1: TButton;

XPManifest1: TXPManifest;

Button3: TButton;

Label1: TLabel;

Edit1: TEdit;

Label2: TLabel;

Edit2: TEdit;

Edit3: TEdit;

Edit4: TEdit;

Edit5: TEdit;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Label6: TLabel;

Button2: TButton;

Label8: TLabel;

Edit6: TEdit;

Memo1: TMemo;

Label7: TLabel;

Label9: TLabel;

Label10: TLabel;

Label11: TLabel;

Label12: TLabel;

Button4: TButton;

procedure cekbenar;

procedure FormCreate(Sender: TObject);

procedure Panel8Click(Sender: TObject);

procedure Button1Click(Sender: TObject);


procedure Label1Click(Sender: TObject);



private

{ Private declarations }

public

{ Public declarations }

end;

var

Form17: TForm17;

blank: TPoint;

points: array [1..9] of TPoint;

time: int64;

done, go: boolean;

h:array [1..4] of integer;

r:integer;

s:TPoint;

implementation

{$R *.dfm}

procedure RenderCell(id: integer);

begin

TPanel(Form17.FindComponent('Panel' + inttostr(id))).Top := (61 * (points[id].y - 1)) + 3;

TPanel(Form17.FindComponent('Panel' + inttostr(id))).Left := (66 * (points[id].x - 1)) + 4;

end;

function pe(p1, p2: TPoint): boolean;

begin

if (p1.X = p2.x) and (p1.Y = p2.y) then begin

Result := true;

end else begin

Result := false;

end;

end;

procedure Check();

var

timestr: string;

begin

if (pe(points[1], Point(1 , 1))) and (pe(points[2], Point(2 , 1))) and (pe(points[3], Point(3 , 1)))

and (pe(points[4], Point(1 , 2))) and (pe(points[5], Point(2 , 2))) and (pe(points[6], Point(3 , 2)))

and (pe(points[7], Point(1 , 3))) and (pe(points[8], Point(2 , 3))) then begin

done := true;

time := GetTickCount - time;

go := false;

if time div 1000 > 60 then begin

timestr := IntToStr(time div 60000) + '.' + IntToStr((time mod 60000) div 6000) + ' Minutes';

end else begin

timestr := IntToStr(time div 1000) + '.' + IntToStr(time mod 1000) + ' Seconds';

end;

Showmessage('You Won!' + #13 + 'Time: ' + timestr);

time := 0;

end;

end;

function heuristik():integer;

var

h1,h2,h3,h4,h5,h6,h7,h8:integer;

h:integer;

begin

h1:=abs((points[1].x-1))+abs((points[1].y-1));








h:=h1+h2+h3+h4+h5+h6+h7+h8;

Result:=h;

end;

procedure RandomizePuzzle();

var

i, j, x: integer;

buffer: array[1..8] of TPoint;

bufpoint: TPoint;

label check;

begin

for x := 0 to 7 do

begin

Randomize;

for I := 1 to 8 do

begin

buffer[i] := points[i];

end;

j := randomrange(2, 9);

for I := j downto 1 do

begin

points[i] := buffer[i + 1];

end;

points[j] := buffer[1];

points[1] := buffer[2];

end;

bufpoint := points[7];

points[7] := points[8];

points[8] := bufpoint;

for I := 1 to 8 do

begin

RenderCell(i);

end;

go := true;

end;

procedure TForm17.Button1Click(Sender: TObject);

var

heu:integer;

begin

RandomizePuzzle();

cekbenar;

heu:=heuristik;

edit6.Text:=inttostr(heu);

end;


begin

application.Terminate;

end;

procedure TForm17.FormCreate(Sender: TObject);

var

i: integer;

begin

time := 0;

done := true;

go := false;

blank := Point(3, 3);

for I := 1 to 8 do begin

points[i] := Point((I mod 3) + 0, (I div 3) + 1);

if points[i].x = 0 then begin

points[i].x := 3;

end;

if i > 6 then begin

points[i].Y := 3;

end;

if i mod 3 = 0 then begin

points[i].Y := points[i].Y - 1;

end;

end;

points[1].X := 1;

points[8].X := 2;

end;

procedure TForm17.Label1Click(Sender: TObject);

begin

ShellExecute(handle, 'open', 'http://www.asimtot.wordpress.com', nil, nil, SW_SHOWNOR-

MAL);

end;

procedure TForm17.Panel8Click(Sender: TObject);

var

id, heu: integer;

p, p2: TPoint;

begin

if go then begin

if done then begin

time := GetTickCount();

end;

done := false;

id := (Sender as TPanel).Tag;

p := blank;

p2 := point(0,0);

if (p.x - 1 = points[id].x) and (p.y = points[id].y) then begin

p2 := points[id];

points[id] := p;

p := p2;

end else if (p.x + 1 = points[id].x) and (p.y = points[id].y) then begin

p2 := points[id];

points[id] := p;

p := p2;

end else if (p.y - 1 = points[id].y) and (p.x = points[id].x) then begin

p2 := points[id];

points[id] := p;

p := p2;

end else if (p.y + 1 = points[id].y) and (p.x = points[id].x) then begin

p2 := points[id];

points[id] := p;

p := p2;

end;

blank := p;

RenderCell(id);

Check();

end;

cekbenar;

heu:=heuristik;

edit6.Text:=inttostr(heu);

end;

procedure TForm17.cekbenar;

var

n,k,i:integer;

begin

n:=0;

for i:=1 to 8 do

begin

if i<=3 then

begin

if (pe(points[i], Point(((i-1) mod 3)+1 , 1))) then

begin

k:=1;

n:=n+k

end;

end;

if (i>3) and (i<=6) then

begin

if pe(points[i], Point(((i-1) mod 3)+1 , 2)) then

begin

k:=1;

n:=n+k

end;

end;

if i>6 then

begin

if pe(points[i], Point(((i-1) mod 3)+1 , 3)) then

begin

k:=1;

n:=n+k

end;

end;

end;

edit1.Text:=inttostr(n);

end;

function atas(blank:TPoint):integer;

var

i,k:integer;

begin

for i:=1 to 8 do

begin

if ((points[i].x)=(blank.x)) and ((points[i].y)=(blank.y)-1) then

begin

k:=i;

break;

end;

end;

Result:=k;

end;

function bawah(blank:TPoint):integer;

var

i,k:integer;

begin

for i:=1 to 8 do

begin

if ((points[i].x)=(blank.x)) and ((points[i].y)=(blank.y)+1) then

begin

k:=i;

break;

end;

end;

Result:=k;

end;

function kiri(blank:TPoint):integer;

var

i,k:integer;

begin

for i:=1 to 8 do

begin

if ((points[i].x)=(blank.x)-1) and ((points[i].y)=(blank.y)) then

begin

k:=i;

break;

end;

end;

Result:=k;

end;

function kanan(blank:TPoint):integer;

var

i,k:integer;

begin

for i:=1 to 8 do

begin

if ((points[i].x)=(blank.x)+1) and ((points[i].y)=(blank.y)) then

begin

k:=i;

break;

end;

end;

Result:=k;

end;

function pindah(b:integer):integer;

var

po:TPoint;

ka:integer;

begin

po:=blank;

blank:=points[b];

points[b]:=po;

ka:=heuristik;

po:=blank;

blank:=points[b];

points[b]:=po;

Result:=ka;

end;


var

ka,ki,nd,ni,mi,jj,j,cc:integer;

begin

if (blank.x=1) or (blank.x=2) then

begin

ka:=kanan(blank);

h[4]:=pindah(ka);

edit4.Text:=inttostr(h[4]);

end

else

begin

h[4]:=99;

edit4.Text:='99';

end;

if (blank.x=2) or (blank.x=3) then

begin

ki:=kiri(blank);

h[2]:=pindah(ki);


end

else

begin

h[2]:=99;

edit3.Text:='99';

end;

if (blank.y=1) or (blank.y=2) then

begin

ni:=bawah(blank);

h[3]:=pindah(ni);


end

else

begin

h[3]:=99;

edit5.Text:='99';

end;

if (blank.y=2) or (blank.y=3) then

begin

nd:=atas(blank);

h[1]:=pindah(nd);


end

else

begin

h[1]:=99;

edit2.Text:='99';

end;

mi:=min(min(min(h[1],h[2]),h[3]),h[4]);

cc:=randomrange(0,3);

if cc=1 then begin for j:=1 to 4 do begin if h[j]=mi then jj:=j; end; if jj=1 then r:=nd; if jj=2 then

r:=ki; if jj=3 then r:=ni; if jj=4 then r:=ka; end;

if cc=2 then begin for j:=4 downto 1 do begin if h[j]=mi then jj:=j; end; if jj=1 then r:=nd; if jj=2

then r:=ki; if jj=3 then r:=ni; if jj=4 then r:=ka; end;

memo1.lines.add(inttostr(r));

s:=blank;

blank:=points[r];

points[r]:=s;

RenderCell(r);

end;


begin

s:=blank;

blank:=points[r];

points[r]:=s;

RenderCell(r);

Check();

end;

end.

makalah tugas 1 puzzle

Documents