仓库地址：https://gitcode.com/feng8403000/math_app_study

引言

记忆数字游戏是一款经典的记忆力训练游戏，玩家需要在短时间内记住一串随机数字，然后准确输入。这款游戏能够有效锻炼短期记忆力和注意力，是认知训练领域的重要工具。在本文中，我们将深入探讨如何使用HarmonyOS ArkTS技术栈实现这款游戏，包括核心算法、状态机设计、UI交互和训练价值等方面。

一、游戏概述与设计理念

1.1 游戏规则

记忆数字游戏的核心玩法非常直观：

• 游戏开始时，屏幕显示一串随机生成的数字
• 数字显示3秒后消失
• 玩家需要在数字键盘上输入刚才看到的数字
• 输入完成后自动验证正确性
• 输入正确则游戏胜利，错误则清空输入重新尝试

1.2 设计目标

在设计这款游戏时，我们设定了以下核心目标：

目标类型	具体目标	实现方式
训练价值	提升短期记忆力和注意力	限时记忆+准确输入
难度递进	从简单到困难的渐进式关卡	数字位数3→4→5→6位
用户体验	流畅的交互和即时反馈	数字键盘输入，实时验证
进度追踪	记录通关进度和最佳时间	全局状态管理+数据持久化
科学验证	基于记忆广度测试原理	标准化的数字记忆任务

1.3 难度递增策略

游戏难度主要通过数字位数来控制：

难度等级	数字位数	记忆难度	适用人群
入门	3位	简单，大多数人能轻松记住	儿童、初学者
简单	4位	中等，需要集中注意力	普通玩家
中等	5位	较难，超过普通人记忆广度	进阶玩家
困难	6位	困难，需要专业训练方法	高级玩家

根据心理学研究，普通人的数字记忆广度大约为7±2位数字，因此5-6位数字已经属于较高难度。

二、项目架构与组件设计

2.1 页面结构

记忆数字游戏包含两个核心页面：

├── MemoryNumbersLevelPage.ets  # 关卡选择页面
└── MemoryNumbersPage.ets       # 游戏主页面

页面职责划分：

• MemoryNumbersLevelPage：展示关卡列表，按难度分类（入门/简单/中等/困难），显示通关时间，提供解锁功能
• MemoryNumbersPage：游戏核心逻辑，包括数字生成、记忆阶段、输入阶段、验证逻辑

2.2 数据模型设计

为了支持多样化的关卡配置，我们设计了两个核心数据类：

class LevelInfo {
  level: number = 0;
  numLength: number = 0;
  label: string = '';

  constructor(level: number, numLength: number, label: string) {
    this.level = level;
    this.numLength = numLength;
    this.label = label;
  }
}

class Category {
  name: string = '';
  description: string = '';
  color: string = '';
  levels: Array<LevelInfo> = [];

  constructor(name: string, description: string, color: string) {
    this.name = name;
    this.description = description;
    this.color = color;
    this.levels = [];
  }
}

LevelInfo字段说明：

字段	类型	说明
level	number	关卡编号
numLength	number	数字位数（3/4/5/6）
label	string	显示标签（如"3位"）

2.3 组件状态定义

游戏页面使用了以下状态变量：

@State numberLength: number = 4;
@State currentLevel: number = 1;
@State gameState: string = 'ready';
@State displayNumbers: string = '';
@State inputNumbers: string = '';
@State timerSeconds: number = 0;
@State bestTime: number = 0;
private timerId: number = 0;

状态变量说明：

变量	类型	说明
numberLength	number	当前关卡的数字位数
currentLevel	number	当前关卡
gameState	string	游戏状态（ready/display/input）
displayNumbers	string	显示的目标数字
inputNumbers	string	用户输入的数字
timerSeconds	number	计时秒数
bestTime	number	当前关卡最佳时间
timerId	number	计时器ID

2.4 状态机设计

游戏采用三态状态机设计：

                    开始记忆
                       ↓
   ┌─────────────── ready ────────────────┐
   │                                       │
   │  输入完成                              │
   ↓                                       ↓
 input ────────────→ check ───────────→ display
   │                                       │
   │         3秒后自动切换                  │
   ↓                                       ↓
 验证结果                            显示数字
   │                                       │
   ├── 正确 → ready（通关）                 │
   └── 错误 → input（重新输入）             │

