| blob | f8ba1af064fb1c2f91937aa0889088c36246f83d |
1 # **************************************************************************************************\r
2 # Názov: PGN_Analyzer.rb\r
3 #\r
4 # Verzia: 0.1 (prva verejna verzia)\r
5 #\r
6 # Stav: rozpracovany/under development\r
7 #\r
8 # Popis: program robi analyzu zapisu sachovej partie vo formate PGN \r
9 #\r
10 # Vstup: nic na prikazovom riadku, vstupom od uzivatela je nazov \r
11 # textoveho suboru, v ktorom je zapis partie ulozeny\r
12 #\r
13 # Vystup: program vypise na vystup retazec "ok", ak je zapis sachovej partie\r
14 # v poriadku, ak nie je vypise na vystup retazec "err"\r
15 #\r
16 # Struktura volania metod:\r
17 #\r
18 # <main>\r
19 # --- Analyzuj\r
20 # ------ AnalyzujHlavicku\r
21 # --------- AnalyzujRiadokHlavicky\r
22 # ------ AnalyzujTahy\r
23 # --------- is_result_token \r
24 # --------- analyzuj_tah \r
25 # ------------ dvojzntah\r
26 # ------------ trojzntah\r
27 # ------------ stvorzntah\r
28 # ------------ patzntah\r
29 #\r
30 # Poznamky: nateraz (v.0.1) je urobena len lexikalna analyza, teda kontroluje sa\r
31 # ci je sachova partia formalne spravne zapisana vo formate PGN, nekontroluje sa\r
32 # ci zapisane tahy su korektne z hladiska sachovych pravidiel, ani to, ake tagy\r
33 # su ci nie su uvedene v hlavicke programu. Je implementovana zakladna funkcionalita \r
34 # co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
35 # Nie je urobena ani chybova diagnostika, v pripade chyby, program jednoducho \r
36 # vypise "err" a skonci neindikujuc co, preco a na ktorom mieste je zle.\r
37 # Nie su vytvorene ani testovacie procedury/skripty a dokumentacia. \r
38 #\r
39 # História zmien:\r
40 # 22.06.2007 - v.0.1 - Slavo FURMAN - prva verejna verzia \r
41 # **************************************************************************************************\r
42 \r
43 # ==================================================================================================\r
44 # metoda: Analyzuj.rb\r
45 #\r
46 # Popis: metoda robi analyzu zapisu sachovej partie vo formate PGN \r
47 #\r
48 # Vstup: retazec, v ktorom je cely zapis sachovej partie, ako sme ho precitali zo suboru\r
49 #\r
50 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
51 # ==================================================================================================\r
52 \r
53 def analyzuj(pgnsubor)\r
54 \r
55 result = "ok"\r
56 \r
57 hlavicka = ""\r
58 tahy = ""\r
59 \r
60 citamehlavicku = 0\r
61 citametahy = 0\r
62 \r
63 # postupne citame obsah vstupneho suboru (ktory sme dostali uz ako retazec)\r
64 # riadok po riadku a do osobitnych retazcov ulozime cast s hlavicku partie \r
65 # a cast s tahmi partie\r
66 \r
67 pgnsubor.each_line do |riadok|\r
68 \r
69 if (riadok.strip.length !=0)\r
70 \r
71 if (citamehlavicku == 0)\r
72 citamehlavicku = 1\r
73 hlavicka = hlavicka + riadok\r
74 \r
75 elsif (citamehlavicku == 1)\r
76 \r
77 hlavicka = hlavicka + riadok\r
78 \r
79 elsif ((citamehlavicku==2) and (citametahy==0))\r
80 \r
81 citametahy=1\r
82 tahy = tahy + riadok\r
83 \r
84 elsif ((citamehlavicku==2) and (citametahy==1))\r
85 \r
86 tahy = tahy + riadok\r
87 \r
88 end\r
89 \r
90 else\r
91 \r
92 if (citamehlavicku == 1) \r
93 citamehlavicku = 2 \r
94 elsif (citametahy == 1) \r
95 citametahy = 2\r
96 end\r
97 \r
98 end\r
99 \r
100 end \r
101 \r
102 #puts "HLAVICKA:"\r
103 #puts hlavicka\r
104 \r
105 #puts "TAHY:"\r
106 #puts tahy\r
107 \r
108 \r
109 #cast s hlavickou analyzujeme v metode "analyzujhlavicku"\r
110 result = analyzujhlavicku(hlavicka)\r
111 if (result !="ok")\r
112 return "err"\r
113 end\r
114 \r
115 #cast s tahmi analyzujeme v metode "analyzujtahy" - volane len ak hlavicka je "ok"\r
116 if (result == "ok")\r
117 result = analyzujtahy(tahy)\r
118 end\r
119 \r
120 return result\r
121 \r
122 end\r
123 \r
124 # ==================================================================================================\r
125 # metoda: analyzujhlavicku.rb\r
126 #\r
127 # Popis: metoda robi analyzu hlavicky zapisu sachovej partie vo formate PGN \r
128 #\r
129 # Vstup: retazec, v ktorom je hlavicka zapisu sachovej partie\r
130 #\r
131 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
132 # ==================================================================================================\r
133 \r
134 def analyzujhlavicku(hlavicka)\r
135 \r
136 result = "ok"\r
137 \r
138 # berieme postupne vsetky riadky hlavicky a analyzujeme ich v metode "analyzujriadokhlavicky"\r
139 hlavicka.each_line do |riadok|\r
140 result = analyzujriadokhlavicky(riadok.chomp)\r
141 if (result == "err")\r
142 return result\r
143 end\r
144 end\r
145 \r
146 return result\r
147 end\r
148 \r
149 # ==================================================================================================\r
150 # metoda: analyzujhlavicku.rb\r
151 #\r
152 # Popis: metoda robi analyzu riadku hlavicky zapisu sachovej partie vo formate PGN \r
153 #\r
154 # Vstup: retazec, v ktorom je riadok z hlavicky zapisu sachovej partie vo formate PGN \r
155 #\r
156 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
157 # ==================================================================================================\r
158 \r
159 def analyzujriadokhlavicky(riadok)\r
160 \r
161 pos = 0\r
162 dlzkar = riadok.length\r
163 \r
164 #puts "analyzujeme -> {" + riadok + "} "\r
165 #puts "dlzkar -> {" + dlzkar.to_s + "} "\r
166 \r
167 result = "ok"\r
168 \r
169 #puts "riadok[0] -> {" + riadok[0].to_s + "} "\r
170 #puts "riadok[dlzkar-1] -> {" + riadok[dlzkar-1].to_s + "} "\r
171 \r
172 # riadok musi zacinat a koncit hranatou zatvorkou\r
173 if (riadok[0].chr.to_s != "[") or (riadok[dlzkar-1].chr.to_s != "]")\r
174 #puts "arh-CHYBA1!"\r
175 return "err"\r
176 end\r
177 \r
178 # preskocime pripadne biele znaky za otvaracou hranatou zatvorkou\r
179 # (pri vsetkych citaniach testujeme aj to ci sa nedostaneme az na koniec\r
180 # analyzivaneho retazca, co by bola chyba)\r
181 pos = 1\r
182 while ((riadok[pos].chr.to_s ==" ") or (riadok[pos].chr.to_s == "\t"))\r
183 pos = pos + 1\r
184 if (pos > dlzkar-2)\r
185 #puts "arh-CHYBA2!"\r
186 return "err"\r
187 end\r
188 end\r
189 \r
190 #puts "pos -> {" + pos.to_s + "} "\r
191 \r
192 # precitame tagname do osobitnej premennej, moze sa hodit, ak v buducnosti budeme \r
193 # testovat aj hodnotu/obsah/vyznam tagname\r
194 tagname = ""\r
195 while ((riadok[pos].chr.to_s !=" ") and (riadok[pos].chr.to_s != "\t"))\r
196 \r
197 #puts "riadok[" + pos.to_s + "] -> " + riadok[pos].to_s + "(" + riadok[pos].chr + ")"\r
198 #puts "pos -> {" + pos.to_s + "}, tagname -> {" + tagname + "}"\r
199 \r
200 tagname = tagname + riadok[pos].chr.to_s\r
201 pos = pos + 1\r
202 if (pos > dlzkar-2)\r
203 #puts "arh-CHYBA3!"\r
204 return "err"\r
205 end\r
206 end\r
207 \r
208 #puts "tagname -> {" + tagname + "} "\r
209 \r
210 # preskocime biele znaky za tagname\r
211 while ((riadok[pos].chr.to_s ==" ") or (riadok[pos].chr.to_s == "\t"))\r
212 pos = pos + 1\r
213 if (pos > dlzkar-2)\r
214 #puts "arh-CHYBA4!"\r
215 return "err"\r
216 end\r
217 end\r
218 \r
219 # hodnota tagname musi zacinat uvodzovkami\r
220 if (riadok[pos].chr.to_s !="\"")\r
221 #puts "arh-CHYBA5!"\r
222 return "err"\r
223 else \r
224 pos = pos + 1 \r
225 end \r
226 \r
227 # precitame hodnotu tagvalue do osobitnej premennej\r
228 tagvalue = ""\r
229 while (riadok[pos].chr.to_s != "\"")\r
230 \r
231 tagvalue = tagvalue + riadok[pos].chr.to_s\r
232 pos = pos + 1\r
233 \r
234 if (pos > dlzkar-2)\r
235 #puts "arh-CHYBA6!"\r
236 return "err"\r
237 end\r
238 end\r
239 \r
240 #puts "tagvalue -> {" + tagvalue + "} "\r
241 \r
242 # preskocime pripadne biele znaky pre zatvaracou hranatou zatvorkou\r
243 while (pos > dlzkar-2)\r
244 \r
245 if ((riadok[pos].chr.to_s !=" ") or (riadok[pos].chr.to_s != "\t"))\r
246 #puts "arh-CHYBA7!"\r
247 return "err"\r
248 end\r
249 end\r
250 \r
251 #ak sme sa bez chyb dostali az tu, je analyzovany retazec ok\r
252 return "ok"\r
253 end\r
254 \r
255 # ==================================================================================================\r
256 # metoda: analyzujtahy.rb\r
257 #\r
258 # Popis: metoda robi analyzu tahov zapisu sachovej partie vo formate PGN \r
259 #\r
260 # Vstup: retazec, v ktorom su tahy zo zapisu sachovej partie vo formate PGN \r
261 #\r
262 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
263 # ==================================================================================================\r
264 \r
265 def analyzujtahy(tahy)\r
266 \r
267 pos = 0\r
268 dlzkat = tahy.length\r
269 \r
270 result = "ok"\r
271 \r
272 #puts "TAHY (" + dlzkat.to_s + "):"\r
273 #puts " " \r
274 #puts tahy \r
275 #puts " "\r
276 \r
277 cislo_aktualne_sprac_tahu = 0\r
278 nasledujuci_token = "nct"\r
279 \r
280 # prechadzame cely vstupny retazec a berieme jeden token za druhym \r
281 # a posielame ich do prislusnych metod na analyzu. Tokeny su od seba \r
282 # oddelene bielymi znakmi.\r
283 #\r
284 # Druhy tokenov su:\r
285 # - cislo tahu\r
286 # - tah bieleho\r
287 # - tah cierneho\r
288 # - vysledok\r
289 \r
290 while (pos < dlzkat)\r
291 \r
292 # preskocime biele znaky\r
293 while ((pos > dlzkat-1) or (tahy[pos].chr.to_s ==" ") or (tahy[pos].chr.to_s == "\t") or (tahy[pos].chr.to_s == "\n"))\r
294 pos = pos + 1\r
295 end \r
296 \r
297 # precitame nasledujuci token\r
298 \r
299 next_token = ""\r
300 \r
301 while ((pos < dlzkat) and (tahy[pos].chr.to_s !=" ") and (tahy[pos].chr.to_s != "\t") and (tahy[pos].chr.to_s != "\n"))\r
302 \r
303 #puts "tahy[" + pos.to_s + "] -> " + tahy[pos].to_s + "(" + tahy[pos].chr + ")"\r
304 #puts "pos -> {" + pos.to_s + "}, next_token -> {" + next_token + "}" \r
305 \r
306 next_token = next_token + tahy[pos].chr.to_s\r
307 pos = pos + 1\r
308 \r
309 end\r
310 \r
311 #puts "next_token -> {" + next_token + "}" \r
312 \r
313 \r
314 #zistime ci dany token predstavuje zapis vysledku sachovej partie\r
315 is_result = is_result_token(next_token)\r
316 \r
317 # ak ano, dalsi token uz nema nasledovat\r
318 if (is_result == "result")\r
319 \r
320 nasledujuci_token == "nothing_more" \r
321 \r
322 else \r
323 \r
324 # ak bol predtym zapis vysledku, tak je to chyba, lebo za vysledok uz nema byt nic \r
325 if (nasledujuci_token == "nothing_more")\r
326 \r
327 puts "at-CHYBA1!"\r
328 return "err"\r
329 \r
330 # ak ma nasledovat token s cislo tahu, testujeme ci je to naozaj cislo tahu\r
331 elsif (nasledujuci_token == "nct")\r
332 \r
333 ntoken = (cislo_aktualne_sprac_tahu + 1).to_s + "."\r
334 \r
335 #puts "ntoken -> {" + ntoken + "}"\r
336 \r
337 if (next_token != ntoken)\r
338 puts "at-CHYBA2!"\r
339 return "err"\r
340 else\r
341 cislo_aktualne_sprac_tahu = cislo_aktualne_sprac_tahu + 1\r
342 nasledujuci_token = "tb"\r
343 end \r
344 \r
345 # ak ma nasledovat token "tah bieleho" alebo "tah cierneho", tak zmenime typ \r
346 # nasledujuceho tokenu a testujeme ci je dany token koretne zapisany tah\r
347 elsif (nasledujuci_token == "tb") \r
348 \r
349 nasledujuci_token = "tc"\r
350 \r
351 if (analyzuj_tah(next_token) == "err")\r
352 puts "at-CHYBA3!"\r
353 return "err" \r
354 end \r
355 \r
356 \r
357 elsif (nasledujuci_token == "tc") \r
358 \r
359 nasledujuci_token = "nct"\r
360 \r
361 if (analyzuj_tah(next_token) == "err")\r
362 puts "at-CHYBA4!"\r
363 return "err" \r
364 end \r
365 \r
366 end \r
367 \r
368 end \r
369 \r
370 end # koniec vonkajsieho cyklu na spracovanie tahov\r
371 \r
372 # ak posledny token nebol vysledok je to chyba\r
373 if (is_result != "result")\r
374 \r
375 result = "err"\r
376 \r
377 end \r
378 \r
379 return result\r
380 \r
381 end\r
382 \r
383 # ==================================================================================================\r
384 # metoda: is_result_token.rb\r
385 #\r
386 # Popis: metoda robi analyzu tokenu (retazca, ktory obsahuje bud cislo tahu, tah, alebo zapis \r
387 # vysledku sachovej partie). Konkretne zistuje ci dany token predstavuje zapis vysledku.\r
388 # Zapis vysledku musi byt v formate:\r
389 # "1-0"\r
390 # "0-1"\r
391 # "1/2-1/2"\r
392 #\r
393 # Vstup: retazec, v ktorom analyzovany token\r
394 #\r
395 # Vystup: vrati retazec "result", ak token predstavuje zapis vysledku, inak vrati retazec "noresult"\r
396 # ==================================================================================================\r
397 \r
398 def is_result_token(token)\r
399 \r
400 irt = "noresult"\r
401 \r
402 if (token == "1-0")\r
403 irt = "result"\r
404 elsif (token == "0-1")\r
405 irt = "result"\r
406 elsif (token == "1/2-1/2")\r
407 irt = "result"\r
408 else\r
409 irt = "noresult" \r
410 end \r
411 \r
412 return irt\r
413 \r
414 end\r
415 \r
416 # ==================================================================================================\r
417 # metoda: analyzuj_tah.rb\r
418 #\r
419 # Popis: metoda robi analyzu tokenu predstavujuceho jeden tah v zapise sachovej \r
420 # partie vo formate PGN. Nateraz sa robi len lexikalna analyza, teda zistuje \r
421 # sa ci je tah formalne spravne zapisany, nekontroluje sa, ci je dany tah mozny/spravny\r
422 # vhladom na pravidla sachu/aktualne postavenie figur na sachovnici. Je implementovana \r
423 # zakladna funkcionalita co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
424 # nerozlisuje ci ide o tah bieleho alebo cierneho, co by sme do buducnosti mohli - bud v jednej\r
425 # alebo dvoch metodach. Umoznilo by to presnejsiu analyzu tahu, najma ak by islo aj o kontrolu\r
426 # jeho spravnosti podla sachovych pravidiel.\r
427 #\r
428 # Vstup: retazec, v ktorom analyzovany token\r
429 #\r
430 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
431 # ==================================================================================================\r
432 \r
433 def analyzuj_tah(tah)\r
434 \r
435 dt = tah.length\r
436 up_tah = ""\r
437 \r
438 # ak je za tahom znak oznacujuci sach alebo mat, tak ho z tokenu odstranime\r
439 # kedze v pri terajsej analyze nema pre nas vyznam. Upraveny token/tah ulozime\r
440 # do novej premennej "up_tah"\r
441 if ((tah[dt-1].chr == "+") or (tah[dt-1].chr == "#"))\r
442 \r
443 i = 0\r
444 \r
445 while (i < dt-1) \r
446 up_tah = up_tah + tah[i].chr.to_s\r
447 i = i + 1\r
448 end\r
449 \r
450 else \r
451 up_tah = tah\r
452 end\r
453 \r
454 #puts up_tah\r
455 \r
456 # ak ide o malu alebo velku rosadu, tak je vsetko "ok" a koncime\r
457 if ((up_tah == "O-O") or (up_tah == "O-O"))\r
458 \r
459 result = "ok"\r
460 return result \r
461 \r
462 end\r
463 \r
464 # zistime dlzku tahu, a volame prislusnu metodu na jeho analyzu. \r
465 # Dlhsie tahy ako 5-znakove (podla nasej analyzy) nemozu existovat.\r
466 \r
467 if (up_tah.length == 2)\r
468 \r
469 result = dvojzntah(up_tah)\r
470 return result \r
471 \r
472 elsif (up_tah.length == 3)\r
473 \r
474 result = trojzntah(up_tah)\r
475 return result \r
476 \r
477 elsif (up_tah.length == 4)\r
478 \r
479 result = stvorzntah(up_tah)\r
480 return result \r
481 \r
482 elsif (up_tah.length == 5)\r
483 \r
484 result = patzntah(up_tah)\r
485 return result \r
486 \r
487 else\r
488 \r
489 puts "problem s tahom - [" + up_tah + "]"\r
490 puts "nespravny pocet znakov v tahu"\r
491 result = "err"\r
492 return result \r
493 \r
494 end\r
495 \r
496 result = "ok"\r
497 return result\r
498 \r
499 end\r
500 \r
501 # ==================================================================================================\r
502 # metoda: dvojzntah.rb\r
503 #\r
504 # Popis: metoda robi analyzu tokenu predstavujuceho dvojznakovy tah v zapise sachovej \r
505 # partie vo formate PGN. Nateraz sa robi len lexikalna analyza, teda zistuje \r
506 # sa ci je tah formalne spravne zapisany, nekontroluje sa, ci je dany tah mozny/spravny\r
507 # vhladom na pravidla sachu/aktualne postavenie figur na sachovnici. Je implementovana \r
508 # zakladna funkcionalita co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
509 #\r
510 # Pri dvojznakovom tokene ide o tah pesiakom (kde nie je branie ani premena pesiaka), \r
511 # kde prvy znak musi byt "a-h" a druhy znak (2-7)\r
512 #\r
513 # Vstup: retazec, v ktorom analyzovany token\r
514 #\r
515 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
516 # ==================================================================================================\r
517 \r
518 \r
519 def dvojzntah(akt_tah)\r
520 \r
521 result = "ok"\r
522 \r
523 #puts "dvojznakovy tah (2) - [" + akt_tah + "]"\r
524 \r
525 if ((akt_tah[0].chr.to_s < "a") or (akt_tah[0].chr.to_s > "h"))\r
526 \r
527 result = "err"\r
528 \r
529 end \r
530 \r
531 if ((akt_tah[1].chr.to_s < "2") or (akt_tah[1].chr.to_s > "7"))\r
532 \r
533 result = "err"\r
534 \r
535 end \r
536 \r
537 return result\r
538 \r
539 end\r
540 \r
541 # ==================================================================================================\r
542 # metoda: trojzntah.rb\r
543 #\r
544 # Popis: metoda robi analyzu tokenu predstavujuceho trojznakovy tah v zapise sachovej \r
545 # partie vo formate PGN. Nateraz sa robi len lexikalna analyza, teda zistuje \r
546 # sa ci je tah formalne spravne zapisany, nekontroluje sa, ci je dany tah mozny/spravny\r
547 # vhladom na pravidla sachu/aktualne postavenie figur na sachovnici. Je implementovana \r
548 # zakladna funkcionalita co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
549 #\r
550 # Pri trojznakovom tokene ide o tah pesiakom, ked sa premiena na inu figuru dosiahnuc \r
551 # svoj posledny rad. Alebo moze ist o bezny tah figurou bez brania.\r
552 #\r
553 # Vstup: retazec, v ktorom analyzovany token\r
554 #\r
555 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
556 # ==================================================================================================\r
557 \r
558 def trojzntah(akt_tah)\r
559 \r
560 if ((akt_tah[0].chr.to_s >= "a") and (akt_tah[0].chr.to_s <= "h"))\r
561 \r
562 if ((akt_tah[1].chr.to_s != "1") and (akt_tah[1].chr.to_s != "8"))\r
563 \r
564 #puts "problem s trojznakovym tahom (1) - [" + akt_tah + "]"\r
565 result = "err"\r
566 return result \r
567 \r
568 else \r
569 \r
570 if ((akt_tah[2].chr.to_s != "N") and (akt_tah[2].chr.to_s != "B") and\r
571 (akt_tah[2].chr.to_s != "R") and (akt_tah[2].chr.to_s != "Q"))\r
572 \r
573 #puts "problem s trojznakovym tahom (2) - [" + akt_tah + "]"\r
574 result = "err"\r
575 return result \r
576 \r
577 else\r
578 \r
579 #puts "trojznakovy tah (3) - [" + akt_tah + "]"\r
580 result = "ok"\r
581 return result \r
582 \r
583 end \r
584 \r
585 end\r
586 \r
587 elsif ((akt_tah[0].chr.to_s == "N") or (akt_tah[0].chr.to_s == "B") or\r
588 (akt_tah[0].chr.to_s == "R") or (akt_tah[0].chr.to_s == "Q") or (akt_tah[0].chr.to_s == "K"))\r
589 \r
590 if ((akt_tah[1].chr.to_s < "a") or (akt_tah[1].chr.to_s > "h"))\r
591 \r
592 #puts "problem s trojznakovym tahom (4) - [" + akt_tah + "]"\r
593 result = "err"\r
594 return result \r
595 \r
596 else \r
597 \r
598 if ((akt_tah[2].chr.to_s < "1") or (akt_tah[2].chr.to_s > "8"))\r
599 \r
600 #puts "problem s trojznakovym tahom (5) - [" + akt_tah + "]"\r
601 result = "err"\r
602 return result \r
603 \r
604 else\r
605 \r
606 #puts "trojznakovy tah (6) - [" + akt_tah + "]"\r
607 result = "ok"\r
608 return result \r
609 \r
610 end \r
611 \r
612 end\r
613 \r
614 else\r
615 \r
616 #puts "problem s trojznakovym tahom (7) - [" + akt_tah + "]"\r
617 result = "err"\r
618 return result \r
619 \r
620 end \r
621 \r
622 #puts "problem s trojznakovym tahom (8) - [" + akt_tah + "]" \r
623 result = "err"\r
624 return result\r
625 \r
626 end\r
627 \r
628 # ==================================================================================================\r
629 # metoda: stvorzntah.rb\r
630 #\r
631 # Popis: metoda robi analyzu tokenu predstavujuceho stvorznakovy tah v zapise sachovej \r
632 # partie vo formate PGN. Nateraz sa robi len lexikalna analyza, teda zistuje \r
633 # sa ci je tah formalne spravne zapisany, nekontroluje sa, ci je dany tah mozny/spravny\r
634 # vhladom na pravidla sachu/aktualne postavenie figur na sachovnici. Je implementovana \r
635 # zakladna funkcionalita co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
636 #\r
637 # Pri stvorznakovom tokene ide o branie pesiakom, alebo branie figurou, alebo tah\r
638 # figurou, ked na dane miesto mozu ist dve figury naraz.\r
639 #\r
640 # Vstup: retazec, v ktorom analyzovany token\r
641 #\r
642 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
643 # ==================================================================================================\r
644 \r
645 def stvorzntah(akt_tah)\r
646 \r
647 if ((akt_tah[0].chr.to_s >= "a") and (akt_tah[0].chr.to_s <= "h"))\r
648 \r
649 if (akt_tah[1].chr.to_s != "x") \r
650 \r
651 #puts "problem so stvorznakovym tahom (1) - [" + akt_tah + "]"\r
652 result = "err"\r
653 return result \r
654 \r
655 else \r
656 \r
657 if ((akt_tah[2].chr.to_s < "a") or (akt_tah[2].chr.to_s > "h"))\r
658 \r
659 #puts "problem so stvorznakovym tahom (2) - [" + akt_tah + "]"\r
660 result = "err"\r
661 return result \r
662 \r
663 else\r
664 \r
665 if ((akt_tah[3].chr.to_s < "2") and (akt_tah[3].chr.to_s > "7"))\r
666 \r
667 #puts "problem so stvorznakovym tahom (3) - [" + akt_tah + "]"\r
668 result = "err"\r
669 return result \r
670 \r
671 else\r
672 \r
673 #puts "stvorznakovy tah (4) - [" + akt_tah + "]"\r
674 result = "ok"\r
675 return result \r
676 \r
677 end \r
678 \r
679 end \r
680 \r
681 end\r
682 \r
683 elsif ((akt_tah[0].chr.to_s == "N") or (akt_tah[0].chr.to_s == "B") or\r
684 (akt_tah[0].chr.to_s == "R") or (akt_tah[0].chr.to_s == "Q") or (akt_tah[0].chr.to_s == "K"))\r
685 \r
686 if (akt_tah[1].chr.to_s == "x") \r
687 \r
688 if ((akt_tah[2].chr.to_s < "a") or (akt_tah[2].chr.to_s > "h"))\r
689 \r
690 #puts "problem so stvorznakovym tahom (5) - [" + akt_tah + "]"\r
691 result = "err"\r
692 return result \r
693 \r
694 else\r
695 \r
696 if ((akt_tah[3].chr.to_s < "1") or (akt_tah[3].chr.to_s > "8"))\r
697 \r
698 #puts "problem so stvorznakovym tahom (6) - [" + akt_tah + "]"\r
699 result = "err"\r
700 return result \r
701 \r
702 else\r
703 \r
704 #puts "stvorznakovy tah (7) - [" + akt_tah + "]"\r
705 result = "ok"\r
706 return result \r
707 \r
708 end \r
709 \r
710 end \r
711 \r
712 else\r
713 \r
714 if ((akt_tah[1].chr.to_s >= "1") and (akt_tah[1].chr.to_s <= "8"))\r
715 \r
716 if ((akt_tah[2].chr.to_s < "a") or (akt_tah[2].chr.to_s > "h"))\r
717 \r
718 #puts "problem so stvorznakovym tahom (8) - [" + akt_tah + "]"\r
719 result = "err"\r
720 return result \r
721 \r
722 else\r
723 \r
724 if ((akt_tah[3].chr.to_s < "1") or (akt_tah[3].chr.to_s > "8"))\r
725 \r
726 #puts "problem so stvorznakovym tahom (9) - [" + akt_tah + "]"\r
727 result = "err"\r
728 return result \r
729 \r
730 else\r
731 \r
732 #puts "stvorznakovy tah (10) - [" + akt_tah + "]"\r
733 result = "ok"\r
734 return result \r
735 \r
736 end \r
737 \r
738 end \r
739 \r
740 elsif ((akt_tah[1].chr.to_s >= "a") and (akt_tah[1].chr.to_s <= "h"))\r
741 \r
742 if ((akt_tah[2].chr.to_s < "a") or (akt_tah[2].chr.to_s > "h"))\r
743 \r
744 #puts "problem so stvorznakovym tahom (11) - [" + akt_tah + "]"\r
745 result = "err"\r
746 return result \r
747 \r
748 else\r
749 \r
750 if ((akt_tah[3].chr.to_s < "1") or (akt_tah[3].chr.to_s > "8"))\r
751 \r
752 #puts "problem so stvorznakovym tahom (12) - [" + akt_tah + "]"\r
753 result = "err"\r
754 return result \r
755 \r
756 else\r
757 \r
758 #puts "stvorznakovy tah (13) - [" + akt_tah + "]"\r
759 result = "ok"\r
760 return result \r
761 \r
762 end \r
763 \r
764 end \r
765 \r
766 else\r
767 \r
768 #puts "problem so stvorznakovym tahom (14) - [" + akt_tah + "]"\r
769 result = "err"\r
770 return result\r
771 \r
772 end\r
773 \r
774 end\r
775 \r
776 else \r
777 \r
778 \r
779 #puts "problem s stvorznakovym tahom (15) - [" + akt_tah + "]" \r
780 result = "err"\r
781 return result\r
782 \r
783 end\r
784 \r
785 #puts "problem s stvorznakovym tahom (16) - [" + akt_tah + "]" \r
786 result = "err"\r
787 return result\r
788 \r
789 end\r
790 \r
791 # ==================================================================================================\r
792 # metoda: patzntah.rb\r
793 #\r
794 # Popis: metoda robi analyzu tokenu predstavujuceho patznakovy tah v zapise sachovej \r
795 # partie vo formate PGN. Nateraz sa robi len lexikalna analyza, teda zistuje \r
796 # sa ci je tah formalne spravne zapisany, nekontroluje sa, ci je dany tah mozny/spravny\r
797 # vhladom na pravidla sachu/aktualne postavenie figur na sachovnici. Je implementovana \r
798 # zakladna funkcionalita co sa tyka PGN formatu, nie je to plna implementacia PGN standardu.\r
799 #\r
800 # Pri patznakovom tokene ide o tah figurou, ked na dane miesto mozu ist dve figury naraz,\r
801 # a sucasne je to branie.\r
802 #\r
803 # Vstup: retazec, v ktorom analyzovany token\r
804 #\r
805 # Vystup: vrati retazec "ok" alebo "err", podla toho ako dopadla analyza \r
806 # ==================================================================================================\r
807 \r
808 def patzntah(akt_tah)\r
809 \r
810 if ((akt_tah[0].chr.to_s >= "a") and (akt_tah[0].chr.to_s <= "h")) \r
811 \r
812 if (akt_tah[1].chr.to_s != "x") \r
813 \r
814 #puts "problem s patznakovym tahom (1) - [" + akt_tah + "]"\r
815 result = "err"\r
816 return result \r
817 \r
818 else \r
819 \r
820 if ((akt_tah[2].chr.to_s < "a") or (akt_tah[2].chr.to_s > "h")) \r
821 \r
822 #puts "problem s patznakovym tahom (2) - [" + akt_tah + "]"\r
823 result = "err"\r
824 return result \r
825 \r
826 else \r
827 \r
828 if ((akt_tah[3].chr.to_s != "1") and (akt_tah[3].chr.to_s != "8")) \r
829 \r
830 \r
831 puts akt_tah[3].chr.to_s\r
832 \r
833 puts "problem s patznakovym tahom (3) - [" + akt_tah + "]"\r
834 result = "err"\r
835 return result \r
836 \r
837 else #4\r
838 \r
839 if ((akt_tah[4].chr.to_s != "N") and (akt_tah[4].chr.to_s != "B") and\r
840 (akt_tah[4].chr.to_s != "R") and (akt_tah[4].chr.to_s != "Q")) \r
841 \r
842 puts "problem s patznakovym tahom (4) - [" + akt_tah + "]"\r
843 result = "err"\r
844 return result\r
845 \r
846 else #5\r
847 \r
848 puts "patznakovy tah (5) - [" + akt_tah + "]"\r
849 result = "ok"\r
850 return result \r
851 \r
852 \r
853 end #5\r
854 \r
855 end #4 \r
856 \r
857 end #3\r
858 \r
859 end #2\r
860 \r
861 elsif ((akt_tah[0].chr.to_s == "N") or (akt_tah[0].chr.to_s == "B") or\r
862 (akt_tah[0].chr.to_s == "R") or (akt_tah[0].chr.to_s == "Q")) \r
863 \r
864 if ((akt_tah[1].chr.to_s >= "1") and (akt_tah[1].chr.to_s <= "8")) \r
865 \r
866 if (akt_tah[2].chr.to_s != "x") \r
867 \r
868 #puts "problem s patznakovym tahom (6) - [" + akt_tah + "]"\r
869 result = "err"\r
870 return result \r
871 \r
872 else \r
873 \r
874 if ((akt_tah[3].chr.to_s < "a") or (akt_tah[3].chr.to_s > "h")) \r
875 \r
876 #puts "problem s patznakovym tahom (7) - [" + akt_tah + "]"\r
877 result = "err"\r
878 return result \r
879 \r
880 else \r
881 \r
882 if ((akt_tah[4].chr.to_s < "1") or (akt_tah[4].chr.to_s > "8")) \r
883 \r
884 #puts "problem s patznakovym tahom (8) - [" + akt_tah + "]"\r
885 result = "err"\r
886 return result \r
887 \r
888 else\r
889 \r
890 #puts "patznakovy tah (9) - [" + akt_tah + "]"\r
891 result = "ok"\r
892 return result \r
893 \r
894 end \r
895 \r
896 end \r
897 \r
898 end \r
899 \r
900 elsif ((akt_tah[1].chr.to_s >= "a") and (akt_tah[1].chr.to_s <= "h"))\r
901 \r
902 if (akt_tah[2].chr.to_s != "x") \r
903 \r
904 #puts "problem s patznakovym tahom (10) - [" + akt_tah + "]"\r
905 result = "err"\r
906 return result \r
907 \r
908 else \r
909 \r
910 if ((akt_tah[3].chr.to_s < "a") or (akt_tah[3].chr.to_s > "h")) \r
911 \r
912 #puts "problem s patznakovym tahom (11) - [" + akt_tah + "]"\r
913 result = "err"\r
914 return result \r
915 \r
916 else \r
917 \r
918 if ((akt_tah[4].chr.to_s < "1") or (akt_tah[4].chr.to_s > "8")) \r
919 \r
920 #puts "problem s patznakovym tahom (12) - [" + akt_tah + "]"\r
921 result = "err"\r
922 return result \r
923 \r
924 else \r
925 \r
926 #puts "patznakovy tah (13) - [" + akt_tah + "]"\r
927 result = "ok"\r
928 return result \r
929 \r
930 end \r
931 \r
932 end \r
933 \r
934 end \r
935 \r
936 else\r
937 \r
938 #puts "problem s patznakovym tahom (14) - [" + akt_tah + "]"\r
939 result = "err"\r
940 return result\r
941 \r
942 end\r
943 \r
944 else \r
945 \r
946 \r
947 #puts "problem s patznakovym tahom (15) - [" + akt_tah + "]" \r
948 result = "err"\r
949 return result\r
950 \r
951 end\r
952 \r
953 #puts "problem s stvorznakovym tahom (16) - [" + akt_tah + "]" \r
954 result = "err"\r
955 return result\r
956 \r
957 end\r
958 \r
959 # ==================================================================================================\r
960 # metoda: <main> = hlavny program\r
961 #\r
962 # Popis: v hlavnom programe precitame zo vstupu meno suboru, v ktorom je yapis partie, \r
963 # ktoru mame analyzovat. Cely obsah suboru precitame do retazca, ktorz posleme \r
964 # do metody "Analzyuj", vratenu hodnotu = vysledok analyzy = zobrazime na vystup\r
965 #\r
966 # Vstup: nic na prikazovom riadku, vstupom od uzivatela je nazov \r
967 # textoveho suboru, v ktorom je zapis partie ulozeny\r
968 #\r
969 # Vystup: program vypise na vystup retazec "ok", ak je zapis sachovej partie\r
970 # v poriadku, ak nie je vypise na vystup retazec "err"\r
971 # ==================================================================================================\r
972 \r
973 \r
974 #puts "zadaj meno suboru: "\r
975 filename = "pgn.txt"\r
976 myfile = File.open(filename,"r")\r
977 pgnsubor = myfile.read\r
978 myfile.close\r
979 #puts pgnsubor\r
980 vysledok = "err"\r
981 vysledok=analyzuj(pgnsubor)\r
982 puts "\n" + vysledok\r