미니게임 (로그라이크 성장)

import 'dart:async';
import 'dart:math';
import 'package:flutter/material.dart';

class RoguelikeMiniGame extends StatefulWidget {
  const RoguelikeMiniGame({super.key});

  @override
  State<RoguelikeMiniGame> createState() => _RoguelikeMiniGameState();
}

class Weapon {
  const Weapon(this.name, this.damage, this.cooldown, this.projectileSpeed);
  final String name;
  final double damage;
  final double cooldown;
  final double projectileSpeed;
}

class Enemy {
  Enemy({required this.position, required this.hp, required this.speed});
  Offset position;
  double hp;
  double speed;
  double radius = 14;
}

class Bullet {
  Bullet({required this.position, required this.velocity, required this.damage});
  Offset position;
  Offset velocity;
  double damage;
  double life = 1.4;
}

class ExpGem {
  ExpGem(this.position, this.value);
  Offset position;
  double value;
}

class UpgradeCard {
  const UpgradeCard(this.name, this.kind, this.rarity, this.value);
  final String name;
  final String kind;
  final String rarity;
  final int value;
}

class _RoguelikeMiniGameState extends State<RoguelikeMiniGame> {
  final random = Random();
  final boardSize = const Size(360, 360);
  final weapons = const [
    Weapon('검', 18, 0.42, 360),
    Weapon('화살', 14, 0.30, 470),
    Weapon('소환', 10, 0.52, 300),
  ];
  final upgradeNames = const ['공격력 강화', '체력 단련', '자석 감각', '재생', '연쇄 번개', '회전 오브'];
  final rarities = const ['일반', '레어', '에픽'];

  Timer? timer;
  late Weapon weapon = weapons.first;
  Offset player = const Offset(180, 180);
  Offset camera = Offset.zero;
  final pressedKeys = <LogicalKeyboardKey>{};
  List<Enemy> enemies = [];
  List<Bullet> bullets = [];
  List<ExpGem> gems = [];
  List<UpgradeCard> cards = [];

  int level = 1;
  int stage = 1;
  double time = 0;
  double spawnTimer = 0;
  double attackTimer = 0;
  int exp = 0;
  int expNeed = 5;
  double hp = 100;
  double maxHp = 100;
  double damageBonus = 0;
  double magnet = 78;
  double regen = 0;
  bool playing = false;

  @override
  void dispose() {
    timer?.cancel();
    super.dispose();
  }

  void startGame([Weapon? selected]) {
    timer?.cancel();
    setState(() {
      weapon = selected ?? weapon;
      player = const Offset(180, 180);
      camera = Offset.zero;
      pressedKeys.clear();
      enemies = List.generate(5, (_) => createEnemy());
      bullets = [];
      gems = [];
      cards = [];
      level = 1;
      stage = 1;
      time = 0;
      spawnTimer = 0;
      attackTimer = 0;
      exp = 0;
      expNeed = 5;
      hp = 100;
      maxHp = 100;
      damageBonus = 0;
      magnet = 78;
      regen = 0;
      playing = true;
    });

    timer = Timer.periodic(const Duration(milliseconds: 16), (_) => tick(0.016));
  }

  Enemy createEnemy() {
    final side = random.nextInt(4);
    final x = side == 0 ? -20.0 : side == 1 ? boardSize.width + 20 : random.nextDouble() * boardSize.width;
    final y = side == 2 ? -20.0 : side == 3 ? boardSize.height + 20 : random.nextDouble() * boardSize.height;
    return Enemy(
      position: Offset(x, y),
      hp: 26 + stage * 5,
      speed: 34 + stage * 3 + random.nextDouble() * 20,
    );
  }

  void tick(double dt) {
    if (!playing || cards.isNotEmpty) return;

    setState(() {
      time += dt;
      stage = max(1, (time ~/ 18) + 1);
      spawnTimer -= dt;
      attackTimer -= dt;
      if (regen > 0 && hp > 0 && hp < maxHp) {
        hp = min(maxHp, hp + maxHp * regen * dt);
      }
      movePlayer(dt);
      moveEnemies(dt);
      moveBullets(dt);
      collectGems(dt);
      autoAttack();

      if (spawnTimer <= 0) {
        enemies.add(createEnemy());
        spawnTimer = max(0.35, 1.15 - stage * 0.06);
      }

      if (hp <= 0) {
        playing = false;
        timer?.cancel();
      }
    });
  }

  void movePlayer(double dt) {
    var dx = 0.0;
    var dy = 0.0;
    if (pressedKeys.contains(LogicalKeyboardKey.arrowLeft) || pressedKeys.contains(LogicalKeyboardKey.keyA)) dx -= 1;
    if (pressedKeys.contains(LogicalKeyboardKey.arrowRight) || pressedKeys.contains(LogicalKeyboardKey.keyD)) dx += 1;
    if (pressedKeys.contains(LogicalKeyboardKey.arrowUp) || pressedKeys.contains(LogicalKeyboardKey.keyW)) dy -= 1;
    if (pressedKeys.contains(LogicalKeyboardKey.arrowDown) || pressedKeys.contains(LogicalKeyboardKey.keyS)) dy += 1;
    final length = sqrt(dx * dx + dy * dy);
    if (length == 0) return;
    player += Offset(dx / length, dy / length) * 170 * dt;
    camera = player - const Offset(180, 180);
  }