状态说明：

状态	说明	UI展示
ready	准备状态	显示"开始记忆"按钮
display	记忆阶段	显示数字，3秒后自动切换
input	输入阶段	显示数字键盘和输入框

三、核心游戏逻辑实现

3.1 数字生成算法

游戏的核心在于生成随机数字串：

private startGame(): void {
  this.displayNumbers = '';
  for (let i = 0; i < this.numberLength; i++) {
    this.displayNumbers += Math.floor(Math.random() * 10).toString();
  }
  this.gameState = 'display';
  setTimeout(() => {
    this.gameState = 'input';
    this.inputNumbers = '';
    this.startTimer();
  }, 3000);
}

生成流程分析：

1. 生成随机数字串（循环numberLength次，每次生成0-9的随机数字）
         ↓
2. 设置游戏状态为display（记忆阶段）
         ↓
3. 3秒后自动切换到input状态（输入阶段）
         ↓
4. 清空输入框，开始计时

算法特点：

• 使用Math.random()生成0-9的随机数字
• 通过字符串拼接构建数字串
• 固定3秒记忆时间，符合心理学记忆广度测试标准

3.2 输入处理逻辑

输入处理是游戏的核心交互逻辑：

private handleInput(key: string): void {
  if (key === '←') {
    if (this.inputNumbers.length > 0) {
      this.inputNumbers = this.inputNumbers.substring(0, this.inputNumbers.length - 1);
    }
  } else if (key === '×') {
    this.inputNumbers = '';
  } else {
    if (this.inputNumbers.length < this.numberLength) {
      this.inputNumbers += key;
      if (this.inputNumbers.length === this.numberLength) {
        this.checkResult();
      }
    }
  }
}

输入处理流程：

用户点击键盘 → 判断按键类型
    ↓
[←] 退格键 → 删除最后一个字符
    ↓
[×] 清空键 → 清空所有输入
    ↓
[数字键] → 添加到输入字符串
    ↓
输入长度达到numberLength → 自动验证结果

输入限制：

• 输入长度不能超过numberLength
• 输入完成后自动触发验证
• 支持退格和清空操作

3.3 结果验证逻辑

结果验证是游戏的核心判定逻辑：

private checkResult(): void {
  this.stopTimer();
  if (this.inputNumbers === this.displayNumbers) {
    let completedLevels: Array<number> = appState.memoryNumbersCompletedLevels;
    let exists: boolean = false;
    for (let i = 0; i < completedLevels.length; i++) {
      if (completedLevels[i] === this.currentLevel) {
        exists = true;
        break;
      }
    }
    if (!exists) {
      completedLevels.push(this.currentLevel);
      completedLevels.sort((a: number, b: number) => a - b);
      appState.memoryNumbersCompletedLevels = completedLevels;
    }
    let levelTimes: Array<number> = appState.memoryNumbersLevelTimes;
    while (levelTimes.length <= this.currentLevel) {
      levelTimes.push(0);
    }
    if (levelTimes[this.currentLevel] === 0 || this.timerSeconds < levelTimes[this.currentLevel]) {
      levelTimes[this.currentLevel] = this.timerSeconds;
      appState.memoryNumbersLevelTimes = levelTimes;
      this.bestTime = this.timerSeconds;
    }
    this.gameState = 'ready';
  } else {
    this.inputNumbers = '';
  }
}

验证流程：

用户输入完成 → 停止计时 → 比较输入与目标
    ↓
匹配成功 → 记录通关进度 → 更新最佳时间 → 返回ready状态
    ↓
匹配失败 → 清空输入 → 重新输入

胜利处理步骤：

1. 停止计时：立即停止计时器，记录当前用时
2. 检查通关状态：判断当前关卡是否已通关
3. 记录通关进度：如果是首次通关，将关卡编号加入已完成数组
4. 更新最佳时间：比较当前用时与历史最佳时间，更新更优的记录
5. 返回ready状态：等待下一次游戏开始

失败处理步骤：

1. 清空输入：清空输入框内容
2. 重新输入：用户可以重新输入数字

四、关卡系统设计

4.1 关卡分类体系

游戏采用四级难度递进体系，共20个关卡：

难度等级	关卡范围	数字位数	颜色标识
入门	1-5	3位	绿色 #32CD32
简单	6-10	4位	青色 #00CED1
中等	11-15	5位	金色 #FFD700
困难	16-20	6位	红色 #FF6347

