"ដប់ប្រាំ" នៅក្នុង Java - របៀបបង្កើតហ្គេមពេញលក្ខណៈ

"ដប់ប្រាំ" ឬ "ដប់ប្រាំ" គឺជាឧទាហរណ៍ដ៏អស្ចារ្យនៃហ្គេមតក្កវិជ្ជាដ៏សាមញ្ញមួយ ដែលពេញនិយមទូទាំងពិភពលោក។ ដើម្បីដោះស្រាយល្បែងផ្គុំរូប អ្នកត្រូវរៀបចំការ៉េដែលមានលេខតាមលំដាប់លំដោយ ពីតូចបំផុតទៅធំ។ វាមិនងាយស្រួលទេ ប៉ុន្តែគួរឱ្យចាប់អារម្មណ៍។

នៅក្នុងមេរៀនថ្ងៃនេះ យើងបង្ហាញអ្នកពីរបៀបអភិវឌ្ឍ Fifteen ក្នុង Java 8 ជាមួយ Eclipse។ ដើម្បីអភិវឌ្ឍ UI យើងនឹងប្រើ Swing API។

យើងរំលឹក៖ សម្រាប់អ្នកអានទាំងអស់នៃ "Habr" - ការបញ្ចុះតម្លៃ 10 rubles នៅពេលចុះឈ្មោះក្នុងវគ្គសិក្សា Skillbox ណាមួយដោយប្រើលេខកូដផ្សព្វផ្សាយ "Habr" ។

Skillbox ណែនាំ៖ វគ្គសិក្សាតាមអ៊ីនធឺណិត "Profession Java Developer".

ការរចនាហ្គេម

នៅដំណាក់កាលនេះ អ្នកត្រូវកំណត់លក្ខណៈសម្បត្តិ៖

• ទំហំ - ទំហំនៃទីលានលេង;
• nbTiles - ចំនួនស្លាកនៅក្នុងវាល។ nbTiles = ទំហំ * ទំហំ - 1;
• ក្រឡាក្បឿងគឺជាស្លាកមួយ ដែលជាអារេមួយវិមាត្រនៃចំនួនគត់។ ស្លាកនីមួយៗនឹងទទួលបានតម្លៃតែមួយគត់នៅក្នុងជួរ [0, nbTiles] ។ សូន្យតំណាងឱ្យការ៉េទទេ;
• blankPos - ទីតាំងនៃការ៉េទទេ។

តក្កវិជ្ជាហ្គេម

យើងត្រូវកំណត់វិធីសាស្រ្តកំណត់ឡើងវិញដែលប្រើដើម្បីចាប់ផ្តើមទីតាំងហ្គេមថ្មី។ នេះជារបៀបដែលយើងកំណត់តម្លៃសម្រាប់ធាតុនីមួយៗនៃអារេស្លាក។ បន្ទាប់មកយើងដាក់ blankPos នៅទីតាំងចុងក្រោយនៃអារេ។

យើងក៏ត្រូវការវិធីសាស្រ្តសាប់ដើម្បីសាប់អារេនៃស្លាក។ យើងមិនរួមបញ្ចូលស្លាកទទេនៅក្នុងដំណើរការសាប់ដើម្បីទុកវានៅទីតាំងដើមរបស់វានោះទេ។

ដោយសារ​តែ​ពាក់កណ្តាល​នៃ​ទីតាំង​ចាប់ផ្តើម​ដែល​អាច​ធ្វើ​បាន​នៃ​ល្បែងផ្គុំរូប​មាន​ដំណោះស្រាយ លទ្ធផល​នៃ​ការ​សាប់​ត្រូវតែ​ពិនិត្យ​ដើម្បី​ប្រាកដថា​ប្លង់​បច្ចុប្បន្ន​អាច​ដោះស្រាយ​បាន​ជាទូទៅ។ ដើម្បីធ្វើដូចនេះយើងកំណត់វិធីសាស្រ្ត isSovable ។

