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>