  void moveEnemies(double dt) {
    for (final enemy in enemies) {
      final delta = player - enemy.position;
      final distance = max(1, delta.distance);
      enemy.position += Offset(delta.dx / distance, delta.dy / distance) * enemy.speed * dt;

      if (distance < enemy.radius + 16) {
        hp -= 16 * dt;
      }
    }
  }

  void moveBullets(double dt) {
    for (final bullet in bullets) {
      bullet.position += bullet.velocity * dt;
      bullet.life -= dt;

      for (final enemy in enemies) {
        if (enemy.hp <= 0) continue;
        if ((enemy.position - bullet.position).distance < enemy.radius + 5) {
          enemy.hp -= bullet.damage;
          bullet.life = 0;
          if (enemy.hp <= 0) {
            gems.add(ExpGem(enemy.position, 2 + stage));
          }
          break;
        }
      }
    }

    bullets.removeWhere((bullet) => bullet.life <= 0);
    enemies.removeWhere((enemy) => enemy.hp <= 0);
  }

  void collectGems(double dt) {
    for (final gem in gems) {
      final delta = player - gem.position;
      final distance = delta.distance;
      if (distance < 16) {
        exp += gem.value.round();
        gem.value = 0;
      } else if (distance < magnet) {
        gem.position += Offset(delta.dx / distance, delta.dy / distance) * 240 * dt;
      }
    }

    gems.removeWhere((gem) => gem.value <= 0);
    if (exp >= expNeed) {
      exp -= expNeed;
      cards = buildCards();
    }
  }

  void autoAttack() {
    if (attackTimer > 0 || enemies.isEmpty) return;
    if (weapon.name == '소환') return;

    enemies.sort((a, b) {
      final ad = (a.position - player).distance;
      final bd = (b.position - player).distance;
      return ad.compareTo(bd);
    });

    final target = enemies.first;
    final delta = target.position - player;
    final distance = max(1, delta.distance);
    if (weapon.name == '검') {
      target.hp -= (weapon.damage + damageBonus) * 1.35;
      attackTimer = weapon.cooldown;
      return;
    }
    bullets.add(Bullet(
      position: player,
      velocity: Offset(delta.dx / distance, delta.dy / distance) * weapon.projectileSpeed,
      damage: weapon.damage + damageBonus,
    ));
    attackTimer = weapon.cooldown;
  }

  List<UpgradeCard> buildCards() {
    final names = [...upgradeNames]..shuffle(random);
    return names.take(3).map((name) {
      final rarity = rarities[random.nextInt(rarities.length)];
      final value = rarity == '에픽' ? 3 : rarity == '레어' ? 2 : 1;
      final kind = name.contains('번개') || name.contains('오브') ? '액티브' : '패시브';
      return UpgradeCard(name, kind, rarity, value);
    }).toList();
  }

  void pickCard(UpgradeCard card) {
    setState(() {
      if (card.name.contains('공격')) damageBonus += card.value * 5;
      if (card.name.contains('체력')) {
        maxHp += card.value * 20;
        hp = maxHp;
      }
      if (card.name.contains('자석')) magnet += card.value * 24;
      if (card.name.contains('재생')) regen += 0.004 * card.value;
      if (card.name.contains('번개') || card.name.contains('오브')) damageBonus += card.value * 3;
      level += 1;
      expNeed = (expNeed * 1.35 + 3).floor();
      cards = [];
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Wrap(
          spacing: 8,
          children: weapons.map((item) {
            return ChoiceChip(
              label: Text(item.name),
              selected: weapon.name == item.name,
              onSelected: (_) => startGame(item),
            );
          }).toList(),
        ),
        const SizedBox(height: 12),
        Text('Stage ' + stage.toString() + ' · Lv ' + level.toString() + ' · 무기 ' + weapon.name),
        LinearProgressIndicator(value: exp / expNeed),
        const SizedBox(height: 12),
        Focus(
          autofocus: true,
          onKeyEvent: (node, event) {
            if (event is KeyDownEvent) pressedKeys.add(event.logicalKey);
            if (event is KeyUpEvent) pressedKeys.remove(event.logicalKey);
            return KeyEventResult.handled;
          },
          child: SizedBox(
            width: boardSize.width,
            height: boardSize.height,
            child: CustomPaint(
              painter: RoguePainter(
                player: player,
                camera: camera,
                enemies: enemies,
                bullets: bullets,
                gems: gems,
                hpRatio: hp / maxHp,
                magnet: magnet,
              ),
            ),
          ),
        ),
        const SizedBox(height: 12),
        if (!playing)
          FilledButton(onPressed: () => startGame(), child: const Text('게임 시작')),
        if (cards.isNotEmpty)
          Wrap(
            spacing: 8,
            runSpacing: 8,
            children: cards.map((card) {
              return OutlinedButton(
                onPressed: () => pickCard(card),
                child: Text(card.rarity + ' · ' + card.kind + ' · ' + card.name + ' +' + card.value.toString()),
              );
            }).toList(),
          ),
      ],
    );
  }
}

