momente şi schiţe de informatică

Modelarea tablei şi jocului de şah (XVI)

Creat: 2012/jul       Comentarii

javaScript | jQuery | JSON | reprezentare 0x88 | șah

Conversia între notaţia obişnuită a câmpurilor şi indecşii corespunzători acestora în .x88Board[] poate fi uşurată, dacă am folosi un tabel TO_x88{} în care (de la bun început) vom fi înregistrat asocierile respective. Va fi util şi un tabel ALL_MOVES{} în care, pentru fiecare piesă şi pentru fiecare câmp [a-h][1-8] - să avem (tot în notaţie obişnuită) lista câmpurilor pe care ar putea muta acea piesă, plecând de pe câmpul indicat.

Un exemplu de utilizare a unor tabele precalculate

Să zicem că tocmai am preluat din textul PGN al partidei, mutarea albului Ne2. Ştim câmpul final 'e2' şi piesa care trebuie mutată - un cal alb. Nu ştim câmpul iniţial al acestui cal - în schimb (vezi sintaxa SAN în (XI) şi (XII)) mai ştim că numai unul singur dintre caii albi, poate muta legal pe e2; prin urmare, putem proceda ca în acest pseudocod:

/* Reducerea posibilităţilor FROM-TO la aceea care este legală */
piece = 2; // codul calului alb
TO = 'e2'; // câmpul final, indicat de SAN (Ne2)
table_cal = ALL_MOVES['N'][TO]; // unde poate muta calul de pe TO = 'e2'
for (i = 0; i < table_cal.length; i++) { 
    FROM = table_cal[i]; // de exemplu: FROM = 'g1', sau FROM = 'c3'  
    if (BOARD[TO_x88[FROM]] == piece) { // există Cal pe câmpul FROM?
        dacă mutarea FROM-TO este legală: // Nc3-e2 lasă regele în şah?
             actualizează x88Board[], conform mutării
             BREAK // şi treci la următoarea mutare din textul PGN
    }
}

În loc de a căuta pe toată tabla, care cai albi pot muta pe 'e2' - am căutat numai pe cele maximum 8 câmpuri preînregistrate în ALL_MOVES['N']['e2'] (câmpurile "TO" pe care poate sări calul din 'e2', sau totuna - câmpurile "FROM" de unde ar putea veni pe 'e2'). Şi am folosit TO_x88{} pentru a transforma FROM din notaţia obişnuită, în index de acces pe BOARD[].

Desigur, am profitat de faptul că mutările calului (şi la fel pentru celelalte piese) sunt reversibile (după mutarea de pe FROM pe TO este posibil şi invers: de pe TO pe FROM); pentru mutările pionului (care sunt ireversibile) va trebui să procedăm altfel decât în pseudocodul de mai sus.

Tabel de conversie la index 0x88 a notaţiei obişnuite

TO_x88{} se poate obţine direct (fără widget-ul pe care îl tot dezvoltăm de ceva vreme aici), încărcând în browser fişierul următor:

<!DOCTYPE html>
<head>
    <script type="text/javascript" src="js/jquery-1.6.2.min.js"></script>
    <script type="text/javascript" src="js/json2.js"></script>
    <title>Tabel de conversie: notaţia obişnuită -> index BOARD[]</title>
</head>
<body>
    <div id="to_x88"></div>
    <script>
function ah18_x88() {
    var a_h = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
    var ah_88 = {}; // câmp [a-h][1-8] ==> index în BOARD[]
    for(var c = 0; c < 8; c++) 
        for(var r = 1; r <= 8; r++) {
            field = a_h[c] + r; // notaţia obişnuită [a-h][1-8]
            // asociază indexul în BOARD[] al câmpului
            ah_88[field] = (field.charCodeAt(0) - 97) + 
                           (field.charCodeAt(1) - 49) * 16;
        }
    return ah_88;
}
$(function() {
    ah_88 = ah18_x88();
    $('#to_x88').html("var TO_x88 = " + JSON.stringify(ah_88));     
});
    </script>
</body>

Vizualizăm sursa generată de browser prin execuţia <script>-ului (în Firefox avem un meniu "View Generated Source") şi copiem conţinutul diviziunii "to_x88" (după o mică reformatare) în fişierul JS al widget-ului nostru (îl numisem mai demult, "brw-sah.js"):

var TO_x88 = { 
    'a1': 0, 'a2': 16, 'a3': 32, 'a4': 48, 'a5': 64, 'a6': 80, 'a7': 96, 'a8': 112,
    'b1': 1, 'b2': 17, 'b3': 33, 'b4': 49, 'b5': 65, 'b6': 81, 'b7': 97, 'b8': 113,
    'c1': 2, 'c2': 18, 'c3': 34, 'c4': 50, 'c5': 66, 'c6': 82, 'c7': 98, 'c8': 114,
    'd1': 3, 'd2': 19, 'd3': 35, 'd4': 51, 'd5': 67, 'd6': 83, 'd7': 99, 'd8': 115,
    'e1': 4, 'e2': 20, 'e3': 36, 'e4': 52, 'e5': 68, 'e6': 84, 'e7': 100, 'e8': 116,
    'f1': 5, 'f2': 21, 'f3': 37, 'f4': 53, 'f5': 69, 'f6': 85, 'f7': 101, 'f8': 117,
    'g1': 6, 'g2': 22, 'g3': 38, 'g4': 54, 'g5': 70, 'g6': 86, 'g7': 102, 'g8': 118,
    'h1': 7, 'h2': 23, 'h3': 39, 'h4': 55, 'h5': 71, 'h6': 87, 'h7': 103, 'h8': 119
};

