init

lib/features/tournament/presentation/provider/active_players_provider.dart

@@ -0,0 +1,8 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import '../../data/models/player_model.dart';
+import 'player_provider.dart';
+
+final activePlayersProvider = Provider<List<PlayerModel>>((ref) {
+  final allPlayers = ref.watch(playerListProvider);
+  return allPlayers.where((p) => p.isActive).toList();
+});

lib/features/tournament/presentation/provider/player_provider.dart

@@ -0,0 +1,71 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:hive_flutter/hive_flutter.dart';
+import '../../data/models/player_model.dart';
+import 'package:uuid/uuid.dart';
+
+// Provider für die Hive-Box
+final playerBoxProvider = Provider<Box<PlayerModel>>((ref) {
+  return Hive.box<PlayerModel>('players');
+});
+
+// Provider für die Liste aller Players (live aktualisiert)
+final playerListProvider = StateNotifierProvider<PlayerNotifier, List<PlayerModel>>((ref) {
+  final box = ref.watch(playerBoxProvider);
+  return PlayerNotifier(box);
+});
+
+class PlayerNotifier extends StateNotifier<List<PlayerModel>> {
+  PlayerNotifier(this.box) : super(box.values.toList()) {
+    // Listener für automatische Updates, falls von außen geändert
+    box.watch().listen((_) {
+      state = box.values.toList();
+    });
+  }
+
+  final Box<PlayerModel> box;
+
+  // Spieler hinzufügen
+  Future<void> addPlayer({
+    required String name,
+    required Gender gender,
+    required SkillLevel skillLevel,
+    required List<Position> positions,
+  }) async {
+    final newPlayer = PlayerModel(
+      id: const Uuid().v4(),
+      name: name,
+      gender: gender,
+      skillLevel: skillLevel,
+      positions: positions,
+    );
+    await box.put(newPlayer.id, newPlayer);
+    state = box.values.toList(); // Update state
+  }
+
+  // Spieler aktualisieren
+  Future<void> updatePlayer(PlayerModel updatedPlayer) async {
+    await updatedPlayer.save();
+    state = box.values.toList();
+  }
+
+  // Spieler löschen
+  Future<void> deletePlayer(PlayerModel player) async {
+    await player.delete();
+    state = box.values.toList();
+  }
+
+  // Alle löschen (z.B. für neues Turnier)
+  Future<void> clearAll() async {
+    await box.clear();
+    state = [];
+  }
+
+
+  void awardWinToPlayers(List<PlayerModel> winners){
+    for(final player in winners){
+      player.wins += 1;
+      player.save();
+    }
+    state = box.values.toList();
+  }
+}

lib/features/tournament/presentation/provider/timer_provider.dart

@@ -0,0 +1,89 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:wakelock_plus/wakelock_plus.dart';
+import 'package:just_audio/just_audio.dart';
+
+final timerProvider = StateNotifierProvider<TimerNotifier, TimerState>((ref) {
+  return TimerNotifier();
+});
+
+class TimerState {
+  final Duration remaining;
+  final bool isRunning;
+  final int selectedMinutes;
+
+  TimerState({
+    this.remaining = Duration.zero,
+    this.isRunning = false,
+    this.selectedMinutes = 15, // Default
+  });
+
+  TimerState copyWith({
+    Duration? remaining,
+    bool? isRunning,
+    int? selectedMinutes,
+  }) {
+    return TimerState(
+      remaining: remaining ?? this.remaining,
+      isRunning: isRunning ?? this.isRunning,
+      selectedMinutes: selectedMinutes ?? this.selectedMinutes,
+    );
+  }
+}
+
+class TimerNotifier extends StateNotifier<TimerState> {
+  TimerNotifier() : super(TimerState());
+
+  DateTime? _endTime;
+  final AudioPlayer _audioPlayer = AudioPlayer();
+
+  void setMinutes(int minutes) {
+    state = state.copyWith(selectedMinutes: minutes);
+  }
+
+  void start() {
+    final duration = Duration(minutes: state.selectedMinutes);
+    _endTime = DateTime.now().add(duration);
+    state = state.copyWith(remaining: duration, isRunning: true);
+    WakelockPlus.enable();
+
+    // Sound vorbereiten (später Asset hinzufügen)
+    _audioPlayer.setAsset('assets/sounds/alarm.mp3').catchError((_) {});
+  }
+
+  void pause() {
+    state = state.copyWith(isRunning: false);
+  }
+
+  void stop() {
+    state = TimerState(selectedMinutes: state.selectedMinutes); // Reset remaining + running
+    _endTime = null;
+    WakelockPlus.disable();
+    _audioPlayer.stop();
+  }
+
+  void tick() {
+    if (!state.isRunning || _endTime == null) return;
+
+    final now = DateTime.now();
+    if (now.isAfter(_endTime!)) {
+      state = state.copyWith(remaining: Duration.zero, isRunning: false);
+      WakelockPlus.disable();
+      _playAlarm();
+      return;
+    }
+
+    state = state.copyWith(remaining: _endTime!.difference(now));
+  }
+
+  Future<void> _playAlarm() async {
+    await _audioPlayer.seek(Duration.zero);
+    await _audioPlayer.play();
+  }
+
+  @override
+  void dispose() {
+    WakelockPlus.disable();
+    _audioPlayer.dispose();
+    super.dispose();
+  }
+}