4.2 关卡初始化

private initCategories(): void {
  let cat1: Category = new Category('入门', '3位数字', '#32CD32');
  for (let i = 1; i <= 5; i++) {
    cat1.levels.push(new LevelInfo(i, 3, '3位'));
  }

  let cat2: Category = new Category('简单', '4位数字', '#00CED1');
  for (let i = 6; i <= 10; i++) {
    cat2.levels.push(new LevelInfo(i, 4, '4位'));
  }

  let cat3: Category = new Category('中等', '5位数字', '#FFD700');
  for (let i = 11; i <= 15; i++) {
    cat3.levels.push(new LevelInfo(i, 5, '5位'));
  }

  let cat4: Category = new Category('困难', '6位数字', '#FF6347');
  for (let i = 16; i <= 20; i++) {
    cat4.levels.push(new LevelInfo(i, 6, '6位'));
  }

  this.categories = [cat1, cat2, cat3, cat4];
}

4.3 难度设计思路

阶段1（1-5关）：3位数字

• 3位数字，记忆难度较低
• 适合初学者熟悉游戏规则
• 大多数人可以轻松记住3位数字

阶段2（6-10关）：4位数字

• 4位数字，需要一定的注意力
• 适合日常训练
• 属于普通人的舒适记忆范围

阶段3（11-15关）：5位数字

• 5位数字，超过普通人的即时记忆范围
• 需要使用记忆技巧（如分组记忆）
• 适合进阶训练

阶段4（16-20关）：6位数字

• 6位数字，较高难度
• 需要专业记忆方法（如记忆宫殿）
• 适合高级玩家挑战

五、计时系统实现

5.1 计时器设计

游戏使用基于setTimeout的递归计时方案：

private startTimer(): void {
  this.timerSeconds = 0;
  this.timerId = 1;
  this.tick();
}

private tick(): void {
  if (this.timerId !== 0) {
    this.timerSeconds++;
    setTimeout(() => {
      this.tick();
    }, 1000);
  }
}

private stopTimer(): void {
  if (this.timerId !== 0) {
    clearInterval(this.timerId);
    this.timerId = 0;
  }
}

计时实现说明：

• 使用递归setTimeout而非setInterval，避免累积误差
• timerId作为计时状态标志，非零表示计时器运行中
• 计时器仅在输入阶段运行，记忆阶段不计时

5.2 时间格式化

private formatTime(seconds: number): string {
  let mins: number = Math.floor(seconds / 60);
  let secs: number = seconds % 60;
  return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
}

格式输出示例：

秒数	格式化结果
5	00:05
45	00:45
120	02:00

5.3 最佳时间显示

Text('最佳: ' + this.formatTime(this.bestTime))
  .fontSize(10)
  .fontColor('#87CEEB')

最佳时间在页面头部显示，让玩家随时了解自己的历史最佳成绩。

六、UI布局与交互设计

6.1 页面布局结构