În fişierul redat mai sus am folosit JSON, pentru a obţine imediat (scutindu-ne de a scrie codul prin care se adaugă apostrofurile, două-puncte, virgulele, etc.) reprezentarea textuală a obiectului ah_88 constituit prin funcţia ah18_x88() - invocând metoda .stringify() a obiectului JSON. De fapt, JSON.stringify() este deja disponibil în unele browsere moderne (şi în acest caz se poate elimina linia din <head> prin care se încarcă "json2.js" în documentul redat mai sus).

Tabelul tuturor mutărilor pieselor

Pentru calculul acestui tabel folosim metoda _gen_moves(), făcând astfel şi o primă testare a generatorului de mutări (vezi (XV)).

Vom proceda astfel: adăugăm (temporar!) widget-ului nostru o metodă publică .allMovesTable(), care constituie obiectul JS conţinând toate mutările pieselor şi îl înscrie (după serializarea lui, cu JSON.stringify()) în diviziunea de document al cărei identificator i-a fost transmis la apelare.

Construcţia unui obiect JS al tuturor mutărilor pieselor

În .allMovesTable() prevedem întâi, şablonul var allMoves = {'N': {}, ...} pentru obiectul JS care trebuie completat; de exemplu allMoves['N']['e2'] va trebui să fie tabloul ['c1', 'c3', 'd4', 'f4', 'g3', 'g1'], conţinând câmpurile pe care poate sări calul aflat pe 'e2' (sau, la fel de valabil: al câmpurilor de unde calul poate veni pe 'e2').

Apoi, se şterg de pe x88Board[] toate piesele care există eventual în momentul apelării metodei; pe parcurs, se va aşeza pe tablă o singură piesă şi se vor genera mutările posibile ale ei - după care piesa va fi ştearsă, reluând pentru altă poziţionare a ei, sau pentru altă piesă.

Culoarea piesei nu contează - încât se alege albul, pentru piese şi pentru partea aflată la mutare; deasemenea, rocadele nu au sens în acest context - încât se resetează this.castle.

Să observăm însă că anularea drepturilor de rocadă este chiar obligatorie: dacă în momentul apelării valoarea .castle ar fi de exemplu 2 (adică albul poate face încă, mutările O-O şi O-O-O), atunci în toate listele de mutări ale piesei se vor adăuga şi câmpurile "TO" ale rocadelor 'g1', 'c1' - dat fiind că _gen_moves() generează toate mutările posibile pentru piesele de pe tablă ale părţii aflate la mutare şi pe de altă parte, rocadele sunt generate fără testarea prealabilă a prezenţei regilor pe câmpurile cuvenite (aceasta rezultând implicit din valoarea curentă .castle).

Mai departe, pentru fiecare piesă (dintre cele cinci existente) şi pentru fiecare câmp al tablei - se generează lista mutărilor (în codificarea binară pe care am introdus-o anterior) şi apoi se reţine din fiecare mutare numai câmpul "TO", constituind cu aceste valori (convertite la notaţia obişnuită) tabloul care se adaugă corespunzător în obiectul allMoves:

allMovesTable: function(id_dest) {
    var allMoves = {
        'N': {}, 'K': {}, 'B': {}, 'R': {}, 'Q': {}
    }; // allMoves['N']['e2'] = ['c1', 'c3', 'd4', 'f4', 'g3', 'g1']

    var BOARD = this.x88Board; // vom avea o singură piesă (albă)
    for (var i = 0; i < 128; i++) BOARD[i] = 0; 

    this.to_move = 0; // fixăm Albul la mutare
    this.castle = 0;  // excludem rocadele (important!) 

    for(var p = 4; p <= 12; p += 2) { // N, K, B, R, Q (piesele albe)
        var piece = PIECE_CHAR[p];
        for(var fld in TO_x88) { // 'a1', 'a2', ..., 'h8'
            BOARD[TO_x88[fld]] = p; // pune piesa p pe câmpul fld
            var moves = []; // codurile mutărilor posibile ale piesei
            this._gen_moves(moves);  
            var to_arr = []; // câmpurile TO din codurile mutărilor
            for(var i = 0, n = moves.length; i < n; i++) {
                var TO = (moves[i] >> 8) & 0xFF; // extrage indexul TO
                to_arr.push(// transformă TO în notaţie obişnuită
                            String.fromCharCode(97 + (TO & 7)) + ((TO >> 4) + 1));
            }
            allMoves[piece][fld] = to_arr;
            BOARD[TO_x88[fld]] = 0; // şterge piesa curentă de pe fld
        }
    }
    $('#' + id_dest).html( // inserează în DOM, la #id_dest
                JSON.stringify(allMoves, null, 2)); 
},

