项目概述

这是一个基于 Electron 开发的射击游戏应用，玩家控制飞船移动并射击敌人，包含多种敌人类型、升级系统、特效和成就系统。本项目展示了如何在 Electron 环境中构建复杂游戏逻辑、物理碰撞和动态难度调整的跨平台桌面游戏，同时新增鸿蒙 PC 平台适配方案。针对鸿蒙特性优化了粒子效果、碰撞检测和 AI 行为，减少资源占用，确保游戏流畅运行，核心玩法（飞船控制、射击、敌人对战、道具收集）在鸿蒙端完全兼容，可作为动作类 Electron 游戏迁移鸿蒙 PC 的实践案例。

技术架构

项目采用 Electron 主进程 - 渲染进程架构，新增鸿蒙适配层，核心模块包括：

1. 主进程模块：负责窗口管理、应用生命周期和鸿蒙环境适配（禁用硬件加速、窗口配置优化）
2. 渲染进程模块：包含游戏核心逻辑、Canvas 渲染（鸿蒙端优化）、物理碰撞和用户交互处理
3. IPC 通信层：实现主进程和渲染进程之间的安全通信（鸿蒙端兼容）
4. 资源管理模块：处理游戏配置、状态持久化和音效管理（适配鸿蒙音频 API）
5. 鸿蒙适配层：处理系统能力配置、.so 库依赖管理、性能优化（粒子简化、AI 轻量化）

核心算法实现（鸿蒙适配优化）

1. 游戏状态管理 - 鸿蒙兼容扩展

javascript

运行

const GAME_STATE = {
    IDLE: 'idle',
    RUNNING: 'running',
    PAUSED: 'paused',
    GAME_OVER: 'gameOver'
};
// 游戏状态变量（鸿蒙兼容优化）
let gameState = GAME_STATE.IDLE;
let isHarmonyOS = process.env.OHOS_ENV ? true : false;
// 鸿蒙端性能配置
const harmonyConfig = {
    particleLimit: 50, // 限制粒子数量
    collisionCheckInterval: 2, // 每2帧检查一次碰撞
    enemySpawnReduce: 0.3, // 敌人生成速率降低30%
    aiUpdateInterval: 150 // AI更新间隔（毫秒）
};

2. 主进程代码（main.js）- 鸿蒙核心适配

javascript

运行

// Electron主进程代码（鸿蒙适配版）
const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
let mainWindow;
let lastTime = 0;

function createWindow() {
    // 鸿蒙PC必须禁用硬件加速（解决Canvas渲染异常、粒子卡顿问题）
    app.disableHardwareAcceleration();

    mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        resizable: true,
        title: '射击游戏',
        webPreferences: {
            preload: path.join(__dirname, 'src', 'preload.js'),
            nodeIntegration: false,
            contextIsolation: true,
            enableRemoteModule: false
        },
        // 鸿蒙PC窗口适配优化
        fullscreenable: false, // 禁用全屏，避免系统兼容性冲突
        titleBarStyle: 'default', // 适配鸿蒙原生标题栏
        backgroundColor: '#000' // 优化初始渲染背景
    });

    // 加载应用的index.html
    mainWindow.loadFile(path.join(__dirname, 'src', 'index.html'));

    // 鸿蒙环境检测与额外配置
    if (process.env.OHOS_ENV) {
        console.log('Running on HarmonyOS PC, applying compatibility patches');
        // 禁用窗口阴影和透明效果，减少性能消耗
        mainWindow.setHasShadow(false);
        mainWindow.setOpacity(1.0);
    }

    // 窗口关闭时触发
    mainWindow.on('closed', () => {
        mainWindow = null;
    });
}

// IPC事件处理（保持原有逻辑，鸿蒙端兼容）
ipcMain.on('game-score-updated', (event, score) => {
    if (mainWindow) {
        mainWindow.setTitle(`射击游戏 - 分数: ${score}`);
    }
});

ipcMain.on('game-over', (event, stats) => {
    console.log('游戏结束', stats);
});

ipcMain.on('request-fullscreen', (event, enabled) => {
    if (mainWindow && !process.env.OHOS_ENV) { // 鸿蒙端禁用全屏
        mainWindow.setFullScreen(enabled);
    }
});

// 应用事件处理（保持原有逻辑）
app.whenReady().then(createWindow);
app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        app.quit();
    }
});
app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
        createWindow();
    }
});

