mirror of
https://github.com/kuhyx/wake-alarm.git
synced 2026-11-20 17:12:22 +01:00
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint,free-days-interop) (push) Waiting to run
Tests / test (push) Waiting to run
Tests / free-days-interop (push) Waiting to run
release-apk / release (APK) (push) Waiting to run
repo-contract / repo contract (push) Waiting to run
Todo: 364208fc
196 lines
5.5 KiB
Dart
196 lines
5.5 KiB
Dart
/// Dismiss-challenge types.
|
|
///
|
|
/// Every kind must keep its prompt **on screen until it is answered**. A
|
|
/// challenge that hides what it asked is unsolvable for someone who has just
|
|
/// walked in from another room, which is why there is no memorise-this kind.
|
|
library;
|
|
|
|
import 'dart:math';
|
|
|
|
/// Words for the reverse challenge — common, unambiguous when read half-asleep.
|
|
const List<String> _reverseWords = <String>[
|
|
'MORNING',
|
|
'COFFEE',
|
|
'PILLOW',
|
|
'BLANKET',
|
|
'ALARM',
|
|
'AWAKE',
|
|
'SHOWER',
|
|
'BREAKFAST',
|
|
'WORKOUT',
|
|
'WINDOW',
|
|
'MONDAY',
|
|
'TUESDAY',
|
|
'FRIDAY',
|
|
'SUNDAY',
|
|
'WEEKEND',
|
|
];
|
|
|
|
/// The four challenge kinds. All keep their prompt visible while answering.
|
|
enum ChallengeKind {
|
|
/// Solve an arithmetic problem.
|
|
math,
|
|
|
|
/// Type shuffled digits in ascending order.
|
|
sort,
|
|
|
|
/// Identify and continue a numeric pattern.
|
|
sequence,
|
|
|
|
/// Type a displayed word backwards.
|
|
reverse,
|
|
}
|
|
|
|
/// A dismiss challenge presented to the user to prove wakefulness.
|
|
class Challenge {
|
|
/// Creates a challenge with its display text, expected answer and hint.
|
|
const Challenge({
|
|
required this.kind,
|
|
required this.display,
|
|
required this.answer,
|
|
required this.hint,
|
|
});
|
|
|
|
/// Which of the five variants this is.
|
|
final ChallengeKind kind;
|
|
|
|
/// Text shown in the large code label.
|
|
final String display;
|
|
|
|
/// Expected typed answer, normalised upper-case.
|
|
final String answer;
|
|
|
|
/// Short instruction shown above the code label.
|
|
final String hint;
|
|
|
|
/// Whether [input] solves this challenge, ignoring case and
|
|
/// surrounding space.
|
|
bool accepts(String input) =>
|
|
input.trim().toUpperCase() == answer.trim().toUpperCase();
|
|
}
|
|
|
|
/// Generates challenges. The random source is injectable so tests are
|
|
/// deterministic.
|
|
class ChallengeGenerator {
|
|
/// Creates a generator; production uses a secure random source.
|
|
ChallengeGenerator({Random? random}) : _random = random ?? Random.secure();
|
|
|
|
final Random _random;
|
|
|
|
/// Picks a challenge kind at random and generates an instance.
|
|
Challenge next() {
|
|
final builders = <Challenge Function()>[math, sort, sequence, reverse];
|
|
return builders[_random.nextInt(builders.length)]();
|
|
}
|
|
|
|
/// An arithmetic problem: addition, subtraction, multiplication or division.
|
|
Challenge math() {
|
|
const hint = 'Solve and type the answer';
|
|
switch (_random.nextInt(4)) {
|
|
case 0:
|
|
final a = 100 + _random.nextInt(400);
|
|
final b = 100 + _random.nextInt(400);
|
|
return Challenge(
|
|
kind: ChallengeKind.math,
|
|
display: '$a + $b = ?',
|
|
answer: '${a + b}',
|
|
hint: hint,
|
|
);
|
|
case 1:
|
|
final a = 200 + _random.nextInt(300);
|
|
final b = 100 + _random.nextInt(a - 100);
|
|
return Challenge(
|
|
kind: ChallengeKind.math,
|
|
display: '$a - $b = ?',
|
|
answer: '${a - b}',
|
|
hint: hint,
|
|
);
|
|
case 2:
|
|
final a = 12 + _random.nextInt(14);
|
|
final b = 3 + _random.nextInt(7);
|
|
return Challenge(
|
|
kind: ChallengeKind.math,
|
|
display: '$a * $b = ?',
|
|
answer: '${a * b}',
|
|
hint: hint,
|
|
);
|
|
default:
|
|
// Division: build a from b first so the quotient is always an integer.
|
|
final b = 3 + _random.nextInt(8);
|
|
final a = (10 + _random.nextInt(20)) * b;
|
|
return Challenge(
|
|
kind: ChallengeKind.math,
|
|
display: '$a ÷ $b = ?',
|
|
answer: '${a ~/ b}',
|
|
hint: hint,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Eight shuffled digits the user must type in ascending order.
|
|
Challenge sort() {
|
|
final pool = List<int>.generate(9, (i) => i + 1);
|
|
for (var i = pool.length - 1; i > 0; i--) {
|
|
final j = _random.nextInt(i + 1);
|
|
final tmp = pool[i];
|
|
pool[i] = pool[j];
|
|
pool[j] = tmp;
|
|
}
|
|
final digits = pool.take(8).toList();
|
|
final ascending = List<int>.from(digits)..sort();
|
|
return Challenge(
|
|
kind: ChallengeKind.sort,
|
|
display: digits.join(' '),
|
|
answer: ascending.join(),
|
|
hint: 'Type digits sorted lowest → highest (no spaces)',
|
|
);
|
|
}
|
|
|
|
/// Four terms of an arithmetic or geometric sequence; the user gives
|
|
/// the fifth term.
|
|
Challenge sequence() {
|
|
const hint = 'Find the pattern and type the next number';
|
|
if (_random.nextInt(2) == 0) {
|
|
final start = 2 + _random.nextInt(14);
|
|
final step = 2 + _random.nextInt(8);
|
|
final terms = List<int>.generate(4, (i) => start + step * i);
|
|
return Challenge(
|
|
kind: ChallengeKind.sequence,
|
|
display: '${terms.join(', ')}, ?',
|
|
answer: '${start + step * 4}',
|
|
hint: hint,
|
|
);
|
|
}
|
|
final start = 2 + _random.nextInt(5);
|
|
final ratio = 2 + _random.nextInt(2);
|
|
final terms = List<int>.generate(4, (i) => start * _pow(ratio, i));
|
|
return Challenge(
|
|
kind: ChallengeKind.sequence,
|
|
display: '${terms.join(', ')}, ?',
|
|
answer: '${start * _pow(ratio, 4)}',
|
|
hint: hint,
|
|
);
|
|
}
|
|
|
|
/// A common word the user must type backwards.
|
|
Challenge reverse() {
|
|
final word = _reverseWords[_random.nextInt(_reverseWords.length)];
|
|
final backwards = word.split('').reversed.join();
|
|
return Challenge(
|
|
kind: ChallengeKind.reverse,
|
|
display: word,
|
|
answer: backwards,
|
|
hint: 'Type the word backwards',
|
|
);
|
|
}
|
|
|
|
/// Integer exponentiation; `pow` returns a `num` and would need a cast.
|
|
static int _pow(int base, int exponent) {
|
|
var result = 1;
|
|
for (var i = 0; i < exponent; i++) {
|
|
result *= base;
|
|
}
|
|
return result;
|
|
}
|
|
}
|