// let — mert a játékos megváltoztatja
let DT = 0.6;
// 0.3 = Gyerek, 0.6 = Lassú
// 1.0 = Normal, 1.5 = Gyors

// const — a szint soha nem megy 50 fölé
const MAX_LEVEL = 50;

// let — a béka mozog, pozíció változik
let frogCol = 5.5;
let lives   = 3;

// const — a pályaméret soha nem változik
const COLS = 12;
const CELL = W / COLS; // 45px

// let — energia fogyhat, töltődhet
let energy = 100;
let score  = 0;

// const — a pálya hossza fix
const LEVEL_DIST = 600;

if (G.castle.hp <= 0) {
  G.phase = 'gameover';
  return;
}

// Kastély HP szín a sáv alapján
if (pct > 0.6) {
  color = '#3a8a3a'; // zöld
} else if (pct > 0.3) {
  color = '#9a8a20'; // sárga
} else {
  color = '#8a2020'; // piros
}

if (ZONE.road.includes(f.row)) {
  // úton van → autó ütötte-e?
  dieFrog('squish');
}

if (ZONE.river.includes(f.row)) {
  // vízen van → van-e alatta rönk?
  if (!onLog) {
    dieFrog('splash');
  }
}

if (surface === 'mud') {
  energy -= 0.22; // sárban gyorsan fogy
} else if (surface === 'road') {
  energy += 0.07; // úton töltődik
} else {
  energy -= 0.05; // egyébként lassan fogy
}

if (energy <= 0) {
  loseLife(player);
}

// forEach: minden toronyra lefut
G.towers.forEach(tower => {
  let best = null;
  let bestDist = ts.range;

  // beágyazott forEach: ellenségek
  G.enemies.forEach(enemy => {
    const d = dist(tower, enemy);
    if (d < bestDist) {
      bestDist = d;
      best = enemy;
    }
  });
});

// Minden tárgy (tojás, kő, sirály)
// ütközésvizsgálata a békaval
G.objects.forEach(obj => {
  if (obj.done) return; // skip
  const dist = Math.hypot(
    frog.x - obj.x,
    frogY  - obj.y
  );
  if (dist < obj.r + 13) {
    collect(obj);
  }
});

// for ciklus — pontosan 5 szegmens
for (let i = 0; i < segs.length; i++) {
  const surf = SURFACES[segs[i]];
  const topY = -((i+1) * segH) + scrollY;
  const botY = -(i * segH) + scrollY;
  ctx.fillStyle = surf.col;
  ctx.fillRect(TL, topY, TW, botY-topY);
}

// Paraméter: hol, mit, milyen színnel
function addFloat(x, y, txt, col) {
  G.floats.push({
    x, y, txt, col,
    life: 95,
    vy: -0.65
  });
}

// Meghívás — mindenhol ugyanígy:
addFloat(enemy.x, enemy.y, '+10g', '#FFD700');
addFloat(p.x, p.y-25, '-1 ❤️', '#f44');

function dieFrog(type) {
  // Ha már halott — ne futtasson le kétszer
  if (G.frog.dead) return;

  G.frog.dead = true;
  G.frog.deathType = type; // 'squish' vagy 'splash'
  G.lives--;
  G.phase = 'dead';
  G.phTimer = 80;
  updateUI();
}

// Kétféle hívás — más paraméterrel:
dieFrog('squish'); // autó elütötte
dieFrog('splash'); // vízbe esett

// Visszatérési értékkel rendelkező függvény
function getSurface(dist, level) {
  const lv   = LEVELS[level - 1];
  const segH = LEVEL_DIST / lv.segs.length;
  const idx  = Math.min(
    Math.floor(dist / segH),
    lv.segs.length - 1
  );
  return lv.segs[idx]; // pl. 'mud'
}

// Felhasználás:
const surf = getSurface(250, 2);
// surf === 'mud' → lassít és fogy az energia

// filter: csak az életben lévők maradnak
G.hProj = G.hProj.filter(p => {
  p.x += p.vx * DT;
  p.y += p.vy * DT;
  p.life -= DT;
  // ha life <= 0 vagy kimegy → töröljük
  return p.life > 0 && p.x > 0 && p.x < W;
});

// every: akkor igaz, ha MINDEGYIK tele
if (G.homes.every(h => h.filled)) {
  G.phase = 'levelup';
  G.score += 500 * G.level;
}

let topList = [
  { name: "Zoli", score: 1500 },
  { name: "Jen",  score: 2200 },
  { name: "Tom",  score: 800  },
];

// Rendezés pont szerint — csökkenő
topList.sort((a, b) => b.score - a.score);

// Csak az első 10 maradjon
topList = topList.slice(0, 10);

// Kiírás: "1. Jen: 2200 pont"
topList.forEach((t, i) => {
  console.log(`${i+1}. ${t.name}: ${t.score}`);
});

let G; // a teljes játékállapot