ប្រសិនបើ speck ជាក់លាក់មួយនាំមុខដោយ speck ដែលមានតម្លៃខ្ពស់ជាងនេះ វាត្រូវបានចាត់ទុកថាជាការបញ្ច្រាស។ នៅ​ពេល​ស្លាក​ទទេ​នៅ​នឹង​កន្លែង ចំនួន​នៃ​ការ​បញ្ច្រាស​ត្រូវ​តែ​មាន​សូម្បី​តែ​សម្រាប់​ផ្ដុំ​រូប​ដែល​អាច​ដោះ​ស្រាយ​បាន។ ដូច្នេះ​យើង​រាប់​ចំនួន​បញ្ច្រាស ហើយ​ត្រឡប់​ពិត​វិញ ប្រសិនបើ​ចំនួន​ស្មើ។

បន្ទាប់មកទៀត វាជារឿងសំខាន់ក្នុងការកំណត់វិធីសាស្ត្រ isSolved ដើម្បីពិនិត្យមើលថាតើ Game Ofteen hand របស់យើងត្រូវបានដោះស្រាយឬអត់។ ដំបូងយើងពិនិត្យមើលកន្លែងដែលស្លាកទទេស្ថិតនៅ។ ប្រសិនបើនៅក្នុងទីតាំងដំបូង នោះប្លង់បច្ចុប្បន្នគឺថ្មី មិនត្រូវបានដោះស្រាយពីមុនទេ។ បន្ទាប់មកយើងធ្វើរង្វិលជុំតាមក្រឡាក្នុងលំដាប់បញ្ច្រាស ហើយប្រសិនបើតម្លៃស្លាកខុសពីសន្ទស្សន៍ +1 ដែលត្រូវគ្នានោះ យើងត្រឡប់មិនពិត។ បើមិនដូច្នេះទេ វាដល់ពេលដែលត្រូវត្រឡប់ពិតវិញនៅចុងបញ្ចប់នៃវិធីសាស្ត្រ ព្រោះរូបផ្គុំត្រូវបានដោះស្រាយរួចហើយ។

វិធីសាស្រ្តមួយទៀតដែលត្រូវកំណត់គឺ newGame ។ វាត្រូវបានទាមទារដើម្បីបង្កើតឧទាហរណ៍ថ្មីនៃហ្គេម។ ដើម្បីធ្វើដូច្នេះ យើងកំណត់បន្ទះហ្គេមឡើងវិញ បន្ទាប់មកសាប់វា ហើយបន្តរហូតដល់ទីតាំងហ្គេមអាចដោះស្រាយបាន។

នេះគឺជាឧទាហរណ៍នៃកូដដែលមានតក្កវិជ្ជាសំខាន់នៃស្លាក៖

private void newGame() {
  do {
    reset(); // reset in initial state
    shuffle(); // shuffle
  } while(!isSolvable()); // make it until grid be solvable
 
  gameOver = false;
}
 
private void reset() {
  for (int i = 0; i < tiles.length; i++) {
    tiles[i] = (i + 1) % tiles.length;
  }
 
  // we set blank cell at the last
  blankPos = tiles.length - 1;
}
 
private void shuffle() {
  // don't include the blank tile in the shuffle, leave in the solved position
  int n = nbTiles;
 
  while (n > 1) {
    int r = RANDOM.nextInt(n--);
    int tmp = tiles[r];
    tiles[r] = tiles[n];
    tiles[n] = tmp;
  }
}
 
// Only half permutations of the puzzle are solvable/
// Whenever a tile is preceded by a tile with higher value it counts
// as an inversion. In our case, with the blank tile in the solved position,
// the number of inversions must be even for the puzzle to be solvable
private boolean isSolvable() {
  int countInversions = 0;
 
  for (int i = 0; i < nbTiles; i++) {
    for (int j = 0; j < i; j++) {
      if (tiles[j] > tiles[i])
        countInversions++;
    }
  }
 
  return countInversions % 2 == 0;
}
 
private boolean isSolved() {
  if (tiles[tiles.length - 1] != 0) // if blank tile is not in the solved position ==> not solved
    return false;
 
  for (int i = nbTiles - 1; i >= 0; i--) {
    if (tiles[i] != i + 1)
      return false;
  }
 
  return true;
}