3. 游戏循环与时间管理 - 鸿蒙性能优化

针对鸿蒙端渲染压力，降低非核心逻辑更新频率：

javascript

运行

function gameLoop(currentTime) {
    // 计算时间增量
    const deltaTime = currentTime - lastTime;
    lastTime = currentTime;

    if (gameState === GAME_STATE.RUNNING) {
        // 鸿蒙端优化：降低更新频率，减少CPU占用
        const updateInterval = isHarmonyOS ? 16 : 8;
        if (currentTime % updateInterval < 8) {
            updatePlayer(deltaTime);
            updateBullets(deltaTime);
            updatePowerUps(deltaTime);
            updateExplosions(deltaTime);
        }

        // 鸿蒙端优化：间隔检查碰撞，减少计算量
        if (!isHarmonyOS || currentTime % (16 * harmonyConfig.collisionCheckInterval) < 8) {
            checkCollisions();
        }

        // 鸿蒙端优化：降低AI更新频率
        if (!isHarmonyOS || currentTime % harmonyConfig.aiUpdateInterval < 8) {
            updateEnemies(deltaTime);
        }

        // 粒子更新（鸿蒙端限制数量）
        updateParticles(deltaTime, isHarmonyOS ? harmonyConfig.particleLimit : Infinity);

        // 关键逻辑保持实时更新
        checkAchievements();
        checkLevelProgress();
    }

    // 渲染游戏画面（鸿蒙端简化特效）
    render(isHarmonyOS);

    // 更新UI（鸿蒙端降低更新频率）
    if (!isHarmonyOS || currentTime % 32 < 8) {
        updateUI();
    }

    // 继续游戏循环
    animationId = requestAnimationFrame(gameLoop);
}

4. 碰撞检测系统 - 鸿蒙效率优化

使用空间划分 + 间隔检查，减少鸿蒙端计算量：

javascript

运行

// 空间划分：将屏幕分为4x4网格，仅检查同网格内对象碰撞
const gridSize = 4;
let collisionGrid = [];

// 初始化碰撞网格
function initCollisionGrid(canvasWidth, canvasHeight) {
    const cellWidth = canvasWidth / gridSize;
    const cellHeight = canvasHeight / gridSize;
    collisionGrid = Array(gridSize).fill().map(() => Array(gridSize).fill().map(() => []));
    return { cellWidth, cellHeight };
}

// 更新对象到碰撞网格
function updateCollisionGrid(objects, cellWidth, cellHeight) {
    // 清空网格
    collisionGrid.forEach(row => row.forEach(cell => cell.length = 0));
    
    objects.forEach(obj => {
        const gridX = Math.min(Math.floor(obj.x / cellWidth), gridSize - 1);
        const gridY = Math.min(Math.floor(obj.y / cellHeight), gridSize - 1);
        collisionGrid[gridY][gridX].push(obj);
    });
}

function checkCollisions() {
    const { cellWidth, cellHeight } = initCollisionGrid(canvas.width, canvas.height);
    
    // 更新所有对象到网格
    const allObjects = [...enemies, ...bullets, ...powerUps, player];
    updateCollisionGrid(allObjects, cellWidth, cellHeight);

    // 仅检查同网格内对象碰撞
    for (let y = 0; y < gridSize; y++) {
        for (let x = 0; x < gridSize; x++) {
            const cellObjects = collisionGrid[y][x];
            // 检查单元格内所有对象对
            for (let i = 0; i < cellObjects.length; i++) {
                for (let j = i + 1; j < cellObjects.length; j++) {
                    const obj1 = cellObjects[i];
                    const obj2 = cellObjects[j];
                    // 仅检查相关对象对（玩家-敌人、子弹-敌人、玩家-道具）
                    if (isRelevantCollisionPair(obj1, obj2) && checkCollision(obj1, obj2)) {
                        handleCollision(obj1, obj2);
                    }
                }
            }
        }
    }
}

// 检查是否为相关碰撞对（减少无效检查）
function isRelevantCollisionPair(obj1, obj2) {
    const types = [obj1.type, obj2.type];
    return (
        (types.includes('player') && types.includes('enemy')) ||
        (types.includes('bullet') && types.includes('enemy')) ||
        (types.includes('player') && types.includes('powerUp'))
    );
}

