shaxmat.html

<!DOCTYPE html>
<html lang="uz">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width,initial-scale=1" />
<title>Shaxmat — Qoidali Offline</title>
<style>
  :root{
    --light:#f0d9b5;
    --dark:#b58863;
    --highlight:#ffd86b;
    --move:#8be0a9;
    --capture:#ff9b9b;
    --board-size:560px;
    --cell:calc(var(--board-size)/8);
  }
  body{font-family:Inter,system-ui,Arial;margin:20px;display:flex;gap:20px;align-items:flex-start;justify-content:center}
  .container{display:flex;gap:20px;align-items:flex-start}
  .board-wrap{background:#fff;padding:12px;border-radius:12px;box-shadow:0 6px 20px rgba(0,0,0,0.08)}
  #board{width:var(--board-size);height:var(--board-size);display:grid;grid-template-columns:repeat(8,1fr);grid-template-rows:repeat(8,1fr);border-radius:8px;overflow:hidden}
  .cell{width:var(--cell);height:var(--cell);display:flex;align-items:center;justify-content:center;font-size:34px;cursor:pointer;user-select:none}
  .white{background:var(--light);color:#111}
  .black{background:var(--dark);color:#111}
  .cell.selected{outline:4px solid var(--highlight);outline-offset:-4px}
  .cell.move{box-shadow:inset 0 0 0 4px rgba(139,224,169,0.5)}
  .cell.capture{box-shadow:inset 0 0 0 4px rgba(255,155,155,0.6)}
  .sidepanel{width:320px;display:flex;flex-direction:column;gap:12px}
  .panel{background:#fff;padding:12px;border-radius:12px;box-shadow:0 6px 20px rgba(0,0,0,0.06)}
  h2{margin:0 0 6px 0;font-size:18px}
  #status{font-weight:700;font-size:18px}
  .moves{max-height:420px;overflow:auto;padding:6px;border-radius:8px;background:#fafafa;font-family:monospace}
  .controls{display:flex;gap:8px}
  button{padding:8px 10px;border-radius:8px;border:1px solid #ddd;background:#fff;cursor:pointer}
  .legend{display:flex;gap:8px;align-items:center;font-size:14px}
  .legend .box{width:14px;height:14px;border-radius:3px}
</style>
</head>
<body>

<div class="container">
  <div class="board-wrap">
    <div id="board" role="grid" aria-label="Shaxmat taxtasi"></div>
  </div>

  <div class="sidepanel">
    <div class="panel">
      <h2>Holat</h2>
      <div id="status">Oq navbati</div>
      <div style="height:8px"></div>
      <div class="controls">
        <button id="undo">Ortga</button>
        <button id="reset">Qayta</button>
        <button id="flip">Taxtani aylantir</button>
      </div>
    </div>

    <div class="panel">
      <h2>Harakatlar</h2>
      <div class="moves" id="moves"></div>
    </div>


  </div>
</div>

<script>
/*
  Oddiy shaxmat dvigateli — offline, to'liq qonuniy yurishlarni tekshiradi,
  shox va matni aniqlaydi. Castling va en-passant oddiy versiyada yo'q,
  ammo barcha asosiy yurishlar, promosiyalar va mat/pat aniqlanadi.
*/

/* --- Unicode belgilari --- */
const PIECES = {
  'r':'♜','n':'♞','b':'♝','q':'♛','k':'♚','p':'♟',
  'R':'♖','N':'♘','B':'♗','Q':'♕','K':'♔','P':'♙'
};

/* --- Dastlabki pozitsiya (8x8 matritsa, 0=qator yuqori (8-rank), 7=qator past (1-rank)) --- */
let board = [
  ['r','n','b','q','k','b','n','r'],
  ['p','p','p','p','p','p','p','p'],
  ['','','','','','','',''],
  ['','','','','','','',''],
  ['','','','','','','',''],
  ['','','','','','','',''],
  ['P','P','P','P','P','P','P','P'],
  ['R','N','B','Q','K','B','N','R']
];

let turn = 'w'; // 'w' yoki 'b'
let selected = null; // {r,c}
let legalMoves = []; // array of {from:{r,c}, to:{r,c}, capture:boolean, promotion:boolean}
let history = []; // past moves for undo
let flipped = false;

/* --- DOM --- */
const boardEl = document.getElementById('board');
const statusEl = document.getElementById('status');
const movesEl = document.getElementById('moves');
document.getElementById('undo').addEventListener('click', undoMove);
document.getElementById('reset').addEventListener('click', resetGame);
document.getElementById('flip').addEventListener('click', () => { flipped = !flipped; renderBoard(); });

/* --- Helper utils --- */
function inBounds(r,c){ return r>=0 && r<8 && c>=0 && c<8 }
function pieceColor(p){ if(!p) return null; return (p===p.toUpperCase()) ? 'w' : 'b' }
function cloneBoard(b){ return b.map(row => row.slice()) }
function posToAlgebraic(r,c){ const files='abcdefgh'; return files[c]+(8-r) }
function algebraicToPos(s){ const files='abcdefgh'; return { c: files.indexOf(s[0]), r: 8-parseInt(s[1]) } }

/* --- Generate all legal moves for current side --- */
function generateLegalMoves(forColor){
  const pseudo = generatePseudoMoves(forColor);
  // filter moves that leave own king in check
  const legal = [];
  for(const m of pseudo){
    const b2 = cloneBoard(board);
    const piece = b2[m.from.r][m.from.c];
    b2[m.to.r][m.to.c] = m.promotion ? (forColor==='w'?'Q':'q') : piece;
    b2[m.from.r][m.from.c] = '';
    // find king position of forColor on b2
    let kingPos = null;
    for(let r=0;r<8;r++) for(let c=0;c<8;c++){
      const p = b2[r][c];
      if(p && (p==='K' && forColor==='w' || p==='k' && forColor==='b')) kingPos={r,c};
    }
    if(!kingPos) continue; // should not happen
    if(!isSquareAttacked(b2, kingPos.r, kingPos.c, oppositeColor(forColor))) legal.push(m);
  }
  return legal;
}

/* --- Generate pseudo-legal moves (not considering leaving king in check) --- */
function generatePseudoMoves(color){
  const moves = [];
  for(let r=0;r<8;r++){
    for(let c=0;c<8;c++){
      const p = board[r][c];
      if(!p) continue;
      const pc = pieceColor(p);
      if(pc !== color) continue;
      const type = p.toLowerCase();
      if(type==='p') generatePawnMoves(r,c,p,moves);
      else if(type==='n') generateKnightMoves(r,c,p,moves);
      else if(type==='b') generateSlidingMoves(r,c,p,[[1,1],[1,-1],[-1,1],[-1,-1]],moves);
      else if(type==='r') generateSlidingMoves(r,c,p,[[1,0],[-1,0],[0,1],[0,-1]],moves);
      else if(type==='q') generateSlidingMoves(r,c,p,[[1,1],[1,-1],[-1,1],[-1,-1],[1,0],[-1,0],[0,1],[0,-1]],moves);
      else if(type==='k') generateKingMoves(r,c,p,moves);
    }
  }
  return moves;
}

/* --- Pawn moves (including two-step and promotion; no en-passant) --- */
function generatePawnMoves(r,c,p,moves){
  const color = pieceColor(p);
  const dir = (color==='w') ? -1 : 1;
  const startRow = (color==='w') ? 6 : 1;
  const promotionRow = (color==='w') ? 0 : 7;
  // one step
  const r1 = r + dir;
  if(inBounds(r1,c) && !board[r1][c]){
    // promotion?
    const prom = (r1===promotionRow);
    moves.push({from:{r,c},to:{r:r1,c},capture:false,promotion:prom});
    // two-step
    const r2 = r + 2*dir;
    if(r===startRow && inBounds(r2,c) && !board[r2][c]) moves.push({from:{r,c},to:{r:r2,c},capture:false,promotion:false});
  }
  // captures
  for(const dc of [-1,1]){
    const cc = c+dc;
    if(inBounds(r1,cc) && board[r1][cc]){
      const target = board[r1][cc];
      if(pieceColor(target) !== color){
        const prom = (r1===promotionRow);
        moves.push({from:{r,c},to:{r:r1,c:cc},capture:true,promotion:prom});
      }
    }
  }
}

/* --- Knight moves --- */
function generateKnightMoves(r,c,p,moves){
  const color = pieceColor(p);
  const deltas = [[2,1],[2,-1],[-2,1],[-2,-1],[1,2],[1,-2],[-1,2],[-1,-2]];
  for(const d of deltas){
    const rr=r+d[0], cc=c+d[1];
    if(!inBounds(rr,cc)) continue;
    const t = board[rr][cc];
    if(!t) moves.push({from:{r,c},to:{r:rr,c:cc},capture:false,promotion:false});
    else if(pieceColor(t)!==color) moves.push({from:{r,c},to:{r:rr,c:cc},capture:true,promotion:false});
  }
}

/* --- Sliding pieces (bishop/rook/queen) --- */
function generateSlidingMoves(r,c,p,directions,moves){
  const color = pieceColor(p);
  for(const d of directions){
    let rr=r+d[0], cc=c+d[1];
    while(inBounds(rr,cc)){
      const t = board[rr][cc];
      if(!t) { moves.push({from:{r,c},to:{r:rr,c:cc},capture:false,promotion:false}); }
      else {
        if(pieceColor(t)!==color) moves.push({from:{r,c},to:{r:rr,c:cc},capture:true,promotion:false});
        break;
      }
      rr+=d[0]; cc+=d[1];
    }
  }
}

/* --- King moves (no castling) --- */
function generateKingMoves(r,c,p,moves){
  const color = pieceColor(p);
  for(let dr=-1;dr<=1;dr++) for(let dc=-1;dc<=1;dc++){
    if(dr===0 && dc===0) continue;
    const rr=r+dr, cc=c+dc;
    if(!inBounds(rr,cc)) continue;
    const t = board[rr][cc];
    if(!t) moves.push({from:{r,c},to:{r:rr,c:cc},capture:false,promotion:false});
    else if(pieceColor(t)!==color) moves.push({from:{r,c},to:{r:rr,c:cc},capture:true,promotion:false});
  }
}

/* --- Is square attacked by color? Use on given board state b --- */
function isSquareAttacked(b, r, c, byColor){
  // pawns
  const dir = (byColor==='w') ? -1 : 1;
  for(const dc of [-1,1]){
    const rr = r + (-dir); // when checking attacked square at (r,c), pawn of byColor must be at r+(-dir)? Easier: simulate pawn attacks
    // Let's use proper logic: a pawn of byColor at (rp,cp) attacks (r,c) if rp+dir==r and cp±1==c
  }
  // We'll implement scanning: for each piece of byColor, see if it attacks (r,c)
  for(let rr=0;rr<8;rr++){
    for(let cc=0;cc<8;cc++){
      const p = b[rr][cc];
      if(!p) continue;
      if(pieceColor(p)!==byColor) continue;
      const t = p.toLowerCase();
      if(t==='p'){
        const pd = (byColor==='w')?-1:1;
        if(rr+pd===r && (cc+1===c || cc-1===c)) return true;
      } else if(t==='n'){
        const deltas = [[2,1],[2,-1],[-2,1],[-2,-1],[1,2],[1,-2],[-1,2],[-1,-2]];
        for(const d of deltas) if(rr+d[0]===r && cc+d[1]===c) return true;
      } else if(t==='b' || t==='q'){
        const dirs = [[1,1],[1,-1],[-1,1],[-1,-1]];
        for(const d of dirs){
          let pr=rr+d[0], pc=cc+d[1];
          while(inBounds(pr,pc)){
            if(pr===r && pc===c) return true;
            if(b[pr][pc]) break;
            pr+=d[0]; pc+=d[1];
          }
        }
      }
      if(t==='r' || t==='q'){
        const dirs = [[1,0],[-1,0],[0,1],[0,-1]];
        for(const d of dirs){
          let pr=rr+d[0], pc=cc+d[1];
          while(inBounds(pr,pc)){
            if(pr===r && pc===c) return true;
            if(b[pr][pc]) break;
            pr+=d[0]; pc+=d[1];
          }
        }
      }
      if(t==='k'){
        if(Math.max(Math.abs(rr-r),Math.abs(cc-c))===1) return true;
      }
    }
  }
  return false;
}

/* --- Opposite color --- */
function oppositeColor(c){ return c==='w' ? 'b' : 'w' }

/* --- Apply move (assumes legal) --- */
function applyMove(move){
  const from = move.from, to = move.to;
  const piece = board[from.r][from.c];
  const captured = board[to.r][to.c] || '';
  // push to history
  history.push({from: {...from}, to:{...to}, piece, captured, promotion: move.promotion});
  // do move
  board[to.r][to.c] = move.promotion ? (pieceColor(piece)==='w' ? 'Q' : 'q') : piece;
  board[from.r][from.c] = '';
  // change turn
  turn = oppositeColor(turn);
}

/* --- Undo --- */
function undoMove(){
  if(history.length===0) return;
  const last = history.pop();
  board[last.from.r][last.from.c] = last.piece;
  board[last.to.r][last.to.c] = last.captured;
  turn = pieceColor(last.piece) === 'w' ? 'w' : 'b'; // restore turn to side who moved
  selected = null;
  legalMoves = [];
  renderBoard();
  updateStatus();
  renderMoves();
}

/* --- Reset --- */
function resetGame(){
  board = [
    ['r','n','b','q','k','b','n','r'],
    ['p','p','p','p','p','p','p','p'],
    ['','','','','','','',''],
    ['','','','','','','',''],
    ['','','','','','','',''],
    ['','','','','','','',''],
    ['P','P','P','P','P','P','P','P'],
    ['R','N','B','Q','K','B','N','R']
  ];
  turn='w';
  selected=null;
  legalMoves=[];
  history=[];
  renderBoard();
  updateStatus();
  renderMoves();
}

/* --- Check if side is in check --- */
function inCheck(color){
  // find king pos
  let kingPos = null;
  for(let r=0;r<8;r++) for(let c=0;c<8;c++){
    const p = board[r][c];
    if(p && ((p==='K' && color==='w') || (p==='k' && color==='b'))) kingPos={r,c};
  }
  if(!kingPos) return false;
  return !isSquareAttacked(board, kingPos.r, kingPos.c, oppositeColor(color));
  // Note: isSquareAttacked returns true if attacked, so if attacked -> inCheck true.
}

/* --- But above logic inverted; fix: isSquareAttacked returns true if attacked.
   So inCheck should return true if isSquareAttacked(...)=true
*/
function inCheck(color){
  let kingPos = null;
  for(let r=0;r<8;r++) for(let c=0;c<8;c++){
    const p = board[r][c];
    if(p && ((p==='K' && color==='w') || (p==='k' && color==='b'))) kingPos={r,c};
  }
  if(!kingPos) return false;
  return isSquareAttacked(board, kingPos.r, kingPos.c, oppositeColor(color));
}

/* --- Is it checkmate? --- */
function isCheckmate(color){
  if(!inCheck(color)) return false;
  const legal = generateLegalMoves(color);
  return legal.length===0;
}

/* --- Is it stalemate? --- */
function isStalemate(color){
  if(inCheck(color)) return false;
  const legal = generateLegalMoves(color);
  return legal.length===0;
}

/* --- Rendering --- */
function renderBoard(){
  boardEl.innerHTML = '';
  const rows = [...Array(8).keys()]; // 0..7
  const cols = [...Array(8).keys()];
  // when flipped, we invert ordering
  const rIter = flipped ? rows.slice().reverse() : rows;
  const cIter = flipped ? cols.slice().reverse() : cols;
  for(const r2 of rIter){
    for(const c2 of cIter){
      // map r2,c2 (visual) to internal coords r,c:
      const r = flipped ? 7-r2 : r2;
      const c = flipped ? 7-c2 : c2;
      const cell = document.createElement('div');
      cell.className = 'cell ' + (((r+c)%2===0)?'white':'black');
      cell.dataset.r = r; cell.dataset.c = c;
      const p = board[r][c];
      if(p) cell.textContent = PIECES[p] || p;
      // highlight selected
      if(selected && selected.r===r && selected.c===c) cell.classList.add('selected');
      // highlight legal moves
      const mv = legalMoves.find(m => m.to.r===r && m.to.c===c);
      if(mv){
        if(mv.capture) cell.classList.add('capture'); else cell.classList.add('move');
      }
      cell.addEventListener('click', () => onCellClick(r,c));
      boardEl.appendChild(cell);
    }
  }
}

/* --- Update status text and detect check/mate/pat --- */
function updateStatus(){
  if(isCheckmate('w')){ statusEl.textContent = 'MAT — Qora yutdi (oq mat)'; return; }
  if(isCheckmate('b')){ statusEl.textContent = 'MOT — Oq yutdi (qora mot boldi)'; return; }
  if(isStalemate('w') || isStalemate('b')){ statusEl.textContent = 'POT — Durrang'; return; }
  if(inCheck(turn)) statusEl.textContent = (turn==='w' ? 'Oq navbati — SHOXDA!' : 'Qora navbati — SHOXDA!');
  else statusEl.textContent = (turn==='w' ? 'Oq navbati' : 'Qora navbati');
}

/* --- Render move history --- */
function renderMoves(){
  movesEl.innerHTML = '';
  const rows = [];
  for(let i=0;i<history.length;i+=2){
    const a = history[i], b = history[i+1];
    const moveNum = Math.floor(i/2)+1;
    const s1 = a ? formatMove(a) : '';
    const s2 = b ? formatMove(b) : '';
    const line = document.createElement('div');
    line.textContent = moveNum + '. ' + s1 + '  ' + (s2? s2 : '');
    movesEl.appendChild(line);
  }
}
function formatMove(m){
  // e.g. e2e4 or Nf3 — keep simple algebraic-ish
  const from = posToAlgebraic(m.from.r,m.from.c);
  const to = posToAlgebraic(m.to.r,m.to.c);
  const prom = m.promotion ? '=Q' : '';
  return from+to+prom;
}

/* --- Handle cell click --- */
function onCellClick(r,c){
  // if there is a selected piece of current turn and clicked on a legal target -> move
  if(selected){
    // find matching legal move
    const move = legalMoves.find(m => m.from.r===selected.r && m.from.c===selected.c && m.to.r===r && m.to.c===c);
    if(move){
      applyMove(move);
      selected=null;
      legalMoves = generateLegalMoves(turn);
      renderBoard();
      updateStatus();
      renderMoves();
      return;
    }
    // otherwise if clicked own piece -> select it
    const p = board[r][c];
    if(p && pieceColor(p)===turn){
      selected={r,c};
      legalMoves = generateLegalMoves(turn).filter(m => m.from.r===r && m.from.c===c);
      renderBoard();
      return;
    }
    // else deselect
    selected=null;
    legalMoves=[];
    renderBoard();
    return;
  } else {
    // no selection yet — if clicked a piece of correct color -> select and show moves
    const p = board[r][c];
    if(p && pieceColor(p)===turn){
      selected={r,c};
      legalMoves = generateLegalMoves(turn).filter(m => m.from.r===r && m.from.c===c);
      renderBoard();
    }
  }
}

/* --- Initialize --- */
function init(){
  legalMoves = generateLegalMoves(turn);
  renderBoard();
  updateStatus();
}
init();

/* --- Small fix: isSquareAttacked used board param b; earlier we had a flawed pawn handling stub. Let's ensure isSquareAttacked function is correct (already implemented above). --- */

/* --- END OF SCRIPT --- */
</script>

</body>
</html>

Built With

Share this project:

Updates

Submission history