ចុងក្រោយ អ្នកត្រូវរៀបចំកម្មវិធីចលនារបស់ស្លាកក្នុងអារេ។ លេខកូដនេះនឹងត្រូវបានហៅនៅពេលក្រោយតាមរយៈការហៅត្រឡប់មកវិញដើម្បីឆ្លើយតបទៅនឹងចលនាទស្សន៍ទ្រនិច។ ហ្គេមរបស់យើងនឹងគាំទ្រចលនាក្រឡាជាច្រើនក្នុងពេលតែមួយ។ ដូច្នេះបន្ទាប់ពីយើងបានបំប្លែងទីតាំងចុចនៅលើអេក្រង់ទៅជាស្លាកមួយ យើងទទួលបានទីតាំងនៃស្លាកទទេ ហើយរកមើលទិសដៅនៃចលនាដើម្បីគាំទ្រចលនារបស់វាជាច្រើនក្នុងពេលតែមួយ។

នេះគឺជាកូដឧទាហរណ៍៖

// get position of the click
int ex = e.getX() - margin;
int ey = e.getY() - margin;
 
// click in the grid ?
if (ex < 0 || ex > gridSize  || ey < 0  || ey > gridSize)
  return;
 
// get position in the grid
int c1 = ex / tileSize;
int r1 = ey / tileSize;
 
// get position of the blank cell
int c2 = blankPos % size;
int r2 = blankPos / size;
 
// we convert in the 1D coord
int clickPos = r1 * size + c1;
 
int dir = 0;
 
// we search direction for multiple tile moves at once
if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
  dir = (r1 - r2) > 0 ? size : -size;
else if (r1 == r2 && Math.abs(c1 - c2) > 0)
  dir = (c1 - c2) > 0 ? 1 : -1;
 
if (dir != 0) {
  // we move tiles in the direction
  do {
    int newBlankPos = blankPos + dir;
    tiles[blankPos] = tiles[newBlankPos];
    blankPos = newBlankPos;
  } while(blankPos != clickPos);
 
tiles[blankPos] = 0;

កំពុងអភិវឌ្ឍ UI ជាមួយ Swing API

វាដល់ពេលសម្រាប់ចំណុចប្រទាក់។ ដំបូងយើងយកថ្នាក់ Jpanel ។ បន្ទាប់មកយើងគូរស្លាកនៅលើវាល - ដើម្បីគណនាទំហំនីមួយៗ យើងនឹងប្រើទិន្នន័យដែលបានបញ្ជាក់ក្នុងប៉ារ៉ាម៉ែត្ររបស់អ្នកបង្កើតហ្គេម៖

gridSize = (dim  -  2 * margin);
tileSize = gridSize / size;

រឹមក៏ជាប៉ារ៉ាម៉ែត្រដែលបានកំណត់នៅក្នុងកម្មវិធីបង្កើតហ្គេមផងដែរ។

ឥឡូវនេះយើងត្រូវកំណត់វិធីសាស្ត្រ drawGrid ដើម្បីគូរក្រឡាចត្រង្គ និងចំនុចនៅលើអេក្រង់។ យើងវិភាគអារេនៃស្លាក និងបម្លែងកូអរដោនេទៅជាកូអរដោនេចំណុចប្រទាក់អ្នកប្រើ។ បន្ទាប់មកយើងគូរស្លាកនីមួយៗដោយលេខដែលត្រូវគ្នានៅចំកណ្តាល៖

private void drawGrid(Graphics2D g) {
  for (int i = 0; i < tiles.length; i++) {
    // we convert 1D coords to 2D coords given the size of the 2D Array
    int r = i / size;
    int c = i % size;
    // we convert in coords on the UI
    int x = margin + c * tileSize;
    int y = margin + r * tileSize;
 
    // check special case for blank tile
    if(tiles[i] == 0) {
      if (gameOver) {
        g.setColor(FOREGROUND_COLOR);
        drawCenteredString(g, "u2713", x, y);
      }
 
      continue;
    }
 
    // for other tiles
    g.setColor(getForeground());
    g.fillRoundRect(x, y, tileSize, tileSize, 25, 25);
    g.setColor(Color.BLACK);
    g.drawRoundRect(x, y, tileSize, tileSize, 25, 25);
    g.setColor(Color.WHITE);
 
    drawCenteredString(g, String.valueOf(tiles[i]), x , y);
  }
}

ជាចុងក្រោយ យើងនឹងបដិសេធវិធីសាស្ត្រ paintComponent ដែលមកពីថ្នាក់ JPane ។ បន្ទាប់មកយើងប្រើវិធីសាស្ត្រ drawGrid ហើយបន្ទាប់មកវិធីសាស្ត្រ drawStartMessage ដើម្បីបង្ហាញសារដែលជំរុញឱ្យយើងចុចដើម្បីចាប់ផ្តើមហ្គេម៖

private void drawStartMessage(Graphics2D g) {
  if (gameOver) {
    g.setFont(getFont().deriveFont(Font.BOLD, 18));
    g.setColor(FOREGROUND_COLOR);
    String s = "Click to start new game";
    g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
        getHeight() - margin);
  }
}
 
