feat: Power-Up System

lib/services/power_up_service.dart

@@ -0,0 +1,95 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+
+/// Power-Up Service
+/// Manages in-game power-ups: shield, multiplier, slow-time.
+/// Handles activation, expiry, and stacking logic.
+class PowerUpService {
+  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
+
+  /// Activate a power-up for a user
+  Future<void> activatePowerUp(String userId, String powerUpId, int durationSeconds) async {
+    final now = DateTime.now();
+    final expiresAt = now.add(Duration(seconds: durationSeconds));
+
+    await _firestore.collection('active_power_ups').doc('$userId-$powerUpId').set({
+      'userId': userId,
+      'powerUpId': powerUpId,
+      'activatedAt': now,
+      'expiresAt': expiresAt,
+      'isActive': true,
+    });
+
+    // Deduct from inventory
+    await _firestore.collection('users').doc(userId).update({
+      'inventory.$powerUpId': FieldValue.increment(-1),
+    });
+
+    print('Power-up $powerUpId activated for $userId (expires in ${durationSeconds}s)');
+  }
+
+  /// Check if a power-up is currently active
+  Future<bool> isPowerUpActive(String userId, String powerUpId) async {
+    final doc = await _firestore
+        .collection('active_power_ups')
+        .doc('$userId-$powerUpId')
+        .get();
+
+    if (!doc.exists) return false;
+
+    final data = doc.data()!;
+    final expiresAt = (data['expiresAt'] as dynamic).toDate();
+    return DateTime.now().isBefore(expiresAt);
+  }
+
+  /// Grant a power-up to user's inventory (e.g., from reward or purchase)
+  Future<void> grantPowerUp(String userId, String powerUpId, int quantity) async {
+    final userRef = _firestore.collection('users').doc(userId);
+
+    await userRef.update({
+      'inventory.$powerUpId': FieldValue.increment(quantity),
+      'totalPowerUpsEarned': FieldValue.increment(quantity),
+      'lastPowerUpAt': DateTime.now(),
+    });
+  }
+
+  /// Get all active power-ups for a user
+  Future<List<Map<String, dynamic>>> getActivePowerUps(String userId) async {
+    final snapshot = await _firestore
+        .collection('active_power_ups')
+        .where('userId', isEqualTo: userId)
+        .where('isActive', isEqualTo: true)
+        .get();
+
+    final now = DateTime.now();
+    final active = <Map<String, dynamic>>[];
+
+    for (final doc in snapshot.docs) {
+      final data = doc.data();
+      final expiresAt = (data['expiresAt'] as dynamic).toDate();
+      if (now.isBefore(expiresAt)) {
+        active.add(data);
+      } else {
+        // Expired — mark as inactive
+        await doc.reference.update({'isActive': false});
+      }
+    }
+
+    return active;
+  }
+
+  /// Purchase a power-up with in-game coins
+  Future<bool> purchasePowerUp(String userId, String powerUpId, int cost) async {
+    final userDoc = await _firestore.collection('users').doc(userId).get();
+    final coins = userDoc.data()?['coins'] ?? 0;
+
+    if (coins < cost) return false;
+
+    // Deduct coins and grant power-up
+    await _firestore.collection('users').doc(userId).update({
+      'coins': FieldValue.increment(-cost),
+    });
+
+    await grantPowerUp(userId, powerUpId, 1);
+    return true;
+  }
+}

test_pr_diff.txt

