给小朋友们整理的四款网页小游戏，全部免下载、免安装，不用跳转，在本页就能直接玩。每款游戏下方都附了链接，点开可以在新窗口全屏畅玩。建议用电脑或平板浏览器体验最佳。
🌻 植物大战僵尸（单机网页版）
经典塔防玩法：收集阳光，种下向日葵、豌豆射手、坚果墙、寒冰射手和樱桃炸弹，挡住一波又一波僵尸的进攻，坚持撑过最后一波就是胜利！
特别适合小朋友的两个贴心开关：♾️ 无限阳光（阳光随便用，专心练布阵）和 🧲 自动拾取（阳光自动入账，不用手忙脚乱去点），还支持暂停和音效开关。
手机竖屏可能显示不全，建议在电脑上玩；也可以在新窗口打开。
⭕ 井字棋 · 儿童版
专为小朋友设计的井字棋：暖色调大按钮，开局电脑先手让孩子后发制人；支持 3×3、4×4、5×5 三种棋盘（大棋盘要四子连线，玩法更有新鲜感），难度分简单/普通/困难，下错了可以悔一步，赢了输了都有战绩记分板。
也可以在新窗口打开。
❌ 井字棋 · 经典版
进阶版井字棋：可以和电脑对战（简单/困难两档 AI），也能两个孩子双人对战；拿不准下哪儿时点 💡 提示 让电脑支一招，比分自动统计，随时可以清零重来。
也可以在新窗口打开。
🧱 俄罗斯方块
永远不过时的经典：消行得分、升级加速，支持暂存方块、暂停和音效，自动记录最高分；底部有一排触屏方向按钮，手机上也能轻松操作。
也可以在新窗口打开。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>植物大战僵尸 · 单机网页版</title>
<style>
  *{box-sizing:border-box}
  body{margin:0;background:#26331a;font-family:"Microsoft YaHei","PingFang SC",sans-serif;
       display:flex;flex-direction:column;align-items:center;min-height:100vh;user-select:none}
  #topbar{display:flex;align-items:center;gap:8px;background:#4c3a1e;border:2px solid #6b5326;
          border-radius:12px;padding:6px 10px;margin-top:10px;flex-wrap:wrap;justify-content:center}
  #sunbox{background:#f7edc7;border-radius:8px;padding:2px 12px 2px 6px;font-weight:900;font-size:22px;
          color:#4a3a10;display:flex;align-items:center;gap:4px;min-width:96px;justify-content:center}
  #seedbar{display:flex;gap:6px}
  .card{width:62px;height:82px;background:linear-gradient(#f3e6b8,#dcc98f);border:2px solid #8a7a4a;
        border-radius:8px;position:relative;cursor:pointer;display:flex;flex-direction:column;
        align-items:center;overflow:hidden;transition:transform .08s}
  .card:hover{transform:translateY(-2px)}
  .card canvas{margin-top:1px}
  .card .cost{font-size:13px;font-weight:900;color:#333}
  .card .cd{position:absolute;left:0;bottom:0;width:100%;height:0;background:rgba(20,20,20,.62);pointer-events:none}
  .card.off{filter:grayscale(.85) brightness(.75)}
  .card.sel{outline:3px solid #ffe14d;box-shadow:0 0 14px #ffe14d}
  .card.shake{animation:shk .3s}
  @keyframes shk{0%,100%{transform:translateX(0)}25%{transform:translateX(-4px)}75%{transform:translateX(4px)}}
  .tbtn{font-size:17px;line-height:1;padding:8px 10px;border-radius:8px;border:2px solid #6b5326;
        background:#f3e6b8;cursor:pointer;color:#4a3a10;font-weight:900}
  .tbtn:hover{background:#fff3cf}
  .tbtn.on{background:#ffd54d;box-shadow:0 0 10px #ffd54d}
  #progressWrap{width:170px;height:18px;background:#2a2a2a;border:1px solid #000;border-radius:9px;
                 position:relative;overflow:hidden}
  #progressFill{height:100%;width:0;background:linear-gradient(90deg,#7ac74f,#ffe14d);transition:width .4s}
  #waveLabel{position:absolute;inset:0;text-align:center;font-size:12px;font-weight:900;color:#fff;
             text-shadow:0 1px 2px #000;line-height:17px}
  #stage{position:relative;margin-top:10px}
  #game{display:block;border:4px solid #33270f;border-radius:10px;background:#3f6b28;cursor:pointer}
  #banner{position:absolute;top:38%;left:50%;transform:translate(-50%,-50%) scale(0);font-size:46px;
          font-weight:900;color:#ff3b30;text-shadow:0 2px 8px #000,0 0 24px #ffb300;
          transition:transform .25s ease;pointer-events:none;white-space:nowrap;letter-spacing:2px}
  #banner.show{transform:translate(-50%,-50%) scale(1)}
  #overlay{position:absolute;inset:0;background:rgba(10,14,5,.72);display:flex;align-items:center;
           justify-content:center;border-radius:10px;z-index:5}
  #overlay.hidden{display:none}
  #ovBox{background:linear-gradient(#f9eec6,#e8d49b);padding:28px 44px;border-radius:16px;text-align:center;
         max-width:560px;box-shadow:0 10px 40px rgba(0,0,0,.6)}
  #ovTitle{margin:0 0 10px;font-size:34px;color:#3d6b1f;text-shadow:0 2px 0 #fff}
  #ovText{margin:0 0 18px;font-size:15px;color:#4a3a10;line-height:1.8;text-align:left}
  #ovBtn{font-size:22px;font-weight:900;padding:10px 46px;border-radius:12px;border:3px solid #3d6b1f;
         background:#7ac74f;color:#fff;cursor:pointer;text-shadow:0 1px 2px #000}
  #ovBtn:hover{background:#8ede5f;transform:scale(1.04)}
  #hint{color:#cfe3b0;font-size:13px;margin:8px 0 16px;opacity:.85}
</style>
</head>
<body>
  <div id="topbar">
    <div id="sunbox"><canvas id="sunIcon" width="34" height="34"></canvas><span id="sunCount">75</span></div>
    <div id="seedbar"></div>
    <button class="tbtn" id="shovelBtn" title="铲子：点击后移除植物（不返还阳光）">
      <svg width="20" height="20" viewBox="0 0 24 24">
        <line x1="5" y1="19" x2="12.5" y2="11.5" stroke="#8a5a2b" stroke-width="3.6" stroke-linecap="round"/>
        <path d="M11.5 10.5 C14.5 7.5 17.8 6.2 21 6.2 C21 9.6 19.8 12.8 16.8 15.8 L13.5 12.5 Z"
              fill="#b7bec4" stroke="#78828a" stroke-width="1.2"/>
      </svg>
    </button>
    <button class="tbtn" id="autoBtn" title="自动拾取：新阳光出现后自动飞入账户">🧲 自动拾取</button>
    <button class="tbtn" id="infiniteBtn" title="无限阳光：种植不消耗阳光">♾️ 无限阳光</button>
    <button class="tbtn" id="muteBtn" title="音效开关">🔊</button>
    <button class="tbtn" id="pauseBtn" title="暂停 / 继续 (P)">⏸</button>
    <div id="progressWrap"><div id="progressFill"></div><div id="waveLabel">准备中…</div></div>
  </div>

  <div id="stage">
    <canvas id="game" width="1060" height="640"></canvas>
    <div id="banner"></div>
    <div id="overlay">
      <div id="ovBox">
        <h1 id="ovTitle">🌻 植物大战僵尸 🧟</h1>
        <p id="ovText">
          <b>玩法说明</b><br>
          · 点击卡片选择植物，再点击草地种植（数字键 1~6 快速选择）<br>
          · 点击掉落 / 生产的<b>阳光</b>收集资源<br>
          · 种向日葵攒经济，豌豆射手防御，坚果墙阻挡，樱桃炸弹救急<br>
          · 僵尸突破一行时，小推车会自动清场（每行仅一次！）<br>
          · 右键 / Esc 取消选择，铲子可移除植物，P 键暂停<br>
          · 坚持住 <b>10 波</b>僵尸进攻即可获胜！<br>
          · 顶栏 <b>🧲 自动拾取</b>（阳光自动飞入账户）与 <b>♾️ 无限阳光</b>（种植不消耗）随时开关
        </p>
        <button id="ovBtn">开始游戏</button>
      </div>
    </div>
  </div>
  <div id="hint">点击卡片 → 点击草地种植 | 点击阳光收集 | 右键/Esc 取消 | P 暂停</div>

<script>
'use strict';
// ===================== 常量 =====================
const TAU = Math.PI*2;
const COLS=9, ROWS=5, CELL=100, GRID_X=100, GRID_Y=70;
const CV_W=1060, CV_H=640;

const PLANTS={
  sunflower :{name:'向日葵',   cost:50,  hp:300,  cd:7,  desc:'定期产出阳光'},
  peashooter:{name:'豌豆射手', cost:100, hp:300,  cd:7,  desc:'向前方发射豌豆'},
  snowpea   :{name:'寒冰射手', cost:175, hp:300,  cd:7,  desc:'冰弹减速僵尸'},
  repeater  :{name:'双发射手', cost:200, hp:300,  cd:7,  desc:'一次发射两颗豌豆'},
  wallnut   :{name:'坚果墙',   cost:50,  hp:3000, cd:20, desc:'高血量阻挡僵尸'},
  cherry    :{name:'樱桃炸弹', cost:150, hp:9999, cd:25, desc:'3×3 范围爆炸'},
};
const ZTYPES={
  normal:{hp:200, speed:16, dmg:35},
  cone  :{hp:640, speed:16, dmg:35},
  bucket:{hp:1300,speed:15, dmg:35},
  run   :{hp:150, speed:44, dmg:35},
};
const WAVES=[
  ['normal','normal'],
  ['normal','normal','normal'],
  ['normal','cone','normal','normal'],
  ['normal','cone','cone','normal','normal','run'],
  ['normal','normal','cone','cone','bucket','normal','normal','cone','normal'],            // 大波
  ['normal','cone','cone','bucket','normal','run','normal','cone'],
  ['cone','cone','bucket','normal','normal','run','run','normal','cone','normal'],
  ['bucket','cone','cone','normal','run','run','bucket','normal','cone','normal','cone'],
  ['cone','bucket','bucket','run','run','cone','normal','normal','cone','cone','run','normal'],
  ['normal','normal','cone','cone','bucket','bucket','run','run','cone','normal','bucket',
   'cone','run','cone','normal','bucket'],                                                  // 最终大波
];
const TOTAL=WAVES.length;

// ===================== DOM =====================
const cvs=document.getElementById('game'), ctx=cvs.getContext('2d');
const sunCountEl=document.getElementById('sunCount');
const seedbar=document.getElementById('seedbar');
const shovelBtn=document.getElementById('shovelBtn');
const muteBtn=document.getElementById('muteBtn');
const pauseBtn=document.getElementById('pauseBtn');
const autoBtn=document.getElementById('autoBtn');
const infiniteBtn=document.getElementById('infiniteBtn');
const progressFill=document.getElementById('progressFill');
const waveLabel=document.getElementById('waveLabel');
const bannerEl=document.getElementById('banner');
const overlay=document.getElementById('overlay');
const ovTitle=document.getElementById('ovTitle');
const ovText=document.getElementById('ovText');
const ovBtn=document.getElementById('ovBtn');

// ===================== 音效 =====================
let AC=null, muted=false;
function sfx(f,d,type,v,f2){
  if(muted) return;
  try{
    AC=AC||new (window.AudioContext||window.webkitAudioContext)();
    const o=AC.createOscillator(), g=AC.createGain(), t0=AC.currentTime;
    o.type=type||'sine'; o.frequency.setValueAtTime(f,t0);
    if(f2) o.frequency.exponentialRampToValueAtTime(f2,t0+d);
    g.gain.setValueAtTime(v||0.15,t0);
    g.gain.exponentialRampToValueAtTime(0.001,t0+d);
    o.connect(g); g.connect(AC.destination);
    o.start(t0); o.stop(t0+d);
  }catch(e){}
}
function jingle(notes,step,type){
  notes.forEach((f,i)=>setTimeout(()=>sfx(f,step*1.7,type||'triangle',0.16),i*step*1000));
}

// ===================== 状态 =====================
let S=null;
let autoPick=false, infiniteSun=false;
function newGame(){
  S={
    sun:75,
    grid:Array.from({length:ROWS},()=>Array(COLS).fill(null)),
    zombies:[], peas:[], suns:[], parts:[], booms:[],
    mowers:Array.from({length:ROWS},(_,r)=>({row:r,x:52,on:false,used:false})),
    wave:0, queue:[], inWave:false, waveClearT:9, spawnT:0,
    spawnedInWave:0, killedInWave:0,
    skyT:5, selected:null, shovel:false, hover:null,
    time:0, paused:false, over:false, started:false,
    shake:0, cooldowns:{},
  };
  for(const k in PLANTS) S.cooldowns[k]=0;
  setCardsSel();
}

// ===================== 工具 =====================
function rr(g,x,y,w,h,r){
  g.beginPath();
  g.moveTo(x+r,y);
  g.arcTo(x+w,y,x+w,y+h,r);
  g.arcTo(x+w,y+h,x,y+h,r);
  g.arcTo(x,y+h,x,y,r);
  g.arcTo(x,y,x+w,y,r);
  g.closePath();
}
function shuffle(a){
  for(let i=a.length-1;i>0;i--){const j=(Math.random()*(i+1))|0;[a[i],a[j]]=[a[j],a[i]];}
  return a;
}
function puff(x,y,color,n,spd){
  for(let i=0;i<(n||8);i++){
    const a=Math.random()*TAU, s=(spd||80)*(0.4+Math.random()*0.8);
    S.parts.push({x,y,vx:Math.cos(a)*s,vy:Math.sin(a)*s-40,life:0.4+Math.random()*0.35,
                  r:2+Math.random()*3.5,color});
  }
}
function cellAt(e){
  const r=cvs.getBoundingClientRect();
  const x=(e.clientX-r.left)*CV_W/r.width, y=(e.clientY-r.top)*CV_H/r.height;
  const col=Math.floor((x-GRID_X)/CELL), row=Math.floor((y-GRID_Y)/CELL);
  return {x,y,col:(col>=0&&col<COLS)?col:null,row:(row>=0&&row<ROWS)?row:null};
}
function showBanner(text,ms){
  bannerEl.textContent=text;
  bannerEl.classList.add('show');
  clearTimeout(showBanner._t);
  showBanner._t=setTimeout(()=>bannerEl.classList.remove('show'),ms||2600);
}

// ===================== 卡片 =====================
const cards={};
function buildCards(){
  seedbar.innerHTML='';
  const keys=Object.keys(PLANTS);
  keys.forEach((key,i)=>{
    const p=PLANTS[key];
    const d=document.createElement('div');
    d.className='card';
    d.title=p.name+'（'+p.cost+' 阳光）'+p.desc+'  [快捷键 '+(i+1)+']';
    const c=document.createElement('canvas'); c.width=52; c.height=54;
    const cost=document.createElement('div'); cost.className='cost'; cost.textContent=p.cost;
    const cd=document.createElement('div'); cd.className='cd';
    d.appendChild(c); d.appendChild(cost); d.appendChild(cd);
    d.onclick=()=>{
      if(!S.started||S.over) return;
      S.shovel=false; shovelBtn.classList.remove('on');
      if(S.selected===key){ S.selected=null; setCardsSel(); return; }
      if((infiniteSun||S.sun>=p.cost) && S.cooldowns[key]<=0){
        S.selected=key; sfx(620,.06,'sine',.08); setCardsSel();
      }else{
        d.classList.add('shake'); setTimeout(()=>d.classList.remove('shake'),320);
        sfx(160,.1,'square',.06);
      }
    };
    seedbar.appendChild(d);
    const g=c.getContext('2d');
    g.save(); g.translate(26,40); g.scale(0.55,0.55);
    drawPlant(g,{kind:key,hp:1,maxHp:1,born:0,recoil:0,fuse:9,hurtT:0},0.6);
    g.restore();
    cards[key]={el:d,cd};
  });
}
function setCardsSel(){
  for(const k in cards) cards[k].el.classList.toggle('sel',S.selected===k);
}
function refreshCards(){
  sunCountEl.textContent=infiniteSun?'∞':S.sun;
  for(const k in cards){
    const p=PLANTS[k];
    cards[k].cd.style.height=(S.cooldowns[k]/p.cd*100)+'%';
    cards[k].el.classList.toggle('off',(!infiniteSun&&S.sun<p.cost)||S.cooldowns[k]>0);
  }
}

// ===================== 种植 / 铲除 =====================
function tryPlant(key,col,row){
  const p=PLANTS[key];
  if(S.grid[row][col]||(!infiniteSun&&S.sun<p.cost)||S.cooldowns[key]>0) return;
  if(!infiniteSun) S.sun-=p.cost;
  S.cooldowns[key]=p.cd;
  S.grid[row][col]={
    kind:key,hp:p.hp,maxHp:p.hp,shootT:0.5,prodT:4+Math.random()*3,
    recoil:0,hurtT:0,born:S.time,fuse:1.15,
  };
  puff(GRID_X+col*CELL+50,GRID_Y+row*CELL+70,'#6abf43',7,70);
  sfx(190,.12,'sine',.16,120);
  S.selected=null; setCardsSel();
}

// ===================== 伤害 / 爆炸 =====================
function damageZombie(z,d){
  if(z.dead) return;
  z.hp-=d; z.hitT=0.1;
  if(z.hp<=0){
    z.dead=true; z.deathT=0; S.killedInWave++;
    puff(z.x,GRID_Y+z.row*CELL+45,'#7a8a5a',6,90);
  }
}
function explode(row,col){
  const x=GRID_X+col*CELL+50, y=GRID_Y+row*CELL+50;
  S.booms.push({x,y,t:0});
  S.shake=0.4;
  puff(x,y,'#ff8c00',18,220); puff(x,y,'#555555',10,120);
  sfx(70,.5,'sawtooth',.3,36);
  for(const z of S.zombies){
    if(!z.dead && Math.abs(z.x-x)<160 && Math.abs(GRID_Y+z.row*CELL+50-y)<160) damageZombie(z,1800);
  }
}

// ===================== 阳光 =====================
function spawnSkySun(){
  S.suns.push({x:GRID_X+30+Math.random()*840,y:-30,ty:GRID_Y+40+Math.random()*430,
               state:'fall',age:0,value:25,vx:0,vy:0});
}
function spawnFlowerSun(row,col){
  const px=GRID_X+col*CELL+50, py=GRID_Y+row*CELL+62;
  S.suns.push({x:px,y:py-46,ty:py-4,vx:(Math.random()-0.5)*50,vy:-70,
               state:'hop',age:0,value:25});
}
function collectSun(s){ s.state='fly'; }

// ===================== 僵尸 / 波次 =====================
function spawnZombie(type){
  const d=ZTYPES[type];
  S.zombies.push({
    type,row:(Math.random()*ROWS)|0,x:CV_W+30+Math.random()*60,
    hp:d.hp,maxHp:d.hp,speed:d.speed*(0.9+Math.random()*0.25),dmg:d.dmg,
    anim:Math.random()*10,eatT:0,slowT:0,hitT:0,dead:false,deathT:0,eating:false,
  });
  if(Math.random()<0.35) sfx(75,.35,'sawtooth',.05,55);
}
function startWave(){
  S.wave++;
  S.inWave=true; S.spawnedInWave=0; S.killedInWave=0;
  S.queue=shuffle(WAVES[S.wave-1].slice());
  const big=(S.wave===5||S.wave===TOTAL);
  showBanner(big?'一大波僵尸正在接近！':'第 '+S.wave+' 波');
  if(big){ sfx(55,.9,'sawtooth',.28,40); S.spawnT=1.6; } else S.spawnT=2.6;
}
function updateWaves(dt){
  if(!S.inWave){
    S.waveClearT-=dt;
    if(S.waveClearT<=0) startWave();
  }else{
    if(S.queue.length){
      S.spawnT-=dt;
      if(S.spawnT<=0){
        spawnZombie(S.queue.pop());
        S.spawnedInWave++;
        const big=(S.wave===5||S.wave===TOTAL);
        S.spawnT=big?(0.4+Math.random()*0.8):(1.0+Math.random()*1.6);
      }
    }else if(S.zombies.length===0){
      S.inWave=false;
      if(S.wave>=TOTAL){ win(); return; }
      S.waveClearT=4.5;
      showBanner('第 '+S.wave+' 波已清除！',1800);
    }
  }
}

// ===================== 胜负 =====================
function win(){
  if(S.over) return;
  S.over=true;
  ovTitle.textContent='🎉 胜利！';
  ovText.innerHTML='你守住了院子，成功抵御了全部 <b>'+TOTAL+'</b> 波僵尸进攻！<br>收获阳光：'+S.sun+' · 剩余小推车：'+S.mowers.filter(m=>!m.used).length;
  ovBtn.textContent='再玩一次';
  overlay.classList.remove('hidden');
  jingle([523,659,784,1046,784,1046]);
}
function lose(){
  if(S.over) return;
  S.over=true;
  ovTitle.textContent='💀 游戏结束';
  ovText.innerHTML='<b>僵尸吃掉了你的脑子！</b><br>坚持到了第 '+S.wave+' 波，再接再厉！';
  ovBtn.textContent='重新开始';
  overlay.classList.remove('hidden');
  jingle([392,330,262,196,131],'0.16','sawtooth');
}

// ===================== 更新 =====================
function update(dt){
  // 冷却 & 天降阳光
  for(const k in S.cooldowns) S.cooldowns[k]=Math.max(0,S.cooldowns[k]-dt);
  S.skyT-=dt;
  if(S.skyT<=0){ spawnSkySun(); S.skyT=7+Math.random()*4; }

  updateWaves(dt);
  updatePlants(dt);
  updatePeas(dt);
  updateZombies(dt);
  updateMowers(dt);
  updateSuns(dt);

  for(const b of S.booms) b.t+=dt;
  S.booms=S.booms.filter(b=>b.t<0.55);
  for(const p of S.parts){ p.x+=p.vx*dt; p.y+=p.vy*dt; p.vy+=220*dt; p.life-=dt; }
  S.parts=S.parts.filter(p=>p.life>0);
  S.shake=Math.max(0,S.shake-dt);
}

function updatePlants(dt){
  for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++){
    const p=S.grid[r][c]; if(!p) continue;
    p.hurtT=Math.max(0,p.hurtT-dt);
    if(p.kind==='sunflower'){
      p.prodT-=dt;
      if(p.prodT<=0){ p.prodT=9+Math.random()*2; spawnFlowerSun(r,c); }
    }else if(p.kind==='cherry'){
      p.fuse-=dt;
      if(p.fuse<=0){ S.grid[r][c]=null; explode(r,c); }
    }else if(p.kind==='peashooter'||p.kind==='snowpea'||p.kind==='repeater'){
      p.recoil=Math.max(0,p.recoil-dt);
      p.shootT-=dt;
      const px=GRID_X+c*CELL+50;
      const has=S.zombies.some(z=>!z.dead&&z.row===r&&z.x>px-30&&z.x<CV_W+40);
      if(has&&p.shootT<=0){
        p.shootT=1.4; p.recoil=0.15;
        const py=GRID_Y+r*CELL+42;
        S.peas.push({x:px+28,y:py,row:r,snow:p.kind==='snowpea',delay:0,gone:false});
        if(p.kind==='repeater') S.peas.push({x:px+28,y:py,row:r,snow:false,delay:0.18,gone:false});
        sfx(520,.05,'square',.045,380);
      }
    }
  }
}

function updatePeas(dt){
  for(const p of S.peas){
    if(p.delay>0){ p.delay-=dt; continue; }
    p.x+=380*dt;
    let hit=null;
    for(const z of S.zombies){
      if(!z.dead&&z.row===p.row&&Math.abs(z.x-p.x)<30){ if(!hit||z.x<hit.x) hit=z; }
    }
    if(hit){
      damageZombie(hit,20);
      if(p.snow) hit.slowT=4;
      puff(p.x,p.y,p.snow?'#aee8ff':'#9adf4f',5,60);
      p.gone=true;
      sfx(210,.04,'square',.05,150);
    }
    if(p.x>CV_W+30) p.gone=true;
  }
  S.peas=S.peas.filter(p=>!p.gone);
}

function updateZombies(dt){
  for(const z of S.zombies){
    if(z.dead){ z.deathT+=dt; continue; }
    z.hitT=Math.max(0,z.hitT-dt);
    if(z.slowT>0) z.slowT-=dt;
    const sf=z.slowT>0?0.45:1;
    z.eating=false;
    const front=z.x-26;
    const col=Math.floor((front-GRID_X)/CELL);
    let plant=null;
    if(col>=0&&col<COLS) plant=S.grid[z.row][col];
    if(plant&&front<=GRID_X+col*CELL+CELL*0.75){
      z.eating=true; z.anim+=dt*0.6;
      z.eatT-=dt;
      if(z.eatT<=0){
        z.eatT=0.6; plant.hp-=z.dmg; plant.hurtT=0.15;
        sfx(140,.08,'square',.06,90);
        if(plant.hp<=0){
          S.grid[z.row][col]=null;
          puff(GRID_X+col*CELL+50,GRID_Y+z.row*CELL+60,'#4a8f2f',10,120);
        }
      }
    }else{
      z.anim+=dt*sf;
      z.x-=z.speed*sf*dt;
    }
    if(z.x<GRID_X-4){
      const m=S.mowers[z.row];
      if(!m.used){ m.used=true; m.on=true; sfx(110,.55,'sawtooth',.2,60); }
      else if(z.x<GRID_X-70){ lose(); }
    }
  }
  S.zombies=S.zombies.filter(z=>!z.dead||z.deathT<0.9);
}

function updateMowers(dt){
  for(const m of S.mowers){
    if(!m.on) continue;
    m.x+=340*dt;
    for(const z of S.zombies){
      if(!z.dead&&z.row===m.row&&z.x<m.x+50) damageZombie(z,99999);
    }
    if(m.x>CV_W+80) m.on=false;
  }
}

function updateSuns(dt){
  for(const s of S.suns){
    s.age+=dt;
    if(autoPick&&s.state!=='fly'&&s.age>0.9) s.state='fly';
    if(s.state==='fall'){
      s.y+=38*dt; s.x+=Math.sin(s.age*2)*8*dt;
      if(s.y>=s.ty) s.state='still';
    }else if(s.state==='hop'){
      s.vy+=340*dt; s.x+=s.vx*dt; s.y+=s.vy*dt;
      if(s.vy>0&&s.y>=s.ty) s.state='still';
    }else if(s.state==='still'){
      if(s.age>10) s.gone=true;
    }else if(s.state==='fly'){
      const tx=56,ty=16,dx=tx-s.x,dy=ty-s.y,d=Math.hypot(dx,dy),sp=1100*dt;
      if(d<sp+6){
        S.sun+=s.value; s.gone=true;
        sfx(880,.12,'sine',.15,1500);
      }else{ s.x+=dx/d*sp; s.y+=dy/d*sp; }
    }
    if(s.age>16&&s.state!=='fly') s.gone=true;
  }
  S.suns=S.suns.filter(s=>!s.gone);
}

// ===================== 绘制 =====================
function drawLawn(){
  ctx.fillStyle='#3f6b28'; ctx.fillRect(0,0,CV_W,CV_H);
  for(let r=0;r<ROWS;r++)for(let c=0;c<COLS;c++){
    ctx.fillStyle=(r+c)%2?'#79bf4e':'#86cd58';
    ctx.fillRect(GRID_X+c*CELL,GRID_Y+r*CELL,CELL,CELL);
  }
  ctx.fillStyle='#8a6a3c'; ctx.fillRect(0,GRID_Y,GRID_X,ROWS*CELL);
  ctx.fillStyle='#75572f'; ctx.fillRect(GRID_X-8,GRID_Y,8,ROWS*CELL);
  ctx.fillStyle='rgba(0,0,0,.14)'; ctx.fillRect(0,GRID_Y+ROWS*CELL,CV_W,CV_H-GRID_Y-ROWS*CELL);
}

function drawPlant(g,p,t){
  const sway=Math.sin(t*2+p.born)*0.06;
  if(p.kind==='sunflower'){
    g.save(); g.rotate(sway*0.5);
    g.strokeStyle='#3e8e2f'; g.lineWidth=6; g.lineCap='round';
    g.beginPath(); g.moveTo(0,-4); g.quadraticCurveTo(4,-22,0,-36); g.stroke();
    g.fillStyle='#4da334';
    g.beginPath(); g.ellipse(-12,-12,10,4.5,-0.5,0,TAU); g.fill();
    g.beginPath(); g.ellipse(12,-9,10,4.5,0.5,0,TAU); g.fill();
    g.translate(0,-50); g.rotate(sway);
    g.fillStyle='#ffd23e';
    for(let i=0;i<12;i++){
      g.save(); g.rotate(i*TAU/12+t*0.25);
      g.beginPath(); g.ellipse(0,-20,6.5,12.5,0,0,TAU); g.fill(); g.restore();
    }
    g.fillStyle='#9c6b30'; g.beginPath(); g.arc(0,0,13,0,TAU); g.fill();
    g.fillStyle='#7a4d1e'; g.beginPath(); g.arc(0,1,10,0,TAU); g.fill();
    g.fillStyle='#fff';
    g.beginPath(); g.arc(-4,-3,2.4,0,TAU); g.arc(4,-3,2.4,0,TAU); g.fill();
    g.fillStyle='#222';
    g.beginPath(); g.arc(-4,-3,1.2,0,TAU); g.arc(4,-3,1.2,0,TAU); g.fill();
    g.strokeStyle='#222'; g.lineWidth=1.4;
    g.beginPath(); g.arc(0,2,4.5,0.15*Math.PI,0.85*Math.PI); g.stroke();
    g.restore();
  }
  else if(p.kind==='peashooter'||p.kind==='snowpea'||p.kind==='repeater'){
    const main=p.kind==='snowpea'?'#59c1e8':'#67c33f';
    const dark=p.kind==='snowpea'?'#2f93b8':'#4a9a24';
    g.save(); g.rotate(sway*0.4);
    g.strokeStyle='#3e8e2f'; g.lineWidth=6; g.lineCap='round';
    g.beginPath(); g.moveTo(0,-2); g.quadraticCurveTo(-3,-18,0,-30); g.stroke();
    g.fillStyle='#4da334'; g.beginPath(); g.ellipse(10,-8,10,4.5,0.6,0,TAU); g.fill();
    g.translate(-p.recoil*30,-44);
    if(p.kind==='repeater'){
      g.fillStyle=dark; rr(g,2,-14,24,11,5); g.fill();
      g.fillStyle='#1e3d10'; g.beginPath(); g.arc(25,-8.5,4,0,TAU); g.fill();
    }
    g.fillStyle=main; g.beginPath(); g.arc(0,0,16,0,TAU); g.fill();
    g.fillStyle=main; rr(g,8,-8,28,16,7); g.fill();
    g.fillStyle=dark; g.beginPath(); g.ellipse(34,0,4.5,6.5,0,0,TAU); g.fill();
    g.fillStyle='#fff'; g.beginPath(); g.arc(2,-6,4,0,TAU); g.fill();
    g.fillStyle='#222'; g.beginPath(); g.arc(3.5,-6,2,0,TAU); g.fill();
    if(p.kind==='snowpea'){
      g.fillStyle='#e8fbff';
      for(let i=0;i<4;i++){
        g.beginPath(); g.arc(-8+((i*5)%16),-14-((i*3)%4),2.2,0,TAU); g.fill();
      }
    }
    g.restore();
  }
  else if(p.kind==='wallnut'){
    g.save(); g.translate(0,-30); g.rotate(sway*0.5+(p.hurtT>0?(Math.random()-0.5)*0.06:0));
    const frac=p.hp/p.maxHp;
    g.fillStyle='#9c6b30';
    g.beginPath(); g.ellipse(0,0,24,30,0,0,TAU); g.fill();
    g.fillStyle='#b98348'; g.beginPath(); g.ellipse(-4,-6,18,22,0,0,TAU); g.fill();
    g.strokeStyle='#6e4517'; g.lineWidth=2.5;
    g.beginPath(); g.ellipse(0,0,24,30,0,0,TAU); g.stroke();
    g.fillStyle='#fff';
    g.beginPath(); g.arc(-7,-4,4.5,0,TAU); g.arc(8,-4,4.5,0,TAU); g.fill();
    g.fillStyle='#222';
    g.beginPath(); g.arc(-6,-3,2.2,0,TAU); g.arc(9,-3,2.2,0,TAU); g.fill();
    g.strokeStyle='#5a3a14'; g.lineWidth=2;
    if(frac>0.5){ g.beginPath(); g.arc(0,8,6,0.15*Math.PI,0.85*Math.PI); g.stroke(); }
    else{ g.beginPath(); g.moveTo(-6,12); g.lineTo(0,9); g.lineTo(6,12); g.stroke(); }
    if(frac<0.66){
      g.strokeStyle='#5a3a14'; g.lineWidth=2;
      g.beginPath(); g.moveTo(14,-26); g.lineTo(10,-16); g.lineTo(16,-8); g.stroke();
    }
    if(frac<0.33){
      g.beginPath(); g.moveTo(-18,-20); g.lineTo(-12,-10); g.lineTo(-19,-2); g.stroke();
      g.beginPath(); g.moveTo(0,28); g.lineTo(4,20); g.stroke();
    }
    g.restore();
  }
  else if(p.kind==='cherry'){
    g.save();
    const pu=p.fuse!==undefined?Math.max(0,0.6-p.fuse):0;
    g.scale(1+pu*0.5,1+pu*0.5);
    g.rotate(sway);
    g.strokeStyle='#3e8e2f'; g.lineWidth=4; g.lineCap='round';
    g.beginPath(); g.moveTo(-10,-32); g.quadraticCurveTo(-4,-52,2,-56); g.stroke();
    g.beginPath(); g.moveTo(12,-28); g.quadraticCurveTo(8,-48,2,-56); g.stroke();
    g.fillStyle='#d42a1e';
    g.beginPath(); g.arc(-10,-18,15,0,TAU); g.fill();
    g.beginPath(); g.arc(13,-14,14,0,TAU); g.fill();
    g.fillStyle='#ff6f5a';
    g.beginPath(); g.arc(-14,-23,5,0,TAU); g.fill();
    g.beginPath(); g.arc(9,-19,4.4,0,TAU); g.fill();
    g.fillStyle='#fff';
    g.beginPath(); g.arc(-13,-20,3,0,TAU); g.arc(-6,-20,3,0,TAU); g.fill();
    g.fillStyle='#222';
    g.beginPath(); g.arc(-12,-19,1.5,0,TAU); g.arc(-7,-19,1.5,0,TAU); g.fill();
    g.strokeStyle='#7a1408'; g.lineWidth=2;
    g.beginPath(); g.moveTo(-17,-25); g.lineTo(-9,-23); g.stroke();
    if(p.fuse!==undefined&&p.fuse<0.35){
      g.fillStyle='rgba(255,255,220,'+(0.35-p.fuse)*2.5+')';
      g.beginPath(); g.arc(2,-18,26,0,TAU); g.fill();
    }
    g.restore();
  }
}

function drawZombie(g,z){
  const baseY=GRID_Y+z.row*CELL+CELL-14;
  g.save();
  g.translate(z.x,baseY);
  if(z.dead){
    const k=Math.min(1,z.deathT/0.9);
    g.globalAlpha=1-k;
    g.rotate(-k*1.45);
  }
  const w=Math.sin(z.anim*7);
  const suit=z.type==='run'?'#7a3b3b':'#4a4a5e';
  // 腿
  g.strokeStyle='#3d3d4a'; g.lineWidth=9; g.lineCap='round';
  g.beginPath(); g.moveTo(-4,-32); g.lineTo(-4-(z.eating?2:w*7),0); g.stroke();
  g.beginPath(); g.moveTo(6,-32); g.lineTo(6+(z.eating?2:w*7),0); g.stroke();
  // 躯干 + 领带
  g.fillStyle=suit; rr(g,-16,-66,30,38,6); g.fill();
  g.fillStyle='#c0392b'; g.fillRect(-5,-64,6,16);
  // 后臂
  g.strokeStyle=suit; g.lineWidth=8;
  g.beginPath(); g.moveTo(-10,-58); g.lineTo(-28,-52+w*3); g.stroke();
  g.fillStyle='#9fae76'; g.beginPath(); g.arc(-30,-52+w*3,5,0,TAU); g.fill();
  // 头
  g.fillStyle='#9fae76'; g.beginPath(); g.arc(-2,-76,14,0,TAU); g.fill();
  if(z.eating){
    g.fillStyle='#6d7a52';
    g.beginPath(); g.arc(-9,-68,4+Math.abs(w)*2.5,0,TAU); g.fill();
  }
  g.fillStyle='#fff';
  g.beginPath(); g.arc(-9,-79,3.4,0,TAU); g.arc(-1,-80,3.4,0,TAU); g.fill();
  g.fillStyle='#222';
  g.beginPath(); g.arc(-11,-79,1.6,0,TAU); g.arc(-3,-80,1.6,0,TAU); g.fill();
  // 头饰
  if(z.type==='cone'){
    g.fillStyle='#e67e22';
    g.beginPath(); g.moveTo(-2,-104); g.lineTo(-15,-72); g.lineTo(11,-72); g.closePath(); g.fill();
    g.fillStyle='#f39c52'; g.fillRect(-9,-84,15,5);
  }else if(z.type==='bucket'){
    g.fillStyle='#95a5a6'; rr(g,-15,-100,26,28,3); g.fill();
    g.fillStyle='#b3bcbe'; g.fillRect(-15,-100,26,6);
    g.strokeStyle='#6d7a7c'; g.lineWidth=2; rr(g,-15,-100,26,28,3); g.stroke();
  }else if(z.type==='run'){
    g.fillStyle='#e74c3c'; rr(g,-17,-90,30,7,3); g.fill();
  }
  // 前臂（伸向前方）
  g.strokeStyle=suit; g.lineWidth=8;
  g.beginPath(); g.moveTo(-12,-56); g.lineTo(-34,-58-w*4); g.stroke();
  g.fillStyle='#9fae76'; g.beginPath(); g.arc(-36,-58-w*4,5,0,TAU); g.fill();
  // 受击 / 减速
  if(z.hitT>0){ g.fillStyle='rgba(255,255,255,.45)'; g.beginPath(); g.arc(-2,-62,36,0,TAU); g.fill(); }
  if(z.slowT>0){ g.fillStyle='rgba(80,160,255,.3)'; g.beginPath(); g.arc(-2,-62,36,0,TAU); g.fill(); }
  g.restore();
}

function drawMower(g,m){
  if(m.used&&!m.on) return;
  const y=GRID_Y+m.row*CELL+CELL-20;
  g.save(); g.translate(m.x,y);
  g.strokeStyle='#555'; g.lineWidth=4; g.lineCap='round';
  g.beginPath(); g.moveTo(-8,-8); g.lineTo(-24,-28); g.stroke();
  g.fillStyle='#c0392b'; rr(g,-18,-18,36,17,4); g.fill();
  g.fillStyle='#e74c3c'; rr(g,-13,-24,22,9,3); g.fill();
  g.fillStyle='#222';
  g.beginPath(); g.arc(-10,2,7,0,TAU); g.arc(10,2,7,0,TAU); g.fill();
  g.fillStyle='#888';
  g.beginPath(); g.arc(-10,2,3,0,TAU); g.arc(10,2,3,0,TAU); g.fill();
  g.restore();
}

function drawSunSprite(g,x,y,r,t,alpha){
  g.save(); g.translate(x,y); g.globalAlpha=alpha==null?1:alpha;
  g.fillStyle='rgba(255,220,60,.22)';
  g.beginPath(); g.arc(0,0,r*1.9,0,TAU); g.fill();
  g.fillStyle='#ffdf4d';
  for(let i=0;i<8;i++){
    g.save(); g.rotate(t*0.9+i*TAU/8);
    g.beginPath(); g.moveTo(r*0.55,-r*0.28); g.lineTo(r*1.45,0); g.lineTo(r*0.55,r*0.28);
    g.closePath(); g.fill(); g.restore();
  }
  g.fillStyle='#ffd700'; g.beginPath(); g.arc(0,0,r,0,TAU); g.fill();
  g.fillStyle='#fff3a0'; g.beginPath(); g.arc(0,0,r*0.55,0,TAU); g.fill();
  g.restore();
}

function render(){
  ctx.save();
  if(S.shake>0) ctx.translate((Math.random()-0.5)*10*S.shake,(Math.random()-0.5)*10*S.shake);
  drawLawn();
  for(const m of S.mowers) drawMower(ctx,m);

  for(let r=0;r<ROWS;r++){
    for(let c=0;c<COLS;c++){
      const p=S.grid[r][c];
      if(p){
        ctx.save();
        ctx.translate(GRID_X+c*CELL+50,GRID_Y+r*CELL+CELL-16);
        drawPlant(ctx,p,S.time);
        ctx.restore();
      }
    }
    const zs=S.zombies.filter(z=>z.row===r).sort((a,b)=>a.x-b.x);
    for(const z of zs) drawZombie(ctx,z);
  }

  for(const p of S.peas){
    if(p.delay>0) continue;
    ctx.fillStyle=p.snow?'rgba(127,212,242,.4)':'rgba(111,206,58,.4)';
    ctx.beginPath(); ctx.arc(p.x-11,p.y,4.5,0,TAU); ctx.fill();
    ctx.fillStyle=p.snow?'#7fd4f2':'#6fce3a';
    ctx.beginPath(); ctx.arc(p.x,p.y,7,0,TAU); ctx.fill();
    ctx.fillStyle=p.snow?'#d9f4ff':'#b8f09a';
    ctx.beginPath(); ctx.arc(p.x-2,p.y-2,2.6,0,TAU); ctx.fill();
  }

  for(const b of S.booms){
    const k=b.t/0.55;
    ctx.globalAlpha=1-k;
    ctx.fillStyle='#ff8c00';
    ctx.beginPath(); ctx.arc(b.x,b.y,40+k*140,0,TAU); ctx.fill();
    ctx.fillStyle='#ffe14d';
    ctx.beginPath(); ctx.arc(b.x,b.y,20+k*90,0,TAU); ctx.fill();
    ctx.globalAlpha=1;
  }

  for(const p of S.parts){
    ctx.globalAlpha=Math.max(0,p.life*2);
    ctx.fillStyle=p.color;
    ctx.beginPath(); ctx.arc(p.x,p.y,p.r,0,TAU); ctx.fill();
  }
  ctx.globalAlpha=1;

  for(const s of S.suns){
    const a=s.state==='still'&&s.age>8?Math.max(0,1-(s.age-8)/2):(s.state==='fly'?1:1);
    drawSunSprite(ctx,s.x,s.y,16,S.time+s.age,a);
  }

  // 悬停高亮 + 种植预览
  if(S.hover&&S.hover.col!=null&&S.hover.row!=null&&S.started&&!S.over&&!S.paused){
    const {col,row}=S.hover;
    const occupied=!!S.grid[row][col];
    if(S.selected){
      ctx.fillStyle=occupied?'rgba(255,60,40,.25)':'rgba(255,255,255,.18)';
      ctx.fillRect(GRID_X+col*CELL,GRID_Y+row*CELL,CELL,CELL);
      if(!occupied){
        ctx.globalAlpha=0.55;
        ctx.save();
        ctx.translate(GRID_X+col*CELL+50,GRID_Y+row*CELL+CELL-16);
        drawPlant(ctx,{kind:S.selected,hp:1,maxHp:1,born:0,recoil:0,fuse:9,hurtT:0},S.time);
        ctx.restore();
        ctx.globalAlpha=1;
      }
    }else if(S.shovel&&occupied){
      ctx.fillStyle='rgba(255,60,40,.3)';
      ctx.fillRect(GRID_X+col*CELL,GRID_Y+row*CELL,CELL,CELL);
    }
  }
  ctx.restore();

  if(S.paused&&!S.over){
    ctx.fillStyle='rgba(0,0,0,.5)'; ctx.fillRect(0,0,CV_W,CV_H);
    ctx.fillStyle='#fff'; ctx.font='900 42px "Microsoft YaHei",sans-serif';
    ctx.textAlign='center'; ctx.textBaseline='middle';
    ctx.fillText('已暂停',CV_W/2,CV_H/2-20);
    ctx.font='22px "Microsoft YaHei",sans-serif';
    ctx.fillText('按 P 或 ⏸ 按钮继续',CV_W/2,CV_H/2+30);
  }
  refreshCards();
  const frac=Math.min(1,((S.wave-1)+(S.inWave?S.killedInWave/Math.max(1,S.spawnedInWave):0))/TOTAL);
  progressFill.style.width=(frac*100)+'%';
  waveLabel.textContent=S.started?('第 '+Math.min(S.wave,TOTAL)+' / '+TOTAL+' 波'):'准备中…';
}

// ===================== 主循环 =====================
let last=0;
function loop(ts){
  const dt=Math.min(0.05,(ts-last)/1000||0);
  last=ts;
  S.time+=dt;
  if(S.started&&!S.paused&&!S.over) update(dt);
  render();
  requestAnimationFrame(loop);
}

// ===================== 交互 =====================
cvs.addEventListener('mousemove',e=>{ S.hover=cellAt(e); });
cvs.addEventListener('mouseleave',()=>{ S.hover=null; });
cvs.addEventListener('contextmenu',e=>{
  e.preventDefault();
  S.selected=null; S.shovel=false; shovelBtn.classList.remove('on'); setCardsSel();
});
cvs.addEventListener('mousedown',e=>{
  if(e.button!==0||!S.started||S.over||S.paused) return;
  const pos=cellAt(e);
  for(const s of S.suns){
    if(s.state!=='fly'&&Math.hypot(s.x-pos.x,s.y-pos.y)<40){ collectSun(s); return; }
  }
  if(pos.col==null||pos.row==null) return;
  if(S.shovel){
    const p=S.grid[pos.row][pos.col];
    if(p){
      S.grid[pos.row][pos.col]=null;
      puff(GRID_X+pos.col*CELL+50,GRID_Y+pos.row*CELL+50,'#8a6a3c',9,110);
      sfx(260,.1,'sine',.12,140);
      S.shovel=false; shovelBtn.classList.remove('on');
    }
    return;
  }
  if(S.selected) tryPlant(S.selected,pos.col,pos.row);
});

shovelBtn.onclick=()=>{
  if(!S.started||S.over) return;
  S.selected=null; setCardsSel();
  S.shovel=!S.shovel;
  shovelBtn.classList.toggle('on',S.shovel);
  sfx(300,.06,'sine',.08);
};
muteBtn.onclick=()=>{ muted=!muted; muteBtn.textContent=muted?'🔇':'🔊'; };
function togglePause(){
  if(!S.started||S.over) return;
  S.paused=!S.paused;
  pauseBtn.textContent=S.paused?'▶':'⏸';
}
pauseBtn.onclick=togglePause;
autoBtn.onclick=()=>{
  autoPick=!autoPick;
  autoBtn.classList.toggle('on',autoPick);
  sfx(560,.06,'sine',.08);
};
infiniteBtn.onclick=()=>{
  infiniteSun=!infiniteSun;
  infiniteBtn.classList.toggle('on',infiniteSun);
  sfx(560,.06,'sine',.08);
};

window.addEventListener('keydown',e=>{
  if(e.key==='Escape'){ S.selected=null; S.shovel=false; shovelBtn.classList.remove('on'); setCardsSel(); }
  else if(e.key==='p'||e.key==='P') togglePause();
  else{
    const i=parseInt(e.key,10);
    const keys=Object.keys(PLANTS);
    if(i>=1&&i<=keys.length&&S.started&&!S.over){
      const k=keys[i-1];
      if(S.selected===k){ S.selected=null; }
      else if((infiniteSun||S.sun>=PLANTS[k].cost)&&S.cooldowns[k]<=0){ S.selected=k; S.shovel=false; shovelBtn.classList.remove('on'); }
      setCardsSel();
    }
  }
});

ovBtn.onclick=()=>{
  if(S.over){ newGame(); }
  overlay.classList.add('hidden');
  S.started=true;
  sfx(660,.1,'sine',.1,880);
};

// ===================== 启动 =====================
newGame();
buildCards();
(function(){
  const g=document.getElementById('sunIcon').getContext('2d');
  drawSunSprite(g,17,17,9,0.8,1);
})();
requestAnimationFrame(loop);
</script>
</body>
</html>

<!DOCTYPE html>
<html data-page-node-id="6bTEUbs7sJo4Rro6FU84pA" lang="zh-CN">
<head data-page-node-id="vOiOLscTLONJjPYQ1qdmyU">

<meta data-page-node-id="lv1BVkRFZXoQ6tiEr0acAf" charset="UTF-8">
<meta data-page-node-id="oVAMQmbTurK9SmlGkAWw9A" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" name="viewport">
<title data-page-node-id="hNtQ7m7AEiDeUw1vUwPpim" data-pnid-children="eUYcjUncbxzAiahpRxtnII">井字棋 · 儿童版</title>
<style data-page-node-id="iRpf9wDNzoWHwoEEi05FeY" data-pnid-children="FnR9kCxTuxpeJXV9wUbVLs">
  :root{
    --bg:#f7f5ef;
    --panel:#ffffff;
    --ink:#2f2a26;
    --ink-soft:#7a6f66;
    --line:#e6dfd4;
    --accent:#c8663f;
    --accent-soft:#f3e2d8;
    --blue:#3f6f8f;
    --blue-soft:#dfeaf2;
    --gold:#c9a227;
    --gold-soft:#faf0d4;
    --shadow:0 2px 8px rgba(80,60,40,.07), 0 12px 32px rgba(80,60,40,.06);
    --radius:18px;
  }
  *{box-sizing:border-box; -webkit-tap-highlight-color:transparent;}
  html,body{margin:0;padding:0;}
  body{
    background:var(--bg);
    color:var(--ink);
    font-family:"PingFang SC","Microsoft YaHei","Hiragino Sans GB",system-ui,sans-serif;
    min-height:100vh;
    display:flex;
    justify-content:center;
    padding:16px 12px 40px;
  }
  .wrap{width:100%;max-width:560px;}

  header{text-align:center;margin:8px 0 18px;}
  h1{
    margin:0;font-size:26px;letter-spacing:2px;font-weight:800;
  }
  h1 .dot{color:var(--accent);}
  .sub{margin:6px 0 0;font-size:13px;color:var(--ink-soft);}

  .card{
    background:var(--panel);
    border:1px solid var(--line);
    border-radius:var(--radius);
    box-shadow:var(--shadow);
    padding:16px;
    margin-bottom:14px;
  }
  .label{
    font-size:12px;color:var(--ink-soft);font-weight:700;
    letter-spacing:1px;margin-bottom:8px;
  }

  /* ---------- 状态栏 ---------- */
  .status{
    display:flex;align-items:center;gap:12px;
  }
  .turn-mark{
    width:44px;height:44px;flex:0 0 44px;
    border-radius:12px;
    display:grid;place-items:center;
    font-size:26px;font-weight:800;
    background:var(--accent-soft);color:var(--accent);
    transition:background .25s, color .25s;
  }
  .turn-mark.ai{background:var(--blue-soft);color:var(--blue);}
  .status-text{flex:1;min-width:0;}
  .status-main{font-size:17px;font-weight:700;}
  .status-sub{font-size:12.5px;color:var(--ink-soft);margin-top:3px;}
  .clock{
    font-variant-numeric:tabular-nums;
    font-size:15px;font-weight:700;color:var(--ink-soft);
    background:#f3f0e9;border-radius:10px;padding:6px 10px;
  }

  /* ---------- 棋盘 ---------- */
  .board-box{display:flex;justify-content:center;padding:6px 0 2px;}
  .board{
    display:grid;
    gap:6px;
    background:var(--line);
    padding:6px;
    border-radius:14px;
    touch-action:manipulation;
  }
  .cell{
    background:#fffdf8;
    border-radius:9px;
    display:grid;place-items:center;
    font-weight:800;
    cursor:pointer;
    position:relative;
    transition:background .15s, transform .12s;
    user-select:none;
  }
  .cell:hover{background:#fdf6ea;}
  .cell:active{transform:scale(.94);}
  .cell .mark{
    opacity:0;transform:scale(.4);
    transition:opacity .18s, transform .18s;
    line-height:1;
  }
  .cell.x .mark{opacity:1;transform:scale(1);color:var(--accent);}
  .cell.o .mark{opacity:1;transform:scale(1);color:var(--blue);}
  .cell.last::after{
    content:"";position:absolute;inset:0;
    border:2px solid var(--gold);border-radius:9px;
    pointer-events:none;
  }
  .cell.hint{
    background:var(--gold-soft);
    animation:hintPulse 1.1s ease-in-out infinite;
    cursor:default;
  }
  .cell.hint .hint-dot{
    opacity:1;
    position:absolute;
    font-size:.34em;
    color:var(--gold);
    transform:scale(1);
    font-weight:900;
    pointer-events:none;
  }
  @keyframes hintPulse{
    0%,100%{ box-shadow:0 0 0 0 rgba(201,162,39,.55); }
    50%{ box-shadow:0 0 0 9px rgba(201,162,39,0); }
  }
  .cell.win{background:var(--accent-soft);}
  .cell.win .mark{animation:pop .4s ease;}
  @keyframes pop{0%{transform:scale(.6)}60%{transform:scale(1.25)}100%{transform:scale(1)}}

  /* ---------- 控制 ---------- */
  .row{display:flex;gap:8px;flex-wrap:wrap;}
  button{
    font-family:inherit;font-size:14px;font-weight:700;
    border:1px solid var(--line);background:#fffdf8;color:var(--ink);
    border-radius:11px;padding:9px 14px;cursor:pointer;
    transition:transform .1s, background .15s, border-color .15s;
  }
  button:active{transform:scale(.95);}
  button:disabled{opacity:.42;cursor:not-allowed;}
  button.primary{background:var(--accent);border-color:var(--accent);color:#fff;}
  button.primary:hover:not(:disabled){background:#b85a35;}
  .seg{display:flex;background:#f3f0e9;border-radius:12px;padding:4px;gap:4px;flex:1;min-width:0;}
  .seg button{
    flex:1;border:none;background:transparent;color:var(--ink-soft);
    border-radius:9px;padding:8px 4px;font-size:13.5px;
  }
  .seg button.on{background:var(--panel);color:var(--ink);box-shadow:0 1px 4px rgba(0,0,0,.09);}

  .scores{display:flex;gap:8px;}
  .score{
    flex:1;background:#faf7f1;border:1px solid var(--line);
    border-radius:12px;padding:10px;text-align:center;
  }
  .score .num{font-size:22px;font-weight:800;line-height:1.2;}
  .score .cap{font-size:11.5px;color:var(--ink-soft);margin-top:2px;}

  .tip{font-size:12.5px;color:var(--ink-soft);line-height:1.7;}
  .tip b{color:var(--ink);}
  kbd{
    background:#f3f0e9;border:1px solid var(--line);border-bottom-width:2px;
    border-radius:5px;padding:1px 6px;font-size:11.5px;font-family:inherit;font-weight:700;
  }
  .banner{
    display:none;
    border-radius:12px;padding:12px 14px;margin-bottom:14px;
    font-weight:700;font-size:15px;text-align:center;
  }
  .banner.show{display:block;animation:pop .35s ease;}
  .banner.win{background:var(--accent-soft);color:var(--accent);}
  .banner.lose{background:var(--blue-soft);color:var(--blue);}
  .banner.draw{background:#f3f0e9;color:var(--ink-soft);}
  .hint-card{background:var(--gold-soft);border-color:#ecd9a0;}
  .hint-card .label{color:#9a7b12;}
  .hint-text{font-size:14px;line-height:1.75;color:#6b5407;font-weight:600;}
  .hint-text .spot{
    display:inline-block;background:#fff;border:1.5px solid var(--gold);
    border-radius:6px;padding:0 7px;margin:0 2px;font-weight:800;color:#8a6d0f;
  }
  footer{text-align:center;font-size:11.5px;color:#a89c90;margin-top:18px;line-height:1.8;}
</style>
</head>
<body data-page-node-id="KlDBVEYIfBjpVVH9BIhXkL">
<div data-page-node-id="alUExnB3srbgiiJgUF7JbZ" class="wrap">

  <header data-page-node-id="m87oIxSnyRSame1ok5NeBh">
    <h1 data-page-node-id="b8EEOBG4l2AdhyYBhf8oAL"><!--pnid:Ia4Xu0DAZXrGjEyE2vIEc5-->井字棋<span data-page-node-id="Xbn6Oe3wxdL8j20VDHMKW7" class="dot"><!--pnid:7DrKQuSKeCnxiNVhBFMqcr-->·</span><!--pnid:b5brX6Xc2cRVBOtw4Tdy2Z-->儿童版</h1>
    <p data-page-node-id="IvdeZPHwJ2A73uYqEV2KOk" class="sub"><!--pnid:ygEoduO5MVwb6j1reTA7RN-->横竖斜先连成三个你就赢啦</p>
  </header>

  <div data-page-node-id="deARRk3RjaRz3qKKslM6Vm" class="banner" id="banner"></div>

  <!--pnid:7GNMg5ZZCt3Pb45nlCvcA2--><!-- 状态 -->
  <div data-page-node-id="I6buzXhkeBZLPxS5GECR5i" class="card">
    <div data-page-node-id="y3uRJC36HcavBlyIKk3dlp" class="status">
      <div data-page-node-id="maYj2oX02b2vMyWS48hRm1" class="turn-mark" id="turnMark"><!--pnid:vPiLTWdzMxql6kIKxoMnm0-->X</div>
      <div data-page-node-id="slSu0xP52sYN53X7pK0C4Q" class="status-text">
        <div data-page-node-id="vyhNX3OYbuUZAiq4DYVG4d" class="status-main" id="statusMain"><!--pnid:zH64d0qZewuvF5TuoYVn8o-->轮到你走</div>
        <div data-page-node-id="OybXwPQSn3uymnGQ3GR8xL" class="status-sub" id="statusSub"><!--pnid:P2gK9VKxjGjswnDdtuiqZb-->点一个格子放下 X</div>
      </div>
      <div data-page-node-id="dnS56rGc4SyVLMlbRj8tll" class="clock" id="clock"><!--pnid:Dd5IY3N4dGokIjM1y0mxYF-->00:00</div>
    </div>
  </div>

  <!--pnid:VpHDgkrynDXBOctblUaTCr--><!-- 棋盘 -->
  <div data-page-node-id="0IAPJVhVVAuRamti4AFHWY" class="card">
    <div data-page-node-id="YlqBPM8KCldVuZluzKrw35" class="board-box"><div data-page-node-id="oByrGdWgVhRcYX2vAmvivi" class="board" id="board"></div></div>
  </div>

  <!--pnid:yaTwX7IqyEooV3fvvet6SV--><!-- 操作 -->
  <div data-page-node-id="7ZGS2brZhnWssHjXhaZiWj" class="card">
    <div data-page-node-id="qsYhuHKF6TExuyVuB7OOC9" class="label"><!--pnid:mihWGoRNurkcitQtX5dOGa-->操作</div>
    <div data-page-node-id="gaUhUIdIdIPcCbYsq2KJj1" class="row">
      <button data-page-node-id="vWzHhDsrBezqfunEYIW2u8" class="primary" id="btnNew" style="flex:1"><!--pnid:sovKPu7OWqVZ4qgflA2HaA-->新的一局</button>
      <button data-page-node-id="cWGf9sDFcuT0LBy4mnMsg3" id="btnHint" style="flex:1"><!--pnid:jKHN8ezIfkyUaU8S0ZeGUn-->💡 提示</button>
    </div>
    <div data-page-node-id="ekBYKI2DXy8OOXMP5PJVtu" class="row" style="margin-top:8px">
      <button data-page-node-id="vQKYosDKYUOiRtlPAinb2Y" id="btnUndo" style="flex:1"><!--pnid:iYiStnGXmpSkNQ9pFwQ2Lx-->悔一步</button>
      <button data-page-node-id="5wwTvPX8ec4kuaJfb2qVcx" id="btnSwap" style="flex:1"><!--pnid:wj8cRKTXlVd1bEi7WSLPDU-->换先手</button>
    </div>
  </div>

  <!--pnid:gXLt6U2RiSuAkLOAXYZnzT--><!-- 提示说明 -->
  <div data-page-node-id="kbdRM24hdzyrWNHhmgbM06" class="card hint-card" id="hintCard">
    <div data-page-node-id="wCnIxBYll9aZh2eFZuIQMq" class="label"><!--pnid:0uxCxFuxguNybkKuSPfsdF-->💡 提示</div>
    <div data-page-node-id="TJYFWSKqRLF27elqaoLpZ7" class="hint-text" id="hintText"><!--pnid:QDLsONSD81oT1tYptkXmne-->点「提示」，我会告诉你该下在哪里。</div>
  </div>

  <!--pnid:OKx9WEDIZKAQV63qwQfAfQ--><!-- 设置 -->
  <div data-page-node-id="HkzJfEwwsOdKXmNEZXe8Yq" class="card">
    <div data-page-node-id="hHD5YJvBzY6vOEGeSYlkTR" class="label"><!--pnid:5cuzEoiS3jWyPOwhVYEqxQ-->棋盘大小</div>
    <div data-page-node-id="W3qLb4rFE6z9ZsjDbWFMBN" class="seg" id="segSize">
      <button data-page-node-id="Z00Xdi2jzuNkH6YGemA9NH" class="on" data-size="3"><!--pnid:yy4SsY8fSgQ6rdEPZ5MG9H-->3×3 · 三子</button>
      <button data-page-node-id="zm5pdUiBGiP0kqKBcb8Aqc" data-size="4"><!--pnid:ibLIQyBYpzKpjBVQlfgzxB-->4×4 · 四子</button>
      <button data-page-node-id="rBHEwE3QbywT4t6Vwwh0e3" data-size="5"><!--pnid:sK8UMlNVd6kna8MARhytt6-->5×5 · 四连</button>
    </div>

    <div data-page-node-id="kvtTIirdOvC0HBDmkg99PG" class="label" style="margin-top:16px"><!--pnid:QOVk7UYATTmSKFF2Zmq7Dy-->电脑难度</div>
    <div data-page-node-id="8NVoMiMeGkbiQpPByVHcYP" class="seg" id="segLevel">
      <button data-page-node-id="iM8KIJBuDG8qao1syPOcny" data-level="easy"><!--pnid:14ut4kKYmwBTrvdYhKInMu-->简单</button>
      <button data-page-node-id="odoBnmOKQxifYsSZEm0kpE" class="on" data-level="normal"><!--pnid:fl3BPMb1m85Dm2zsJ6072x-->普通</button>
      <button data-page-node-id="zHq5fnJTXDAWvACRg4X9dX" data-level="hard"><!--pnid:faDqWwEG5pdmQUhKrgGhzl-->困难</button>
    </div>
  </div>

  <!--pnid:Cpi9lPcNsv5lDkmCnXe5ez--><!-- 战绩 -->
  <div data-page-node-id="LjHyU9YPKKD5l5HlEaLHhw" class="card">
    <div data-page-node-id="w4x4biJlI2tv0RRtFhQu8A" class="label"><!--pnid:HsVI2Bd5bUN2sBzvaFtKHB-->战绩（本机保存）</div>
    <div data-page-node-id="lEVi2JcSnAx35FENdfoUsK" class="scores">
      <div data-page-node-id="MRaslOCVayTlxQgeLcXgVB" class="score"><div data-page-node-id="jVDAyhX5BFBGJlaOm6QQKx" class="num" id="sWin" style="color:var(--accent)"><!--pnid:3ABzdspk7IHZ1L7J1C0vA4-->0</div><div data-page-node-id="czQw6wjWOsVUE44UMPmQja" class="cap"><!--pnid:1FwMvqJdNKmxJS0WdciXmm-->你赢</div></div>
      <div data-page-node-id="7jzRIInuvXEGQgKyZTFb7u" class="score"><div data-page-node-id="EZEZlmz6S1DCTEHggNZB3a" class="num" id="sLose" style="color:var(--blue)"><!--pnid:r0Ar9OrekaAFAIF2iio9Kb-->0</div><div data-page-node-id="VPpvKoJMv5hUnJBWWjTJeW" class="cap"><!--pnid:dGAVrMB3fcohUryBoSPF6Y-->电脑赢</div></div>
      <div data-page-node-id="h0cUHu4alISGCzmqq00POn" class="score"><div data-page-node-id="zJkNsqtxqwY9Lcb10GBS8G" class="num" id="sDraw"><!--pnid:Y2pjwLNYR99nbjSA1tl1dJ-->0</div><div data-page-node-id="QW1T1rXzEILzTGg8g1rliC" class="cap"><!--pnid:vad0Sm8VwGMJWL2pfIDCNM-->平局</div></div>
    </div>
    <div data-page-node-id="SCYGVZ3QkM8wm64RMo3vMW" style="margin-top:10px"><button data-page-node-id="DtIrerbQlP9qS6CEF4cvOM" id="btnReset" style="width:100%"><!--pnid:Ha6HK9lWlBjWqmnQiSzNrq-->清空战绩</button></div>
  </div>

  <!--pnid:TWfuE3zCWPwpIR6qKtt17p--><!-- 玩法 -->
  <div data-page-node-id="mLJKwGHOXUTYDvcEbMHZRo" class="card">
    <div data-page-node-id="FWoLJH6FoeSW2RdFtAb7xl" class="label"><!--pnid:RoXiAdcjCyX1lqexrA9CHG-->怎么玩</div>
    <div data-page-node-id="E9KE9Im3nbpwu59fiTVNNm" class="tip"><!--pnid:xxyHrCh3xicp1OWlYx9Sig-->
      你执 <b data-page-node-id="uwzvdW34h0wc530xqqUoXf"><!--pnid:mUGBD9KjNgDgMcQUOxAiTP-->X</b><!--pnid:rueNgFIE5yv8gXoVgdVPLx-->，电脑执 <b data-page-node-id="G4wzBUtSfkOcwcjphn3a5V"><!--pnid:Bk08ePXqavPV0OAV6o1ERN-->O</b><!--pnid:wmhtSc7kORt94Zuj1rhQgz-->，轮流落子。<br data-page-node-id="8K95P3f1WN7lv2FhYH4rq7"><!--pnid:DB8HEXnbFPZkQ1UJApIoyH-->
      先把 <b data-page-node-id="e6f5MQot5HK959qiKTKNP4"><!--pnid:mafBcqvKa36oxD3wHGJAxq-->横、竖或斜线</b><!--pnid:dPwotwF5K1euJBRZIRjImq--> 连成一整条就赢——3×3 连 3 个，4×4 和 5×5 连 4 个。<br data-page-node-id="2lNSNpVP7cqSO1YfOZS7PU"><!--pnid:FCsMa25Q25gUnq2gFJJwFD-->
      棋盘下满了还没人连成线，就是平局。<br data-page-node-id="cMIwRgizE2tjcvxYxUmQrB"><!--pnid:DJK2utiuArJoRbM49Q4Xyu-->
      不知道该下哪？点 <b data-page-node-id="xdB3S0nQTwFwqaTyLmDavI"><!--pnid:r7YMbV5mzjplY7f8oDwy5J-->💡 提示</b><!--pnid:ASKHazqPocpcKY3Qp90WbE-->，会告诉你下在哪里、为什么这么下。<br data-page-node-id="wxeWIwFRVTrzm43RJMsCEk"><!--pnid:QCRxuDXwWyxq7U8wwJeikY-->
      提示：电脑在<b data-page-node-id="s6duLi8pZTI28yGDyH4DJ3"><!--pnid:eydHGDh30TDqppZqT4ivye-->困难</b><!--pnid:xbUZ0OVE0xX1Eeh4EqMElw-->难度下会算最佳走法，几乎赢不了；<b data-page-node-id="frUs7rPZWIsYLX5oWZpZHp"><!--pnid:TguN3RqwtLTsFwjU04nzBU-->简单</b><!--pnid:NY2wq3HoamvvqRdJDd9iCM-->难度适合刚学规则的小朋友。
    </div>
  </div>

  <footer data-page-node-id="YzMPSBcCdTgKJwl4JmQLT9"><!--pnid:gjcq7wiGcIeGtpqbWEgcHj-->纯前端单文件网页 · 无需联网 · 战绩只存在这台设备<br data-page-node-id="BpfqHFSGIoo6abmjTBUAJ6"><!--pnid:5RCoBedZZ1OQZiPtUzNJRJ-->建议在家长陪伴下使用，每次玩 15–20 分钟，记得远眺休息眼睛</footer>
</div>

<script data-page-node-id="qOViO3DV4KtbXZyXKvYoZT" data-pnid-children="FvNqFlvJpIlQn3do8IUJtQ">
(() => {
  'use strict';

  // ============ 配置 ============
  const SIZES = { 3:{k:3,cell:88}, 4:{k:4,cell:64}, 5:{k:4,cell:52} };
  let size = 3;
  let level = 'normal';
  let humanIsX = true;

  let board = [];        // 0空 1=X(玩家) 2=O(电脑) — 始终按此标记，humanIsX 决定谁是人
  let k = 3;
  let history = [];
  let lastMove = -1;
  let winCells = [];
  let over = false;
  let thinking = false;
  let startTime = 0, elapsed = 0, tickTimer = null;
  let hintCell = -1;      // 被提示高亮的格子，-1 表示无
  let hintText = '';      // 提示文字

  const $ = id => document.getElementById(id);
  const boardEl = $('board');

  // ============ 战绩存档 ============
  const KEY = 'ttt_kids_score_v1';
  let score = {win:0, lose:0, draw:0};
  try{
    const raw = localStorage.getItem(KEY);
    if(raw) score = Object.assign(score, JSON.parse(raw));
  }catch(e){}
  function saveScore(){
    try{ localStorage.setItem(KEY, JSON.stringify(score)); }catch(e){}
  }
  function paintScore(){
    $('sWin').textContent = score.win;
    $('sLose').textContent = score.lose;
    $('sDraw').textContent = score.draw;
  }

  // ============ 音效 ============
  let actx = null;
  function beep(freq, dur, type){
    try{
      if(!actx) actx = new (window.AudioContext||window.webkitAudioContext)();
      if(actx.state === 'suspended') actx.resume();
      const o = actx.createOscillator(), g = actx.createGain();
      o.type = type || 'sine';
      o.frequency.value = freq;
      g.gain.setValueAtTime(0.0001, actx.currentTime);
      g.gain.exponentialRampToValueAtTime(0.14, actx.currentTime + 0.012);
      g.gain.exponentialRampToValueAtTime(0.0001, actx.currentTime + dur);
      o.connect(g); g.connect(actx.destination);
      o.start(); o.stop(actx.currentTime + dur + 0.02);
    }catch(e){}
  }
  const sPlace = () => beep(520, 0.07, 'triangle');
  const sWin   = () => { [523,659,784,1046].forEach((f,i)=>setTimeout(()=>beep(f,0.14,'sine'), i*95)); };
  const sLose  = () => { [392,330,262].forEach((f,i)=>setTimeout(()=>beep(f,0.19,'triangle'), i*115)); };
  const sDraw  = () => { [440,440].forEach((f,i)=>setTimeout(()=>beep(f,0.13,'sine'), i*110)); };

  // ============ 胜负判定 ============
  function lines(){
    const res = [];
    const n = size;
    // 横、竖
    for(let r=0;r<n;r++){
      for(let c=0;c<n;c++){
        if(c+k<=n){ const a=[]; for(let i=0;i<k;i++) a.push(r*n+c+i); res.push(a); }
        if(r+k<=n){ const a=[]; for(let i=0;i<k;i++) a.push((r+i)*n+c); res.push(a); }
      }
    }
    // 斜向：左上→右下 与 右上→左下
    for(let r=0;r<n;r++) for(let c=0;c<n;c++){
      if(r+k<=n && c+k<=n){ const a=[]; for(let i=0;i<k;i++) a.push((r+i)*n+c+i); res.push(a); }
      if(r+k<=n && c-(k-1)>=0){ const a=[]; for(let i=0;i<k;i++) a.push((r+i)*n+c-i); res.push(a); }
    }
    return res;
  }
  let ALL_LINES = [];
  function findWin(b){
    for(const L of ALL_LINES){
      const v = b[L[0]];
      if(v === 0) continue;
      let ok = true;
      for(let i=1;i<L.length;i++) if(b[L[i]] !== v){ ok = false; break; }
      if(ok) return L.slice();
    }
    return null;
  }
  function isFull(b){ return b.every(v => v !== 0); }

  // ============ AI：Minimax + Alpha-Beta ============
  function evaluate(b, ai, hu){
    const L = findWin(b);
    if(L) return b[L[0]] === ai ? 1 : -1;
    if(isFull(b)) return 0;
    let s = 0;
    for(const line of ALL_LINES){
      let ac = 0, hc = 0;
      for(const idx of line){
        if(b[idx] === ai) ac++;
        else if(b[idx] === hu) hc++;
      }
      if(ac && hc) continue;   // 该线已被双方占据，威胁抵消
      if(ac) s += [0, 2, 12, 60, 200][ac] || 200;
      if(hc) s -= [0, 2, 12, 60, 200][hc] || 200;
    }
    // 限制在 ±400 内，永远小于 WIN_BASE(1000)，避免与胜负分值混淆
    return Math.max(-400, Math.min(400, s));
  }
  function emptyCells(b){
    const a = [];
    for(let i=0;i<b.length;i++) if(b[i] === 0) a.push(i);
    return a;
  }
  // 走法排序：优先占中心、再占已有子旁边
  function orderMoves(b, ai){
    const n = size, mid = (n-1)/2;
    return emptyCells(b).sort((p,q) => score(b,p,ai) - score(b,q,ai));
    function score(b, idx, ai){
      const r = Math.floor(idx/n), c = idx%n;
      let s = 10 - (Math.abs(r-mid) + Math.abs(c-mid)) * 2;
      const dirs = [[1,0],[0,1],[1,1],[1,-1]];
      for(const [dr,dc] of dirs){
        for(let d=1;d<k;d++){
          const r2=r+dr*d, c2=c+dc*d;
          if(r2<0||r2>=n||c2<0||c2>=n) continue;
          const v = b[r2*n+c2];
          if(v === ai) s += 6;
          else if(v === 0) s += 1;
        }
      }
      return s;
    }
  }

  // 胜负分值必须远大于 evaluate 的启发式分值区间，
  // 否则深度截断时启发式分数会盖过"已经输定了"的事实，导致 AI 主动送死。
  // WIN_BASE 取 1000，evaluate 的返回值被限制在 ±400 以内，两者不会混淆。
  const WIN_BASE = 1000;

  // 负向极大（negamax）：只维护"当前该走这一方"的视角，递归时取负号。
  // 相比"maxFor/toMove 双参数"，negamax 只有一个视角，
  // 不可能出现 min/max 分支判断写反导致凭空造出胜局的问题。
  // ply 从 0 开始计，用于奖励速胜：越早取胜分值越高。
  //
  // 注意：这里刻意不使用置换表(TT)。带 TT 的 Alpha-Beta 存在一个隐蔽问题——
  // 胜负分值与 ply 绑定（WIN_BASE - ply），同一个局面在不同 ply 下分值不同；
  // 而 Alpha-Beta 剪枝又会提前退出，导致缓存下来的值只是"边界"而非精确值。
  // 两者叠加会让 AI 偶尔选到次优甚至送命的走法（实测 2000 局里输 10 局，
  // 禁用 TT 后为 0 局）。去掉 TT 后单步约 10ms，完全够用，正确性优先。
  function negamax(b, depth, alpha, beta, side, ply){
    const L = findWin(b);
    if(L) return b[L[0]] === side ? (WIN_BASE - ply) : -(WIN_BASE - ply);
    if(isFull(b)) return 0;
    if(depth === 0) return evaluate(b, side, 3 - side);

    const moves = orderMoves(b, side);
    let best = -Infinity;
    for(const m of moves){
      b[m] = side;
      const val = -negamax(b, depth-1, -beta, -alpha, 3 - side, ply + 1);
      b[m] = 0;
      if(val > best) best = val;
      if(best > alpha) alpha = best;
      if(alpha >= beta) break;                      // beta 剪枝
    }
    return best;
  }

  // 搜索深度随棋盘大小调整：
  // 3x3 总共最多 8 手，depth 9 即为完整搜索 → 困难难度绝无漏洞
  // 4x4 / 5x5 完整搜索组合数过大，用有限深度 + Alpha-Beta 剪枝 + 走法排序 + 置换表
  // 深度经过实测校准：保证单步最坏耗时 < 300ms，避免界面卡顿
  function depthFor(){
    if(size === 3) return 9;   // 完整搜索，实测约 6ms/步
    if(size === 4) return 4;   // 实测最坏约 120ms
    return 3;                 // 实测最坏约 150ms
  }

  function aiMove(){
    const ai = humanIsX ? 2 : 1;
    const hu = 3 - ai;
    const empties = emptyCells(board);
    if(!empties.length) return;

    let pick;

    if(level === 'easy'){
      // 简单：60% 随机走，40% 挡一手
      if(Math.random() < 0.6){
        pick = empties[Math.floor(Math.random()*empties.length)];
      }else{
        const blocker = findWinningMove(board, hu);
        pick = blocker !== -1 ? blocker : empties[Math.floor(Math.random()*empties.length)];
      }
    }else{
      const depth = level === 'normal' ? 2 : depthFor();
      const cap = level === 'normal' ? 10 : size*size;
      const cand = orderMoves(board, ai).slice(0, cap);
      let bestScore = -Infinity;
      const scored = [];
      for(const m of cand){
        board[m] = ai;
        // negamax 视角：始终以 AI 自己为 side，ply 表示已走步数
        const s = -negamax(board, depth-1, -Infinity, Infinity, hu, 1);
        board[m] = 0;
        scored.push([m, s]);
        if(s > bestScore) bestScore = s;
      }
      // 在最优分里随机挑一个，增加变化
      const top = scored.filter(x => x[1] === bestScore);
      pick = top[Math.floor(Math.random()*top.length)][0];

      // 普通难度留一点"失误感"：8% 概率走次优，让新手有机会赢
      if(level === 'normal' && Math.random() < 0.08 && scored.length > 1){
        pick = scored[Math.floor(Math.random()*Math.min(4, scored.length))][0];
      }
    }
    return pick;
  }

  function findWinningMove(b, player){
    for(const L of ALL_LINES){
      let cnt = 0, empty = -1, blocked = false;
      for(const idx of L){
        if(b[idx] === player) cnt++;
        else if(b[idx] === 0) empty = idx;
        else blocked = true;
      }
      if(cnt === k-1 && !blocked && empty !== -1) return empty;
    }
    return -1;
  }

  // ============ 提示 ============
  // 分级提示：能直接说明原因，而不只是给出坐标。
  //   1) 自己能连成线 → 提示直接指出"下这里就赢"
  //   2) 对手下一手能赢 → 提示去堵
  //   3) 自己能造出双重威胁（fork）→ 提示这是进攻机会
  //   4) 以上都没有 → 用当前难度做一步最优搜索，提示"最佳一手"
  // 提示强度跟随难度：简单只说"试试这里"，困难会附带战术解释。
  function showHint(){
    if(over || thinking){
      hintCell = -1;
      hintText = over ? '这局已经结束啦，点「新的一局」再来一次吧。' : '电脑正在想，等一下下。';
      paintHint(); paint();
      return;
    }
    if(humanIsX === false && !board.some(v => v === 0)){ /* 兜底 */ }

    const me   = humanIsX ? 1 : 2;
    const foe  = 3 - me;
    const empt = emptyCells(board);
    if(!empt.length){
      hintCell = -1;
      hintText = '棋盘已经满了，没有可以下的地方了。';
      paintHint(); paint();
      return;
    }

    const myMark  = humanIsX ? '✕' : '◯';
    const foeMark = humanIsX ? '◯' : '✕';
    const posText = i => `第 ${Math.floor(i / size) + 1} 行第 ${(i % size) + 1} 列`;

    // 1) 我能一步连成线
    const winAt = findWinningMove(board, me);
    if(winAt !== -1){
      hintCell = winAt;
      hintText = `下这里就能连成 ${k} 个，<b>直接赢</b>！位置：${posText(winAt)}。`;
      paintHint(); paint();
      return;
    }

    // 2) 对手能一步连成线 → 必须堵
    const blockAt = findWinningMove(board, foe);
    if(blockAt !== -1){
      hintCell = blockAt;
      hintText = `<b>小心！</b>电脑下一步就要在${posText(blockAt)}连成 ${k} 个了，` +
                 `赶紧去那里堵住它。`;
      paintHint(); paint();
      return;
    }

    // 3) 能造出双重威胁（两个格子同时成线，电脑挡不住）
    const forks = [];
    for(const m of empt){
      board[m] = me;
      const a = findWinningMove(board, me);
      if(a !== -1){
        // 该点成线后，看是否还有另一处能成线
        board[m] = 0;
        board[a] = me;
        const b = findWinningMove(board, me);
        board[a] = 0;
        if(b !== -1 && b !== m) forks.push(m);
      }
      board[m] = 0;
    }
    if(forks.length){
      hintCell = forks[0];
      hintText = level === 'hard'
        ? `这里能同时威胁<b>两个</b>位置，电脑堵不过来，进攻的机会！位置：${posText(forks[0])}。`
        : `试试这里，能让电脑很为难。位置：${posText(forks[0])}。`;
      paintHint(); paint();
      return;
    }

    // 4) 用当前难度算一步最优
    const depth = level === 'easy' ? 1 : (level === 'normal' ? 3 : depthFor());
    let best = -Infinity, bestMoves = [];
    for(const m of empt){
      board[m] = me;
      const v = -negamax(board, depth-1, -Infinity, Infinity, foe, 1);
      board[m] = 0;
      if(v > best){ best = v; bestMoves = [m]; }
      else if(v === best) bestMoves.push(m);
    }
    if(!bestMoves.length) bestMoves = empt;
    const pick = bestMoves[0];
    hintCell = pick;

    const s = best > 400 ? '这一手很稳，能把局面握在自己手里。'
            : best > 0   ? '这一手不错，能占住主动。'
            : best < -400 ? '局面有点被动，先稳住别急。'
            : '这一手比较安全，走下去看看。';
    hintText = `试试 <b>${posText(pick)}</b>。${level === 'hard' ? s : ''}`;
    paintHint(); paint();
  }

  function clearHint(){
    if(hintCell === -1 && !hintText) return;
    hintCell = -1;
    hintText = '';
    paintHint();
  }

  function paintHint(){
    const el = $('hintText');
    if(!el) return;
    el.innerHTML = hintText || '点「提示」，我会告诉你该下在哪里。';
  }

  // ============ 渲染 ============
  function paint(){
    boardEl.innerHTML = '';
    boardEl.style.gridTemplateColumns = `repeat(${size}, 1fr)`;
    const maxPx = Math.min(340, window.innerWidth - 90);
    const cellPx = Math.floor(Math.min(SIZES[size].cell, maxPx / size));
    boardEl.style.width = (cellPx * size + 6 * size + 12) + 'px';

    board.forEach((v, i) => {
      const isHint = (i === hintCell && v === 0 && !over);
      const d = document.createElement('div');
      d.className = 'cell' + (v === 1 ? ' x' : v === 2 ? ' o' : '')
                  + (i === lastMove ? ' last' : '')
                  + (isHint ? ' hint' : '')
                  + (winCells.includes(i) ? ' win' : '');
      d.style.width = cellPx + 'px';
      d.style.height = cellPx + 'px';
      d.style.fontSize = Math.round(cellPx * 0.58) + 'px';
      d.innerHTML = `<span class="mark">${v === 1 ? '✕' : v === 2 ? '◯' : ''}</span>`;
      if(isHint) d.innerHTML += '<span class="hint-dot">▼</span>';
      if(!over && !thinking) d.addEventListener('click', () => humanPlay(i));
      boardEl.appendChild(d);
    });
  }

  function setStatus(main, sub, mark, isAi){
    $('statusMain').textContent = main;
    $('statusSub').textContent = sub;
    const tm = $('turnMark');
    tm.textContent = mark;
    tm.classList.toggle('ai', !!isAi);
  }

  function refreshStatus(){
    if(over){
      if(winCells.length){
        const winner = board[winCells[0]];
        const humanWon = (winner === 1) === humanIsX;
        setStatus(humanWon ? '你赢啦！🎉' : '电脑赢了 😿',
                  humanWon ? '这步走得真漂亮' : '再来一局，这次一定能赢',
                  winner === 1 ? '✕' : '◯', !(winner === 1));
      }else{
        setStatus('平局 🤝','棋盘满了，谁也没连成线','—', false);
      }
      return;
    }
    const humanTurn = !thinking;
    setStatus(humanTurn ? '轮到你走' : '电脑思考中…',
              humanTurn ? `点一个格子放下 ${humanIsX ? '✕' : '◯'}` : '稍等一下下…',
              humanTurn ? (humanIsX ? '✕' : '◯') : (humanIsX ? '◯' : '✕'),
              !humanTurn);
    $('btnUndo').disabled = history.length === 0;
  }

  function showBanner(type, text){
    const b = $('banner');
    b.className = 'banner show ' + type;
    b.textContent = text;
  }
  function hideBanner(){ $('banner').className = 'banner'; }

  // ============ 计时 ============
  function fmt(ms){
    const t = Math.floor(ms/1000);
    return String(Math.floor(t/60)).padStart(2,'0') + ':' + String(t%60).padStart(2,'0');
  }
  function startClock(){
    stopClock();
    startTime = Date.now() - elapsed;
    tickTimer = setInterval(()=>{
      elapsed = Date.now() - startTime;
      $('clock').textContent = fmt(elapsed);
    }, 200);
  }
  function stopClock(){
    if(tickTimer){ clearInterval(tickTimer); tickTimer = null; }
  }

  // ============ 流程 ============
  function reset(){
    stopClock(); elapsed = 0; $('clock').textContent = '00:00';
    k = SIZES[size].k;
    ALL_LINES = lines();
    board = new Array(size*size).fill(0);
    history = [];
    lastMove = -1; winCells = []; over = false; thinking = false;
    hintCell = -1; hintText = '';
    hideBanner();
    paint();
    refreshStatus();
    $('btnUndo').disabled = true;
    $('btnHint').disabled = false;
    paintHint();
    startClock();   // 从开局就计时，避免首步即胜时 startTime 为 0
  }

  function humanPlay(i){
    if(over || thinking || board[i] !== 0) return;
    const human = humanIsX ? 1 : 2;
    // 落子后上一轮的提示已失效，先清掉再重绘
    hintCell = -1; hintText = '';
    paintHint();
    board[i] = human;
    lastMove = i;
    history.push({ i, player: human });
    sPlace();
    paint();
    if(afterMove()) return;
    aiTurn();
  }

  function aiTurn(){
    thinking = true;
    refreshStatus();
    paint();
    const wait = level === 'hard' ? 260 : 340;
    setTimeout(()=>{
      const pick = aiMove();
      if(pick === undefined || pick === -1){ thinking = false; afterMove(); return; }
      const ai = humanIsX ? 2 : 1;
      board[pick] = ai;
      lastMove = pick;
      history.push({ i: pick, player: ai });
      sPlace();
      thinking = false;
      paint();
      if(!afterMove()) refreshStatus();
    }, wait);
  }

  function afterMove(){
    const L = findWin(board);
    if(L){
      winCells = L; over = true;
      stopClock(); elapsed = Date.now() - startTime; $('clock').textContent = fmt(elapsed);
      const winner = board[L[0]];
      const humanWon = (winner === 1) === humanIsX;
      if(humanWon){ score.win++; sWin(); showBanner('win','恭喜！你赢了 🎉'); }
      else { score.lose++; sLose(); showBanner('lose','电脑赢了，再来一局吧！'); }
      saveScore(); paintScore(); paint(); refreshStatus();
      $('btnUndo').disabled = true;
      hintCell = -1; $('btnHint').disabled = true; paintHint();
      return true;
    }
    if(isFull(board)){
      over = true;
      stopClock();
      score.draw++; sDraw();
      showBanner('draw','平局，棋盘满啦');
      saveScore(); paintScore(); paint(); refreshStatus();
      $('btnUndo').disabled = true;
      hintCell = -1; $('btnHint').disabled = true; paintHint();
      return true;
    }
    if(!startTime) startClock();
    return false;
  }

  function undo(){
    if(!history.length || thinking) return;
    const moves = (history.length >= 2) ? 2 : 1;
    for(let i=0;i<moves;i++){
      const m = history.pop();
      board[m.i] = 0;
      lastMove = history.length ? history[history.length-1].i : -1;
    }
    over = false; winCells = []; hideBanner();
    hintCell = -1; hintText = '';
    $('btnHint').disabled = false;
    paintHint();
    paint(); refreshStatus();
  }

  // ============ 事件 ============
  $('btnNew').addEventListener('click', reset);
  $('btnUndo').addEventListener('click', undo);
  $('btnHint').addEventListener('click', showHint);
  $('btnSwap').addEventListener('click', ()=>{
    humanIsX = !humanIsX;
    $('btnSwap').textContent = humanIsX ? '换先手' : '再换回来';
    reset();
  });
  $('btnReset').addEventListener('click', ()=>{
    score = {win:0, lose:0, draw:0};
    saveScore(); paintScore();
  });

  $('segSize').addEventListener('click', e=>{
    const b = e.target.closest('button'); if(!b) return;
    [...$('segSize').children].forEach(x=>x.classList.remove('on'));
    b.classList.add('on');
    size = +b.dataset.size;
    reset();
  });
  $('segLevel').addEventListener('click', e=>{
    const b = e.target.closest('button'); if(!b) return;
    [...$('segLevel').children].forEach(x=>x.classList.remove('on'));
    b.classList.add('on');
    level = b.dataset.level;
  });

  window.addEventListener('resize', ()=>{ paint(); });

  // ============ 启动 ============
  paintScore();
  reset();
  // 首局自动落子：电脑执先
  if(!humanIsX) aiTurn();
})();
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>井字棋 · Tic-Tac-Toe</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; -webkit-tap-highlight-color: transparent; }
  :root {
    --panel: rgba(255, 255, 255, .06);
    --line: rgba(255, 255, 255, .14);
    --text: #eef0ff;
    --muted: #9aa0c3;
    --x: #4cc9f0;
    --o: #f72585;
    --win: #ffd166;
  }
  body {
    min-height: 100vh;
    display: flex; flex-direction: column; align-items: center; justify-content: center;
    gap: 15px; padding: 20px 16px;
    font-family: "Segoe UI", "PingFang SC", "Microsoft YaHei", system-ui, sans-serif;
    color: var(--text);
    background: radial-gradient(1200px 800px at 15% 0%, #231a5e 0%, #0f1226 45%, #0b0d1f 100%);
    user-select: none;
  }
  h1 { font-size: 27px; letter-spacing: 8px; font-weight: 700; }
  h1 b { color: var(--win); }
  .subtitle { color: var(--muted); font-size: 13px; margin-top: -14px; letter-spacing: 1px; }

  .modes { display: flex; background: var(--panel); border: 1px solid var(--line); border-radius: 999px; padding: 4px; gap: 4px; }
  .modes button {
    border: 0; background: transparent; color: var(--muted); padding: 7px 16px; border-radius: 999px;
    font-size: 14px; cursor: pointer; transition: .2s; font-family: inherit;
  }
  .modes button.active { background: linear-gradient(135deg, #4361ee, #7209b7); color: #fff; box-shadow: 0 4px 14px rgba(67, 97, 238, .35); }

  .scores { display: flex; gap: 14px; }
  .score {
    min-width: 92px; text-align: center; background: var(--panel); border: 1px solid var(--line);
    border-radius: 14px; padding: 8px 12px;
  }
  .score .num { font-size: 22px; font-weight: 700; }
  .score .label { font-size: 12px; color: var(--muted); margin-top: 2px; }
  .score.x .num { color: var(--x); }
  .score.o .num { color: var(--o); }
  .score.d .num { color: var(--win); }

  .board {
    display: grid; grid-template-columns: repeat(3, 96px); grid-template-rows: repeat(3, 96px);
    gap: 9px; padding: 12px; background: var(--panel); border: 1px solid var(--line);
    border-radius: 22px; box-shadow: 0 20px 50px rgba(0, 0, 0, .45);
  }
  .cell {
    background: rgba(255, 255, 255, .04); border: 1px solid var(--line); border-radius: 14px;
    display: flex; align-items: center; justify-content: center; cursor: pointer;
    position: relative; transition: background .15s, transform .1s;
  }
  .cell:hover { background: rgba(255, 255, 255, .09); }
  .cell:active { transform: scale(.96); }
  .cell.filled { cursor: default; }
  .cell.win {
    background: rgba(255, 209, 102, .12); border-color: rgba(255, 209, 102, .6);
    box-shadow: 0 0 18px rgba(255, 209, 102, .25) inset, 0 0 22px rgba(255, 209, 102, .2);
  }
  .cell.hint { border-color: rgba(255, 209, 102, .75); animation: hintPulse 1.1s ease-in-out infinite; }
  .cell.hint::before {
    content: "★"; position: absolute; top: 6px; right: 9px; font-size: 15px;
    color: var(--win); pointer-events: none;
  }
  @keyframes hintPulse {
    0%, 100% { box-shadow: 0 0 10px rgba(255, 209, 102, .12), inset 0 0 10px rgba(255, 209, 102, .12); }
    50% { box-shadow: 0 0 22px rgba(255, 209, 102, .45), inset 0 0 14px rgba(255, 209, 102, .3); }
  }
  .cell svg { width: 64%; height: 64%; }
  .cell svg line, .cell svg circle { fill: none; stroke-width: 10; stroke-linecap: round; }
  .cell.x svg line { stroke: var(--x); }
  .cell.o svg circle { stroke: var(--o); }
  .cell svg .stroke { stroke-dasharray: 200; stroke-dashoffset: 200; animation: draw .28s ease-out forwards; }
  @keyframes draw { to { stroke-dashoffset: 0; } }

  .board.turn-x .cell:not(.filled):hover::after,
  .board.turn-o .cell:not(.filled):hover::after {
    position: absolute; font-size: 50px; font-weight: 800; opacity: .25; pointer-events: none;
  }
  .board.turn-x .cell:not(.filled):hover::after { content: "✕"; color: var(--x); }
  .board.turn-o .cell:not(.filled):hover::after { content: "◯"; color: var(--o); }

  .status { min-height: 28px; font-size: 17px; letter-spacing: 1px; }
  .status .sx { color: var(--x); font-weight: 700; }
  .status .so { color: var(--o); font-weight: 700; }

  .actions { display: flex; gap: 12px; }
  .btn {
    border: 1px solid var(--line); background: var(--panel); color: var(--text);
    padding: 8px 22px; border-radius: 12px; font-size: 14px; cursor: pointer;
    transition: .2s; font-family: inherit;
  }
  .btn:hover { background: rgba(255, 255, 255, .12); }
  .btn:disabled { opacity: .4; cursor: not-allowed; pointer-events: none; }
  .btn.primary { background: linear-gradient(135deg, #4361ee, #7209b7); border-color: transparent; }
  .btn.primary:hover { filter: brightness(1.15); }

  @media (max-width: 430px) {
    .board { grid-template-columns: repeat(3, 92px); grid-template-rows: repeat(3, 92px); }
    h1 { font-size: 24px; letter-spacing: 5px; }
  }
</style>
</head>
<body>
  <h1>井字棋 <b>✕ ◯</b></h1>
  <p class="subtitle">三子连珠即获胜 · 人机模式你执 ✕ 先手</p>

  <div class="modes" id="modes">
    <button data-mode="pvp" class="active">双人对战</button>
    <button data-mode="easy">人机 · 简单</button>
    <button data-mode="hard">人机 · 困难</button>
  </div>

  <div class="scores">
    <div class="score x"><div class="num" id="scoreX">0</div><div class="label" id="labelX">玩家 ✕</div></div>
    <div class="score d"><div class="num" id="scoreD">0</div><div class="label">平局</div></div>
    <div class="score o"><div class="num" id="scoreO">0</div><div class="label" id="labelO">玩家 ◯</div></div>
  </div>

  <div class="board turn-x" id="board"></div>

  <div class="status" id="status"></div>

  <div class="actions">
    <button class="btn primary" id="restart">再来一局</button>
    <button class="btn" id="hint">💡 提示</button>
    <button class="btn" id="clear">比分清零</button>
  </div>

<script>
  const boardEl = document.getElementById('board');
  const statusEl = document.getElementById('status');
  const hintBtn = document.getElementById('hint');
  const LINES = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]];
  const X_SVG = '<svg viewBox="0 0 100 100"><line class="stroke" x1="24" y1="24" x2="76" y2="76"/><line class="stroke" x1="76" y1="24" x2="24" y2="76" style="animation-delay:.15s"/></svg>';
  const O_SVG = '<svg viewBox="0 0 100 100"><circle class="stroke" cx="50" cy="50" r="27"/></svg>';

  let mode = 'pvp';
  let board = Array(9).fill(null);
  let current = 'X';
  let over = false;
  let cells = [];
  let hintIndex = null;
  // 每种模式独立记分
  let scores = { pvp: {X:0, O:0, D:0}, easy: {X:0, O:0, D:0}, hard: {X:0, O:0, D:0} };
  try {
    const saved = JSON.parse(localStorage.getItem('tictactoe-scores-v1'));
    if (saved && saved.pvp && saved.easy && saved.hard) scores = saved;
  } catch (e) {}

  function saveScores() {
    try { localStorage.setItem('tictactoe-scores-v1', JSON.stringify(scores)); } catch (e) {}
  }

  // ---------- 棋盘 ----------
  function createBoard() {
    boardEl.innerHTML = '';
    cells = [];
    for (let i = 0; i < 9; i++) {
      const c = document.createElement('div');
      c.className = 'cell';
      c.setAttribute('aria-label', '格子 ' + (i + 1));
      c.addEventListener('click', () => onCell(i));
      boardEl.appendChild(c);
      cells.push(c);
    }
  }

  function renderScores() {
    document.getElementById('scoreX').textContent = scores[mode].X;
    document.getElementById('scoreO').textContent = scores[mode].O;
    document.getElementById('scoreD').textContent = scores[mode].D;
    const vsAI = mode !== 'pvp';
    document.getElementById('labelX').textContent = vsAI ? '你 (✕)' : '玩家 ✕';
    document.getElementById('labelO').textContent = vsAI ? '电脑 (◯)' : '玩家 ◯';
  }

  function setStatus(html) { statusEl.innerHTML = html; }

  function mark(sym) {
    return sym === 'X' ? '<span class="sx">✕</span>' : '<span class="so">◯</span>';
  }

  function updateStatus(thinking) {
    boardEl.classList.remove('turn-x', 'turn-o');
    hintBtn.disabled = over || thinking || (mode !== 'pvp' && current === 'O');
    if (over) return;
    boardEl.classList.add(current === 'X' ? 'turn-x' : 'turn-o');
    if (thinking) { setStatus('电脑思考中…'); return; }
    if (mode === 'pvp') setStatus('轮到 ' + mark(current));
    else setStatus(current === 'X' ? '轮到你了 ' + mark('X') : '电脑回合…');
  }

  // ---------- 对局 ----------
  function onCell(i) {
    if (over || board[i]) return;
    if (mode !== 'pvp' && current === 'O') return; // 电脑回合禁止落子
    play(i);
  }

  function play(i) {
    clearHint();
    board[i] = current;
    const c = cells[i];
    c.classList.add('filled', current === 'X' ? 'x' : 'o');
    c.innerHTML = current === 'X' ? X_SVG : O_SVG;

    const w = getWinner(board);
    if (w) return finish({ player: w.player, line: w.line });
    if (board.every(Boolean)) return finish({ draw: true });

    current = current === 'X' ? 'O' : 'X';
    if (mode !== 'pvp' && current === 'O') {
      updateStatus(true);
      setTimeout(aiMove, 380);
    } else {
      updateStatus();
    }
  }

  function getWinner(b) {
    for (const line of LINES) {
      const [a, c, d] = line;
      if (b[a] && b[a] === b[c] && b[a] === b[d]) return { player: b[a], line };
    }
    return null;
  }

  function finish(res) {
    over = true;
    boardEl.classList.remove('turn-x', 'turn-o');
    hintBtn.disabled = true;
    if (res.line) {
      res.line.forEach(i => cells[i].classList.add('win'));
      scores[mode][res.player]++;
      if (mode === 'pvp') setStatus(mark(res.player) + ' 获胜！🎉');
      else setStatus(res.player === 'X' ? '你赢了！🎉' : '电脑获胜 🤖');
    } else {
      scores[mode].D++;
      setStatus('平局！🤝');
    }
    saveScores();
    renderScores();
  }

  function reset() {
    board = Array(9).fill(null);
    current = 'X';
    over = false;
    clearHint();
    createBoard();
    updateStatus();
  }

  // ---------- 电脑 AI ----------
  function aiMove() {
    if (over) return;
    const empties = board.map((v, i) => v ? null : i).filter(v => v !== null);
    if (!empties.length) return;
    const cands = mode === 'hard' ? bestMovesFor('O') : empties;
    play(cands[Math.floor(Math.random() * cands.length)]);
  }

  // 极大极小搜索：返回 ai 一方的所有最优落点
  function bestMovesFor(ai) {
    let best = -Infinity, candidates = [];
    for (let i = 0; i < 9; i++) {
      if (board[i]) continue;
      board[i] = ai;
      const s = minimax(board, 0, false, ai);
      board[i] = null;
      if (s > best) { best = s; candidates = [i]; }
      else if (s === best) candidates.push(i);
    }
    return candidates;
  }

  function minimax(b, depth, maximizing, ai) {
    const w = getWinner(b);
    if (w) return w.player === ai ? 10 - depth : depth - 10;
    if (b.every(Boolean)) return 0;
    const human = ai === 'X' ? 'O' : 'X';
    let best = maximizing ? -Infinity : Infinity;
    for (let i = 0; i < 9; i++) {
      if (b[i]) continue;
      b[i] = maximizing ? ai : human;
      const s = minimax(b, depth + 1, !maximizing, ai);
      b[i] = null;
      best = maximizing ? Math.max(best, s) : Math.min(best, s);
    }
    return best;
  }

  // ---------- 提示 ----------
  function clearHint() {
    if (hintIndex !== null && cells[hintIndex]) {
      cells[hintIndex].classList.remove('hint');
    }
    hintIndex = null;
  }

  function showHint() {
    if (over || (mode !== 'pvp' && current === 'O')) return;
    clearHint();
    const cands = bestMovesFor(current);
    if (!cands.length) return;
    hintIndex = cands[Math.floor(Math.random() * cands.length)];
    cells[hintIndex].classList.add('hint');
    setStatus('💡 建议 ' + mark(current) + ' 落在高亮格子');
  }

  // ---------- 事件 ----------
  document.getElementById('modes').addEventListener('click', e => {
    const btn = e.target.closest('button[data-mode]');
    if (!btn) return;
    mode = btn.dataset.mode;
    document.querySelectorAll('#modes button').forEach(b => b.classList.toggle('active', b === btn));
    renderScores();
    reset();
  });
  document.getElementById('restart').addEventListener('click', reset);
  document.getElementById('hint').addEventListener('click', showHint);
  document.getElementById('clear').addEventListener('click', () => {
    scores[mode] = { X: 0, O: 0, D: 0 };
    saveScores();
    renderScores();
  });

  createBoard();
  renderScores();
  updateStatus();
</script>
</body>
</html>

<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" />
<link rel="icon" href="data:," />
<title>俄罗斯方块 · Tetris</title>
<style>
  :root {
    --bg1: #0b0e1a; --bg2: #131a33;
    --panel: rgba(255,255,255,0.05);
    --border: rgba(255,255,255,0.09);
    --text: #e8ecf8; --muted: #8b93b5;
    --accent: #6c5ce7;
  }
  * { box-sizing: border-box; margin: 0; padding: 0; }
  html, body { height: 100%; }
  body {
    font-family: "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif;
    background:
      radial-gradient(1100px 700px at 15% -10%, #1b2450 0%, transparent 60%),
      radial-gradient(900px 600px at 110% 110%, #241a4d 0%, transparent 55%),
      linear-gradient(160deg, var(--bg2), var(--bg1));
    color: var(--text);
    display: flex; flex-direction: column; align-items: center; justify-content: center;
    min-height: 100vh; padding: 14px; gap: 12px;
    user-select: none; -webkit-user-select: none;
  }

  .header { display: flex; align-items: center; gap: 14px; }
  .header h1 {
    font-size: 22px; font-weight: 700; letter-spacing: 8px; text-indent: 8px;
    background: linear-gradient(90deg, #7dd3fc, #c084fc);
    -webkit-background-clip: text; background-clip: text; color: transparent;
  }
  .icon-btn {
    background: var(--panel); border: 1px solid var(--border); border-radius: 10px;
    width: 38px; height: 32px; cursor: pointer; color: var(--text); font-size: 15px;
  }
  .icon-btn:hover { background: rgba(255,255,255,.1); }

  .game { display: flex; gap: 14px; align-items: stretch; }
  .side { display: flex; flex-direction: column; gap: 12px; width: 132px; }
  .panel { background: var(--panel); border: 1px solid var(--border); border-radius: 14px; padding: 12px; }
  .panel h2 { font-size: 11px; letter-spacing: 3px; color: var(--muted); text-align: center; margin-bottom: 8px; font-weight: 600; }
  .panel canvas { display: block; margin: 0 auto; }

  .stats { display: flex; flex-direction: column; gap: 9px; }
  .stat { display: flex; justify-content: space-between; align-items: baseline; }
  .stat span { color: var(--muted); font-size: 12px; }
  .stat b { font-size: 16px; font-variant-numeric: tabular-nums; }

  .board-wrap { position: relative; }
  #board {
    display: block; border-radius: 12px; background: #0d1226;
    box-shadow: 0 0 0 1px var(--border), 0 12px 44px rgba(0,0,0,.55), 0 0 70px rgba(108,92,231,.14);
  }

  .overlay {
    position: absolute; inset: 0; z-index: 5;
    display: flex; align-items: center; justify-content: center;
    background: rgba(8,10,22,.74); backdrop-filter: blur(5px); border-radius: 12px;
  }
  .overlay.hidden { display: none; }
  .overlay-card { text-align: center; padding: 24px; animation: pop .25s ease; }
  .overlay-card h1 { font-size: 26px; letter-spacing: 5px; margin-bottom: 12px; }
  .overlay-card p { color: var(--muted); font-size: 13px; line-height: 1.9; margin-bottom: 20px; }
  @keyframes pop { from { transform: scale(.92); opacity: 0; } to { transform: scale(1); opacity: 1; } }

  .btn {
    background: linear-gradient(135deg, var(--accent), #a855f7); color: #fff;
    border: 0; padding: 11px 34px; border-radius: 10px; font-size: 15px; cursor: pointer;
    box-shadow: 0 6px 20px rgba(108,92,231,.45); font-family: inherit; letter-spacing: 2px;
  }
  .btn:hover { filter: brightness(1.15); }
  .btn:active { transform: translateY(1px); }

  .legend { color: var(--muted); font-size: 12px; display: flex; flex-wrap: wrap; gap: 6px 16px; justify-content: center; max-width: 660px; }
  .legend span { white-space: nowrap; }
  kbd {
    background: rgba(255,255,255,.07); border: 1px solid var(--border); border-bottom-width: 2px;
    border-radius: 5px; padding: 1px 6px; font-family: inherit; font-size: 11px; margin: 0 2px;
  }

  .touch-controls { display: none; }
  @media (pointer: coarse) {
    .touch-controls {
      display: grid; grid-template-columns: repeat(7, 1fr); gap: 8px;
      width: min(96vw, 500px);
    }
    .touch-controls button {
      height: 52px; font-size: 20px; color: var(--text);
      background: var(--panel); border: 1px solid var(--border); border-radius: 12px;
      touch-action: none; -webkit-tap-highlight-color: transparent; cursor: pointer;
    }
    .touch-controls button:active { background: rgba(255,255,255,.14); }
    .legend { display: none; }
  }

  @media (max-width: 720px) {
    .game { flex-direction: column; align-items: center; }
    .side { flex-direction: row; width: 100%; max-width: 360px; }
    .side .panel { flex: 1; }
    .stats { display: grid; grid-template-columns: 1fr 1fr; gap: 6px 16px; align-content: center; }
    .side.left { order: 1; } .board-wrap { order: 2; } .side.right { order: 3; }
  }
</style>
</head>
<body>

  <div class="header">
    <h1>俄罗斯方块</h1>
    <button id="muteBtn" class="icon-btn" title="音效开关">🔊</button>
  </div>

  <div class="game">
    <aside class="side left">
      <div class="panel">
        <h2>暂存</h2>
        <canvas id="hold"></canvas>
      </div>
      <div class="panel stats">
        <div class="stat"><span>分数</span><b id="score">0</b></div>
        <div class="stat"><span>最高分</span><b id="best">0</b></div>
        <div class="stat"><span>等级</span><b id="level">1</b></div>
        <div class="stat"><span>行数</span><b id="lines">0</b></div>
      </div>
    </aside>

    <div class="board-wrap">
      <canvas id="board"></canvas>
      <div id="overlay" class="overlay">
        <div class="overlay-card">
          <h1 id="ovTitle">俄罗斯方块</h1>
          <p id="ovText"></p>
          <button id="ovBtn" class="btn">开始游戏</button>
        </div>
      </div>
    </div>

    <aside class="side right">
      <div class="panel">
        <h2>下一个</h2>
        <canvas id="next"></canvas>
      </div>
    </aside>
  </div>

  <div class="legend">
    <span><kbd>←</kbd><kbd>→</kbd> 移动</span>
    <span><kbd>↓</kbd> 软降</span>
    <span><kbd>↑</kbd>/<kbd>X</kbd> 旋转 · <kbd>Z</kbd> 反转</span>
    <span><kbd>空格</kbd> 硬降</span>
    <span><kbd>C</kbd> 暂存</span>
    <span><kbd>P</kbd> 暂停</span>
    <span><kbd>R</kbd> 重开</span>
  </div>

  <div class="touch-controls">
    <button data-act="hold">暂存</button>
    <button data-act="ccw">⟲</button>
    <button data-act="cw">⟳</button>
    <button data-act="left">◀</button>
    <button data-act="down">▼</button>
    <button data-act="right">▶</button>
    <button data-act="drop">⤓</button>
  </div>

<script>
(() => {
'use strict';

// ---------- 常量 ----------
const COLS = 10, ROWS = 20;
const LOCK_DELAY = 500, MAX_LOCK_RESETS = 15;
const CLEAR_TIME = 280;
const DAS = 160, ARR = 45, SOFT_ARR = 40;
const LINE_SCORES = [0, 100, 300, 500, 800];

const SHAPES = {
  I: [[0,0,0,0],[1,1,1,1],[0,0,0,0],[0,0,0,0]],
  O: [[1,1],[1,1]],
  T: [[0,1,0],[1,1,1],[0,0,0]],
  S: [[0,1,1],[1,1,0],[0,0,0]],
  Z: [[1,1,0],[0,1,1],[0,0,0]],
  J: [[1,0,0],[1,1,1],[0,0,0]],
  L: [[0,0,1],[1,1,1],[0,0,0]],
};
const COLORS = { I:'#00e5ff', O:'#facc15', T:'#c084fc', S:'#4ade80', Z:'#ff5d6c', J:'#60a5fa', L:'#fb923c' };

// ---------- 状态 ----------
let board, bag = [], queue = [], cur = null, holdType = null, canHold = true;
let score = 0, lines = 0, level = 1, best = 0;
let state = 'ready'; // ready | playing | paused | over
let dropTimer = 0, lockTimer = 0, lockResets = 0;
let rowsToClear = [], clearingTimer = 0;
let dasDir = 0, dasTimer = 0, arrTimer = 0, softTimer = 0;
const input = { left: false, right: false, down: false };

try { best = parseInt(localStorage.getItem('tetris.best'), 10) || 0; } catch (e) {}

// ---------- DOM ----------
const $ = id => document.getElementById(id);
const boardCanvas = $('board'), nextCanvas = $('next'), holdCanvas = $('hold');
const overlay = $('overlay'), ovTitle = $('ovTitle'), ovText = $('ovText'), ovBtn = $('ovBtn');
const scoreEl = $('score'), bestEl = $('best'), levelEl = $('level'), linesEl = $('lines');
const muteBtn = $('muteBtn');

let ctxBoard, ctxNext, ctxHold, CELL = 30, nextHorizontal = false;
const PC = 18; // 预览格尺寸

// ---------- 工具 ----------
function shuffle(a) {
  for (let i = a.length - 1; i > 0; i--) {
    const j = (Math.random() * (i + 1)) | 0;
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}
function cloneMatrix(m) { return m.map(r => r.slice()); }
function rr(ctx, x, y, w, h, r) {
  r = Math.min(r, w / 2, h / 2);
  ctx.beginPath();
  ctx.moveTo(x + r, y);
  ctx.arcTo(x + w, y, x + w, y + h, r);
  ctx.arcTo(x + w, y + h, x, y + h, r);
  ctx.arcTo(x, y + h, x, y, r);
  ctx.arcTo(x, y, x + w, y, r);
  ctx.closePath();
}
function setupCanvas(canvas, w, h) {
  const dpr = window.devicePixelRatio || 1;
  canvas.width = Math.round(w * dpr);
  canvas.height = Math.round(h * dpr);
  canvas.style.width = w + 'px';
  canvas.style.height = h + 'px';
  const ctx = canvas.getContext('2d');
  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
  return ctx;
}

// ---------- 音效 ----------
let audioCtx = null, muted = false;
function initAudio() {
  if (!audioCtx) {
    try { audioCtx = new (window.AudioContext || window.webkitAudioContext)(); } catch (e) {}
  }
  if (audioCtx && audioCtx.state === 'suspended') audioCtx.resume();
}
function beep(freq, dur = 0.06, type = 'square', gain = 0.03, when = 0) {
  if (!audioCtx || muted) return;
  const t = audioCtx.currentTime + when;
  const o = audioCtx.createOscillator(), g = audioCtx.createGain();
  o.type = type; o.frequency.value = freq;
  g.gain.setValueAtTime(gain, t);
  g.gain.exponentialRampToValueAtTime(0.0001, t + dur);
  o.connect(g); g.connect(audioCtx.destination);
  o.start(t); o.stop(t + dur + 0.02);
}
const SFX = {
  move:   () => beep(220, 0.03, 'square', 0.015),
  rotate: () => beep(330, 0.05, 'square', 0.02),
  lock:   () => beep(150, 0.08, 'triangle', 0.03),
  hold:   () => beep(440, 0.05, 'sine', 0.02),
  clear:  () => [440, 554, 659].forEach((f, i) => beep(f, 0.09, 'square', 0.025, i * 0.07)),
  tetris: () => [523, 659, 784, 1046].forEach((f, i) => beep(f, 0.12, 'square', 0.03, i * 0.08)),
  level:  () => [523, 784].forEach((f, i) => beep(f, 0.1, 'sine', 0.03, i * 0.1)),
  over:   () => [392, 330, 262, 196].forEach((f, i) => beep(f, 0.18, 'sawtooth', 0.028, i * 0.15)),
};
function playSound(name) { if (SFX[name]) SFX[name](); }

// ---------- 核心 ----------
function bagNext() {
  if (!bag.length) bag = shuffle(['I','O','T','S','Z','J','L']);
  return bag.pop();
}

function collides(matrix, px, py) {
  for (let r = 0; r < matrix.length; r++) {
    for (let c = 0; c < matrix[r].length; c++) {
      if (!matrix[r][c]) continue;
      const x = px + c, y = py + r;
      if (x < 0 || x >= COLS || y >= ROWS) return true;
      if (y >= 0 && board[y][x]) return true;
    }
  }
  return false;
}

function spawnPiece(type) {
  const shape = SHAPES[type];
  cur = { type, matrix: cloneMatrix(shape), x: Math.floor((COLS - shape.length) / 2), y: 0 };
  dropTimer = 0; lockTimer = 0; lockResets = 0;
  if (collides(cur.matrix, cur.x, cur.y)) gameOver();
}

function spawnFromQueue() {
  const type = queue.shift();
  queue.push(bagNext());
  canHold = true;
  spawnPiece(type);
}

function resetLock() {
  if (lockResets < MAX_LOCK_RESETS) { lockTimer = 0; lockResets++; }
}

function moveH(dir, silent) {
  if (!cur || state !== 'playing' || clearingTimer > 0) return false;
  if (!collides(cur.matrix, cur.x + dir, cur.y)) {
    cur.x += dir;
    if (!silent) playSound('move');
    if (collides(cur.matrix, cur.x, cur.y + 1)) resetLock();
    return true;
  }
  return false;
}

function rotateMatrix(m, dir) {
  const n = m.length, res = Array.from({ length: n }, () => Array(n).fill(0));
  for (let r = 0; r < n; r++)
    for (let c = 0; c < n; c++) {
      if (dir > 0) res[c][n - 1 - r] = m[r][c];
      else res[n - 1 - c][r] = m[r][c];
    }
  return res;
}

function rotate(dir) {
  if (!cur || state !== 'playing' || clearingTimer > 0) return;
  if (cur.type === 'O') { playSound('rotate'); return; }
  const m = rotateMatrix(cur.matrix, dir);
  const kicks = [0, -1, 1, -2, 2];
  for (const dx of kicks) {
    if (!collides(m, cur.x + dx, cur.y)) { cur.matrix = m; cur.x += dx; playSound('rotate'); resetLock(); return; }
  }
  for (const dx of kicks) { // 落地时向上踢一格
    if (!collides(m, cur.x + dx, cur.y - 1)) { cur.matrix = m; cur.x += dx; cur.y -= 1; playSound('rotate'); resetLock(); return; }
  }
}

function softStep() {
  if (!cur || state !== 'playing' || clearingTimer > 0) return false;
  if (!collides(cur.matrix, cur.x, cur.y + 1)) {
    cur.y++; score++; dropTimer = 0; lockResets = 0;
    updateHUD();
    return true;
  }
  return false;
}

function hardDrop() {
  if (!cur || state !== 'playing' || clearingTimer > 0) return;
  let dist = 0;
  while (!collides(cur.matrix, cur.x, cur.y + 1)) { cur.y++; dist++; }
  score += dist * 2;
  updateHUD();
  lockPiece();
}

function holdSwap() {
  if (!cur || !canHold || state !== 'playing' || clearingTimer > 0) return;
  const t = cur.type;
  if (holdType) { const h = holdType; holdType = t; spawnPiece(h); }
  else { holdType = t; spawnFromQueue(); }
  canHold = false;
  playSound('hold');
}

function lockPiece() {
  let topOut = false;
  for (let r = 0; r < cur.matrix.length; r++) {
    for (let c = 0; c < cur.matrix[r].length; c++) {
      if (!cur.matrix[r][c]) continue;
      const y = cur.y + r, x = cur.x + c;
      if (y < 0) { topOut = true; continue; }
      board[y][x] = cur.type;
    }
  }
  cur = null;
  if (topOut) { gameOver(); return; }

  rowsToClear = [];
  for (let r = 0; r < ROWS; r++) if (board[r].every(v => v)) rowsToClear.push(r);

  if (rowsToClear.length) {
    clearingTimer = CLEAR_TIME;
    playSound(rowsToClear.length === 4 ? 'tetris' : 'clear');
  } else {
    playSound('lock');
    spawnFromQueue();
  }
}

function finishClear() {
  const n = rowsToClear.length;
  rowsToClear.forEach(r => {
    board.splice(r, 1);
    board.unshift(Array(COLS).fill(0));
  });
  rowsToClear = [];
  score += LINE_SCORES[n] * level;
  lines += n;
  const newLevel = Math.floor(lines / 10) + 1;
  if (newLevel > level) { level = newLevel; playSound('level'); }
  updateHUD();
  spawnFromQueue();
}

function dropInterval() {
  return Math.max(70, 1000 * Math.pow(0.82, level - 1));
}

function gameOver() {
  state = 'over'; cur = null;
  if (score > best) {
    best = score;
    try { localStorage.setItem('tetris.best', String(best)); } catch (e) {}
  }
  updateHUD();
  const record = score > 0 && score >= best ? ' · 新纪录！' : '';
  showOverlay('游戏结束', `得分 ${score} · 消除 ${lines} 行${record}`, '再来一局');
  playSound('over');
}

function resetGame() {
  board = Array.from({ length: ROWS }, () => Array(COLS).fill(0));
  bag = []; queue = [];
  for (let i = 0; i < 5; i++) queue.push(bagNext());
  score = 0; lines = 0; level = 1;
  holdType = null; canHold = true;
  rowsToClear = []; clearingTimer = 0;
  dasDir = 0; dasTimer = 0; arrTimer = 0; softTimer = 0;
  input.left = input.right = input.down = false;
  spawnFromQueue();
  updateHUD();
}

// ---------- 界面 ----------
function updateHUD() {
  scoreEl.textContent = score;
  bestEl.textContent = best;
  levelEl.textContent = level;
  linesEl.textContent = lines;
}

function showOverlay(title, text, btn) {
  ovTitle.textContent = title;
  ovText.innerHTML = text;
  ovBtn.textContent = btn;
  overlay.classList.remove('hidden');
}
function hideOverlay() { overlay.classList.add('hidden'); }

function start() {
  if (state !== 'ready') return;
  initAudio(); state = 'playing'; hideOverlay(); ovBtn.blur();
}
function restart() {
  initAudio(); resetGame(); state = 'playing'; hideOverlay(); ovBtn.blur();
}
function pause() { state = 'paused'; showOverlay('已暂停', '按 P 或 Enter 继续', '继续'); }
function resume() { state = 'playing'; hideOverlay(); ovBtn.blur(); }
function pauseToggle() {
  if (state === 'playing') pause();
  else if (state === 'paused') resume();
}

function drawCell(ctx, x, y, size, color) {
  const r = Math.max(2, size * 0.16);
  ctx.fillStyle = color;
  rr(ctx, x + 0.5, y + 0.5, size - 1, size - 1, r); ctx.fill();
  ctx.fillStyle = 'rgba(255,255,255,0.26)';
  rr(ctx, x + 2.5, y + 2.5, size - 5, (size - 2) * 0.3, r * 0.55); ctx.fill();
  ctx.strokeStyle = 'rgba(0,0,0,0.35)'; ctx.lineWidth = 1;
  rr(ctx, x + 1.5, y + 1.5, size - 3, size - 3, r * 0.8); ctx.stroke();
}

function drawMatrix(m, px, py, ghost, color) {
  for (let r = 0; r < m.length; r++) {
    for (let c = 0; c < m[r].length; c++) {
      if (!m[r][c]) continue;
      const y = py + r;
      if (y < 0) continue;
      const x = (px + c) * CELL, yy = y * CELL;
      if (ghost) {
        ctxBoard.fillStyle = color + '16';
        rr(ctxBoard, x + 1, yy + 1, CELL - 2, CELL - 2, CELL * 0.16); ctxBoard.fill();
        ctxBoard.strokeStyle = color + '59'; ctxBoard.lineWidth = 1.5;
        rr(ctxBoard, x + 1.5, yy + 1.5, CELL - 3, CELL - 3, CELL * 0.16); ctxBoard.stroke();
      } else {
        drawCell(ctxBoard, x, yy, CELL, color);
      }
    }
  }
}

function drawPreview(ctx, type, x, y, w, h, alpha) {
  const m = SHAPES[type];
  let minR = Infinity, maxR = -Infinity, minC = Infinity, maxC = -Infinity;
  for (let r = 0; r < m.length; r++)
    for (let c = 0; c < m[r].length; c++)
      if (m[r][c]) {
        minR = Math.min(minR, r); maxR = Math.max(maxR, r);
        minC = Math.min(minC, c); maxC = Math.max(maxC, c);
      }
  const bw = (maxC - minC + 1) * PC, bh = (maxR - minR + 1) * PC;
  const ox = x + (w - bw) / 2 - minC * PC, oy = y + (h - bh) / 2 - minR * PC;
  ctx.save();
  ctx.globalAlpha = alpha;
  for (let r = 0; r < m.length; r++)
    for (let c = 0; c < m[r].length; c++)
      if (m[r][c]) drawCell(ctx, ox + c * PC, oy + r * PC, PC, COLORS[type]);
  ctx.restore();
}

function drawPreviews() {
  const hw = 104, hh = 72;
  ctxHold.clearRect(0, 0, hw, hh);
  if (holdType) drawPreview(ctxHold, holdType, 0, 0, hw, hh, canHold ? 1 : 0.35);

  if (nextHorizontal) {
    const slot = 56;
    ctxNext.clearRect(0, 0, 5 * slot, slot);
    for (let i = 0; i < Math.min(5, queue.length); i++)
      drawPreview(ctxNext, queue[i], i * slot, 0, slot, slot, 1);
  } else {
    const slot = 52;
    ctxNext.clearRect(0, 0, 104, 5 * slot);
    for (let i = 0; i < Math.min(5, queue.length); i++)
      drawPreview(ctxNext, queue[i], 0, i * slot, 104, slot, 1);
  }
}

function draw() {
  const w = COLS * CELL, h = ROWS * CELL;
  ctxBoard.clearRect(0, 0, w, h);

  const g = ctxBoard.createLinearGradient(0, 0, 0, h);
  g.addColorStop(0, '#0e1330'); g.addColorStop(1, '#0a0d1e');
  ctxBoard.fillStyle = g; ctxBoard.fillRect(0, 0, w, h);

  ctxBoard.strokeStyle = 'rgba(255,255,255,0.045)';
  ctxBoard.lineWidth = 1;
  ctxBoard.beginPath();
  for (let c = 1; c < COLS; c++) { ctxBoard.moveTo(c * CELL + .5, 0); ctxBoard.lineTo(c * CELL + .5, h); }
  for (let r = 1; r < ROWS; r++) { ctxBoard.moveTo(0, r * CELL + .5); ctxBoard.lineTo(w, r * CELL + .5); }
  ctxBoard.stroke();

  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++) {
      const t = board[r][c];
      if (!t || rowsToClear.includes(r)) continue;
      drawCell(ctxBoard, c * CELL, r * CELL, CELL, COLORS[t]);
    }

  if (clearingTimer > 0) {
    const p = clearingTimer / CLEAR_TIME;
    const alpha = 0.25 + 0.55 * Math.abs(Math.sin(p * Math.PI * 2.5));
    ctxBoard.fillStyle = `rgba(255,255,255,${alpha})`;
    for (const r of rowsToClear) ctxBoard.fillRect(0, r * CELL, w, CELL);
  }

  if (cur) {
    const color = COLORS[cur.type];
    let gy = cur.y;
    while (!collides(cur.matrix, cur.x, gy + 1)) gy++;
    if (gy !== cur.y) drawMatrix(cur.matrix, cur.x, gy, true, color);
    drawMatrix(cur.matrix, cur.x, cur.y, false, color);
  }

  drawPreviews();
}

// ---------- 输入 ----------
function setDir(dir) {
  dasDir = dir; dasTimer = 0; arrTimer = 0;
  if (dir !== 0) moveH(dir);
}

document.addEventListener('keydown', (e) => {
  if (e.ctrlKey || e.metaKey || e.altKey) return;
  switch (e.code) {
    case 'ArrowLeft':
      e.preventDefault();
      if (!e.repeat && !input.left) { input.left = true; setDir(-1); }
      break;
    case 'ArrowRight':
      e.preventDefault();
      if (!e.repeat && !input.right) { input.right = true; setDir(1); }
      break;
    case 'ArrowDown':
      e.preventDefault();
      if (!e.repeat) { input.down = true; softTimer = 0; softStep(); }
      break;
    case 'ArrowUp': case 'KeyX':
      e.preventDefault();
      if (!e.repeat) rotate(1);
      break;
    case 'KeyZ':
      if (!e.repeat) rotate(-1);
      break;
    case 'Space':
      e.preventDefault();
      if (e.repeat) break;
      if (state === 'ready') start();
      else if (state === 'over') restart();
      else if (state === 'playing') hardDrop();
      break;
    case 'Enter':
      if (e.repeat) break;
      if (state === 'ready') start();
      else if (state === 'over') restart();
      else if (state === 'paused') resume();
      break;
    case 'KeyC': case 'ShiftLeft': case 'ShiftRight':
      if (!e.repeat) holdSwap();
      break;
    case 'KeyP': case 'Escape':
      if (!e.repeat) pauseToggle();
      break;
    case 'KeyR':
      if (!e.repeat) restart();
      break;
  }
});

document.addEventListener('keyup', (e) => {
  switch (e.code) {
    case 'ArrowLeft':  input.left = false;  if (dasDir === -1) setDir(input.right ? 1 : 0); break;
    case 'ArrowRight': input.right = false; if (dasDir === 1)  setDir(input.left ? -1 : 0); break;
    case 'ArrowDown':  input.down = false; break;
  }
});

// 触控按钮（长按左右/软降连续动作）
document.querySelectorAll('.touch-controls button').forEach(btn => {
  const act = btn.dataset.act;
  let iv = null;
  const fire = () => {
    switch (act) {
      case 'left':  moveH(-1); break;
      case 'right': moveH(1); break;
      case 'down':  softStep(); break;
      case 'cw':    rotate(1); break;
      case 'ccw':   rotate(-1); break;
      case 'drop':  hardDrop(); break;
      case 'hold':  holdSwap(); break;
    }
  };
  btn.addEventListener('pointerdown', e => {
    e.preventDefault(); initAudio();
    if (state === 'ready') { start(); return; }
    fire();
    if (['left', 'right', 'down'].includes(act)) iv = setInterval(fire, 110);
  });
  ['pointerup', 'pointercancel', 'pointerleave'].forEach(ev =>
    btn.addEventListener(ev, () => { clearInterval(iv); iv = null; }));
});

ovBtn.addEventListener('click', () => {
  if (state === 'ready') start();
  else if (state === 'paused') resume();
  else if (state === 'over') restart();
});

muteBtn.addEventListener('click', () => {
  initAudio();
  muted = !muted;
  muteBtn.textContent = muted ? '🔇' : '🔊';
});

document.addEventListener('visibilitychange', () => {
  if (document.hidden && state === 'playing') pause();
});

// ---------- 主循环 ----------
function update(dt) {
  if (clearingTimer > 0) {
    clearingTimer -= dt;
    if (clearingTimer <= 0) { clearingTimer = 0; finishClear(); }
    return;
  }
  if (!cur) return;

  if (dasDir !== 0) {
    dasTimer += dt;
    if (dasTimer >= DAS) {
      arrTimer += dt;
      while (arrTimer >= ARR) { arrTimer -= ARR; if (!moveH(dasDir, true)) break; }
    }
  }

  if (input.down) {
    softTimer += dt;
    while (softTimer >= SOFT_ARR) { softTimer -= SOFT_ARR; if (!softStep()) break; }
  } else {
    softTimer = 0;
  }

  if (!cur) return;

  if (collides(cur.matrix, cur.x, cur.y + 1)) {
    lockTimer += dt;
    if (lockTimer >= LOCK_DELAY) lockPiece();
  } else {
    dropTimer += dt;
    if (dropTimer >= dropInterval()) { dropTimer = 0; cur.y++; lockResets = 0; }
  }
}

let last = performance.now(), lastRafTick = 0;
function frame(now) {
  const dt = Math.min(100, now - last);
  last = now;
  if (state === 'playing') update(dt);
  draw();
}

// ---------- 尺寸 ----------
function resizeBoard() {
  const availH = window.innerHeight - 170;
  const availW = window.innerWidth - 40;
  CELL = Math.max(18, Math.min(30, Math.floor(availH / ROWS), Math.floor(availW / COLS)));
  ctxBoard = setupCanvas(boardCanvas, COLS * CELL, ROWS * CELL);
}
function resizePreviews() {
  nextHorizontal = window.innerWidth <= 720;
  ctxNext = nextHorizontal ? setupCanvas(nextCanvas, 5 * 56, 56) : setupCanvas(nextCanvas, 104, 5 * 52);
  ctxHold = setupCanvas(holdCanvas, 104, 72);
}
function resizeAll() { resizeBoard(); resizePreviews(); }
window.addEventListener('resize', resizeAll);

// ---------- 启动 ----------
resizeAll();
resetGame();
updateHUD();
showOverlay('俄罗斯方块',
  '← → 移动　↑ 旋转　↓ 软降　空格 硬降<br>C 暂存　P 暂停　R 重开<br>每 10 行升一级，速度越来越快！',
  '开始游戏');
// 部分内嵌环境会挂起 rAF，用定时器兜底驱动主循环
requestAnimationFrame(function raf(now) {
  lastRafTick = performance.now();
  frame(now);
  requestAnimationFrame(raf);
});
setInterval(() => {
  if (performance.now() - lastRafTick > 200) frame(performance.now());
}, 16);

})();
</script>
</body>
</html>