// 基础碰撞检测（保持原有逻辑）
function checkCollision(obj1, obj2) {
    return obj1.x < obj2.x + obj2.width &&
           obj1.x + obj1.width > obj2.x &&
           obj1.y < obj2.y + obj2.height &&
           obj1.y + obj1.height > obj2.y;
}

5. 粒子效果系统 - 鸿蒙简化优化

限制粒子数量，使用对象池重用，减少内存分配：

javascript

运行

// 粒子对象池（鸿蒙端优化核心）
const particlePool = {
    pool: [],
    maxSize: harmonyConfig.particleLimit,
    
    getParticle(x, y, size, color) {
        // 从池中获取空闲粒子
        let particle = this.pool.find(p => !p.active);
        if (!particle) {
            // 池满则复用最旧粒子
            if (this.pool.length >= this.maxSize) {
                particle = this.pool.shift();
            } else {
                particle = { active: false };
                this.pool.push(particle);
            }
        }
        
        // 初始化粒子属性
        particle.x = x;
        particle.y = y;
        particle.size = size;
        particle.color = color;
        particle.speedX = (Math.random() - 0.5) * 4;
        particle.speedY = (Math.random() - 0.5) * 4;
        particle.life = 60; // 生命周期（帧数）
        particle.active = true;
        
        return particle;
    },
    
    updateAll(deltaTime) {
        // 更新所有活跃粒子
        this.pool.forEach(particle => {
            if (particle.active) {
                particle.x += particle.speedX;
                particle.y += particle.speedY;
                particle.life--;
                // 生命周期结束标记为空闲
                if (particle.life <= 0) {
                    particle.active = false;
                }
            }
        });
    },
    
    renderAll(ctx, isHarmonyOS) {
        // 渲染所有活跃粒子（鸿蒙端简化绘制）
        this.pool.forEach(particle => {
            if (particle.active) {
                ctx.fillStyle = particle.color;
                // 鸿蒙端简化：使用矩形替代圆形，减少绘制耗时
                if (isHarmonyOS) {
                    ctx.fillRect(particle.x, particle.y, particle.size, particle.size);
                } else {
                    ctx.beginPath();
                    ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2);
                    ctx.fill();
                }
            }
        });
    }
};

// 创建爆炸效果（鸿蒙端限制粒子数量）
function createExplosion(x, y, size) {
    const particleCount = isHarmonyOS ? Math.min(Math.floor(size / 3), 20) : Math.floor(size / 2);
    for (let i = 0; i < particleCount; i++) {
        const particleSize = isHarmonyOS ? Math.random() * 3 + 1 : Math.random() * 5 + 2;
        const color = `rgba(${Math.floor(Math.random() * 255)}, ${Math.floor(Math.random() * 60)}, 0, 0.8)`;
        particlePool.getParticle(x, y, particleSize, color);
    }
}

// 更新粒子（调用对象池方法）
function updateParticles(deltaTime, particleLimit) {
    particlePool.updateAll(deltaTime);
}

6. 敌人 AI 系统 - 鸿蒙轻量化调整

简化 AI 行为模式，减少决策计算：

javascript

运行

// 创建敌人（鸿蒙端降低属性强度）
function createEnemy(type, speedMultiplier = 1, healthMultiplier = 1) {
    let enemy = {
        type,
        x: Math.random() * (canvas.width - 50),
        y: -50,
        width: 30,
        height: 30,
        speed: 2,
        health: 1,
        score: 10,
        shootRate: 0,
        shootTimer: 0
    };

    // 根据敌人类型设置属性（鸿蒙端调整参数）
    switch (type) {
        case 'BASIC':
            enemy.width = 30;
            enemy.height = 30;
            enemy.speed = isHarmonyOS ? 1.5 : 2;
            enemy.health = 1 * healthMultiplier;
            enemy.score = 10;
            break;
        case 'FAST':
            enemy.width = 25;
            enemy.height = 25;
            enemy.speed = isHarmonyOS ? 3 : 4;
            enemy.health = 1 * healthMultiplier;
            enemy.score = 15;
            break;
        case 'TANK':
            enemy.width = 40;
            enemy.height = 40;
            enemy.speed = isHarmonyOS ? 0.8 : 1;
            enemy.health = isHarmonyOS ? 2 : 3 * healthMultiplier;
            enemy.score = 30;
            enemy.shootRate = isHarmonyOS ? 3000 : 2000; // 鸿蒙端降低射击频率
            break;
        case 'BOSS':
            enemy.width = 80;
            enemy.height = 80;
            enemy.speed = isHarmonyOS ? 1 : 1.5;
            enemy.health = isHarmonyOS ? 15 : 20 * healthMultiplier;
            enemy.score = 100;
            enemy.shootRate = isHarmonyOS ? 2000 : 1500;
            break;
    }

    // 鸿蒙端降低敌人生成密度
    if (isHarmonyOS) {
        enemy.speed *= 0.9;
        enemy.health *= 0.8;
    }

    enemies.push(enemy);
}

