function spawnObjects(level) {
  const objs = [];
  const span = LEVEL_DIST * 8; // teljes pálya px-ben

  // evenSpread: egyenletes elosztás a pályán
  function evenSpread(count, S_start, typeObj) {
    const S_end = span - 200;         // utolsó 200px = célterület
    const gap  = (S_end - S_start) / (count - 1);
    for (let i = 0; i < count; i++) {
      // Kis véletlenszerűség a gapon belül (nem pontosan egyenletes)
      const S = S_start + i*gap + (Math.random()-.5)*gap*.5;
      // World Y: a játékos ekkor éri el (screen_y = o.y + scrollY = PLAYER_Y)
      const y = PLAYER_Y - S;
      objs.push({ ...typeObj, y });
    }
  }

  evenSpread(20+level*4, 150, { type:'egg',   r:9  });
  evenSpread(lv.rocks*3,  250, { type:'rock',  r:13 });
  evenSpread(lv.gulls*3,  300, { type:'gull',  r:15 });

  // X pozíció: véletlenszerű (pálya szélességén belül)
  objs.forEach(o => { o.x = TL + 14 + Math.random()*(TW-28); });
  return objs;
}

// Minden felszín tulajdonságai egy helyen
const SURFACES = {
  grass: { name:'🌿 Fű',    col:'#4aaa22', spd:1.00, slip:0.0 },
  sand:  { name:'🏖️ Homok', col:'#e8c84a', spd:0.58, slip:0.0 },
  ice:   { name:'❄️ Jég',   col:'#b8e8ff', spd:1.22, slip:0.88 },
  mud:   { name:'💧 Sár',   col:'#8B5a30', spd:0.40, slip:0.0 },
  road:  { name:'🛤️ Út',   col:'#777',    spd:1.38, slip:0.0 },
};

// Felhasználás: a sebesség a felszíntől függ
const surf = SURFACES[getSurface(dist, level)];
const scrollSpd = BASE_SPD * surf.spd * lv.spdMul;

// Csúszás jégen: vx nem csökken gyorsan
if (!K.left && !K.right) {
  p.vx *= (surf.slip > 0 ? surf.slip : 0.74);
  // Jégen slip=0.88 → lassan lassul (csúszik)
  // Fűn slip=0   → 0.74-gyel szorozva gyorsan megáll
}

function getSurface(dist, level) {
  const lv   = LEVELS[level - 1];
  const segH = LEVEL_DIST / lv.segs.length;  // szegmens hossza
  const idx  = Math.min(
    Math.floor(dist / segH),
    lv.segs.length - 1
  );
  return lv.segs[idx]; // pl. 'mud'
}
// pl. level 2 = ['grass','mud','grass','mud','grass']
// dist=180m → szegmens=120m → idx=1 → 'mud'

// 1. Ugrás INDÍTÁSA — billentyű lenyomásakor
if (K.up && !p.jumping && !p.inShell) {
  p.jumping = true;
  p.jumpT   = 0;     // idő számláló nullára
}

// 2. Ugrás ANIMÁLÁSA — minden frame-ben
if (p.jumping) {
  p.jumpT++;
  // sin(0)=0 → sin(π/2)=1 (csúcs) → sin(π)=0 (le)
  p.jumpH = Math.sin(p.jumpT / 22 * Math.PI) * 38;
  //                 ↑ 22 frame alatt tér vissza   ↑ 38px magas

  if (p.jumpT >= 22) {  // 22 frame eltelt
    p.jumping = false;
    p.jumpH   = 0;
  }
}

// 3. Rajzoláskor: jumpH-val feljebb kerül a béka
ctx.translate(p.x, PLAYER_Y - p.jumpH);

// 4. Ütközésnél: ugrás közben a béka "feljebb" van
const frogScreenY = PLAYER_Y - p.jumpH;
const d = Math.hypot(p.x - rock.x, frogScreenY - sy);

// Kő: !p.jumping szükséges → ugrással elkerülhető
if (o.type === 'rock' && !p.jumping && pd < o.r+11) {
  loseLife(p);
}

// Sirály: !p.inShell kell → csak páncéllal kerülhető el
if (o.type === 'gull' && !p.inShell && pd < o.r+12) {
  loseLife(p);
}