private void drawCenteredString(Graphics2D g, String s, int x, int y) {
  // center string s for the given tile (x,y)
  FontMetrics fm = g.getFontMetrics();
  int asc = fm.getAscent();
  int desc = fm.getDescent();
  g.drawString(s,  x + (tileSize - fm.stringWidth(s)) / 2,
      y + (asc + (tileSize - (asc + desc)) / 2));
}
 
@Override
protected void paintComponent(Graphics g) {
  super.paintComponent(g);
  Graphics2D g2D = (Graphics2D) g;
  g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  drawGrid(g2D);
  drawStartMessage(g2D);
}

ឆ្លើយតបទៅនឹងសកម្មភាពរបស់អ្នកប្រើនៅក្នុង UI

ដើម្បីឱ្យហ្គេមដំណើរការបាន វាចាំបាច់ក្នុងការដោះស្រាយសកម្មភាពរបស់អ្នកប្រើប្រាស់នៅក្នុង UI ។ ដើម្បីធ្វើដូចនេះយើងបន្ថែមការអនុវត្ត MouseListener នៅលើ Jpanel និងកូដសម្រាប់ផ្លាស់ទីស្លាកដែលបានបង្ហាញខាងលើរួចហើយ៖

addMouseListener(new MouseAdapter() {
  @Override
  public void mousePressed(MouseEvent e) {
    // used to let users to interact on the grid by clicking
    // it's time to implement interaction with users to move tiles to solve the game !
    if (gameOver) {
      newGame();
    } else {
      // get position of the click
      int ex = e.getX() - margin;
      int ey = e.getY() - margin;
 
      // click in the grid ?
      if (ex < 0 || ex > gridSize  || ey < 0  || ey > gridSize)
        return;
 
      // get position in the grid
      int c1 = ex / tileSize;
      int r1 = ey / tileSize;
 
      // get position of the blank cell
      int c2 = blankPos % size;
      int r2 = blankPos / size;
 
      // we convert in the 1D coord
      int clickPos = r1 * size + c1;
 
      int dir = 0;
 
      // we search direction for multiple tile moves at once
      if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
        dir = (r1 - r2) > 0 ? size : -size;
      else if (r1 == r2 && Math.abs(c1 - c2) > 0)
        dir = (c1 - c2) > 0 ? 1 : -1;
 
      if (dir != 0) {
        // we move tiles in the direction
        do {
          int newBlankPos = blankPos + dir;
          tiles[blankPos] = tiles[newBlankPos];
          blankPos = newBlankPos;
        } while(blankPos != clickPos);
 
        tiles[blankPos] = 0;
      }
 
      // we check if game is solved
      gameOver = isSolved();
    }
 
    // we repaint panel
    repaint();
  }
});

កូដត្រូវបានដាក់នៅក្នុងអ្នកបង្កើតនៃថ្នាក់ GameOfFifteen ។ នៅចុងបញ្ចប់ យើងហៅវិធីសាស្ត្រហ្គេមថ្មី ដើម្បីចាប់ផ្តើមហ្គេមថ្មី។

កូដហ្គេមពេញ

