脚本执行顺序

使用统一的控制脚本来初始化其他脚本

一般我都会有一个 Game.ts 的脚本作为总的控制脚本，假如我还有 Player.ts, Enemy.ts, Menu.ts 三个组件，那么他们的初始化过程是这样的：

  1. // Game.ts
  2. import { _decorator, Component, Node } from "cc";
  3. const { ccclass, property } = _decorator;
  5. import { Player } from './Player';
  6. import { Enemy } from './Enemy';
  7. import { Menu }from './Menu';
  9. @ccclass("Game")
  10. export class Game extends Component {
  12.     private player =Player; 
  13.     private enemy =Enemy;
  14.     private menu =Menu;
  16.     onLoad(){
  17.         this.player.init();
  18.         this.enemy.init();
  19.         this.menu.init();
  20.     }
  21. }

其中在 Player.ts, Enemy.ts 和 Menu.ts 中需要实现 init 方法，并将初始化逻辑放进去。这样我们就可以保证 Player, Enemy 和 Menu 的初始化顺序。

在 Update 中用自定义方法控制更新顺序

同理如果要保证以上三个脚本的每帧更新顺序，我们也可以将分散在每个脚本里的 update 替换成自己定义的方法：

  1. //Player.ts
  2.     static updataPlayer(deltaTime: number) {
  4.     }

然后在 Game.ts 脚本的 update 里调用这些方法：

  1. // Game.ts
  2.     update (deltaTime: number) {
  3.         this.player.updataPlayer(deltaTime);
  4.         this.enemy.updataEnemy(deltaTime);
  5.         this.menu.updateMenu(deltaTime);
  6.     }

控制同一个节点上的组件执行顺序

在同一个节点上的组件脚本执行顺序，可以通过组件在 属性检查器 里的排列顺序来控制。排列在上的组件会先于排列在下的组件执行。我们可以通过组件右上角的齿轮按钮里的 Move Up 和 Move Down 菜单来调整组件的排列顺序和执行顺序。

假如我们有两个组件 CompA 和 CompB，他们的内容分别是：

  1. // CompA.ts
  2. import { _decorator, Component, Node } from "cc";
  3. const { ccclass, property } = _decorator;
  5. @ccclass("CompA")
  6. export class CompA extends Component {
  8.     onLoad(){
  9.         console.log('CompA onLoad!');
  10.     }
  12.     start () {
  13.         console.log('CompA start!');
  14.     }
  16.     update (deltaTime: number) {
  17.         console.log('CompA update!');
  18.     }
  19. }
  22. // CompB.ts
  23. import { _decorator, Component, Node } from "cc";
  24. const { ccclass, property } = _decorator;
  26. @ccclass("CompB")
  27. export class CompB extends Component {
  29.     onLoad(){
  30.         console.log('CompB onLoad!');
  31.     }
  33.     start () {
  34.         console.log('CompB start!');
  35.     }
  37.     update (deltaTime: number) {
  38.         console.log('CompB update!');
  39.     }
  40. }

组件顺序 CompA 在 CompB 上面时，输出：

  1. CompA onLoad!
  2. CompB onLoad!
  3. CompA start!
  4. CompB start!
  5. CompA update!
  6. CompB update!

在 属性检查器 里通过 CompA 组件右上角齿轮菜单里的 Move Down 将 CompA 移到 CompB 下面后，输出：

  1. CompB onLoad!
  2. CompA onLoad!
  3. CompB start!
  4. CompA start!
  5. CompB update!
  6. CompA update!

设置组件执行优先级

如果以上方法还是不能提供所需的控制粒度，还可以直接设置组件的 executionOrder。executionOrder 会影响组件的生命周期回调的执行优先级。设置方法如下：

  1. //Player.ts
  2. import { _decorator, Component, Node } from "cc";
  3. const { ccclass, executionOrder } = _decorator;
  5. @ccclass("Player")
  6. @executionOrder(-1)
  7. export class Player extends Component {
  9.     onLoad () {
  10.         console.log('Player onLoad!');
  11.     }
  12. }
  1. // Menu.ts
  2. import { _decorator, Component, Node } from "cc";
  3. const { ccclass, executionOrder } = _decorator;
  5. @ccclass("Menu")
  6. @executionOrder(1)
  7. export class Menu extends Component {
  9.     onLoad () {
  10.         console.log('Menu onLoad!');
  11.     }
  12. }

executionOrder 越小，该组件相对其它组件就会越先执行。executionOrder 默认为 0，因此设置为负数的话，就会在其它默认的组件之前执行。executionOrder 只对 onLoad, onEnable, start, update 和 lateUpdate 有效，对 onDisable 和 onDestroy 无效。