Shuffle vorbereitungen

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

@@ -68,4 +68,12 @@ class PlayerNotifier extends StateNotifier<List<PlayerModel>> {
     }
     state = box.values.toList();
   }
+
+  void resetAllWins(){
+    for(final player in box.values){
+      player.wins = 0;
+      player.save();
+    }
+    state = box.values.toList();
+  }
 }

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

@@ -0,0 +1,99 @@
+// lib/features/tournament/presentation/provider/shuffle_settings_provider.dart
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:hive/hive.dart';
+
+part 'shuffle_settings_provider.g.dart'; // Für den Hive-Generator
+
+// Enum mit Hive-Annotationen
+@HiveType(typeId: 5) // Freie typeId wählen (z. B. 5, nicht bereits vergeben)
+enum ShuffleMode {
+  @HiveField(0)
+  random,
+
+  @HiveField(1)
+  balanced,
+
+  @HiveField(2)
+  aggressive,
+
+  @HiveField(3)
+  positionBased,
+}
+
+// ShuffleSettings-Klasse
+@HiveType(typeId: 4)
+class ShuffleSettings extends HiveObject {
+  @HiveField(0)
+  ShuffleMode mode;
+
+  @HiveField(1)
+  bool prioritizeGenderBalance;
+
+  @HiveField(2)
+  bool prioritizeLevelBalance;
+
+  @HiveField(3)
+  bool usePositions;
+
+  ShuffleSettings({
+    this.mode = ShuffleMode.balanced,
+    this.prioritizeGenderBalance = true,
+    this.prioritizeLevelBalance = true,
+    this.usePositions = true,
+  });
+
+  // copyWith für immutable Updates
+  ShuffleSettings copyWith({
+    ShuffleMode? mode,
+    bool? prioritizeGenderBalance,
+    bool? prioritizeLevelBalance,
+    bool? usePositions,
+  }) {
+    return ShuffleSettings(
+      mode: mode ?? this.mode,
+      prioritizeGenderBalance: prioritizeGenderBalance ?? this.prioritizeGenderBalance,
+      prioritizeLevelBalance: prioritizeLevelBalance ?? this.prioritizeLevelBalance,
+      usePositions: usePositions ?? this.usePositions,
+    );
+  }
+}
+
+// Provider
+final shuffleSettingsProvider = StateNotifierProvider<ShuffleSettingsNotifier, ShuffleSettings>((ref) {
+  return ShuffleSettingsNotifier();
+});
+
+class ShuffleSettingsNotifier extends StateNotifier<ShuffleSettings> {
+  static const String _boxName = 'shuffle_settings';
+  static const String _key = 'settings';
+
+  ShuffleSettingsNotifier() : super(ShuffleSettings()) {
+    _load();
+  }
+
+  Future<void> _load() async {
+    final box = await Hive.openBox<ShuffleSettings>(_boxName);
+    final saved = box.get(_key);
+    if (saved != null) {
+      state = saved;
+    }
+  }
+
+  Future<void> update({
+    ShuffleMode? mode,
+    bool? prioritizeGenderBalance,
+    bool? prioritizeLevelBalance,
+    bool? usePositions,
+  }) async {
+    state = state.copyWith(
+      mode: mode,
+      prioritizeGenderBalance: prioritizeGenderBalance,
+      prioritizeLevelBalance: prioritizeLevelBalance,
+      usePositions: usePositions,
+    );
+
+    final box = await Hive.openBox<ShuffleSettings>(_boxName);
+    await box.put(_key, state);
+  }
+}

lib/features/tournament/presentation/provider/shuffle_settings_provider.g.dart

@@ -0,0 +1,99 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'shuffle_settings_provider.dart';
+
+// **************************************************************************
+// TypeAdapterGenerator
+// **************************************************************************
+
+class ShuffleSettingsAdapter extends TypeAdapter<ShuffleSettings> {
+  @override
+  final int typeId = 4;
+
+  @override
+  ShuffleSettings read(BinaryReader reader) {
+    final numOfFields = reader.readByte();
+    final fields = <int, dynamic>{
+      for (int i = 0; i < numOfFields; i++) reader.readByte(): reader.read(),
+    };
+    return ShuffleSettings(
+      mode: fields[0] as ShuffleMode,
+      prioritizeGenderBalance: fields[1] as bool,
+      prioritizeLevelBalance: fields[2] as bool,
+      usePositions: fields[3] as bool,
+    );
+  }
+
+  @override
+  void write(BinaryWriter writer, ShuffleSettings obj) {
+    writer
+      ..writeByte(4)
+      ..writeByte(0)
+      ..write(obj.mode)
+      ..writeByte(1)
+      ..write(obj.prioritizeGenderBalance)
+      ..writeByte(2)
+      ..write(obj.prioritizeLevelBalance)
+      ..writeByte(3)
+      ..write(obj.usePositions);
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ShuffleSettingsAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class ShuffleModeAdapter extends TypeAdapter<ShuffleMode> {
+  @override
+  final int typeId = 5;
+
+  @override
+  ShuffleMode read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return ShuffleMode.random;
+      case 1:
+        return ShuffleMode.balanced;
+      case 2:
+        return ShuffleMode.aggressive;
+      case 3:
+        return ShuffleMode.positionBased;
+      default:
+        return ShuffleMode.random;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, ShuffleMode obj) {
+    switch (obj) {
+      case ShuffleMode.random:
+        writer.writeByte(0);
+        break;
+      case ShuffleMode.balanced:
+        writer.writeByte(1);
+        break;
+      case ShuffleMode.aggressive:
+        writer.writeByte(2);
+        break;
+      case ShuffleMode.positionBased:
+        writer.writeByte(3);
+        break;
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ShuffleModeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}