// G.phase lehetséges értékei:
// 'play'    — normál játék folyik
// 'dead'    — béka halott, animáció lejátszódik
// 'levelup' — szint teljesítve, átmenet
// 'gameover'— nincs több élet

// Update-ben: csak a megfelelő állapot fut
function update() {
  G.frame++;
  if (G.phase === 'play')     updatePlay();
  if (G.phase === 'dead')     updateDead();
  if (G.phase === 'levelup')  updateLevelUp();
}

// Halál — állapot váltás
function dieFrog() {
  if (G.frog.dead) return; // már halott → ne fusson le kétszer
  G.frog.dead = true;
  G.phase     = 'dead';     // átváltás dead állapotba
  G.phTimer   = 80;         // 80 frame-ig marad dead-ben
  G.lives--;
}

// Dead állapot: visszaszámol majd visszaáll
function updateDead() {
  G.phTimer--;
  if (G.phTimer <= 0) {
    if (G.lives <= 0) {
      G.phase = 'gameover';
    } else {
      G.phase = 'play';    // visszaáll játékba
      resetFrog();         // béka kezdőpozícióba
    }
  }
}

// Nehézségi szintek konfigurációja
const DIFF_CFG = [
  { name:'🐌 Gyerek', carSpd:0.45, logSpd:0.45, logGap:0.7 },
  { name:'🐢 Lassú',  carSpd:0.75, logSpd:0.75, logGap:0.85 },
  { name:'⚔️ Normal', carSpd:1.0,  logSpd:1.0,  logGap:1.0 },
  { name:'💀 Gyors',  carSpd:1.6,  logSpd:1.5,  logGap:1.2 },
];

// Kiválasztott nehézség indexe (0-3)
let DIFF = 2; // Normal az alapértelmezett

// Felhasználás — csak a konfigot kell kiolvasni:
function makeCars(level, diff) {
  const dc = DIFF_CFG[diff];
  const spdMul = dc.carSpd * (1 + level * .08);
  // spdMul = alap nehézség * szint-szorzó
  // Gyerek, 1. szint: 0.45 * 1.0 = 0.45
  // Gyors, 5. szint:  1.6  * 1.4 = 2.24
}

function updateAI() {
  // Nem dönt minden frame-ben — csak 25-65 frame-enként
  a.aiTimer--;
  if (a.aiTimer <= 0) {
    a.aiTimer = 25 + Math.floor(Math.random() * 40);

    let best = W/2, bestSc = -Infinity;

    // Minden objektumot értékel
    G.objects.forEach(o => {
      if (o.done) return;
      const sy = o.y + G.scrollY;
      if (sy < AI_Y+100 && sy > AI_Y-60) {
        if (o.type === 'egg' || o.type === 'boost') {
          const sc = 90 - Math.abs(o.x - a.x); // közelebb = jobb
          if (sc > bestSc) { bestSc = sc; best = o.x; }
        }
        if (o.type === 'gull') {
          if (Math.abs(o.x - a.x) < 55) best = a.x + (a.x < W/2 ? 55 : -55);
        }
      }
    });

    // aiErr: kis hiba → nem tökéletes az AI
    a.aiTargetX = best + a.aiErr * TW * .4;
  }

  // Simán mozog a célpont felé
  const diff = a.aiTargetX - a.x;
  a.vx += Math.sign(diff) * Math.min(Math.abs(diff)*.09, .85);
}

// AI automatikusan ugrik ha kő van közel előtte
if (!a.jumping) {
  G.objects.forEach(o => {
    if (o.type !== 'rock' || o.done) return;
    const sy = o.y + G.scrollY;
    if (sy > AI_Y-60 && sy < AI_Y+20
        && Math.abs(o.x - a.x) < 35) {
      a.jumping = true; a.jumpT = 0;
    }
  });
}

// Fogyás/töltés mértéke felszínenként (per frame)
const drainMap = { grass:0.04, sand:0.08, ice:0.05, mud:0.08, road:0 };
const fillMap  = { grass:0,    sand:0,    ice:0,    mud:0,    road:0.06 };

// Melyik felszínen vagyunk?
const surfName = getSurface(G.totalDist, G.level);

// Energia frissítés: fogyás - töltés, 0 és 100 között
p.energy = Math.max(0, Math.min(100,
  p.energy - drainMap[surfName] + fillMap[surfName]
));

