鸿蒙跨端历史人物问答游戏开发指南 原创

鸿蒙跨端历史人物问答游戏开发指南

一、项目概述

本文基于HarmonyOS的知识图谱和分布式技术，开发一款历史人物问答游戏。该系统能够通过知识图谱查询历史人物信息，实现多玩家问答对战，并将游戏状态同步到多设备，借鉴了《鸿蒙跨端U同步》中多设备数据同步的技术原理。

二、系统架构

±--------------------+ ±--------------------+ ±--------------------+
游戏主机 <-----> 分布式数据总线 <-----> 玩家设备
(Host Device) (Distributed Bus) (Player Devices)
±---------±---------+ ±---------±---------+ ±---------±---------+

±---------v----------+ ±---------v----------+ ±---------v----------+
知识图谱模块 游戏逻辑模块 状态同步模块
(Knowledge Graph) (Game Logic) (State Sync)

±--------------------+ ±--------------------+ ±--------------------+

三、核心代码实现
知识图谱服务

// src/main/ets/service/KnowledgeGraphService.ts
import { distributedData } from ‘@ohos.data.distributedData’;
import { BusinessError } from ‘@ohos.base’;
import { http } from ‘@ohos.net.http’;
import { knowledgeGraph } from ‘@ohos.ai.knowledgeGraph’;