class RoguePainter extends CustomPainter {
  const RoguePainter({
    required this.player,
    required this.camera,
    required this.enemies,
    required this.bullets,
    required this.gems,
    required this.hpRatio,
    required this.magnet,
  });

  final Offset player;
  final Offset camera;
  final List<Enemy> enemies;
  final List<Bullet> bullets;
  final List<ExpGem> gems;
  final double hpRatio;
  final double magnet;

  @override
  void paint(Canvas canvas, Size size) {
    final bg = Paint()..color = const Color(0xFFEDF6FB);
    canvas.drawRRect(RRect.fromRectAndRadius(Offset.zero & size, const Radius.circular(8)), bg);

    canvas.save();
    canvas.translate(-camera.dx, -camera.dy);

    canvas.drawCircle(player, magnet, Paint()..color = const Color(0x18FFD23F));
    for (final gem in gems) {
      canvas.drawCircle(gem.position, 6, Paint()..color = const Color(0xFF37D6A1));
    }
    for (final bullet in bullets) {
      canvas.drawCircle(bullet.position, 5, Paint()..color = const Color(0xFFFFD23F));
    }
    for (final enemy in enemies) {
      canvas.drawCircle(enemy.position, enemy.radius, Paint()..color = const Color(0xFFFF647C));
      canvas.drawCircle(enemy.position.translate(-4, -4), 3, Paint()..color = Colors.white);
    }

    canvas.drawCircle(player, 25, Paint()..color = const Color(0x2937D6A1));
    canvas.drawCircle(player, 18, Paint()..color = const Color(0xFF37D6A1));
    canvas.drawCircle(player, 18, Paint()..style = PaintingStyle.stroke..strokeWidth = 4..color = const Color(0xFFF5F1E7));
    canvas.drawCircle(player.translate(-6, -4), 3, Paint()..color = const Color(0xFF101311));
    canvas.drawCircle(player.translate(6, -4), 3, Paint()..color = const Color(0xFF101311));
    canvas.drawRRect(
      RRect.fromRectAndRadius(Rect.fromCenter(center: player.translate(0, 8), width: 18, height: 8), const Radius.circular(4)),
      Paint()..color = const Color(0xFFFF647C),
    );
    canvas.restore();
    canvas.drawRRect(
      RRect.fromRectAndRadius(const Rect.fromLTWH(12, 12, 130, 10), const Radius.circular(99)),
      Paint()..color = const Color(0xFFE3EDF5),
    );
    canvas.drawRRect(
      RRect.fromRectAndRadius(Rect.fromLTWH(12, 12, 130 * hpRatio.clamp(0, 1), 10), const Radius.circular(99)),
      Paint()..color = const Color(0xFF14B8A6),
    );
  }

  @override
  bool shouldRepaint(covariant RoguePainter oldDelegate) => true;
}

Container(
  padding: const EdgeInsets.all(20),
  decoration: BoxDecoration(
    color: Colors.white,
    border: Border.all(color: const Color(0xFFDCE6EF)),
    borderRadius: BorderRadius.circular(8),
  ),
  child: Column(
    crossAxisAlignment: CrossAxisAlignment.start,
    children: [
      const Text(
        '로그라이크 생존',
        style: TextStyle(fontSize: 22, fontWeight: FontWeight.w900),
      ),
      const SizedBox(height: 14),
      Wrap(
        spacing: 8,
        children: const [Chip(label: Text('무기 검')), Chip(label: Text('Stage 1')), Chip(label: Text('Lv 1'))],
      ),
      const SizedBox(height: 14),
      SizedBox(
        width: 320,
        height: 220,
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            LinearProgressIndicator(value: exp / expNeed),
            const SizedBox(height: 12),
            Wrap(
              spacing: 8,
              children: jobs.map((job) {
                return ChoiceChip(
                  label: Text(job.weapon),
                  selected: hero.weapon == job.weapon,
                  onSelected: (_) => setState(() => hero = job),
                );
              }).toList(),
            ),
            const SizedBox(height: 12),
            Text('공격력 $attackPower · 체력 $hp/$maxHp'),
            const SizedBox(height: 12),
            FilledButton(
              onPressed: attackMonster,
              child: Text('${hero.skill} HP $monsterHp'),
            ),
            if (levelUpCards.isNotEmpty)
              Wrap(children: levelUpCards.map((card) => OutlinedButton(
                onPressed: () => pickCard(card),
                child: Text(card.name),
              )).toList()),
          ],
        ),
      ),
    ],
  ),
)