// 更新敌人（鸿蒙端简化行为逻辑）
function updateEnemies(deltaTime) {
    enemies.forEach(enemy => {
        // 基础移动（鸿蒙端简化路径）
        switch (enemy.type) {
            case 'BASIC':
                enemy.y += enemy.speed; // 直线移动（保留核心逻辑）
                break;
            case 'FAST':
                // 鸿蒙端简化：小幅摇摆改为固定偏移
                enemy.y += enemy.speed;
                enemy.x += Math.sin(enemy.y / 50) * 1.5;
                break;
            case 'TANK':
                enemy.y += enemy.speed;
                // 鸿蒙端简化：射击逻辑改为固定间隔
                enemy.shootTimer += deltaTime;
                if (enemy.shootTimer > enemy.shootRate) {
                    enemyShoot(enemy);
                    enemy.shootTimer = 0;
                }
                break;
            case 'BOSS':
                // 鸿蒙端简化：复杂移动改为左右往返
                enemy.x += enemy.speed * (enemy.moveDirection || 1);
                if (enemy.x > canvas.width - enemy.width || enemy.x < 0) {
                    enemy.moveDirection = enemy.moveDirection ? -enemy.moveDirection : -1;
                }
                enemy.y += 0.2;
                break;
        }

        // 移除超出屏幕的敌人
        if (enemy.y > canvas.height + enemy.height) {
            enemies.splice(enemies.indexOf(enemy), 1);
        }
    });
}

7. IPC 通信机制 - 鸿蒙兼容调整

javascript

运行

// 渲染进程preload.js（鸿蒙兼容版）
const { contextBridge, ipcRenderer } = require('electron');

// 向渲染进程暴露API
contextBridge.exposeInMainWorld('shootingGameAPI', {
    // 游戏控制API（鸿蒙端兼容）
    startGame: () => ipcRenderer.send('game-start'),
    pauseGame: () => ipcRenderer.send('game-pause'),
    resumeGame: () => ipcRenderer.send('game-resume'),
    restartGame: () => ipcRenderer.send('game-restart'),
    endGame: () => ipcRenderer.send('game-end'),
    
    // 窗口控制API（鸿蒙端禁用全屏）
    setFullscreen: (enabled) => {
        if (!process.env.OHOS_ENV) {
            ipcRenderer.send('request-fullscreen', enabled);
        }
    },
    updateWindowTitle: (title) => ipcRenderer.send('update-window-title', title),
    
    // 事件监听API
    onGameStart: (callback) => ipcRenderer.on('game-start', callback),
    onGamePause: (callback) => ipcRenderer.on('game-pause', callback),
    onGameResume: (callback) => ipcRenderer.on('game-resume', callback),
    
    // 新增：鸿蒙环境检测
    env: {
        isHarmonyOS: process.env.OHOS_ENV ? true : false
    }
});

项目结构

1. 原始 Electron 项目结构（保持不变）

plaintext

57-shooting-game/
├── README.md          # 项目说明文档
├── main.js            # Electron主进程代码
├── package.json       # 项目配置和依赖
└── src/               # 渲染进程代码
    ├── index.html     # 应用主页面
    ├── preload.js     # 预加载脚本
    ├── renderer.js    # 游戏核心逻辑
    ├── style.css      # 样式表
    └── config.js      # 游戏配置常量

2. 鸿蒙 PC 适配后项目结构（新增 / 调整）

plaintext