// Ha elfogy → élet vész, energia visszaáll 100-ra
if (p.energy <= 0) {
  p.energy = 100;
  loseLife(p);
  addFloat(p.x, PLAYER_Y-40, '⚡ Energia kimerült!', '#e03030');
}

// Vízcsomag felvétel
if (o.type === 'energy' && pd < o.r+13) {
  o.done = true;
  if (p.energy >= 100) {
    G.score += 25 * G.level; // teli → bónusz pont
  } else {
    p.energy = Math.min(100, p.energy + 40); // tölt
  }
}

// SPAWN: objektum world Y kiszámítása
// Akkor éri el a játékost amikor scrollY = S
// screen_y = o.y + scrollY = PLAYER_Y
// → o.y = PLAYER_Y - S
const y = PLAYER_Y - S;  // negatív szám (képernyő felett)

// UPDATE: csak scrollY nő — objektumok NEM mozognak!
G.scrollY += scrollSpd;  // ez a "haladás"
G.totalDist = G.scrollY / 8; // méterré konvertálva

// DRAW: screen pozíció kiszámítása
G.objects.forEach(o => {
  const sy = o.y + G.scrollY; // screen_y
  if (sy < -40 || sy > H+40) return; // képernyőn kívül: skip
  drawEgg(o.x, sy);  // screen koordinátán rajzolódik
});

// ÜTKÖZÉS: screen_y-t kell összehasonlítani
const d = Math.hypot(p.x - o.x, PLAYER_Y - sy);

function drawTurtle(x, y, t, frame) {
  if (t.stunned > 0 && Math.floor(frame/5) % 2) return; // villog
  const jy = t.jumpH || 0;

  ctx.save();
  ctx.translate(x, y - jy);           // origó a teknős közepébe
  ctx.rotate(tilt);                    // vx alapján dőlés

  // 1. RÉTEG: árnyék (mindig lejjebb)
  ctx.fillStyle = 'rgba(0,0,0,.18)';
  ctx.ellipse(2, 18, 14, 4, 0, 0, Math.PI*2);

  // 2. RÉTEG: lábak (páncél alá kerülnek)
  drawLegs(walk);

  // 3. RÉTEG: páncél (a lábak felett)
  drawShell(t.inShell);

  // 4. RÉTEG: fej (páncél felett)
  if (!t.inShell) drawHead(walk);

  ctx.restore();

  // 5. RÉTEG: felirat (külön save/restore)
  ctx.save();
  ctx.translate(x, y - jy);
  ctx.fillText(t.isAI ? '🤖 AI' : '🐢 Te', 0, -28);
  ctx.restore();
}

// Páncél: radiális gradiens + hex minta
const g2 = ctx.createRadialGradient(-3,-4,2, 0,1,14);
g2.addColorStop(0, '#3a9a28'); // belül világos
g2.addColorStop(1, '#1a5a10'); // kívül sötét
ctx.fillStyle = g2;
ctx.beginPath();
ctx.ellipse(0, 1, 14, 11, 0, 0, Math.PI*2);
ctx.fill();

// Hex minta vonalakkal
ctx.strokeStyle = 'rgba(0,0,0,.22)';
ctx.lineWidth = 1;
ctx.beginPath(); ctx.ellipse(0,1,8,6,0,0,Math.PI*2); ctx.stroke();
ctx.beginPath(); ctx.moveTo(0,-8); ctx.lineTo(0,10);  ctx.stroke();
ctx.beginPath(); ctx.moveTo(-14,1); ctx.lineTo(14,1); ctx.stroke();

function initLevel(lvNum) {
  G = {
    // Játékelemek
    hero:    { x:155, y:300, hp:100, maxHp:100, spd:2, vx:0, vy:0 },
    castle:  { hp:200, maxHp:200, x:0, w:80 },
    towers:  [],    // épített tornyok tömbje
    enemies: [],    // aktív ellenségek
    hProj:   [],    // hős lövedékei
    tProj:   [],    // torony lövedékek
    floats:  [],    // lebegő szövegek

    // Erőforrások
    gold:    50,
    score:   0,

    // Pálya állapot
    level:   lvNum,
    wave:    0,
    phase:   'play',
    frame:   0,
  };
}