ជំហានចុងក្រោយមុននឹងឃើញហ្គេមកំពុងដំណើរការគឺត្រូវដាក់កូដទាំងអស់បញ្ចូលគ្នា។ នេះជាអ្វីដែលកើតឡើង៖

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
// We are going to create a Game of 15 Puzzle with Java 8 and Swing
// If you have some questions, feel free to read comments ;)
public class GameOfFifteen extends JPanel { // our grid will be drawn in a dedicated Panel
 
  // Size of our Game of Fifteen instance
  private int size;
  // Number of tiles
  private int nbTiles;
  // Grid UI Dimension
  private int dimension;
  // Foreground Color
  private static final Color FOREGROUND_COLOR = new Color(239, 83, 80); // we use arbitrary color
  // Random object to shuffle tiles
  private static final Random RANDOM = new Random();
  // Storing the tiles in a 1D Array of integers
  private int[] tiles;
  // Size of tile on UI
  private int tileSize;
  // Position of the blank tile
  private int blankPos;
  // Margin for the grid on the frame
  private int margin;
  // Grid UI Size
  private int gridSize;
  private boolean gameOver; // true if game over, false otherwise
 
  public GameOfFifteen(int size, int dim, int mar) {
    this.size = size;
    dimension = dim;
    margin = mar;
    
    // init tiles
    nbTiles = size * size - 1; // -1 because we don't count blank tile
    tiles = new int[size * size];
    
    // calculate grid size and tile size
    gridSize = (dim - 2 * margin);
    tileSize = gridSize / size;
    
    setPreferredSize(new Dimension(dimension, dimension + margin));
    setBackground(Color.WHITE);
    setForeground(FOREGROUND_COLOR);
    setFont(new Font("SansSerif", Font.BOLD, 60));
    
    gameOver = true;
    
    addMouseListener(new MouseAdapter() {
      @Override
      public void mousePressed(MouseEvent e) {
        // used to let users to interact on the grid by clicking
        // it's time to implement interaction with users to move tiles to solve the game !
        if (gameOver) {
          newGame();
        } else {
          // get position of the click
          int ex = e.getX() - margin;
          int ey = e.getY() - margin;
          
          // click in the grid ?
          if (ex < 0 || ex > gridSize  || ey < 0  || ey > gridSize)
            return;
          
          // get position in the grid
          int c1 = ex / tileSize;
          int r1 = ey / tileSize;
          
          // get position of the blank cell
          int c2 = blankPos % size;
          int r2 = blankPos / size;
          
          // we convert in the 1D coord
          int clickPos = r1 * size + c1;
          
          int dir = 0;
          
          // we search direction for multiple tile moves at once
          if (c1 == c2  &&  Math.abs(r1 - r2) > 0)
            dir = (r1 - r2) > 0 ? size : -size;
          else if (r1 == r2 && Math.abs(c1 - c2) > 0)
            dir = (c1 - c2) > 0 ? 1 : -1;
            
          if (dir != 0) {
            // we move tiles in the direction
            do {
              int newBlankPos = blankPos + dir;
              tiles[blankPos] = tiles[newBlankPos];
              blankPos = newBlankPos;
            } while(blankPos != clickPos);
            
            tiles[blankPos] = 0;
          }
          
          // we check if game is solved
          gameOver = isSolved();
        }
        
        // we repaint panel
        repaint();
      }
    });
    
    newGame();
  }
 
  private void newGame() {
    do {
      reset(); // reset in intial state
      shuffle(); // shuffle
    } while(!isSolvable()); // make it until grid be solvable
    
    gameOver = false;
  }
 
  private void reset() {
    for (int i = 0; i < tiles.length; i++) {
      tiles[i] = (i + 1) % tiles.length;
    }
    
    // we set blank cell at the last
    blankPos = tiles.length - 1;
  }
 
  private void shuffle() {
    // don't include the blank tile in the shuffle, leave in the solved position
    int n = nbTiles;
    
    while (n > 1) {
      int r = RANDOM.nextInt(n--);
      int tmp = tiles[r];
      tiles[r] = tiles[n];
      tiles[n] = tmp;
    }
  }
 