Am adăugat .allMovesTable() în cadrul widget-ului nostru numai în scopul de a obţine tabelul ALL_MOVES{}, de care vom avea nevoie mai încolo (şi eventual, în scopul testării generatorului de mutări); după ce vom fi obţinut acest tabel - putem şterge metoda redată mai sus.

Obţinerea efectivă a tabelului tuturor mutărilor pieselor

Rămâne să invocăm această metodă dintr-un fişier HTML care instanţiază widget-ul nostru - de exemplu (rezumând la strictul necesar):

<!DOCTYPE html>
<head>
    <script src="js/jquery-1.7.2.min.js"></script>
    <script src="js/jquery.ui.core.min.js"></script>
    <script src="js/jquery.ui.widget.min.js"></script>
    <link href="css/pgnbrw.css" rel="stylesheet" type="text/css" />
    <script src="js/pgnbrw.js"></script>
    <title>Tabelul tuturor mutărilor pieselor</title>
</head>
<body>
<textarea id="txtPGN"></textarea> <!-- pentru instanţierea widget-ului -->
<div id="allMoves"></div> <!-- aici vom obţine tabelul tuturor mutărilor -->
<script>
    $(function() {
        $('#txtPGN').pgnbrw({field_size: 20, show_PGN: false, with_FEN: false})
                    .pgnbrw('allMovesTable', 'allMoves');
    });
</script>
</body>

Cum se vede mai sus - am făcut unele modificări de denumiri faţă de (VII) (de când n-am mai redat un HTML pentru instanţierea widget-ului): am renunţat la denumirile "brw-sah.js", "brw-sah.css" (de-acum vor fi "pgnbrw.*") şi am redenumit widget-ul prin .pgnbrw(), în loc de ".fenBrowser()".

Nu derularea unei partide de şah ne interesează, încât am instanţiat widget-ul folosind opţiuni de anulare a unor anumite zone; după instanţiere, .pgnbrw('allMovesTable', 'allMoves') invocă metoda publică definită mai sus, indicându-i (ca parametru) diviziunea "allMoves".

Încărcând în browser, obţinem ceea ce redăm parţial alături. Dedesubtul tablei de şah avem textul tabelului care ne interesează; îl copiem din fereastra browserului într-un editor de text - în gedit. Dacă dorim (mai ales, pentru a verifica uşor mutările generate) putem formata textul respectiv folosind meniul "Search/Replace" (căutăm "}, " şi înlocuim cu "},\n\n", etc.).

În final - înscriem tabelul în "pgnbrw.js" (în zona variabilelor exterioare widget-ului):

var ALL_MOVES = {
   'N': {
       'a1': ['b3','c2'],
       'b1': ['a3','c3','d2'],
       'c1': ['a2','b3','d3','e2'],
       // etc.
       'g8': ['f6','e7','h6'],
       'h8': ['g6','f7']
   },
   'K': {
       'a1': ['a2','b2','b1'], 
       'b1': ['a2','b2','c2','a1','c1'],
       //etc.
       'h8': ['g8', 'g7', 'h7']
   },
   'B': {
       'a1': ['b2','c3','d4','e5','f6','g7','h8'],
       'b1': ['c2','d3','e4','f5','g6','h7','a2'],
       // etc.
       'h8': ['a1','b2','c3','d4','e5','f6','g7']
   },
   'R': {
       'a1': ['b1','c1','d1','e1','f1','g1','h1','a2','a3','a4','a5','a6','a7','a8'],
       //etc.
   },
   'Q': {
       'a1': ['b1','c1','d1','e1','f1','g1','h1','a2','a3','a4','a5','a6','a7','a8',
              'b2','c3','d4','e5','f6','g7','h8'],
       //etc.
   }
};

Avem de folosit acest tabel (în maniera pseudocodului formulat la început) în cursul metodei de validare a mutării curente din textul PGN al partidei: mutarea SAN respectivă ne dă câmpul TO, iar tabelul de mai sus ne furnizează câmpurile FROM posibile pentru acest TO; aceste posibilităţi "FROM-TO" sunt apoi reduse folosind _gen_moves() şi _makeMove(), la aceea care este legală.

Media Dinamică

Articolul 50

Drumuri

ŞahStartTemp

25
32
17
4
19
34
14
3
26
33
16
5
31
24
15
18
35
20
2
13
27
6
9
23
30
11
8
21
28
12
22
29
10
7

Ambiţiile Cavalerului

Localităţi

Judeţ:

Constituirea unei baze de date colectând cu Python de pe web

Bliţuri

Load another random Bliţ

//slightchess

Decoraţiuni hiperbolice

SALARII 2017, 2018

//bacMath
variante BAC matematică

Bacalaureat 2015 -
de la forma microsoftizată, la R

modelare ŞAH, I-XX
construcţia unui PGN-browser()

Linux şi aplicaţii Web
în 24 de ore

Orar şcolar - exemplu
după un orar generat de "aSc Orare"

Orar Adjust
ajustează orarul şcolar