function initLevel() {
  G = {
    hero:    { x: 155, y: 300, hp: 100 },
    castle:  { hp: 200, maxHp: 200 },
    enemies: [],   // tömb az objektumban!
    towers:  [],
    gold:    0,
    wave:    0,
    phase:   'play'
  };
}
// Elérés: G.castle.hp, G.hero.x, stb.

function makeTurtle(x, isAI) {
  return {
    x,            // rövidítés: x: x
    vx:     0,
    lives:  3,
    energy: 100,
    jumping: false,
    inShell: false,
    isAI,         // rövidítés: isAI: isAI
    eggs:   0
  };
}

// Két teknős, ugyanazzal a szerkezettel:
const player = makeTurtle(W/2-22, false);
const ai     = makeTurtle(W/2+22, true);

const profil = {
  name:  "Zoli",
  score: 4500,
  hero: {                  // beágyazott objektum
    spd:   2,
    dmg:   3,
    level: 15
  },
  games: ["castle", "froggy"] // tömb benne
};

// Elérés láncolással:
profil.hero.spd   // 2
profil.games[0]  // "castle"

const K = {}; // lenyomott gombok

document.addEventListener('keydown', e => {
  K[e.key.toLowerCase()] = true;
  if (e.key === 'e') doInteract();
});
document.addEventListener('keyup', e => {
  K[e.key.toLowerCase()] = false;
});

// A game loopban folyamatosan ellenőrzi:
if (K['a'] || K['arrowleft']) hero.vx -= speed;

document.addEventListener('keydown', e => {
  const k = e.key;
  if (k === 'ArrowUp'   || k === 'w') {
    dpad(0, 1);  // fel
  } else if (k === 'ArrowLeft' || k === 'a') {
    dpad(-1, 0); // bal
  }
  // Space / Enter: újrakezdés
  if (k === ' ' || k === 'Enter') {
    e.preventDefault();
    startGame();
  }
});

document.addEventListener('keydown', e => {
  if (e.key === 'ArrowUp') {
    K.up = true;      // ugrás
    e.preventDefault();// oldal ne görgessen
  } if (e.key === 'ArrowDown') {
    K.down = true;    // páncél
  }
});
document.addEventListener('keyup', e => {
  if (e.key === 'ArrowUp')   K.up   = false;
  if (e.key === 'ArrowDown') K.down = false;
});

CV.addEventListener('click', e => {
  const rect = CV.getBoundingClientRect();
  const mx = (e.clientX - rect.left) * (W/rect.width);
  const my = (e.clientY - rect.top)  * (H/rect.height);

  // Legközelebbi hex keresése
  let best = null, bestD = HEX_SIZE * 1.1;
  G.hexes.forEach(h => {
    const {x,y} = hexCenter(h.col, h.row);
    const d = Math.hypot(mx-x, my-y);
    if (d < bestD) { bestD = d; best = h; }
  });
  if (best) selectHex(best.col, best.row);
});

let touchStart = null;

CV.addEventListener('touchstart', e => {
  touchStart = {
    x: e.touches[0].clientX,
    y: e.touches[0].clientY
  };
}, { passive: false });

CV.addEventListener('touchend', e => {
  const dx = e.changedTouches[0].clientX - touchStart.x;
  const dy = e.changedTouches[0].clientY - touchStart.y;
  if (Math.abs(dx) > Math.abs(dy))
    dpad(dx > 0 ? 1 : -1, 0); // vízszintes
  else
    dpad(0, dy < 0 ? 1 : -1); // függőleges
});

<!-- HTML: érintős gomb -->
<div class="dp"
  ontouchstart="K.left=true"
  ontouchend="K.left=false">⬅️</div>

// JS: a K objektum alapján mozog a teknős
if (K.left)  turtle.vx -= accel;
if (K.right) turtle.vx += accel;

// Véletlenszerű y pozíció a pálya magasságán belül
const y = UIH + et.r + Math.random() * (GH - et.r * 2);

// Energia töltési animáció — Math.min biztosítja
// hogy nem megy 100 fölé
p.energy = Math.min(100, p.energy + 40);

// HP 0 alá ne menjen:
G.castle.hp = Math.max(0, G.castle.hp - dmg);

// jumpT 0-tól 22-ig megy
// Math.sin() 0→1→0 parabolát ír le
p.jumpH = Math.sin(p.jumpT / 22 * Math.PI) * 38;
// jumpH: 0 → 38px (csúcs) → 0 vissza

// Ha időkeret lejárt — leszállt
if (p.jumpT >= 22) {
  p.jumping = false;
  p.jumpH   = 0;
}

// frame folyamatosan nő (0, 1, 2, 3...)
// sin(frame * 0.2) → -1 és 1 között oszcillál
// Ez adja a lépegető animációt
const walk = Math.sin(frame * 0.2) * 2;

// A teknős lábai ellentétesen lépnek:
ctx.ellipse(-10, 12 + walk, 7, 4, ...);
ctx.ellipse( 10, 12 - walk, 7, 4, ...);