interface HistoricalFigure {
id: string;
name: string;
birthYear: number;
deathYear: number;
nationality: string;
occupation: string[];
achievements: string[];
relatedFigures: string[];
interface Question {

id: string;
type: ‘birth_year’ ‘death_year’ ‘nationality’ ‘occupation’
‘achievement’;
figureId: string;
questionText: string;
options: string[];
correctAnswer: string;
difficulty: ‘easy’ ‘medium’
‘hard’;
export class KnowledgeGraphService {

private static instance: KnowledgeGraphService;
private kvStore: distributedData.KVStore | null = null;
private readonly STORE_ID = ‘history_quiz_store’;
private httpRequest = http.createHttp();
private kgClient: knowledgeGraph.KnowledgeGraphClient | null = null;
private readonly API_KEY = ‘YOUR_KNOWLEDGE_GRAPH_API_KEY’;
private readonly API_URL = ‘https://kgsearch.googleapis.com/v1/entities:search’;

private constructor() {
this.initKVStore();
this.initKnowledgeGraphClient();
public static getInstance(): KnowledgeGraphService {

if (!KnowledgeGraphService.instance) {
  KnowledgeGraphService.instance = new KnowledgeGraphService();

return KnowledgeGraphService.instance;

private async initKVStore(): Promise<void> {

try {
  const options: distributedData.KVManagerConfig = {
    bundleName: 'com.example.historyquiz',
    userInfo: {
      userId: '0',
      userType: distributedData.UserType.SAME_USER_ID

};

  const kvManager = distributedData.createKVManager(options);
  this.kvStore = await kvManager.getKVStore({
    storeId: this.STORE_ID,
    options: {
      createIfMissing: true,
      encrypt: false,
      backup: false,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.SINGLE_VERSION

});

catch (e) {

  console.error(Failed to initialize KVStore. Code: {e.code}, message: {e.message});

}

private async initKnowledgeGraphClient(): Promise<void> {
try {
this.kgClient = await knowledgeGraph.createKnowledgeGraphClient();
catch (e) {

  console.error(Failed to initialize Knowledge Graph client. Code: {e.code}, message: {e.message});

}

public async searchHistoricalFigure(name: string): Promise<HistoricalFigure | null> {
try {
// 先检查本地缓存
const cachedFigure = await this.getCachedFigure(name);
if (cachedFigure) return cachedFigure;

  // 调用知识图谱API
  const response = await this.httpRequest.request(
    this.API_URL,

method: http.RequestMethod.GET,

      header: {
        'Content-Type': 'application/json'
      },
      extraData: {
        query: name,
        key: this.API_KEY,
        limit: 1,
        types: 'Person',
        languages: 'zh'

}

  );
  
  const result = JSON.parse(response.result);
  if (result.itemListElement && result.itemListElement.length > 0) {
    const figure = this.parseFigureData(result.itemListElement[0].result);
    if (figure) {
      await this.cacheFigure(figure);
      return figure;

}

  return null;

catch (e) {

  console.error(Failed to search historical figure. Code: {e.code}, message: {e.message});
  return null;

}

private parseFigureData(data: any): HistoricalFigure | null {
if (!data.name || !data.description) return null;

return {
  id: data['@id'] || figure_${Date.now()},
  name: data.name,
  birthYear: this.extractYear(data.birthDate),
  deathYear: this.extractYear(data.deathDate),
  nationality: this.extractNationality(data.description),
  occupation: this.extractOccupations(data.description),
  achievements: this.extractAchievements(data.detailedDescription?.articleBody),
  relatedFigures: [] // 实际应用中应从知识图谱获取关联人物
};

private extractYear(dateStr: string): number {

if (!dateStr) return 0;
const yearMatch = dateStr.match(/\d{4}/);
return yearMatch ? parseInt(yearMatch[0]) : 0;

private extractNationality(description: string): string {

if (!description) return '未知';
const nationalityMatch = description.match(/(中国美国 英国 法国 德国 俄国

日本)/);
return nationalityMatch ? nationalityMatch[0] : ‘未知’;
private extractOccupations(description: string): string[] {

if (!description) return [];
const occupations: string[] = [];

if (description.includes('政治家')) occupations.push('政治家');
if (description.includes('军事家')) occupations.push('军事家');
if (description.includes('科学家')) occupations.push('科学家');
if (description.includes('艺术家')) occupations.push('艺术家');
if (description.includes('文学家')) occupations.push('文学家');

return occupations.length > 0 ? occupations : ['历史人物'];

private extractAchievements(description: string): string[] {

if (!description) return [];
// 简化的成就提取逻辑
const sentences = description.split(/[。！？]/);
return sentences.slice(0, 3); // 取前3句作为成就

private async getCachedFigure(name: string): Promise<HistoricalFigure | null> {

if (!this.kvStore) return null;

try {
  const entry = await this.kvStore.get(figure_${name});
  return entry?.value || null;

catch (e) {

  console.error(Failed to get cached figure. Code: {e.code}, message: {e.message});
  return null;

}

private async cacheFigure(figure: HistoricalFigure): Promise<void> {
if (this.kvStore) {
try {
await this.kvStore.put(figure_${figure.name}, { value: figure });
catch (e) {

    console.error(Failed to cache figure. Code: {e.code}, message: {e.message});

}

public async generateQuestion(figure: HistoricalFigure): Promise<Question> {

const questionTypes: Question['type'][] = [
  'birth_year', 'death_year', 'nationality', 'occupation', 'achievement'
];

const type = questionTypes[Math.floor(Math.random() * questionTypes.length)];
let questionText = '';
let correctAnswer = '';
let options: string[] = [];

switch (type) {
  case 'birth_year':
    questionText = ${figure.name}出生于哪一年？;
    correctAnswer = figure.birthYear.toString();
    options = this.generateYearOptions(figure.birthYear);
    break;
  case 'death_year':
    questionText = ${figure.name}逝世于哪一年？;
    correctAnswer = figure.deathYear.toString();
    options = this.generateYearOptions(figure.deathYear);
    break;
  case 'nationality':
    questionText = ${figure.name}的国籍是？;
    correctAnswer = figure.nationality;
    options = this.generateNationalityOptions(figure.nationality);
    break;
  case 'occupation':
    questionText = ${figure.name}的主要职业是？;
    correctAnswer = figure.occupation[0];
    options = this.generateOccupationOptions(figure.occupation[0]);
    break;
  case 'achievement':
    questionText = ${figure.name}的主要成就是？;
    correctAnswer = figure.achievements[0];
    options = this.generateAchievementOptions(figure.achievements[0]);
    break;

return {

  id: question_${Date.now()},
  type,
  figureId: figure.id,
  questionText,
  options: this.shuffleArray(options),
  correctAnswer,
  difficulty: this.determineDifficulty(figure)
};

private generateYearOptions(correctYear: number): string[] {

const options = [correctYear.toString()];
while (options.length < 4) {
  const randomYear = correctYear + Math.floor(Math.random() * 20) - 10;
  if (randomYear > 0 && !options.includes(randomYear.toString())) {
    options.push(randomYear.toString());

}

return options;

private generateNationalityOptions(correctNationality: string): string[] {

const nationalities = ['中国', '美国', '英国', '法国', '德国', '俄国', '日本'];
const options = [correctNationality];
while (options.length < 4) {
  const randomNat = nationalities[Math.floor(Math.random() * nationalities.length)];
  if (!options.includes(randomNat)) {
    options.push(randomNat);

}

return options;

private generateOccupationOptions(correctOccupation: string): string[] {

const occupations = ['政治家', '军事家', '科学家', '艺术家', '文学家', '哲学家', '探险家'];
const options = [correctOccupation];
while (options.length < 4) {
  const randomOcc = occupations[Math.floor(Math.random() * occupations.length)];
  if (!options.includes(randomOcc)) {
    options.push(randomOcc);

}

return options;

private generateAchievementOptions(correctAchievement: string): string[] {

// 实际应用中应从知识图谱获取其他成就作为干扰项
const achievements = [
  '领导了重要的历史变革',
  '创作了著名的文学作品',
  '做出了重大科学发现',
  '建立了新的国家',
  '推动了艺术发展',
  '发明了重要技术'
];

const options = [correctAchievement];
while (options.length < 4) {
  const randomAch = achievements[Math.floor(Math.random() * achievements.length)];
  if (!options.includes(randomAch)) {
    options.push(randomAch);

}

return options;

private shuffleArray(array: any[]): any[] {

for (let i = array.length - 1; i > 0; i--) {
  const j = Math.floor(Math.random() * (i + 1));
  [array[i], array[j]] = [array[j], array[i]];

return array;

private determineDifficulty(figure: HistoricalFigure): ‘easy’ ‘medium’
‘hard’ {

// 简化的难度判断逻辑
if (figure.achievements.length > 0 && figure.occupation.length > 0) {
  return Math.random() > 0.7 ? 'hard' : (Math.random() > 0.3 ? 'medium' : 'easy');

return ‘easy’;

public async destroy(): Promise<void> {

if (this.kvStore) {
  this.kvStore.off('dataChange');

}

游戏服务

// src/main/ets/service/GameService.ts
import { distributedData } from ‘@ohos.data.distributedData’;
import { BusinessError } from ‘@ohos.base’;
import { KnowledgeGraphService } from ‘./KnowledgeGraphService’;

interface Player {
id: string;
name: string;
avatar: string;
score: number;
correctAnswers: number;
wrongAnswers: number;
lastAnswerTime: number;
interface GameState {

id: string;
status: ‘waiting’ ‘playing’
‘finished’;
currentQuestion: Question | null;
players: Player[];
questionHistory: Question[];
startTime: number;
endTime: number;
lastUpdateTime: number;
export class GameService {

private static instance: GameService;
private kvStore: distributedData.KVStore | null = null;
private readonly STORE_ID = ‘history_quiz_game_store’;
private kgService = KnowledgeGraphService.getInstance();
private currentGame: GameState | null = null;

private constructor() {
this.initKVStore();
public static getInstance(): GameService {

if (!GameService.instance) {
  GameService.instance = new GameService();

return GameService.instance;

private async initKVStore(): Promise<void> {

try {
  const options: distributedData.KVManagerConfig = {
    bundleName: 'com.example.historyquiz',
    userInfo: {
      userId: '0',
      userType: distributedData.UserType.SAME_USER_ID

};

  const kvManager = distributedData.createKVManager(options);
  this.kvStore = await kvManager.getKVStore({
    storeId: this.STORE_ID,
    options: {
      createIfMissing: true,
      encrypt: false,
      backup: false,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.SINGLE_VERSION

});

  this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_REMOTE, (data) => {
    data.insertEntries.forEach((entry: distributedData.Entry) => {
      if (entry.key === 'game_state') {
        this.notifyGameStateChange(entry.value.value as GameState);

});

  });

catch (e) {

  console.error(Failed to initialize KVStore. Code: {e.code}, message: {e.message});

}

public async createNewGame(hostPlayer: Player): Promise<GameState> {
const newGame: GameState = {
id: game_${Date.now()},
status: ‘waiting’,
currentQuestion: null,
players: [hostPlayer],
questionHistory: [],
startTime: 0,
endTime: 0,
lastUpdateTime: Date.now()
};

this.currentGame = newGame;
await this.syncGameState();
return newGame;

public async joinGame(gameId: string, player: Player): Promise<GameState | null> {

if (!this.kvStore) return null;

try {
  const entry = await this.kvStore.get(gameId);
  const gameState = entry?.value as GameState;
  
  if (gameState && gameState.status === 'waiting') {
    if (!gameState.players.some(p => p.id === player.id)) {
      gameState.players.push(player);
      gameState.lastUpdateTime = Date.now();
      await this.kvStore.put(gameId, { value: gameState });
      this.currentGame = gameState;

return gameState;

return null;

catch (e) {

  console.error(Failed to join game. Code: {e.code}, message: {e.message});
  return null;

}

public async startGame(gameId: string): Promise<Question | null> {
if (!this.currentGame || this.currentGame.id !== gameId) return null;

this.currentGame.status = 'playing';
this.currentGame.startTime = Date.now();

const firstQuestion = await this.generateNewQuestion();
this.currentGame.currentQuestion = firstQuestion;
this.currentGame.lastUpdateTime = Date.now();

await this.syncGameState();
return firstQuestion;

public async generateNewQuestion(): Promise<Question | null> {

if (!this.currentGame) return null;

// 从预定义的历史人物列表中随机选择
const historicalFigures = [
  '孔子', '秦始皇', '拿破仑', '爱因斯坦', '达芬奇', 
  '李白', '武则天', '莎士比亚', '牛顿', '哥伦布'
];

const randomFigure = historicalFigures[Math.floor(Math.random() * historicalFigures.length)];
const figure = await this.kgService.searchHistoricalFigure(randomFigure);

if (!figure) return null;

const question = await this.kgService.generateQuestion(figure);
return question;

public async submitAnswer(playerId: string, answer: string): Promise<boolean> {

if (!this.currentGame || !this.currentGame.currentQuestion) return false;

const player = this.currentGame.players.find(p => p.id === playerId);
if (!player) return false;

const isCorrect = answer === this.currentGame.currentQuestion.correctAnswer;
const now = Date.now();

if (isCorrect) {
  player.score += this.calculateScore(this.currentGame.currentQuestion.difficulty, now);
  player.correctAnswers++;

else {

  player.wrongAnswers++;

player.lastAnswerTime = now;

this.currentGame.lastUpdateTime = now;

// 将当前问题添加到历史记录
this.currentGame.questionHistory.push(this.currentGame.currentQuestion);

// 生成新问题
const newQuestion = await this.generateNewQuestion();
this.currentGame.currentQuestion = newQuestion;

await this.syncGameState();
return isCorrect;

private calculateScore(difficulty: ‘easy’ ‘medium’
‘hard’, answerTime: number): number {

const baseScores = {
  easy: 10,
  medium: 20,
  hard: 30
};

const timeBonus = Math.max(0, 10 - Math.floor((answerTime - this.currentGame.lastUpdateTime) / 1000));
return baseScores[difficulty] + timeBonus;

public async endGame(): Promise<void> {

if (!this.currentGame) return;

this.currentGame.status = 'finished';
this.currentGame.endTime = Date.now();
this.currentGame.lastUpdateTime = Date.now();

await this.syncGameState();
this.currentGame = null;

private async syncGameState(): Promise<void> {

if (this.kvStore && this.currentGame) {
  try {
    await this.kvStore.put(this.currentGame.id, { value: this.currentGame });

catch (e) {

    console.error(Failed to sync game state. Code: {e.code}, message: {e.message});

}

private notifyGameStateChange(newState: GameState): void {

// 使用时间戳解决冲突 - 保留最新的游戏状态
if (!this.currentGame || newState.lastUpdateTime > this.currentGame.lastUpdateTime) {
  this.currentGame = newState;

}

public async getCurrentGame(): Promise<GameState | null> {
return this.currentGame;
public async destroy(): Promise<void> {

if (this.kvStore) {
  this.kvStore.off('dataChange');

}

游戏界面组件

// src/main/ets/components/HistoryQuizGame.ets
@Component
export struct HistoryQuizGame {
private gameService = GameService.getInstance();
private kgService = KnowledgeGraphService.getInstance();
@State currentGame: GameState | null = null;
@State playerName: string = ‘’;
@State playerAvatar: string = $r(‘app.media.default_avatar’);
@State showCreateDialog: boolean = false;
@State showJoinDialog: boolean = false;
@State gameIdToJoin: string = ‘’;

aboutToAppear(): void {
this.loadCurrentGame();
private async loadCurrentGame(): Promise<void> {

this.currentGame = await this.gameService.getCurrentGame();

build() {

Column() {
  // 标题
  Text('历史人物问答')
    .fontSize(24)
    .fontWeight(FontWeight.Bold)
    .margin({ bottom: 20 });
  
  // 游戏状态显示
  if (this.currentGame) {
    this.buildGameScreen();

else {

    this.buildLobbyScreen();

}

.width('100%')
.height('100%')
.padding(20)

// 创建游戏对话框
if (this.showCreateDialog) {
  Dialog.show({
    title: '创建新游戏',
    content: this.buildCreateDialogContent(),
    confirm: {
      value: '创建',
      action: () => {
        this.createNewGame();
        this.showCreateDialog = false;

},

    cancel: () => {
      this.showCreateDialog = false;

});

// 加入游戏对话框

if (this.showJoinDialog) {
  Dialog.show({
    title: '加入游戏',
    content: this.buildJoinDialogContent(),
    confirm: {
      value: '加入',
      action: () => {
        this.joinGame();
        this.showJoinDialog = false;

},

    cancel: () => {
      this.showJoinDialog = false;

});

}

@Builder
private buildLobbyScreen() {
Column() {
Text(‘欢迎来到历史人物问答’)
.fontSize(18)
.margin({ bottom: 30 });

  Row() {
    Text('玩家名称:')
      .fontSize(16)
      .margin({ right: 10 });
    
    TextInput({ placeholder: '输入你的名字', text: this.playerName })
      .width('60%')
      .onChange((value: string) => {
        this.playerName = value;
      });

.width(‘100%’)

  .margin({ bottom: 20 });
  
  Button('创建新游戏')
    .type(ButtonType.Capsule)
    .width('80%')
    .backgroundColor('#4CAF50')
    .fontColor('#FFFFFF')
    .margin({ bottom: 20 })
    .onClick(() => {
      this.showCreateDialog = true;
    });
  
  Button('加入游戏')
    .type(ButtonType.Capsule)
    .width('80%')
    .backgroundColor('#2196F3')
    .fontColor('#FFFFFF')
    .onClick(() => {
      this.showJoinDialog = true;
    });

.width(‘100%’)

.height('100%')
.justifyContent(FlexAlign.Center)
.alignItems(HorizontalAlign.Center);

@Builder

private buildGameScreen() {
if (!this.currentGame) return;

Column() {
  // 游戏状态
  Row() {
    Text(this.currentGame.status === 'waiting' ? '等待玩家加入...' : 
         this.currentGame.status === 'playing' ? '游戏中' : '游戏结束')
      .fontSize(18)
      .fontWeight(FontWeight.Bold)
      .layoutWeight(1);
    
    Text(玩家: ${this.currentGame.players.length})
      .fontSize(16);

.width(‘100%’)

  .margin({ bottom: 20 });
  
  // 当前问题
  if (this.currentGame.currentQuestion && this.currentGame.status === 'playing') {
    this.buildQuestionScreen();

// 玩家列表

  this.buildPlayersList();
  
  // 控制按钮
  if (this.currentGame.status === 'waiting') {
    Button('开始游戏')
      .type(ButtonType.Capsule)
      .width('80%')
      .backgroundColor('#FF4081')
      .fontColor('#FFFFFF')
      .margin({ top: 20 })
      .onClick(() => {
        this.startGame();
      });

else if (this.currentGame.status === ‘finished’) {

    Button('返回大厅')
      .type(ButtonType.Capsule)
      .width('80%')
      .backgroundColor('#9C27B0')
      .fontColor('#FFFFFF')
      .margin({ top: 20 })
      .onClick(() => {
        this.leaveGame();
      });

}

@Builder

private buildQuestionScreen() {
if (!this.currentGame?.currentQuestion) return;

const question = this.currentGame.currentQuestion;

Column() {
  Text(question.questionText)
    .fontSize(20)
    .fontWeight(FontWeight.Bold)
    .textAlign(TextAlign.Center)
    .margin({ bottom: 30 });
  
  Grid() {
    ForEach(question.options, (option, index) => {
      GridItem() {
        Button(option)
          .type(ButtonType.Normal)
          .width('100%')
          .height(80)
          .fontSize(16)
          .backgroundColor('#FFFFFF')
          .onClick(() => {
            this.submitAnswer(option);
          });

})

.columnsTemplate(‘1fr 1fr’)

  .rowsTemplate('1fr 1fr')
  .columnsGap(10)
  .rowsGap(10)
  .width('100%')
  .height(180)
  .margin({ bottom: 20 });
  
  Text(难度: ${this.getDifficultyText(question.difficulty)})
    .fontSize(14)
    .fontColor('#666666');

.width(‘100%’)

.padding(20)
.backgroundColor('#F5F5F5')
.borderRadius(15)
.margin({ bottom: 20 });

@Builder

private buildPlayersList() {
if (!this.currentGame) return;

Column() {
  Text('玩家列表')
    .fontSize(16)
    .fontWeight(FontWeight.Bold)
    .margin({ bottom: 10 });
  
  List({ space: 10 }) {
    ForEach(this.currentGame.players, (player) => {
      ListItem() {
        Row() {
          Image(player.avatar)
            .width(40)
            .height(40)
            .margin({ right: 15 })
            .borderRadius(20);
          
          Column() {
            Text(player.name)
              .fontSize(16)
              .fontWeight(FontWeight.Bold);
            
            Text(得分: ${player.score})
              .fontSize(14)
              .fontColor('#666666');

.layoutWeight(1);

          if (this.currentGame.status === 'finished') {
            Text({player.correctAnswers}正确/{player.wrongAnswers}错误)
              .fontSize(14)
              .fontColor('#666666');

}

        .width('100%')
        .padding(10)

})

.width(‘100%’)

  .height(200);

.width(‘100%’);

@Builder

private buildCreateDialogContent() {
Column() {
Text(‘设置游戏选项’)
.fontSize(18)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 20 });

  Row() {
    Text('玩家头像:')
      .fontSize(16)
      .margin({ right: 10 });
    
    Image(this.playerAvatar)
      .width(60)
      .height(60)
      .borderRadius(30)
      .onClick(() => {
        this.selectAvatar();
      });

.width(‘100%’)

  .margin({ bottom: 15 });

.width(‘100%’)

.padding(10);

@Builder

private buildJoinDialogContent() {
Column() {
Text(‘输入游戏ID’)
.fontSize(18)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 20 });

  TextInput({ placeholder: '输入游戏ID', text: this.gameIdToJoin })
    .width('100%')
    .onChange((value: string) => {
      this.gameIdToJoin = value;
    });

.width(‘100%’)

.padding(10);

private async createNewGame(): Promise<void> {

if (!this.playerName.trim()) {
  prompt.showToast({ message: '请输入玩家名称', duration: 2000 });
  return;

const player: Player = {

  id: player_${Date.now()},
  name: this.playerName,
  avatar: this.playerAvatar,
  score: 0,
  correctAnswers: 0,
  wrongAnswers: 0,
  lastAnswerTime: 0
};

this.currentGame = await this.gameService.createNewGame(player);

private async joinGame(): Promise<void> {

if (!this.playerName.trim()) {
  prompt.showToast({ message: '请输入玩家名称', duration: 2000 });
  return;

if (!this.gameIdToJoin.trim()) {

  prompt.showToast({ message: '请输入游戏ID', duration: 2000 });
  return;

const player: Player = {

  id: player_${Date.now()},
  name: this.playerName,
  avatar: this.playerAvatar,
  score: 0,
  correctAnswers: 0,
  wrongAnswers: 0,
  lastAnswerTime: 0
};

const gameState = await this.gameService.joinGame(this.gameIdToJoin, player);
if (gameState) {
  this.currentGame = gameState;

else {

  prompt.showToast({ message: '加入游戏失败', duration: 2000 });

}

private async startGame(): Promise<void> {
if (!this.currentGame) return;

const question = await this.gameService.startGame(this.currentGame.id);
if (question) {
  this.currentGame.currentQuestion = question;

}

private async submitAnswer(answer: string): Promise<void> {
if (!this.currentGame) return;

const playerId = this.currentGame.players[0].id; // 简化为当前玩家
const isCorrect = await this.gameService.submitAnswer(playerId, answer);

prompt.showToast({ 
  message: isCorrect ? '回答正确!' : '回答错误!', 
  duration: 2000 
});

private async leaveGame(): Promise<void> {

this.currentGame = null;

private selectAvatar(): void {

// 实际应用中应提供头像选择功能
const avatars = [
  $r('app.media.avatar1'),
  $r('app.media.avatar2'),
  $r('app.media.avatar3')
];

this.playerAvatar = avatars[Math.floor(Math.random() * avatars.length)];

private getDifficultyText(difficulty: ‘easy’ ‘medium’
‘hard’): string {

switch (difficulty) {
  case 'easy': return '简单';
  case 'medium': return '中等';
  case 'hard': return '困难';
  default: return difficulty;

}

四、与游戏同步技术的结合点
分布式状态同步：借鉴游戏中多玩家状态同步机制，实现游戏状态的跨设备实时同步

实时问答交互：类似游戏中的实时操作反馈，确保多玩家同时答题的公平性

主机/客户端角色：类似游戏中的主机/客户端角色，确定游戏主机和玩家设备

时间同步机制：确保多设备间的时间戳一致，类似游戏中的时间同步

数据压缩传输：优化问题和游戏状态的传输效率，类似游戏中的网络优化

五、关键特性实现
知识图谱查询：

  const figure = await this.kgService.searchHistoricalFigure('孔子');

问题生成算法：

  const question = await this.kgService.generateQuestion(figure);

游戏状态同步：

  await this.kvStore.put(this.currentGame.id, { value: this.currentGame });

得分计算：

  const score = baseScores[difficulty] + timeBonus;

六、性能优化策略
本地缓存优先：

  const cachedFigure = await this.getCachedFigure(name);

if (cachedFigure) return cachedFigure;

批量状态更新：

  private scheduleSync(): void {
 if (this.syncTimer) clearTimeout(this.syncTimer);
 this.syncTimer = setTimeout(() => {
   this.syncGameState();
   this.syncTimer = null;
 }, 1000); // 1秒内多次更新只同步一次

资源释放管理：

  public async destroy(): Promise<void> {
 if (this.kvStore) {
   this.kvStore.off('dataChange');

}

网络请求节流：

  private lastApiRequestTime = 0;

private readonly API_REQUEST_INTERVAL = 3000; // 3秒请求间隔

private async searchHistoricalFigure(name: string): Promise<HistoricalFigure | null> {
const now = Date.now();
if (now - this.lastApiRequestTime < this.API_REQUEST_INTERVAL) {
return null;
this.lastApiRequestTime = now;

 // API请求逻辑...

七、项目扩展方向
更多历史人物：扩展知识图谱覆盖的历史人物范围

多人语音聊天：增加玩家间的语音交流功能

成就系统：设置游戏成就和奖励

历史知识学习：提供历史人物详细资料学习模式

自定义题库：允许用户创建和分享自定义问题

八、总结

本历史人物问答游戏实现了以下核心功能：
基于知识图谱的历史人物信息查询

智能问题生成与多玩家问答对战

实时游戏状态同步与分数计算

直观的用户界面和交互体验

通过借鉴游戏中的多设备同步技术，我们构建了一个寓教于乐的历史知识学习工具。该项目展示了HarmonyOS在分布式技术和知识图谱应用方面的强大能力，为开发者提供了教育类应用开发的参考方案。