init

2026-06-15 16:42:28 +03:30
commit 068930c7bd
158 changed files with 5330 additions and 0 deletions
@@ -0,0 +1,615 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:flame/components.dart';
+import 'package:flame/effects.dart';
+import 'package:flame/game.dart';
+import 'package:flutter/material.dart';
+
+import '../game_cubit.dart';
+import '../game_models.dart';
+import 'card_component.dart';
+
+/// صحنه‌ی میز حکم با انیمیشن. شما همیشه پایین میز (rel=0) هستید.
+/// کامپوننت‌های دست و trick ماندگارند و با افکت حرکت جابه‌جا می‌شوند.
+class HokmGame extends FlameGame {
+  final GameCubit cubit;
+  GameState? _s;
+  StreamSubscription? _sub;
+
+  final Map<String, CardComponent> _hand = {}; // کارت‌های دستِ شما (با کد)
+  final Map<String, CardComponent> _trick = {}; // کارت‌های روی زمین (با کد)
+  final List<Component> _backs = []; // پشت‌کارت حریفان
+  final List<Component> _info = []; // نام/امتیاز/حکم/نوبت
+
+  double _cardW = 60;
+  double _cardH = 87;
+
+  double _shake = 0; // شدت تکانِ صفحه (افکت برد با حکم)
+  double _t = 0; // زمان برای نوسان تکان
+  bool _prevTrickDone = false;
+
+  HokmGame(this.cubit);
+
+  @override
+  Color backgroundColor() => const Color(0xFF2C0A10);
+
+  @override
+  Future<void> onLoad() async {
+    add(_Felt());
+    _sub = cubit.stream.listen((ui) {
+      if (ui.state != null) {
+        final s = ui.state!;
+        if (s.trickDone && !_prevTrickDone) _onTrickComplete(s);
+        _prevTrickDone = s.trickDone;
+        _s = s;
+        _relayout();
+      }
+    });
+    if (cubit.state.state != null) {
+      _s = cubit.state.state;
+      _relayout();
+    }
+  }
+
+  @override
+  void update(double dt) {
+    super.update(dt);
+    _t += dt;
+    if (_shake > 0) _shake = math.max(0, _shake - dt * 2.2);
+  }
+
+  @override
+  void render(Canvas canvas) {
+    if (_shake > 0) {
+      final dx = math.sin(_t * 55) * _shake * size.x * 0.018;
+      final dy = math.cos(_t * 70) * _shake * size.y * 0.010;
+      canvas.save();
+      canvas.translate(dx, dy);
+      super.render(canvas);
+      canvas.restore();
+    } else {
+      super.render(canvas);
+    }
+  }
+
+  // هنگام کامل‌شدن یک دست: اگر برنده «بریده» باشد (خالِ زمینه آتو نبوده ولی
+  // کارتِ برنده آتوست — یعنی بازیکن چون خال زمینه را نداشت آتو زد) تکان + رعد.
+  void _onTrickComplete(GameState s) {
+    if (s.trick.length < 4) return;
+    final winner = _winnerCard(s);
+    final cutWithTrump = s.trump != null &&
+        s.leadSuit != s.trump &&
+        _suitName(winner.card) == s.trump;
+    _shake = cutWithTrump ? 1.0 : 0.3;
+    if (cutWithTrump) add(_Lightning());
+  }
+
+  TrickCard _winnerCard(GameState s) {
+    var best = s.trick.first;
+    for (final tc in s.trick.skip(1)) {
+      if (_beats(tc.card, best.card, s.trump, s.leadSuit)) best = tc;
+    }
+    return best;
+  }
+
+  // آیا کارت a کارت b را می‌برد (با توجه به حکم و خال زمینه)؟ مطابق منطق سرور.
+  bool _beats(String a, String b, String? trump, String? lead) {
+    final aT = _suitName(a) == trump, bT = _suitName(b) == trump;
+    if (aT && !bT) return true;
+    if (!aT && bT) return false;
+    if (aT && bT) return _rankValue(a) > _rankValue(b);
+    if (_suitName(a) != lead) return false;
+    if (_suitName(b) != lead) return true;
+    return _rankValue(a) > _rankValue(b);
+  }
+
+  @override
+  void onGameResize(Vector2 size) {
+    super.onGameResize(size);
+    if (isLoaded) _relayout();
+  }
+
+  @override
+  void onRemove() {
+    _sub?.cancel();
+    super.onRemove();
+  }
+
+  int _rel(int seat) => (seat - _s!.yourSeat + 4) % 4;
+
+  static String _suitName(String code) {
+    switch (code[code.length - 1]) {
+      case 'H':
+        return 'hearts';
+      case 'D':
+        return 'diamonds';
+      case 'C':
+        return 'clubs';
+      default:
+        return 'spades';
+    }
+  }
+
+  bool _legal(String code) {
+    final s = _s!;
+    if (s.phase != 'playing' || s.trickDone || !s.isMyTurn) return false;
+    final lead = s.leadSuit;
+    if (lead == null || lead.isEmpty) return true;
+    final hasLead = s.yourHand.any((c) => _suitName(c) == lead);
+    return !hasLead || _suitName(code) == lead;
+  }
+
+  void _relayout() {
+    final s = _s;
+    if (s == null) return;
+    _cardW = size.x * 0.19; // کارت‌های بزرگ‌تر (مطابق تصویر مرجع)
+    _cardH = _cardW * kCardRatio;
+
+    _rebuildBacksAndInfo(s);
+    _layoutTrick(s);
+    _layoutHand(s);
+  }
+
+  // افکت حرکت بدون انباشته‌شدن.
+  void _moveTo(CardComponent c, Vector2 target, {double dur = 0.38}) {
+    c.children.whereType<MoveToEffect>().toList().forEach((e) => e.removeFromParent());
+    if ((c.position - target).length < 0.5) {
+      c.position = target;
+      return;
+    }
+    c.add(MoveToEffect(
+        target, EffectController(duration: dur, curve: Curves.easeOutCubic)));
+  }
+
+  // ترتیب خال‌ها برای چیدنِ دست (سیاه/قرمز متناوب تا تفکیک بصری راحت‌تر باشد).
+  static const _suitOrder = {'S': 0, 'H': 1, 'C': 2, 'D': 3};
+
+  static int _rankValue(String code) {
+    switch (code.substring(0, code.length - 1)) {
+      case 'A':
+        return 14;
+      case 'K':
+        return 13;
+      case 'Q':
+        return 12;
+      case 'J':
+        return 11;
+      default:
+        return int.tryParse(code.substring(0, code.length - 1)) ?? 0;
+    }
+  }
+
+  static int _cardCompare(String a, String b) {
+    final sa = _suitOrder[a[a.length - 1]] ?? 0;
+    final sb = _suitOrder[b[b.length - 1]] ?? 0;
+    if (sa != sb) return sa - sb;
+    return _rankValue(a) - _rankValue(b);
+  }
+
+  void _layoutHand(GameState s) {
+    // کارت‌های دست بر اساس خال و سپس رتبه مرتب می‌شوند تا کار بازیکن راحت‌تر باشد.
+    final codes = List<String>.from(s.yourHand)..sort(_cardCompare);
+    final n = codes.length;
+
+    // کارت‌هایی که دیگر در دست نیستند و به trick هم نرفته‌اند ⇒ حذف.
+    for (final code in _hand.keys.toList()) {
+      if (!codes.contains(code)) {
+        final c = _hand.remove(code)!;
+        if (!_trick.containsKey(code)) c.removeFromParent();
+      }
+    }
+
+    final handW = size.x * 0.72;
+    final step = n > 1 ? (handW - _cardW) / (n - 1) : 0.0;
+    final startX = size.x / 2 - (step * (n - 1)) / 2;
+    final y = size.y * 0.84;
+
+    for (var i = 0; i < n; i++) {
+      final code = codes[i];
+      final target = Vector2(startX + i * step, y);
+      final legal = _legal(code);
+      final dim = s.phase == 'playing' && s.isMyTurn && !legal;
+      var c = _hand[code];
+      if (c == null) {
+        // کارت جدید ⇒ از مرکز میز پخش می‌شود.
+        c = CardComponent(
+          code: code,
+          faceUp: true,
+          size: Vector2(_cardW, _cardH),
+          position: size / 2,
+        );
+        _hand[code] = c;
+        add(c);
+      } else {
+        c.size = Vector2(_cardW, _cardH);
+      }
+      c.onTap = legal ? () => cubit.playCard(code) : null;
+      c.dimmed = dim;
+      c.priority = 10 + i;
+      _moveTo(c, target);
+    }
+  }
+
+  void _layoutTrick(GameState s) {
+    final present = s.trick.map((t) => t.card).toSet();
+
+    // کارت‌های trick که دیگر نیستند (دست جمع شد) ⇒ به سمت برنده (نوبت بعدی) برو و حذف شو.
+    for (final code in _trick.keys.toList()) {
+      if (!present.contains(code)) {
+        final c = _trick.remove(code)!;
+        final winnerOrigin = _seatOrigin(_rel(s.turn));
+        c.children.whereType<MoveToEffect>().toList().forEach((e) => e.removeFromParent());
+        c.add(SequenceEffect([
+          MoveToEffect(winnerOrigin,
+              EffectController(duration: 0.25, curve: Curves.easeIn)),
+          RemoveEffect(),
+        ]));
+      }
+    }
+
+    for (final tc in s.trick) {
+      final slot = size / 2 + _trickOffset(_rel(tc.seat));
+      var c = _trick[tc.card];
+      if (c == null) {
+        // اگر خودِ شما بازی کردید، همان کارتِ دست را منتقل کن (پرواز به وسط).
+        c = _hand.remove(tc.card);
+        if (c != null) {
+          c.onTap = null;
+          c.dimmed = false;
+        } else {
+          c = CardComponent(
+            code: tc.card,
+            faceUp: true,
+            size: Vector2(_cardW, _cardH),
+            position: _seatOrigin(_rel(tc.seat)),
+          );
+          add(c);
+        }
+        _trick[tc.card] = c;
+      }
+      c.size = Vector2(_cardW, _cardH);
+      c.priority = 5;
+      _moveTo(c, slot);
+    }
+  }
+
+  Vector2 _seatOrigin(int rel) {
+    final c = size / 2;
+    switch (rel) {
+      case 1:
+        return Vector2(size.x * 0.10, c.y);
+      case 2:
+        return Vector2(c.x, size.y * 0.14);
+      case 3:
+        return Vector2(size.x * 0.90, c.y);
+      default:
+        return Vector2(c.x, size.y * 0.82);
+    }
+  }
+
+  Vector2 _trickOffset(int rel) {
+    final d = _cardW * 0.62;
+    switch (rel) {
+      case 1:
+        return Vector2(-d, 0);
+      case 2:
+        return Vector2(0, -d);
+      case 3:
+        return Vector2(d, 0);
+      default:
+        return Vector2(0, d);
+    }
+  }
+
+  void _rebuildBacksAndInfo(GameState s) {
+    for (final c in _backs) {
+      c.removeFromParent();
+    }
+    for (final c in _info) {
+      c.removeFromParent();
+    }
+    _backs.clear();
+    _info.clear();
+
+    // پشت‌کارت حریفان
+    for (var seat = 0; seat < 4; seat++) {
+      if (seat == s.yourSeat) continue;
+      final rel = _rel(seat);
+      final count = seat < s.handCounts.length ? s.handCounts[seat] : 0;
+      _addBacks(rel, count);
+    }
+    _addTricksWon(s);
+    _addScorePucks(s);
+    _addInfo(s);
+  }
+
+  // شمارنده ۱: دست‌های برده‌ی این هَند (tricks_won) — دسته‌کارتِ پشت‌رو + عدد.
+  // با هر دست یکی اضافه می‌شود؛ رسیدن به ۷ یعنی پایان هَند (سرور صفر می‌کند).
+  void _addTricksWon(GameState s) {
+    const gold = Color(0xFFE9B949);
+    for (var team = 0; team < 2; team++) {
+      final won = team < s.tricksWon.length ? s.tricksWon[team] : 0;
+      if (won <= 0) continue;
+      final mine = team == s.yourSeat % 2;
+      final w = _cardW * 0.40, h = w * kCardRatio;
+      final base = mine
+          ? Vector2(size.x * 0.30, size.y * 0.60)
+          : Vector2(size.x * 0.70, size.y * 0.40);
+      final step = Vector2(w * 0.40, 0);
+      final n = won.clamp(1, 7);
+      final start = base - step * ((n - 1) / 2);
+      for (var i = 0; i < n; i++) {
+        final c = CardComponent(
+          code: '',
+          faceUp: false,
+          size: Vector2(w, h),
+          position: start + step * i.toDouble(),
+          priority: 2,
+        );
+        _backs.add(c);
+        add(c);
+      }
+      final badge = TextComponent(
+        text: '$won',
+        anchor: Anchor.center,
+        position: base - Vector2(0, h * 0.7),
+        priority: 21,
+        textRenderer: TextPaint(
+          style: TextStyle(
+            fontFamily: 'Dana',
+            color: gold,
+            fontSize: _cardW * 0.34,
+            fontWeight: FontWeight.bold,
+            shadows: const [Shadow(color: Colors.black, blurRadius: 4)],
+          ),
+        ),
+      );
+      _info.add(badge);
+      add(badge);
+    }
+  }
+
+  // شمارنده ۲: امتیاز بازی (scores = هندهای برده) — دیسک مرکزیِ هر تیم، ۰ تا ۷.
+  // رسیدن به ۷ یعنی پایان کل بازی.
+  void _addScorePucks(GameState s) {
+    final radius = size.x * 0.05;
+    for (var team = 0; team < 2; team++) {
+      final score = team < s.scores.length ? s.scores[team] : 0;
+      final mine = team == s.yourSeat % 2;
+      final pos = mine
+          ? Vector2(size.x / 2, size.y * 0.72) // تیم شما: پایینِ مرکز
+          : Vector2(size.x / 2, size.y * 0.28); // تیم حریف: بالای مرکز
+      final puck = _Puck(score, radius: radius, position: pos)..priority = 22;
+      _info.add(puck);
+      add(puck);
+    }
+  }
+
+  void _addBacks(int rel, int count) {
+    if (count <= 0) return;
+    final n = count.clamp(1, 13);
+    final w = _cardW * 0.7, h = _cardH * 0.7;
+    final c = size / 2;
+    Vector2 base, stepV;
+    switch (rel) {
+      case 2:
+        base = Vector2(c.x, size.y * 0.12);
+        stepV = Vector2(size.x * 0.45 / 13, 0);
+        break;
+      case 1:
+        base = Vector2(size.x * 0.07, c.y);
+        stepV = Vector2(0, size.y * 0.4 / 13);
+        break;
+      default:
+        base = Vector2(size.x * 0.93, c.y);
+        stepV = Vector2(0, size.y * 0.4 / 13);
+    }
+    final start = base - stepV * ((n - 1) / 2);
+    for (var i = 0; i < n; i++) {
+      final comp = CardComponent(
+        code: '',
+        faceUp: false,
+        size: Vector2(w, h),
+        position: start + stepV * i.toDouble(),
+        priority: 1,
+      );
+      _backs.add(comp);
+      add(comp);
+    }
+  }
+
+  void _addInfo(GameState s) {
+    void addText(String text, Vector2 pos, double fs, Color color,
+        {Anchor anchor = Anchor.center, bool bold = false}) {
+      final t = TextComponent(
+        text: text,
+        anchor: anchor,
+        position: pos,
+        priority: 20,
+        textRenderer: TextPaint(
+            style: TextStyle(
+                fontFamily: 'Dana',
+                color: color,
+                fontSize: fs,
+                fontWeight: bold ? FontWeight.bold : FontWeight.normal)),
+      );
+      _info.add(t);
+      add(t);
+    }
+
+    if (s.trump != null) {
+      final (sym, col) = _trumpGlyph(s.trump!);
+      addText('حکم: $sym', Vector2(size.x * 0.04, size.y * 0.04), size.x * 0.05,
+          col, anchor: Anchor.topLeft, bold: true);
+    }
+    addText(
+        '${s.scores.isNotEmpty ? s.scores[0] : 0} - ${s.scores.length > 1 ? s.scores[1] : 0}',
+        Vector2(size.x / 2, size.y * 0.04),
+        size.x * 0.05,
+        const Color(0xFFE9B949),
+        anchor: Anchor.topCenter);
+
+    for (final p in s.players) {
+      final rel = _rel(p.seat);
+      final pos = _seatLabelPos(rel);
+      final isTurn = s.turn == p.seat;
+      addText(
+        '${p.name}${p.bot ? ' (ربات)' : ''}${p.connected ? '' : ' …'}',
+        pos,
+        size.x * 0.035,
+        isTurn ? const Color(0xFFE9B949) : Colors.white70,
+        bold: isTurn,
+      );
+      if (isTurn) {
+        final dot = CircleComponent(
+          radius: size.x * 0.012,
+          anchor: Anchor.center,
+          position: pos - Vector2(0, size.y * 0.03),
+          paint: Paint()..color = const Color(0xFFE9B949),
+        )..priority = 20;
+        _info.add(dot);
+        add(dot);
+      }
+    }
+  }
+
+  Vector2 _seatLabelPos(int rel) {
+    switch (rel) {
+      case 1:
+        return Vector2(size.x * 0.07, size.y * 0.30);
+      case 2:
+        return Vector2(size.x / 2, size.y * 0.07);
+      case 3:
+        return Vector2(size.x * 0.93, size.y * 0.30);
+      default:
+        return Vector2(size.x / 2, size.y * 0.975);
+    }
+  }
+
+  (String, Color) _trumpGlyph(String suit) {
+    switch (suit) {
+      case 'hearts':
+        return ('♥', const Color(0xFFD32F2F));
+      case 'diamonds':
+        return ('♦', const Color(0xFFD32F2F));
+      case 'clubs':
+        return ('♣', Colors.white);
+      default:
+        return ('♠', Colors.white);
+    }
+  }
+}
+
+/// افکت رعد روی زمین هنگام برد با حکم؛ پس از مدت کوتاهی خودش حذف می‌شود.
+class _Lightning extends PositionComponent with HasGameReference {
+  double _life = 0.55;
+  static const _max = 0.55;
+  final _rng = math.Random();
+  final List<List<Offset>> _bolts = [];
+
+  @override
+  Future<void> onLoad() async {
+    size = game.size;
+    final center = Offset(size.x / 2, size.y / 2);
+    for (var i = 0; i < 3; i++) {
+      // هر رعد یک خط شکسته از یک نقطه‌ی تصادفیِ کناری به سمت مرکز.
+      final start = Offset(_rng.nextDouble() * size.x, _rng.nextDouble() * size.y * 0.4);
+      final pts = <Offset>[start];
+      const segs = 6;
+      for (var s = 1; s <= segs; s++) {
+        final t = s / segs;
+        final base = Offset.lerp(start, center, t)!;
+        final jitter = (1 - t) * size.x * 0.06;
+        pts.add(base + Offset((_rng.nextDouble() - 0.5) * jitter, (_rng.nextDouble() - 0.5) * jitter));
+      }
+      _bolts.add(pts);
+    }
+  }
+
+  @override
+  void update(double dt) {
+    _life -= dt;
+    if (_life <= 0) removeFromParent();
+  }
+
+  @override
+  void render(Canvas canvas) {
+    final op = (_life / _max).clamp(0.0, 1.0);
+    final glow = Paint()
+      ..color = const Color(0xFFFFE082).withValues(alpha: op * 0.5)
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = size.x * 0.02
+      ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 6);
+    final core = Paint()
+      ..color = const Color(0xFFFFFDE7).withValues(alpha: op)
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = size.x * 0.006
+      ..strokeCap = StrokeCap.round;
+    for (final bolt in _bolts) {
+      final path = Path()..moveTo(bolt.first.dx, bolt.first.dy);
+      for (final p in bolt.skip(1)) {
+        path.lineTo(p.dx, p.dy);
+      }
+      canvas.drawPath(path, glow);
+      canvas.drawPath(path, core);
+    }
+  }
+}
+
+/// دیسکِ فلزیِ شمارش دست‌های برده‌ی یک تیم (۰ تا ۷).
+class _Puck extends PositionComponent {
+  final int count;
+  _Puck(this.count, {required double radius, super.position})
+      : super(size: Vector2.all(radius * 2), anchor: Anchor.center);
+
+  @override
+  void render(Canvas canvas) {
+    final r = size.x / 2;
+    final c = Offset(r, r);
+    canvas.drawCircle(c, r, Paint()..color = const Color(0xFF14110F));
+    canvas.drawCircle(
+      c,
+      r * 0.92,
+      Paint()
+        ..style = PaintingStyle.stroke
+        ..strokeWidth = r * 0.22
+        ..color = const Color(0xFFB8860B),
+    );
+    final tp = TextPainter(
+      text: TextSpan(
+        text: '$count',
+        style: TextStyle(
+          fontFamily: 'Dana',
+          color: const Color(0xFFE9B949),
+          fontSize: r * 1.05,
+          fontWeight: FontWeight.bold,
+        ),
+      ),
+      textDirection: TextDirection.ltr,
+    )..layout();
+    tp.paint(canvas, c - Offset(tp.width / 2, tp.height / 2));
+  }
+}
+
+/// نمدِ سبز میز.
+class _Felt extends PositionComponent with HasGameReference {
+  @override
+  void render(Canvas canvas) {
+    final w = game.size.x, h = game.size.y;
+    final rect = Rect.fromCenter(
+      center: Offset(w / 2, h / 2),
+      width: w * 0.86,
+      height: h * 0.62,
+    );
+    final rrect = RRect.fromRectAndRadius(rect, Radius.circular(h * 0.3));
+    canvas.drawRRect(rrect, Paint()..color = const Color(0xFF1B5E20));
+    canvas.drawRRect(
+      rrect,
+      Paint()
+        ..style = PaintingStyle.stroke
+        ..strokeWidth = 6
+        ..color = const Color(0xFFB8860B),
+    );
+  }
+}