653 lines
26 KiB
Dart
653 lines
26 KiB
Dart
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 'package:flutter/services.dart' show HapticFeedback;
|
|
|
|
import '../../../../../core/service/app_sounds.dart';
|
|
import '../../../../../core/settings/app_settings.dart';
|
|
import '../../../../../core/theme/app_theme.dart';
|
|
import '../../../domain/entities/game_entities.dart';
|
|
import '../../bloc/game_bloc.dart';
|
|
import 'anim_gate.dart';
|
|
import 'card_codes.dart';
|
|
import 'card_component.dart';
|
|
import 'cut_fx.dart';
|
|
import 'shuffle_animation.dart';
|
|
import 'table_pieces.dart';
|
|
import 'turn_heartbeat.dart';
|
|
|
|
/// صحنهی میز حکم با انیمیشن. شما همیشه پایین میز (rel=0) هستید.
|
|
/// کامپوننتهای دست و trick ماندگارند و با افکت حرکت جابهجا میشوند.
|
|
///
|
|
/// این کلاس فقط «وضعیتِ سرور → چیدمانِ صحنه» را مدیریت میکند:
|
|
/// - [_layoutHand] / [_layoutTrick] کارتهای دست و زمین (ماندگار، با انیمیشن).
|
|
/// - [_rebuildBacksAndInfo] عناصرِ بازساختهشونده (پشتکارت، شمارندهها، برچسبها).
|
|
/// - [_checkCut] + [update]/[render] افکتِ «بریدن با حکم» (تکان + رعد).
|
|
class HokmGame extends FlameGame {
|
|
final GameBloc cubit;
|
|
|
|
/// اسکینِ کارت (از فروشگاه/کیفپول انتخاب میشود)؛ تصاویر از backend میآیند.
|
|
final String skin;
|
|
|
|
// وضعیت بازی و اشتراکِ stream.
|
|
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;
|
|
List<String> _prevTrick = const [];
|
|
bool _highlightedTrick = false; // آیا کارتِ برندهی دستِ کامل هایلایت شده (یکبار)
|
|
// افکتِ بریدن با حکم: کمبوِ روبُریدن + آتش + «مکثِ آتش» (منطق در CutFx جدا شده).
|
|
final CutFx _cut = CutFx();
|
|
int _prevHandSize = 0; // برای تشخیصِ پخشِ کارت (دستِ جدید) جهت صدای بُر زدن
|
|
String _prevHandSig = ''; // امضای دست؛ برای تشخیصِ بُرِ مجدد (تغییرِ ۵ کارت در فازِ حکم)
|
|
bool _silent = false; // هنگام خروج از میز، دیگر صدایی پخش نشود
|
|
String? _prevTrump; // برای تشخیصِ لحظهی انتخابِ حکم
|
|
|
|
// دروازهی انیمیشن (اینترو/بُر/پخش) — منطق در AnimGate جدا شده است.
|
|
final AnimGate _anim = AnimGate();
|
|
|
|
/// آیا انیمیشنی در حال اجراست؛ صفحه از این برای پنهانکردنِ دیالوگِ حکم استفاده میکند.
|
|
ValueNotifier<bool> get animating => _anim.animating;
|
|
|
|
// ضربانِ قلبِ نوبتِ کاربر (منطق در TurnHeartbeat جدا شده است).
|
|
final TurnHeartbeat _heart = TurnHeartbeat();
|
|
|
|
/// URL کاملِ تصویرِ فرش (از سرور)؛ خالی یعنی میزِ ترسیمیِ کلاسیک. فرشِ تصویری
|
|
/// بهعنوانِ سطحِ میز (بریده در شکلِ میز) روی زمینِ لاجوردی کشیده میشود.
|
|
final String carpetUrl;
|
|
|
|
HokmGame(this.cubit, {this.skin = 'simple', this.carpetUrl = ''});
|
|
|
|
@override
|
|
Color backgroundColor() => AppColors.lapisNight;
|
|
|
|
@override
|
|
Future<void> onLoad() async {
|
|
add(Felt(carpetUrl: carpetUrl));
|
|
if (!AppSettings.I.lowGraphics.value) {
|
|
add(Motes()); // ذراتِ طلاییِ معلق برای اتمسفر (در حالتِ کممصرف خاموش)
|
|
}
|
|
_sub = cubit.stream.listen((ui) {
|
|
if (ui.state == null) return;
|
|
final s = ui.state!;
|
|
// در حینِ «مکثِ آتش»، آخرین وضعیت را بافر کن و بعد از مکث اعمالش کن.
|
|
if (_cut.holding) {
|
|
_cut.pending = s;
|
|
return;
|
|
}
|
|
_applyState(s);
|
|
});
|
|
if (cubit.state.state != null) {
|
|
_prevTrick = cubit.state.state!.trick.map((t) => t.card).toList();
|
|
_prevHandSize = cubit.state.state!.yourHand.length;
|
|
_prevHandSig = (cubit.state.state!.yourHand.toList()..sort()).join(',');
|
|
_prevTrump = cubit.state.state!.trump;
|
|
_s = cubit.state.state;
|
|
_relayout();
|
|
}
|
|
}
|
|
|
|
/// اعمالِ یک وضعیتِ بازی روی صحنه (صداها/انیمیشنها + چیدمانِ دوباره). در حالتِ
|
|
/// عادی مستقیم از استریم صدا زده میشود؛ در «مکثِ آتش» پس از پایانِ مکث.
|
|
void _applyState(GameState s) {
|
|
_checkTrickSounds(s);
|
|
// شروعِ دستِ جدید (پخشِ کارت): انیمیشن و صدای بُر زدن.
|
|
// دستِ اول تا پایانِ نمایشِ «جستجوی حریف» به تعویق میافتد تا انیمیشن
|
|
// زیرِ اوورلی پنهان نشود و صدا با تصویر هماهنگ باشد.
|
|
if (_prevHandSize == 0 && s.yourHand.isNotEmpty && !_silent) {
|
|
if (_anim.introActive) {
|
|
_anim.markPendingShuffle();
|
|
} else {
|
|
_shuffleNow();
|
|
}
|
|
}
|
|
// بُرِ مجدد: هنوز در فازِ حکم هستیم اما ۵ کارتِ حاکم عوض شده ⇒ انیمیشنِ بُر دوباره.
|
|
final sig = (s.yourHand.toList()..sort()).join(',');
|
|
if (!_silent &&
|
|
!_anim.introActive &&
|
|
s.phase == 'choose_trump' &&
|
|
s.trump == null &&
|
|
_prevHandSize > 0 &&
|
|
_prevHandSig.isNotEmpty &&
|
|
sig != _prevHandSig) {
|
|
_shuffleNow();
|
|
}
|
|
_prevHandSig = sig;
|
|
// لحظهی انتخابِ حکم: صدا + نمایشِ بزرگِ حکم در مرکز.
|
|
if (_prevTrump == null && s.trump != null && !_silent) {
|
|
AppSounds.selectHokm();
|
|
_spawnTrumpReveal(s.trump!);
|
|
_dealAllNow(); // پخشِ بقیهی کارتها (بازی تا پایانِ آن قفل است)
|
|
}
|
|
_prevTrump = s.trump;
|
|
_prevHandSize = s.yourHand.length;
|
|
_s = s;
|
|
_relayout();
|
|
}
|
|
|
|
@override
|
|
void onGameResize(Vector2 size) {
|
|
super.onGameResize(size);
|
|
if (isLoaded) _relayout();
|
|
}
|
|
|
|
@override
|
|
void onRemove() {
|
|
_sub?.cancel();
|
|
AppSounds.stopHeartBeat();
|
|
super.onRemove();
|
|
}
|
|
|
|
// ===== صداها و افکتِ بریدن با حکم (تکان + رعد) =====
|
|
|
|
// با هر تغییرِ زمین: افزودنِ کارت ⇒ صدای گذاشتن/انداختن (و بریدن با حکم ⇒
|
|
// شمشیر + تکان + رعد)؛ خالیشدنِ زمین ⇒ صدای جمعشدنِ دست.
|
|
void _checkTrickSounds(GameState s) {
|
|
final now = s.trick.map((t) => t.card).toList();
|
|
// در زمانِ اینترو/بُر زدن/پخش، کارتی روی میز نشان داده نمیشود ⇒ صدا هم نه.
|
|
if (_silent || _anim.busy) {
|
|
_prevTrick = now;
|
|
return;
|
|
}
|
|
final addedOne =
|
|
now.length == _prevTrick.length + 1 && _isPrefix(_prevTrick, now);
|
|
if (now.length <= 1) _cut.resetTrick(); // دستِ جدید ⇒ ریستِ بالاترین حکم
|
|
if (addedOne) {
|
|
final card = s.trick.last;
|
|
// بریدن: خالِ راهبر حکم نیست و کارتِ بازیشده حکم است.
|
|
final isTrump = s.trump != null &&
|
|
s.leadSuit != null &&
|
|
s.leadSuit != s.trump &&
|
|
suitName(card.card) == s.trump;
|
|
final rank = isTrump ? rankValue(card.card) : 0;
|
|
// افکتِ بریدن فقط وقتی حکمِ بازیشده «دست را میبرد» (اولین بریدن یا روبُریدنِ
|
|
// بالاتر). حکمِ پایینتر (بازنده) فقط صدای گذاشتن.
|
|
if (isTrump && _cut.registerWinningCut(rank, _t)) {
|
|
_shake = 1.0;
|
|
add(Lightning());
|
|
if (!AppSettings.I.lowGraphics.value) {
|
|
add(CutBurst()); // فلاش + شوکویو + جرقه (کممصرف: خاموش)
|
|
// سه بریدنِ پیاپی یا بیشتر ⇒ افکتِ آتش (هرچه کمبو بیشتر، شعله بلندتر).
|
|
if (_cut.combo >= 3) {
|
|
_shake = 1.4; // تکانِ قویتر برای اوجِ کمبو
|
|
add(FireBurst(intensity: _cut.combo));
|
|
// مکثِ کوتاه پس از آتش تا لحظه دیده شود؛ کارتِ بعدی (کاربر یا بات)
|
|
// تا پایانِ مکث اعمال نمیشود.
|
|
_cut.startHold(_t);
|
|
}
|
|
}
|
|
AppSounds.cut(); // بریدن با حکم (شمشیر)
|
|
HapticFeedback.heavyImpact(); // ضربهی لمسیِ بُرِش با حکم
|
|
} else {
|
|
AppSounds.placeCard(); // کارت روی میز نشست
|
|
}
|
|
} else if (now.isEmpty && _prevTrick.isNotEmpty) {
|
|
AppSounds.takeCard(); // دستِ کامل جمع شد
|
|
}
|
|
_prevTrick = now;
|
|
}
|
|
|
|
/// قطعِ صداهای بازی هنگام خروج از میز (جلوگیری از پخشِ صدای کارت پس از ترک).
|
|
void silence() {
|
|
_silent = true;
|
|
_cut.clearHold(); // مکثِ آتش را لغو کن تا وضعیتِ بافرشده اعمال/رها نشود
|
|
AppSounds.stopHeartBeat();
|
|
}
|
|
|
|
/// پایانِ نمایشِ «جستجوی حریف»؛ اگر بُرِ دستِ اول به تعویق افتاده بود، اکنون
|
|
/// (که اوورلی کنار رفته) با صدا و تصویرِ هماهنگ اجرا میشود.
|
|
void endIntro() {
|
|
if (_anim.endIntro() && !_silent) _shuffleNow();
|
|
}
|
|
|
|
/// اجرای همزمانِ انیمیشن و صدای بُر زدن (صدا با پایانِ انیمیشن قطع میشود).
|
|
/// در طولِ انیمیشن، بازیِ کارت قفل است تا کارتی وسطِ بُر زدن انداخته نشود.
|
|
void _shuffleNow() {
|
|
if (_silent) return;
|
|
AppSounds.shuffle(cutoffMs: ShuffleAnimation.totalMs);
|
|
add(ShuffleAnimation(size));
|
|
_anim.beginShuffle();
|
|
Future.delayed(const Duration(milliseconds: ShuffleAnimation.totalMs), () {
|
|
_anim.endShuffle();
|
|
if (_s != null && !_silent) _relayout(); // فعالسازیِ دوبارهی کارتها
|
|
});
|
|
}
|
|
|
|
/// پخشِ بقیهی کارتها پس از انتخابِ حکم؛ تا پایانِ انیمیشن بازیِ کارت قفل است.
|
|
void _dealAllNow() {
|
|
if (_silent) return;
|
|
AppSounds.shuffle(cutoffMs: ShuffleAnimation.dealMs);
|
|
add(ShuffleAnimation(size, dealOnly: true));
|
|
_anim.beginDeal();
|
|
Future.delayed(const Duration(milliseconds: ShuffleAnimation.dealMs), () {
|
|
_anim.endDeal();
|
|
if (_s != null && !_silent) _relayout();
|
|
});
|
|
}
|
|
|
|
/// نمایشِ بزرگ و گذرای حکمِ انتخابشده در مرکزِ میز (با پاپ).
|
|
void _spawnTrumpReveal(String trump) {
|
|
final (sym, col) = suitGlyph(trump);
|
|
final reveal = TextComponent(
|
|
text: 'حکم $sym',
|
|
anchor: Anchor.center,
|
|
position: size / 2 - Vector2(0, size.y * 0.10),
|
|
priority: 7000,
|
|
scale: Vector2.all(0.4),
|
|
textRenderer: TextPaint(
|
|
style: TextStyle(
|
|
fontFamily: 'Dana',
|
|
color: col,
|
|
fontSize: size.x * 0.11,
|
|
fontWeight: FontWeight.bold,
|
|
shadows: const [Shadow(color: Colors.black, blurRadius: 6)],
|
|
),
|
|
),
|
|
);
|
|
reveal.add(
|
|
ScaleEffect.to(
|
|
Vector2.all(1.0),
|
|
EffectController(duration: 0.35, curve: Curves.easeOutBack),
|
|
),
|
|
);
|
|
reveal.add(RemoveEffect(delay: 1.3));
|
|
add(reveal);
|
|
}
|
|
|
|
static bool _isPrefix(List<String> a, List<String> b) {
|
|
for (var i = 0; i < a.length; i++) {
|
|
if (a[i] != b[i]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@override
|
|
void update(double dt) {
|
|
super.update(dt);
|
|
_t += dt;
|
|
// پایانِ «مکثِ آتش»: آخرین وضعیتِ بافرشده را اعمال کن (یا صحنه را تازه کن).
|
|
if (_cut.holdExpired(_t)) {
|
|
_cut.holding = false;
|
|
final p = _cut.pending;
|
|
_cut.pending = null;
|
|
if (!_silent) {
|
|
if (p != null) {
|
|
_applyState(p);
|
|
} else if (_s != null) {
|
|
_relayout();
|
|
}
|
|
}
|
|
}
|
|
if (_shake > 0) _shake = math.max(0, _shake - dt * 2.2);
|
|
_heart.update(dt, _s,
|
|
silent: _silent, busy: _anim.busy);
|
|
}
|
|
|
|
@override
|
|
void render(Canvas canvas) {
|
|
if (_shake <= 0) {
|
|
super.render(canvas);
|
|
return;
|
|
}
|
|
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();
|
|
}
|
|
|
|
// ===== چیدمان =====
|
|
|
|
// جایگاهِ نسبیِ یک seat نسبت به شما: 0=پایین، 1=چپ، 2=بالا، 3=راست.
|
|
int _rel(int seat) => (seat - _s!.yourSeat + 4) % 4;
|
|
|
|
void _relayout() {
|
|
final s = _s;
|
|
if (s == null) return;
|
|
_cardW = size.x * 0.22; // کارتهای روی میز بزرگتر (دیدِ بهتر)
|
|
_cardH = _cardW * kCardRatio;
|
|
|
|
_rebuildBacksAndInfo(s);
|
|
_layoutTrick(s);
|
|
_layoutHand(s);
|
|
}
|
|
|
|
// آیا این کارت در نوبتِ فعلی قابل بازی است (با رعایت follow-suit)؟
|
|
bool _legal(String code) {
|
|
final s = _s!;
|
|
// هنگامِ اینترو/بُر زدن/پخشِ کارتها یا مکثِ آتش، بازیِ کارت مجاز نیست.
|
|
if (_anim.busy || _cut.holding) return false;
|
|
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 _moveTo(CardComponent c, Vector2 target,
|
|
{double dur = 0.38, bool bounce = false}) {
|
|
c.children.whereType<MoveToEffect>().toList().forEach(
|
|
(e) => e.removeFromParent(),
|
|
);
|
|
if ((c.position - target).length < 0.5) {
|
|
c.position = target;
|
|
return;
|
|
}
|
|
// کارتِ تازهنشسته روی میز با کمی overshoot مینشیند (حسِ «جا افتادن»).
|
|
c.add(
|
|
MoveToEffect(
|
|
target,
|
|
EffectController(
|
|
duration: dur, curve: bounce ? Curves.easeOutBack : Curves.easeOutCubic),
|
|
),
|
|
);
|
|
}
|
|
|
|
// ناحیهی وسط میز که رهاکردنِ کارت در آن یعنی بازی (بالاتر از دستِ شما).
|
|
Rect _dropZone() =>
|
|
Rect.fromLTRB(size.x * 0.15, size.y * 0.22, size.x * 0.85, size.y * 0.66);
|
|
|
|
void _layoutHand(GameState s) {
|
|
// در زمانِ اینترو/بُر زدنِ ابتدای هَند، کارتهای دست پنهاناند و پس از پایانِ
|
|
// بُر زدن «پخش» میشوند (میآیند). در زمانِ پخشِ بقیهی کارتها مخفی نمیشوند.
|
|
if (_anim.cardsHidden) {
|
|
for (final c in _hand.values.toList()) {
|
|
c.removeFromParent();
|
|
}
|
|
_hand.clear();
|
|
return;
|
|
}
|
|
// مرتبسازی بر اساس خال و رتبه تا انتخاب برای بازیکن راحتتر باشد.
|
|
final codes = List<String>.from(s.yourHand)..sort(compareCards);
|
|
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 hw = size.x * 0.24, hh = hw * kCardRatio;
|
|
final cx = size.x / 2;
|
|
final baseY = size.y * 0.86;
|
|
final tMax = (n - 1) / 2;
|
|
// زاویهی بینِ کارتها؛ با تعدادِ زیاد جمعتر میشود تا بادبزن بیشازحد باز نشود.
|
|
final perCard = n > 1 ? (0.9 / (n - 1)).clamp(0.0, 0.11) : 0.0;
|
|
final maxA = perCard * tMax;
|
|
// شعاعِ قوس از عرضِ گسترشِ دست مشتق میشود تا فاصلهها متوازن بماند.
|
|
final spreadX = size.x * 0.86 - hw;
|
|
final radius = maxA > 0.01 ? (spreadX / 2) / math.sin(maxA) : size.y;
|
|
final pivotY = baseY + radius;
|
|
|
|
for (var i = 0; i < n; i++) {
|
|
final code = codes[i];
|
|
final a = (i - tMax) * perCard; // زاویهی این کارت روی قوس
|
|
final target = Vector2(
|
|
cx + radius * math.sin(a),
|
|
pivotY - radius * math.cos(a),
|
|
);
|
|
final legal = _legal(code);
|
|
var c = _hand[code];
|
|
final isNew = c == null;
|
|
if (c == null) {
|
|
// کارت جدید ⇒ پشترو از مرکز میز (دسته) پخش میشود و سپس رو میگردد.
|
|
c = CardComponent(
|
|
code: code,
|
|
faceUp: false,
|
|
skin: skin,
|
|
size: Vector2(hw, hh),
|
|
position: size / 2,
|
|
);
|
|
_hand[code] = c;
|
|
add(c);
|
|
} else {
|
|
c.size = Vector2(hw, hh);
|
|
}
|
|
c.angle = a; // چرخشِ کارت همراستا با شعاعِ قوس
|
|
c.homeAngle = a; // زاویهی مرجع برای بازگشت پس از کشیدنِ ناقص
|
|
c.onPlay = legal ? () => cubit.playCard(code) : null;
|
|
c.dimmed = s.phase == 'playing' && s.isMyTurn && !legal;
|
|
c.home = target;
|
|
c.dropZone = _dropZone();
|
|
c.restPriority = 10 + i;
|
|
c.priority = 10 + i;
|
|
_moveTo(c, target);
|
|
if (isNew) c.flipToFront(delay: 0.28 + i * 0.04); // پس از رسیدن، رو شود
|
|
}
|
|
}
|
|
|
|
void _layoutTrick(GameState s) {
|
|
// در زمانِ اینترو/بُر زدن/پخش، کارتهای روی میز پنهان میمانند تا با انیمیشن
|
|
// تداخل نکنند (پس از پایانِ انیمیشن دوباره چیده میشوند).
|
|
if (_anim.busy) {
|
|
for (final c in _trick.values.toList()) {
|
|
c.removeFromParent();
|
|
}
|
|
_trick.clear();
|
|
return;
|
|
}
|
|
final present = s.trick.map((t) => t.card).toSet();
|
|
|
|
// کارتهای trick که دیگر نیستند (دست جمع شد) ⇒ برنده کارتها را «جمع میکند»:
|
|
// به سمتِ جایگاهِ برنده (s.turn) پرواز میکنند، کوچک میشوند و محو (scoop).
|
|
final winnerOrigin = _seatOrigin(_rel(s.turn));
|
|
var i = 0;
|
|
for (final code in _trick.keys.toList()) {
|
|
if (present.contains(code)) continue;
|
|
final c = _trick.remove(code)!;
|
|
c.highlight = false;
|
|
c.priority = 30; // رویِ همه هنگام جمعشدن
|
|
c.children.whereType<Effect>().toList().forEach((e) => e.removeFromParent());
|
|
final delay = i * 0.05; // ترتیبِ کوتاه برای حسِ «جارو کردن»
|
|
c.add(ScaleEffect.to(
|
|
Vector2.all(0.5),
|
|
EffectController(duration: 0.34, startDelay: delay, curve: Curves.easeIn),
|
|
));
|
|
c.add(SequenceEffect([
|
|
MoveToEffect(
|
|
winnerOrigin,
|
|
EffectController(
|
|
duration: 0.36, startDelay: delay, curve: Curves.easeInBack),
|
|
),
|
|
RemoveEffect(),
|
|
]));
|
|
i++;
|
|
}
|
|
|
|
for (final tc in s.trick) {
|
|
final slot = size / 2 + _trickOffset(_rel(tc.seat));
|
|
var c = _trick[tc.card];
|
|
final isNew = c == null; // فقط کارتِ تازهنشسته bounce میشود
|
|
if (c == null) {
|
|
// اگر خودِ شما بازی کردید، همان کارتِ دست را منتقل کن (پرواز به وسط).
|
|
c = _hand.remove(tc.card);
|
|
if (c != null) {
|
|
c.onPlay = null;
|
|
c.dimmed = false;
|
|
c.home = null;
|
|
c.resetScale(); // کارتِ بازیشده هماندازهی بقیهی کارتهای میز
|
|
} else {
|
|
c = CardComponent(
|
|
code: tc.card,
|
|
faceUp: true,
|
|
skin: skin,
|
|
size: Vector2(_cardW, _cardH),
|
|
position: _seatOrigin(_rel(tc.seat)),
|
|
);
|
|
add(c);
|
|
}
|
|
_trick[tc.card] = c;
|
|
}
|
|
c.size = Vector2(_cardW, _cardH);
|
|
c.angle = 0; // کارتهای روی زمین صافاند (چرخشِ بادبزنیِ دست حذف میشود)
|
|
c.priority = 5;
|
|
_moveTo(c, slot, bounce: isNew);
|
|
}
|
|
|
|
// دستِ کامل (۴ کارت) ⇒ کارتِ برنده را طلایی هایلایت کن و یکبار «پاپ» بزن،
|
|
// تا کاربر پیش از جمعشدنِ کارتها بفهمد چه کسی برد.
|
|
if (s.trickDone && s.trick.length == 4) {
|
|
final ws = _winnerSeat(s.trick, s.trump, s.leadSuit);
|
|
for (final tc in s.trick) {
|
|
final comp = _trick[tc.card];
|
|
if (comp == null) continue;
|
|
final win = tc.seat == ws;
|
|
comp.highlight = win;
|
|
if (win && !_highlightedTrick) comp.pulse();
|
|
}
|
|
_highlightedTrick = true;
|
|
} else if (!s.trickDone) {
|
|
_highlightedTrick = false;
|
|
for (final c in _trick.values) {
|
|
c.highlight = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// برندهی دستِ جاری را از روی کارتها + حکم + خالِ زمینه حساب میکند (سمتِ کلاینت).
|
|
int _winnerSeat(List<TrickCard> trick, String? trump, String? lead) {
|
|
var best = trick.first;
|
|
for (final tc in trick.skip(1)) {
|
|
if (_beats(tc.card, best.card, trump, lead)) best = tc;
|
|
}
|
|
return best.seat;
|
|
}
|
|
|
|
bool _beats(String a, String b, String? trump, String? lead) {
|
|
final aS = suitName(a), bS = suitName(b);
|
|
final aT = aS == trump, bT = bS == trump;
|
|
if (aT && !bT) return true;
|
|
if (!aT && bT) return false;
|
|
if (aT && bT) return rankValue(a) > rankValue(b);
|
|
if (aS != lead) return false; // فقط کارتِ همخالِ زمینه میتواند ببرد
|
|
if (bS != lead) return true;
|
|
return rankValue(a) > rankValue(b);
|
|
}
|
|
|
|
// مبدأِ نشستنِ هر جایگاه (برای پرتاب/جمعِ کارتها).
|
|
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);
|
|
}
|
|
}
|
|
|
|
// جابهجاییِ کارتِ هر جایگاه از مرکز، در ناحیهی trick.
|
|
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();
|
|
|
|
// پشتِ کارتِ حریفان در زمانِ بُر زدنِ ابتدای هَند پنهان است (انیمیشنِ بُر
|
|
// خودش کارتها را پخش میکند)؛ پس از آن نمایش داده میشود.
|
|
final hideBacks = _anim.cardsHidden;
|
|
for (var seat = 0; seat < 4 && !hideBacks; seat++) {
|
|
if (seat == s.yourSeat) continue;
|
|
final count = seat < s.handCounts.length ? s.handCounts[seat] : 0;
|
|
_addBacks(_rel(seat), count);
|
|
}
|
|
// امتیاز/نام/نشان/تاج/شمارندهی نوبت و دستهای برده (tricks_won) اکنون در
|
|
// اوورلیِ Flutter (TableHud) نمایش داده میشوند تا واضحتر و کمشلوغتر باشند.
|
|
}
|
|
|
|
// پشتکارتهای یک حریف بهصورت بادبزنی.
|
|
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;
|
|
double angle = 0; // کارتهای کناری ۹۰° میچرخند تا «بهسمتِ» بازیکنِ کنار باشند
|
|
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(0, c.y);
|
|
stepV = Vector2(0, size.y * 0.36 / 13);
|
|
angle = math.pi / 2;
|
|
break;
|
|
default:
|
|
base = Vector2(size.x, c.y);
|
|
stepV = Vector2(0, size.y * 0.36 / 13);
|
|
angle = -math.pi / 2;
|
|
}
|
|
final start = base - stepV * ((n - 1) / 2);
|
|
for (var i = 0; i < n; i++) {
|
|
_addBack(start + stepV * i.toDouble(), Vector2(w, h),
|
|
priority: 1, angle: angle);
|
|
}
|
|
}
|
|
|
|
// ===== کمکیهای ساختِ عنصر (ثبت در فهرستِ بازساختهشونده) =====
|
|
|
|
void _addBack(Vector2 pos, Vector2 sz,
|
|
{required int priority, double angle = 0}) {
|
|
final c = CardComponent(
|
|
code: '',
|
|
faceUp: false,
|
|
skin: skin,
|
|
size: sz,
|
|
position: pos,
|
|
angle: angle,
|
|
priority: priority,
|
|
);
|
|
_backs.add(c);
|
|
add(c);
|
|
}
|
|
|
|
}
|