Author: Raghunath Dhungel
A Simple example of Artificial Intelligence using Delphi Array (Computer simulates
learning process of human, learning by correcting mistakes !)
Answer:
Artificial Intelligence (AI) is an advance branch of science that studies the
process of human thinking and attempts to apply the knowledge to simulate the same
process in machines. As computers are far ahead in the marathon of processing
machines, AI is considered to be the branch of Computer Science than that of
General Science.
There have been many research and development in the field of Artificial
Intelligence. The area of research include speech and pattern recognition, natural
language processing, learning from previous experiences (learning by making and
correcting mistakes!), reasoning under the situations providing limited or
incomplete information etc. AI is practically applied in the field of computer
games, expert systems, neural networks, robotics and many other fields of science
and technology.
In this article we will try to demonstrate a very simple practical example of
artificial Intelligence programming in Delphi using Delphi arrays. I have chosen a
Nepali game named "GATTA TIPNE KHEL" (meaning pebble picking game) for this
purpose. We can see small children playing this game in the playground.
(By the way, Nepal, my nation, is a small Asian country between India and China.
Recently Nepal was in the main highlight of media for the notorious Royal Massacre
in which the whole family of the ruling king were cruelly killed.)
In this pebble picking game a pile of some pebbles is kept in the ground. One of
the two players picks one, two or three pebbles at a time in his turn, leaving the
pile for the other player to pick for his alternate turn. In this alternate picking
process, the player who picks the last pebble(s) will be the loser and called to be
a DOOM in Nepali.
The main logic of the game is to leave the pile of pebbles with 13, 9, 5 or 1
pebble(s) for the opponent to pick.
In the program the starting number of pebbles are set to 17, 21, 25, 29 … etc. so
that computer could win always if it does not make a mistake. But in the real play
computer seems to be gradually learning by correcting mistakes of the previously
played games. At last it finds all its mistakes and corrects them to become an
unbeatable champion. It seems computer simulates the psychological learning process
of animal, learning by correcting and not repeating the mistakes.
A multidimensional array of elements (1..4,1..3) is chosen as the instruction book
for the computer to pick the pebbles. The instruction book contains four pages with
three lines of instructions to pick pebbles. The first line instructs to pick a
single pebble, the second line instructs to pick 2 and the third line instructs to
pick 3 pebbles. At the beginning, computer chooses a random page and a random line
of instruction to pick the pebble. When the game finishes, if computer looses the
game, the last instruction is red-marked (erased) and the instruction will not be
read in the future. After playing many games, all the instructions leading to a
lost game will be red marked and there will be left only the instructions those
lead to a win.
Well, it is enough for the description of the game.
Let us jump directly to the code below:
1 unit Unit1;
2
3 interface
4
5 uses
6 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
7 StdCtrls, ExtCtrls, Buttons;
8
9 type
10 TForm1 = class(TForm)
11 Panel1: TPanel;
12 LabelPeb1: TLabel;
13 LabelPeb2: TLabel;
14 Panel2: TPanel;
15 Panel3: TPanel;
16 Panel4: TPanel;
17 Label1: TLabel;
18 ComboBox1: TComboBox;
19 Label2: TLabel;
20 Label3: TLabel;
21 Label4: TLabel;
22 Label5: TLabel;
23 Label6: TLabel;
24 LabelIWon: TLabel;
25 LabelYouWon: TLabel;
26 LabelTotPlayed: TLabel;
27 ListBox1: TListBox;
28 GroupBox1: TGroupBox;
29 BitBtn1: TBitBtn;
30 BitBtn2: TBitBtn;
31 BitBtn3: TBitBtn;
32 BitBtn5: TBitBtn;
33 Panel5: TPanel;
34 Labelbtn: TLabel;
35 BitBtnResign: TBitBtn;
36 Label7: TLabel;
37 procedure FormCreate(Sender: TObject);
38 procedure ComboBox1Change(Sender: TObject);
39 procedure BitBtnResignClick(Sender: TObject);
40 procedure LabelbtnClick(Sender: TObject);
41 procedure BitBtn1Click(Sender: TObject);
42 private
43 { Private declarations }
44
45 //Procedure to display remaining Pebbles
46 procedure DispPebbles(const nPebs: integer);
47 //Procedure to reset Variables and Labels after a game is finished
48 procedure Finish;
49 //Procedure to enable or Disable some controls;
50 procedure ManageEnabling(lValue: Boolean);
51 //Procedure to display winning or loosing messages
52 procedure Messaging(const lost: Boolean; const resigning: Boolean);
53 //Real Procedure for playing the game
54 procedure LearnByMistakes;
55 public
56 { Public declarations }
57 end;
58
59 var
60 Form1: TForm1;
61
62 implementation
63
64 {$R *.DFM}
65
66 var
67 PlayedGames, ComputerWon: Integer;
68 totPebs, RemainPebs, nTurn: Integer;
69 OldPageNum, OldLineNum: Integer;
70
71 //18 possible permutations of 3 digits: 1,2 and 3
72 //to determine the number of pebbles to take for the computer
73 aPermutations: array[1..6, 1..3] of integer;
74 // A book containing the instruction pages(4) and lines(3 in each page) to draw
75 the pebbles for the computer
76 aPages: array[1..4, 1..3] of integer;
77
78 procedure TForm1.FormCreate(Sender: TObject);
79 // Permutations of 1,2 and 3 in the group of 3s to fill the permutation Array
80 const
81 cPermutations = '123132213231312321';
82 var
83 x, y: Integer;
84 begin
85 //Filling Permutation Array
86 for x := 1 to 6 do
87 for y := 1 to 3 do
88 aPermutations[x, y] := strtoInt(copy(cPermutations, (x - 1) * 3 + y, 1));
89 //Filling the lines of all pages of the instruction Book (array
90 aPages[1..4,1..3]).
91 for x := 1 to 4 do
92 for y := 1 to 3 do
93 aPages[x, y] := y;
94 ComboBox1.ItemIndex := 1;
95 PlayedGames := 0;
96 ComputerWon := 0;
97 totPebs := 17; {Default to 17 pebbles}
98 RemainPebs := 17; {All are intact up to Now}
99 end;
100
101 procedure TForm1.DispPebbles(const nPebs: integer);
102 begin
103 LabelPeb1.Caption := intToStr(nPebs);
104 LabelPeb2.Caption := LabelPeb1.Caption;
105 end;
106
107 procedure TForm1.ManageEnabling(lValue: Boolean);
108 begin
109 BitBtn1.Enabled := lValue;
110 BitBtn2.Enabled := lValue;
111 BitBtn3.Enabled := lValue;
112 Labelbtn.Enabled := lValue;
113 BitBtnResign.Enabled := lValue;
114 GroupBox1.Enabled := lValue;
115 if (RemainPebs < 3) and (RemainPebs > 0) and lValue then
116 begin
117 if RemainPebs < 3 then
118 BitBtn3.Enabled := False;
119 if RemainPebs < 2 then
120 BitBtn2.Enabled := False;
121 end
122
123 end;
124
125 procedure TForm1.Finish;
126 begin
127 LabelTotPlayed.caption := intToStr(PlayedGames);
128 LabelIWon.caption := intToStr(ComputerWon);
129 LabelYouWon.caption := intToStr(PlayedGames - ComputerWon);
130 DispPebbles(strToInt(ComboBox1.Items[ComboBox1.ItemIndex]));
131 totPebs := strtoint(LabelPeb1.Caption);
132 RemainPebs := totPebs;
133 ManageEnabling(True);
134 ComboBox1.Enabled := True;
135 Labelbtn.Enabled := False;
136 BitBtnResign.Enabled := False;
137 end;
138
139 procedure TForm1.ComboBox1Change(Sender: TObject);
140 begin
141 DispPebbles(strToInt(ComboBox1.Items[ComboBox1.ItemIndex]));
142 totPebs := strtoint(LabelPeb1.Caption);
143 RemainPebs := totPebs;
144 end;
145
146 procedure TForm1.Messaging(const lost: Boolean; const resigning: Boolean);
147 begin
148 inc(PlayedGames);
149 MESSAGEBEEP(0);
150 if lost then
151 begin
152 if resigning then
153 showmessage('I Resign ! You won the game again !!')
154 else
155 showmessage('Congratulations ! You won !! I acknowledges defeat !');
156 end
157 else
158 begin
159 inc(ComputerWon);
160 showmessage('Hi ! You lost ! I WON THIS GAME !!');
161 end;
162 Finish;
163 end;
164
165 procedure TForm1.LearnByMistakes;
166 var
167 x, PageNum, LineNum, nTemp, nTakes: integer;
168 begin
169 if RemainPebs <= 0 then
170 begin
171 //Openent drew the last pebble(s) ! Computer won !!
172 //DispPebbles(0);
173 Messaging(False, False);
174 exit;
175 end;
176 nTemp := random(6) + 1;
177 PageNum := RemainPebs mod 4;
178 if PageNum = 0 then
179 PageNum := 4;
180 for x := 1 to 3 do
181 begin
182 LineNum := aPermutations[nTemp, x];
183 if (aPages[PageNum, LineNum] > 0) then
184 break;
185 end;
186 if x > 3 then {No unmarked instructions remained ! All are redmarked !!}
187 begin
188 // The effect of this move was unknown previously. But it proved to be fatal
189 this time !
190 // RedMark This oldLineNum of this oldPageNum !
191 aPages[OldPageNum, OldLineNum] := -99;
192 // Lost with Resigning Message !
193 ListBox1.Items.add(intTostr(nTurn) + '. I resigned ');
194 DispPebbles(RemainPebs);
195 Messaging(True, True);
196 exit;
197 end;
198 nTakes := aPages[PageNum, LineNum];
199 if nTakes >= RemainPebs then
200 begin
201 ListBox1.Items.add(intTostr(nTurn) + '. I (Computer): ' + intTostr(RemainPebs));
202 //I am the last drawer and I lost !!
203 // RedMark This LineNum of this PageNum !
204 aPages[PageNum, LineNum] := -99;
205 DispPebbles(0);
206 Messaging(True, False);
207 exit;
208 end;
209 ListBox1.Items.add(intTostr(nTurn) + '. I (Computer): ' + intTostr(nTakes));
210 showmessage('I (Computer) take: ' + IntTostr(nTakes) +
211 ' Pebble(s) for this turn !');
212 OldPageNum := PageNum;
213 oldLineNum := LineNum;
214 RemainPebs := RemainPebs - nTakes;
215 ManageEnabling(True);
216 DispPebbles(RemainPebs);
217 end;
218
219 procedure TForm1.BitBtnResignClick(Sender: TObject);
220 begin
221 inc(PlayedGames);
222 inc(ComputerWon);
223 inc(nTurn);
224 ListBox1.Items.add(intTostr(nTurn) + '. You resigned');
225 Finish;
226 end;
227
228 procedure TForm1.LabelbtnClick(Sender: TObject);
229 begin
230 BitBtnResign.SetFocus;
231 BitBtnResign.Click;
232 end;
233
234 procedure TForm1.BitBtn1Click(Sender: TObject);
235 var
236 nTaken: Integer;
237 begin
238 with Sender as TBitBtn do
239 nTaken := Tag;
240 ManageEnabling(False);
241 if (RemainPebs = totPebs) then
242 begin
243 ComboBox1.Enabled := False;
244 ListBox1.Clear;
245 nTurn := 1;
246 end
247 else
248 inc(nTurn);
249 ListBox1.Items.add(intTostr(nTurn) + '. You: ' + intTostr(nTaken));
250 RemainPebs := RemainPebs - nTaken;
251 DispPebbles(RemainPebs);
252 LearnByMistakes;
253 end;
254
255 end.
A zipped file game.zip contains all stuffs (forms, units and project file) of the
running project of this game. This project was compiled and run with Delphi - 3.
At last for the interested friends:
I have programmed a game of strategic thinking using the principles of Artificial
Intelligence. The game is somehow like Chess.
The game was programmed using PowerBasic and Assembly Language. This game has won
the First Prize in The First All Nepal Software Competition, SOFTWARE MEET 2000.
The game can be downloaded at:
http//:www.viewnepal.com/gamezip.exehttp//:www.viewnepal.com/gamezip.exe (a self
extracting pkzip file). I will be glad to provide a copy through e-mail if the
download does not work.
For users, who are interessted in Artificical intelligence: You can find a Delphi
component for ArtificialNeuronalNetworks under
http://www.logiware.de/annhttp://www.logiware.de/ann
Component Download: http://www.delphi3000.com/redirect.asp?Link=../article/2551/game.zip
|