build() {
  Column({ space: 16 }) {
    Row() {
      Button('← 返回')
        .fontSize(14)
        .fontColor('#FFD700')
        .backgroundColor('transparent')
        .borderColor('#FFD700')
        .borderWidth(1)
        .padding({ left: 12, right: 12 })
        .onClick(() => router.back())

      Text('记忆数字')
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFD700')

      Column({ space: 2 }) {
        Text('第' + this.currentLevel + '关')
          .fontSize(12)
          .fontColor('#87CEEB')
        Text('最佳: ' + this.formatTime(this.bestTime))
          .fontSize(10)
          .fontColor('#87CEEB')
      }
    }
    .width('100%')
    .justifyContent(FlexAlign.SpaceBetween)
    .padding({ left: 20, right: 20 })
    .margin({ top: 40 })

    Text(this.formatTime(this.timerSeconds))
      .fontSize(32)
      .fontColor('#87CEEB')
      .fontWeight(FontWeight.Bold)

    if (this.gameState === 'ready') {
      Column({ space: 16 }) {
        Text('记忆 ' + this.numberLength + ' 位数字')
          .fontSize(18)
          .fontColor('#FFD700')
        Button('开始记忆')
          .fontSize(18)
          .fontColor('#0A192F')
          .backgroundColor('#FFD700')
          .borderRadius(12)
          .padding({ left: 40, right: 40, top: 12, bottom: 12 })
          .onClick(() => this.startGame())
      }
    } else if (this.gameState === 'display') {
      Column({ space: 16 }) {
        Text('记住这些数字')
          .fontSize(18)
          .fontColor('#87CEEB')
        Text(this.displayNumbers)
          .fontSize(48)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFD700')
          .letterSpacing(10)
      }
    } else if (this.gameState === 'input') {
      Column({ space: 16 }) {
        Text('请输入刚才的数字')
          .fontSize(18)
          .fontColor('#87CEEB')
        Text(this.inputNumbers)
          .fontSize(48)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFD700')
          .letterSpacing(10)
        Grid() {
          // 数字键盘
        }
        .width('90%')
        .height(240)
        .columnsTemplate('1fr 1fr 1fr')
        .rowsTemplate('1fr 1fr 1fr 1fr')
        Column({ space: 8 }) {
          Text('游戏说明')
            .fontSize(14)
            .fontWeight(FontWeight.Bold)
            .fontColor('#FFD700')
          Text('记住显示的数字，然后准确输入')
            .fontSize(12)
            .fontColor('#87CEEB')
            .textAlign(TextAlign.Center)
        }
        .width('90%')
        .padding({ top: 8, bottom: 16 })
      }
    }
  }
  .width('100%')
  .height('100%')
  .backgroundColor('#0A192F')
  .padding({ bottom: 80 })
}

布局层次结构：

Column (主容器)
├── Row (顶部导航栏)
│   ├── Button (返回)
│   ├── Text (标题)
│   └── Column (关卡信息)
│       ├── Text (关卡)
│       └── Text (最佳时间)
├── Text (计时器)
└── Column (内容区域)
    ├── [ready] Column
    │   ├── Text (游戏提示)
    │   └── Button (开始记忆)
    ├── [display] Column
    │   ├── Text (记忆提示)
    │   └── Text (显示数字)
    └── [input] Column
        ├── Text (输入提示)
        ├── Text (输入数字)
        ├── Grid (数字键盘)
        └── Column (游戏说明)

6.2 数字键盘设计

数字键盘是游戏的核心交互组件：

Grid() {
  ForEach(['1', '2', '3', '4', '5', '6', '7', '8', '9', '×', '0', '←'], (key: string) => {
    GridItem() {
      Button(key)
        .fontSize(24)
        .fontColor(key === '×' || key === '←' ? '#FF6B6B' : '#FFFFFF')
        .backgroundColor(key === '×' || key === '←' ? 'rgba(255, 107, 107, 0.2)' : 'rgba(255, 215, 0, 0.1)')
        .borderColor('#FFD700')
        .borderWidth(1)
        .borderRadius(8)
        .width('100%')
        .height('100%')
        .onClick(() => this.handleInput(key))
    }
  })
}
.width('90%')
.height(240)
.columnsTemplate('1fr 1fr 1fr')
.rowsTemplate('1fr 1fr 1fr 1fr')

键盘布局：

| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |
| × | 0 | ← |

键盘设计要点：

• 功能键区分：清空键(×)和退格键(←)使用红色标识，与数字键区分
• 响应式布局：使用Grid组件实现3×4的键盘布局
• 统一视觉风格：所有按键使用金色边框，保持视觉一致性

6.3 数字显示设计

数字显示是游戏的核心视觉组件：

Text(this.displayNumbers)
  .fontSize(48)
  .fontWeight(FontWeight.Bold)
  .fontColor('#FFD700')
  .letterSpacing(10)

显示设计要点：

