• 脚本执行顺序
    • 使用统一的控制脚本来初始化其他脚本
    • 在 Update 中用自定义方法控制更新顺序
    • 控制同一个节点上的组件执行顺序
    • 设置组件执行优先级

    脚本执行顺序

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

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

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

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

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

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

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

    然后在 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 UpMove Down 菜单来调整组件的排列顺序和执行顺序。

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

    1. // CompA.ts
    2. import { _decorator, Component, Node } from "cc";
    3. const { ccclass, property } = _decorator;
    4. @ccclass("CompA")
    5. export class CompA extends Component {
    6. onLoad(){
    7. console.log('CompA onLoad!');
    8. }
    9. start () {
    10. console.log('CompA start!');
    11. }
    12. update (deltaTime: number) {
    13. console.log('CompA update!');
    14. }
    15. }
    16. // CompB.ts
    17. import { _decorator, Component, Node } from "cc";
    18. const { ccclass, property } = _decorator;
    19. @ccclass("CompB")
    20. export class CompB extends Component {
    21. onLoad(){
    22. console.log('CompB onLoad!');
    23. }
    24. start () {
    25. console.log('CompB start!');
    26. }
    27. update (deltaTime: number) {
    28. console.log('CompB update!');
    29. }
    30. }

    组件顺序 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;
    4. @ccclass("Player")
    5. @executionOrder(-1)
    6. export class Player extends Component {
    7. onLoad () {
    8. console.log('Player onLoad!');
    9. }
    10. }
    1. // Menu.ts
    2. import { _decorator, Component, Node } from "cc";
    3. const { ccclass, executionOrder } = _decorator;
    4. @ccclass("Menu")
    5. @executionOrder(1)
    6. export class Menu extends Component {
    7. onLoad () {
    8. console.log('Menu onLoad!');
    9. }
    10. }

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