ohos_hap/                # 鸿蒙应用根目录（整合Electron项目）
├── electron/            # Electron鸿蒙核心依赖
│   └── libs/
│       └── arm64-v8a/  # 鸿蒙核心库文件（必须完整）
│           ├── libelectron.so
│           ├── libadapter.so
│           ├── libffmpeg.so
│           └── libc++_shared.so
├── web_engine/
│   └── src/
│       └── main/
│           └── resources/
│               └── resfile/
│                   └── resources/
│                       └── app/  # 原有57-shooting-game项目代码迁移至此
│                           ├── main.js          # 已适配鸿蒙的主进程代码
│                           ├── package.json     # 适配后的依赖配置
│                           └── src/             # 原有src目录完整迁移
│                               ├── index.html
│                               ├── preload.js
│                               ├── renderer.js
│                               ├── style.css
│                               └── config.js
└── module.json5        # 鸿蒙应用配置文件（新增）

鸿蒙适配核心配置文件

1. package.json（适配调整）

json

{
  "name": "shooting-game-harmonyos",
  "version": "1.0.0",
  "main": "main.js",
  "scripts": {
    "start": "electron .", // 原有Electron运行脚本
    "dev": "electron . --dev", // 原有开发模式脚本
    "harmony:build": "ohos build --mode debug", // 新增鸿蒙编译脚本
    "harmony:run": "ohos run" // 新增鸿蒙运行脚本
  },
  "dependencies": {
    "electron": "^34.0.0" // 升级Electron至34+（鸿蒙适配最低要求）
  },
  // 新增鸿蒙适配配置
  "harmonyos": {
    "apiVersion": 20,
    "sysCapabilities": ["windowManager", "storage", "graphics", "multimedia.audio"]
  }
}

2. module.json5（鸿蒙新增配置文件）

json5

{
  "app": {
    "bundleName": "com.example.shootinggame",
    "bundleVersion": "1.0.0",
    "minAPIVersion": 20
  },
  "module": {
    "name": "shooting_module",
    "type": "application",
    "srcPath": "./",
    "deviceTypes": ["pc"], // 指定为鸿蒙PC设备
    "reqSysCapabilities": [ // 仅保留必要系统能力
      "windowManager", // 窗口管理能力
      "storage", // 本地存储（游戏设置/高分记录）
      "graphics", // 图形渲染（Canvas依赖）
      "multimedia.audio", // 音效播放
      "permission:ohos.permission.READ_USER_STORAGE",
      "permission:ohos.permission.WRITE_USER_STORAGE"
    ],
    "abilities": [
      {
        "name": "MainAbility",
        "srcPath": "./web_engine",
        "description": "射击游戏主入口",
        "icon": "$media:icon",
        "label": "Shooting Game",
        "visible": true,
        "launchType": "standard"
      }
    ]
  }
}

鸿蒙 PC 适配改造核心步骤

1. 环境准备

• 系统要求：Windows 10/11、8GB RAM 以上、20GB 可用空间
• 工具安装：
  • DevEco Studio 5.0+（安装鸿蒙 SDK API 20+）
  • Node.js 18.x+
  • Electron 34+（鸿蒙适配最低版本）

2. 项目迁移与依赖配置

1. 登录Electron 鸿蒙官方仓库
2. 下载 Electron 34 + 版本的 Release 包（.zip 格式）
3. 解压后将electron/libs/arm64-v8a/目录复制到ohos_hap/electron/libs/下（确保 4 个核心.so 库完整）
4. 将原有 57-shooting-game 项目的所有文件复制到ohos_hap/web_engine/src/main/resources/resfile/resources/app/目录下

3. 代码改造

1. 修改 main.js：添加硬件加速禁用代码，优化窗口配置
2. 调整 package.json：升级 Electron 版本，新增鸿蒙编译 / 运行脚本
3. 创建 module.json5：配置应用信息、系统能力和设备类型
4. 优化 renderer.js：
   • 新增鸿蒙环境判断逻辑
   • 实现粒子系统对象池，限制粒子数量
   • 优化碰撞检测（空间划分 + 间隔检查）
   • 简化敌人 AI 行为模式，降低更新频率
   • 调整游戏循环，减少非核心逻辑更新次数

4. 编译与运行

1. 在 DevEco Studio 中打开 ohos_hap 目录
2. 配置签名：进入 File → Project Structure → Signing Configs，自动生成调试签名
3. 连接鸿蒙 PC 设备：启用开发者模式和 USB 调试，通过 USB Type-C 连接电脑
4. 编译运行：点击 Run 按钮或执行npm run harmony:run