• 大字体显示：使用48sp的大号字体，确保数字清晰可见
• 金色高亮：使用金色(#FFD700)字体，突出显示目标数字
• 字母间距：设置10px的字母间距，使数字之间有足够的间隔

七、路由与参数传递

7.1 路由参数定义

interface RouteParams {
  level: number;
  numLength: number;
}

7.2 页面跳转

private startLevel(info: LevelInfo): void {
  router.pushUrl({ 
    url: 'pages/MemoryNumbersPage', 
    params: { 
      level: info.level, 
      numLength: info.numLength 
    } 
  });
}

7.3 参数接收

aboutToAppear(): void {
  let params: RouteParams = router.getParams() as RouteParams;
  if (params !== undefined) {
    if (params.level !== undefined) {
      this.currentLevel = params.level;
    }
    if (params.numLength !== undefined) {
      this.numberLength = params.numLength;
    }
  }
  let levelTimes: Array<number> = appState.memoryNumbersLevelTimes;
  if (levelTimes.length > this.currentLevel && levelTimes[this.currentLevel] > 0) {
    this.bestTime = levelTimes[this.currentLevel];
  }
}

参数传递流程：

关卡选择页 → 点击关卡 → 构造参数 → router.pushUrl → 游戏页
                                                       ↓
                                              aboutToAppear → 解析参数 → 加载最佳时间

八、状态管理与数据持久化

8.1 全局状态管理

游戏进度通过AppState单例进行管理：

memoryNumbersCompletedLevels: Array<number> = [];
memoryNumbersLevelTimes: Array<number> = [];

8.2 通关记录更新

let completedLevels: Array<number> = appState.memoryNumbersCompletedLevels;
let exists: boolean = false;
for (let i = 0; i < completedLevels.length; i++) {
  if (completedLevels[i] === this.currentLevel) {
    exists = true;
    break;
  }
}
if (!exists) {
  completedLevels.push(this.currentLevel);
  completedLevels.sort((a: number, b: number) => a - b);
  appState.memoryNumbersCompletedLevels = completedLevels;
}

注意事项：

由于ArkTS的响应式状态更新机制，直接修改数组元素不会触发UI更新，必须重新赋值。在这个实现中，我们直接在原数组上push元素并排序，然后重新赋值给appState，这是一种可行的方案。

8.3 最佳时间记录

let levelTimes: Array<number> = appState.memoryNumbersLevelTimes;
while (levelTimes.length <= this.currentLevel) {
  levelTimes.push(0);
}
if (levelTimes[this.currentLevel] === 0 || this.timerSeconds < levelTimes[this.currentLevel]) {
  levelTimes[this.currentLevel] = this.timerSeconds;
  appState.memoryNumbersLevelTimes = levelTimes;
  this.bestTime = this.timerSeconds;
}

时间记录策略：

• 使用数组索引对应关卡编号，便于快速查找
• 0表示未通关或无记录
• 只记录最佳时间（最短用时）
• 同时更新本地bestTime状态，用于UI显示

九、性能优化策略

9.1 状态切换优化

游戏状态切换是频繁发生的操作，因此需要注意优化：

// 使用字符串状态而非枚举
@State gameState: string = 'ready';

// 状态切换直接赋值
this.gameState = 'display';
this.gameState = 'input';

优化要点：

• 使用字符串状态简单直接，避免复杂的状态机实现
• 状态切换通过直接赋值实现，响应式更新自动触发UI变化

9.2 计时器优化

使用递归setTimeout避免累积误差：

private tick(): void {
  if (this.timerId !== 0) {
    this.timerSeconds++;
    setTimeout(() => {
      this.tick();
    }, 1000);
  }
}

优势：

• setTimeout在回调执行后重新计算下一次延迟
• 避免setInterval因执行时间波动导致的累积误差
• 适合需要高精度计时的场景

9.3 键盘渲染优化

数字键盘使用ForEach进行列表渲染：

Grid() {
  ForEach(['1', '2', '3', '4', '5', '6', '7', '8', '9', '×', '0', '←'], (key: string) => {
    GridItem() {
      Button(key)
        // 内容
    }
  })
}

优化策略：

• 使用ForEach进行列表渲染，ArkUI会自动优化渲染性能
• 键盘按键数量固定（12个），渲染压力较小
• 使用Grid布局实现响应式键盘

十、训练价值与科学原理

10.1 记忆广度测试原理

记忆数字游戏基于经典的记忆广度测试（Memory Span Test）：

测试维度	原理说明	游戏机制
短期记忆	通过限时记忆训练工作记忆能力	3秒记忆时间
数字记忆	训练数字信息的编码和存储能力	随机数字串
注意力	需要高度集中才能记住数字	无干扰的记忆环境
反应速度	输入阶段计时，提升信息提取速度	输入时间记录

10.2 记忆广度标准

根据心理学研究，成年人的数字记忆广度大约为7±2位：

数字位数	难度等级	说明
3-4位	简单	大多数人能轻松完成
5-6位	中等	需要集中注意力
7-8位	困难	超过平均水平
9位以上	专业	需要记忆技巧

10.3 记忆技巧推荐

针对不同难度，可以使用以下记忆技巧：

难度	记忆技巧	说明
3-4位	直接记忆	短期记忆可以直接存储
5-6位	分组记忆	将数字分成两组（如"123-456"）
7-8位	图像联想	将数字转化为图像或场景
9位以上	记忆宫殿	使用位置记忆法存储数字

10.4 训练效果评估

根据认知科学研究，记忆训练的效果可以从以下几个方面评估：

评估指标	说明
完成时间	记录每关用时，观察是否逐渐缩短
错误次数	统计输入错误的次数（当前版本不记录）
连续通关数	一次训练中连续通关的关卡数
记忆广度	通过能完成的最大数字位数来评估

10.5 科学训练建议

根据认知科学研究，建议以下训练方案：

每周训练次数：3-5次
每次训练时长：10-15分钟
训练间隔：每次训练后休息5分钟
难度递进：从3位开始，逐步提升到6位
训练目标：达到5-6位的稳定记忆能力

10.6 实际应用场景

记忆数字训练在以下场景中具有实际应用价值：

场景	应用方式
学生学习	提升学习记忆能力和课堂注意力
职场人士	提升工作记忆和信息处理能力
老年人认知训练	延缓记忆衰退，保持大脑活跃
脑力运动员	提升记忆竞技能力
日常训练	保持大脑健康和认知活力

十一、代码优化建议

11.1 计时器实现改进

当前停止计时器使用clearInterval，但实际上应该使用clearTimeout：

private stopTimer(): void {
  if (this.timerId !== 0) {
    clearTimeout(this.timerId); // 改为clearTimeout
    this.timerId = 0;
  }
}

11.2 游戏结束提示

当前游戏结束后只是返回ready状态，没有胜利提示。可以添加胜利弹窗：

// 添加胜利状态
@State isGameWon: boolean = false;

// 胜利时设置状态
private checkResult(): void {
  this.stopTimer();
  if (this.inputNumbers === this.displayNumbers) {
    // ... 记录进度 ...
    this.isGameWon = true;
  } else {
    this.inputNumbers = '';
  }
}

// 在build中添加胜利界面
if (this.isGameWon) {
  Column() {
    Text('恭喜通关!')
      .fontSize(36)
      .fontColor('#FFD700')
      .fontWeight(FontWeight.Bold)
    // ... 其他胜利信息 ...
  }
}

11.3 记忆时间可配置

当前记忆时间固定为3秒，可以根据难度动态调整：

private getMemoryTime(): number {
  if (this.numberLength === 3) return 3000;
  if (this.numberLength === 4) return 3000;
  if (this.numberLength === 5) return 4000;
  return 5000;
}

11.4 输入错误反馈

当前输入错误只是清空输入，没有反馈。可以添加错误提示：

// 添加错误状态
@State showError: boolean = false;

private checkResult(): void {
  this.stopTimer();
  if (this.inputNumbers === this.displayNumbers) {
    // 正确处理
  } else {
    this.showError = true;
    setTimeout(() => {
      this.showError = false;
    }, 500);
    this.inputNumbers = '';
  }
}

十二、总结

通过本文的详细分析，我们深入了解了记忆数字游戏的完整实现过程。从核心算法到UI交互，从状态管理到性能优化，每个环节都体现了HarmonyOS ArkTS开发的最佳实践。

关键技术要点：

1. 状态机设计：三态状态机（ready/display/input）管理游戏流程
2. 随机数字生成：生成指定长度的随机数字串
3. 数字键盘交互：自定义数字键盘，支持输入、退格和清空操作
4. 结果验证逻辑：比较输入与目标，正确则通关，错误则重新输入
5. 计时系统：仅在输入阶段计时，记录最佳成绩
6. 全局状态管理：AppState单例实现跨页面数据共享

这款游戏不仅是一个娱乐应用，更是一个基于科学原理的记忆训练工具。通过合理的难度设计和标准化的记忆任务，玩家可以在游戏中提升短期记忆力和注意力。

在未来的迭代中，可以考虑增加更多难度级别（如7位、8位数字），引入多人对战模式，添加记忆时间动态调整，以及添加更详细的训练数据分析功能，为用户提供更全面的记忆训练体验。