  // Only half permutations of the puzzle are solvable.
  // Whenever a tile is preceded by a tile with higher value it counts
  // as an inversion. In our case, with the blank tile in the solved position,
  // the number of inversions must be even for the puzzle to be solvable
  private boolean isSolvable() {
    int countInversions = 0;
    
    for (int i = 0; i < nbTiles; i++) {
      for (int j = 0; j < i; j++) {
        if (tiles[j] > tiles[i])
          countInversions++;
      }
    }
    
    return countInversions % 2 == 0;
  }
 
  private boolean isSolved() {
    if (tiles[tiles.length - 1] != 0) // if blank tile is not in the solved position ==> not solved
      return false;
    
    for (int i = nbTiles - 1; i >= 0; i--) {
      if (tiles[i] != i + 1)
        return false;      
    }
    
    return true;
  }
 
  private void drawGrid(Graphics2D g) {
    for (int i = 0; i < tiles.length; i++) {
      // we convert 1D coords to 2D coords given the size of the 2D Array
      int r = i / size;
      int c = i % size;
      // we convert in coords on the UI
      int x = margin + c * tileSize;
      int y = margin + r * tileSize;
      
      // check special case for blank tile
      if(tiles[i] == 0) {
        if (gameOver) {
          g.setColor(FOREGROUND_COLOR);
          drawCenteredString(g, "u2713", x, y);
        }
        
        continue;
      }
      
      // for other tiles
      g.setColor(getForeground());
      g.fillRoundRect(x, y, tileSize, tileSize, 25, 25);
      g.setColor(Color.BLACK);
      g.drawRoundRect(x, y, tileSize, tileSize, 25, 25);
      g.setColor(Color.WHITE);
      
      drawCenteredString(g, String.valueOf(tiles[i]), x , y);
    }
  }
 
  private void drawStartMessage(Graphics2D g) {
    if (gameOver) {
      g.setFont(getFont().deriveFont(Font.BOLD, 18));
      g.setColor(FOREGROUND_COLOR);
      String s = "Click to start new game";
      g.drawString(s, (getWidth() - g.getFontMetrics().stringWidth(s)) / 2,
          getHeight() - margin);
    }
  }
 
  private void drawCenteredString(Graphics2D g, String s, int x, int y) {
    // center string s for the given tile (x,y)
    FontMetrics fm = g.getFontMetrics();
    int asc = fm.getAscent();
    int desc = fm.getDescent();
    g.drawString(s,  x + (tileSize - fm.stringWidth(s)) / 2,
        y + (asc + (tileSize - (asc + desc)) / 2));
  }
 
  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2D = (Graphics2D) g;
    g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    drawGrid(g2D);
    drawStartMessage(g2D);
  }
 
  public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> {
      JFrame frame = new JFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setTitle("Game of Fifteen");
      frame.setResizable(false);
      frame.add(new GameOfFifteen(4, 550, 30), BorderLayout.CENTER);
      frame.pack();
      // center on the screen
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
    });
  }
 
 
}

ចុងក្រោយ តោះលេង!

វាដល់ពេលហើយដើម្បីបើកដំណើរការហ្គេម ហើយសាកល្បងវានៅក្នុងសកម្មភាព។ វាលគួរតែមើលទៅដូចនេះ៖

តោះព្យាយាមដោះស្រាយល្បែងផ្គុំរូប។ ប្រសិនបើអ្វីៗដំណើរការល្អ យើងទទួលបាន៖

អស់ហើយ។ តើអ្នករំពឹងច្រើនជាងនេះទេ? 🙂

Skillbox ណែនាំ៖

• វគ្គសិក្សាជាក់ស្តែង "អ្នកអភិវឌ្ឍន៍ចល័ត PRO".
• បានអនុវត្តវគ្គសិក្សាតាមអ៊ីនធឺណិត "អ្នកវិភាគទិន្នន័យ Python".
• វគ្គសិក្សាជាក់ស្តែងរយៈពេលពីរឆ្នាំ "ខ្ញុំជាអ្នកបង្កើតគេហទំព័រ PRO".

ប្រភព: www.habr.com