5. 验证检查项

• ✅ 应用窗口正常显示，无黑屏 / 闪退
• ✅ 飞船移动流畅，响应无延迟
• ✅ 子弹发射、飞行逻辑正常
• ✅ 敌人生成、移动、射击行为正常
• ✅ 碰撞检测准确（飞船 - 敌人、子弹 - 敌人、飞船 - 道具）
• ✅ 粒子效果（爆炸、击中反馈）正常播放
• ✅ 道具收集和效果生效正常
• ✅ 分数计算、关卡升级逻辑正常
• ✅ 控制台无 "SysCap 不匹配" 或 "找不到.so 文件" 错误
• ✅ 响应式布局生效，窗口大小可调整
• ✅ 音效正常播放（若启用）

跨平台兼容性

平台	适配策略	特殊处理
Windows	标准 Electron 运行	无特殊配置
macOS	标准 Electron 运行	保留 dock 图标激活逻辑
Linux	标准 Electron 运行	确保系统依赖库完整
鸿蒙 PC	通过 Electron 鸿蒙适配层运行	1. 禁用硬件加速2. 使用特定目录结构3. 粒子系统对象池 + 数量限制4. 碰撞检测空间划分 + 间隔检查5. 简化敌人 AI 行为模式6. 降低非核心逻辑更新频率7. 配置必要系统能力（windowManager、storage、graphics）

鸿蒙端调试技巧与常见问题解决

1. 调试技巧

• 日志查看：在 DevEco Studio 的 Log 面板中过滤 "Electron" 或 "ShootingGame" 关键词，定位渲染和逻辑错误
• 性能分析：使用 DevEco Studio 的 Performance 工具，重点监控 Canvas 渲染和 AI 更新耗时
• 粒子调试：启用鸿蒙端粒子计数日志，验证粒子数量是否控制在限制范围内

2. 常见问题解决

问题现象	解决方案
"SysCap 不匹配" 错误	检查 module.json5 中的 reqSysCapabilities，仅保留必要系统能力
"找不到.so 文件" 错误	确认 arm64-v8a 目录下 4 个核心库文件完整
窗口不显示 / 黑屏	在 main.js 中添加 app.disableHardwareAcceleration ()，检查窗口尺寸配置
粒子效果卡顿	降低粒子数量限制，使用矩形绘制替代圆形
碰撞检测不准确	调整碰撞网格大小，确保对象正确分区
AI 敌人反应迟缓	优化 AI 更新间隔，简化行为逻辑
音效无法播放	检查 module.json5 中 multimedia.audio 系统能力配置
游戏帧率过低	进一步降低敌人生成速率，简化粒子效果，延长碰撞检查间隔

性能优化建议（鸿蒙端专属）

1. 对象池重用：对粒子、子弹、敌人等频繁创建 / 销毁的对象使用对象池，减少垃圾回收

2. 渲染优化：

   • 简化绘制形状（矩形替代圆形、渐变禁用）
   • 批量处理 Canvas 渲染，减少 drawCall 次数
   • 禁用非必要的透明效果和阴影

3. 逻辑优化：

   • 进一步降低敌人 AI 复杂度，固定行为模式
   • 限制同时存在的敌人和子弹数量
   • 关卡升级时逐步提升难度，避免瞬间性能压力

4. 资源优化：

   • 压缩音效文件，使用单声道低比特率格式
   • 延迟加载非初始关卡的资源
   • 及时清理不活跃对象的事件监听

如何运行

1. 原有 Electron 环境（Windows/macOS/Linux）

bash

运行

# 安装依赖
npm install

# 启动应用
npm start

# 开发模式
npm run dev

2. 鸿蒙 PC 环境

bash

运行

# 进入鸿蒙应用根目录
cd ohos_hap

# 安装依赖
npm install

# 编译项目
npm run harmony:build

# 连接设备后运行
npm run harmony:run

总结

本项目提供了射击游戏的完整实现和 Electron 迁移鸿蒙 PC 的专项优化方案，重点解决了动作类游戏在鸿蒙端的性能瓶颈（粒子过多、碰撞检测频繁、AI 计算复杂）。通过学习本项目，您可以掌握 Electron 游戏开发、Canvas 优化、鸿蒙 PC 平台适配等核心技术，适合 Electron 开发者和鸿蒙生态开发者深入实践。