@@ -0,0 +1,169 @@
+diff --git a/test/services/daily_challenge_service_test.dart b/test/services/daily_challenge_service_test.dart
+new file mode 100644
+index 0000000..b1d65d7
+--- /dev/null
++++ b/test/services/daily_challenge_service_test.dart
+@@ -0,0 +1,163 @@
++import 'package:flutter_test/flutter_test.dart';
++import 'package:mockito/mockito.dart';
++import 'package:cloud_firestore/cloud_firestore.dart';
++import 'package:volt_rush/services/daily_challenge_service.dart';
++
++class MockFirestore extends Mock implements FirebaseFirestore {}
++class MockCollectionReference extends Mock implements CollectionReference {}
++class MockDocumentReference extends Mock implements DocumentReference {}
++class MockQuerySnapshot extends Mock implements QuerySnapshot {}
++class MockQueryDocumentSnapshot extends Mock implements QueryDocumentSnapshot {}
++
++void main() {
++  late DailyChallengeService service;
++  late MockFirestore mockFirestore;
++  late MockCollectionReference mockCollection;
++  late MockDocumentReference mockDocRef;
++  late MockQuerySnapshot mockQuerySnapshot;
++  late MockQueryDocumentSnapshot mockQueryDocSnapshot;
++
++  setUp(() {
++    mockFirestore = MockFirestore();
++    mockCollection = MockCollectionReference();
++    mockDocRef = MockDocumentReference();
++    mockQuerySnapshot = MockQuerySnapshot();
++    mockQueryDocSnapshot = MockQueryDocumentSnapshot();
++    service = DailyChallengeService();
++    service._firestore = mockFirestore;
++  });
++
++  group('getTodayChallenge', () {
++    test('should return null when no challenge exists', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.where('date', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.where('userId', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.get()).thenAnswer((_) async => mockQuerySnapshot);
++      when(mockQuerySnapshot.docs).thenReturn([]);
++
++      // act
++      final result = await service.getTodayChallenge('user1');
++
++      // assert
++      expect(result, isNull);
++    });
++
++    test('should return challenge data when challenge exists', () async {
++      // arrange
++      final challengeData = {'challenge': 'data'};
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.where('date', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.where('userId', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.get()).thenAnswer((_) async => mockQuerySnapshot);
++      when(mockQuerySnapshot.docs).thenReturn([mockQueryDocSnapshot]);
++      when(mockQueryDocSnapshot.data()).thenReturn(challengeData);
++
++      // act
++      final result = await service.getTodayChallenge('user1');
++
++      // assert
++      expect(result, equals(challengeData));
++    });
++
++    test('should handle empty userId', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.where('date', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.where('userId', isEqualTo: anyNamed('isEqualTo'))).thenReturn(mockCollection);
++      when(mockCollection.get()).thenAnswer((_) async => mockQuerySnapshot);
++      when(mockQuerySnapshot.docs).thenReturn([]);
++
++      // act
++      final result = await service.getTodayChallenge('');
++
++      // assert
++      expect(result, isNull);
++    });
++  });
++
++  group('completeChallenge', () {
++    test('should update challenge and user data', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++      when(mockFirestore.collection('users')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++
++      // act
++      await service.completeChallenge('user1', 'challenge1', 100);
++
++      // assert
++      verify(mockDocRef.update(any)).called(2);
++    });
++
++    test('should handle negative score', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++      when(mockFirestore.collection('users')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++
++      // act
++      await service.completeChallenge('user1', 'challenge1', -100);
++
++      // assert
++      verify(mockDocRef.update(any)).called(2);
++    });
++
++    test('should handle empty userId', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++      when(mockFirestore.collection('users')).thenReturn(mockCollection);
++      when(mockCollection.doc(any)).thenReturn(mockDocRef);
++      when(mockDocRef.update(any)).thenAnswer((_) async => null);
++
++      // act
++      await service.completeChallenge('', 'challenge1', 100);
++
++      // assert
++      verify(mockDocRef.update(any)).called(2);
++    });
++  });
++
++  group('generateNextChallenge', () {
++    test('should add new challenge to Firestore', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.add(any)).thenAnswer((_) async => mockDocRef);
++
++      // act
++      await service.generateNextChallenge('user1');
++
++      // assert
++      verify(mockCollection.add(any)).called(1);
++    });
++
++    test('should handle empty userId', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.add(any)).thenAnswer((_) async => mockDocRef);
++
++      // act
++      await service.generateNextChallenge('');
++
++      // assert
++      verify(mockCollection.add(any)).called(1);
++    });
++
++    test('should handle Firestore errors', () async {
++      // arrange
++      when(mockFirestore.collection('daily_challenges')).thenReturn(mockCollection);
++      when(mockCollection.add(any)).thenThrow(Exception('Firestore error'));
++
++      // act & assert
++      expect(() => service.generateNextChallenge('user1'), throwsException);
++    });
++  });
++}