function update() {
  if (!G || G.phase !== 'play') return;
  G.frame++;

  // Sorrendben fut le minden frame-ben:
  moveHero(G.hero);       // 1. Hős mozog
  spawnWave();            // 2. Új ellenségek jönnek?
  moveEnemies();          // 3. Ellenségek mozognak
  towerAI();              // 4. Tornyok lőnek
  moveProjectiles();      // 5. Lövedékek mozognak
  checkCollisions();      // 6. Ütközések vizsgálata
  checkWinLose();         // 7. Nyert/veszített?
}

function genLevel(lvNum) {
  // Hullámok száma: 5-től 10-ig nő
  const waves = 5 + Math.floor(lvNum / 5);

  // Ellenség típusok — magasabb szinten több és erősebb
  const ENEMY_TYPES = [
    { hp: 20+lvNum*4,  spd: 0.8+lvNum*0.02, gold: 5,  col: '#c83030' },
    { hp: 60+lvNum*8,  spd: 0.5+lvNum*0.01, gold: 12, col: '#8030c8' },
    { hp: 150+lvNum*15, spd: 0.35,            gold: 25, col: '#303080' },
  ];

  // Hullámok generálása
  const waveData = [];
  for (let w = 0; w < waves; w++) {
    // Ellenség szám: szinttel és hullámmal nő
    const count = 3 + Math.floor(lvNum/2) + Math.floor(w/2);
    // Típus: magasabb hullámban erősebb típus is megjelenhet
    const maxType = Math.min(2, Math.floor(lvNum/10) + Math.floor(w/3));
    waveData.push({ count, maxType });
  }
  return { waves, waveData, ENEMY_TYPES };
}

function towerAI() {
  G.towers.forEach(tower => {
    // Töltési idő (cooldown) csökken
    if (tower.cooldown > 0) { tower.cooldown -= DT; return; }

    // Legközelebbi ellenség keresése hatótávon belül
    let best = null, bestDist = tower.range;
    G.enemies.forEach(e => {
      const d = Math.hypot(e.x - tower.x, e.y - tower.y);
      if (d < bestDist) { bestDist = d; best = e; }
    });

    if (!best) return; // nincs célpont

    // Lövedék irány kiszámítása
    const angle = Math.atan2(best.y - tower.y, best.x - tower.x);
    G.tProj.push({
      x: tower.x, y: tower.y,
      vx: Math.cos(angle) * tower.projSpd,
      vy: Math.sin(angle) * tower.projSpd,
      dmg: tower.dmg, life: 120
    });
    tower.cooldown = tower.fireRate;
  });
}

// ALAP célzás: oda lő ahol AZ ELLENSÉG VAN
const angle = Math.atan2(e.y - t.y, e.x - t.x);

// ELŐREJELZŐ célzás: oda lő ahol AZ ELLENSÉG LESZ
// 1. Mennyi idő alatt ér a lövedék az ellenséghez?
const dist = Math.hypot(e.x - t.x, e.y - t.y);
const travelTime = dist / t.projSpd; // frame-ekben

// 2. Hol lesz az ellenség travelTime frame múlva?
const predX = e.x + e.vx * travelTime;
const predY = e.y + e.vy * travelTime;

// 3. Az előrejelzett pozícióra célzunk
const angle = Math.atan2(predY - t.y, predX - t.x);

// Lövedék indítása az előrejelzett szögben:
G.tProj.push({
  vx: Math.cos(angle) * t.projSpd,
  vy: Math.sin(angle) * t.projSpd,
});

// MENTÉS: objektum → JSON szöveg → localStorage
function saveGame(name) {
  const saveData = {
    level: G.level, score: G.score,
    heroSpd: G.hero.spd, gold: G.gold
  };
  localStorage.setItem('cs_save_'+name, JSON.stringify(saveData));
}

// BETÖLTÉS: localStorage → JSON szöveg → objektum
function loadGame(name) {
  const raw = localStorage.getItem('cs_save_'+name);
  if (!raw) return null;
  return JSON.parse(raw);
}

// TOP 10 lista kezelése
function saveTop(name, score, level) {
  let top = getTop();
  top.push({ name, score, level, date: new Date().toLocaleDateString('hu') });
  top.sort((a, b) => b.score - a.score); // csökkenő sorrend
  localStorage.setItem('cs_top10', JSON.stringify(top.slice(0, 10)));
}