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

    脚本执行顺序

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

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

    1. // Game.js
    3. const Player = require('Player');
    4. const Enemy = require('Enemy');
    5. const Menu = require('Menu');
    7. cc.Class({
    8.     extends: cc.Component,
    9.     properties: {
    10.         player: Player,
    11.         enemy: Enemy,
    12.         menu: Menu
    13.     },
    15.     onLoad: function () {
    16.         this.player.init();
    17.         this.enemy.init();
    18.         this.menu.init();
    19.     }
    20. });

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

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

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

    1. // Player.js
    2.     updatePlayer: function (dt) {
    3.         // do player update
    4.     }

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

    1. // Game.js
    2.     update: function (dt) {
    3.         this.player.updatePlayer(dt);
    4.         this.enemy.updateEnemy(dt);
    5.         this.menu.updateMenu(dt);
    6.     }

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

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

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

    1. // CompA.js
    2. cc.Class({
    3.     extends: cc.Component,
    5.     onLoad: function () {
    6.         cc.log('CompA onLoad!');
    7.     },
    9.     start: function () {
    10.         cc.log('CompA start!');
    11.     },
    13.     update: function (dt) {
    14.         cc.log('CompA update!');
    15.     },
    16. });
    18. // CompB.js
    19. cc.Class({
    20.     extends: cc.Component,
    22.     onLoad: function () {
    23.         cc.log('CompB onLoad!');
    24.     },
    26.     start: function () {
    27.         cc.log('CompB start!');
    28.     },
    30.     update: function (dt) {
    31.         cc.log('CompB update!');
    32.     },
    33. });

    组件顺序 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.js
    3. cc.Class({
    4.     extends: cc.Component,
    5.     editor: {
    6.         executionOrder: -1
    7.     },
    9.     onLoad: function () {
    10.         cc.log('Player onLoad!');
    11.     }
    12. });
    1. // Menu.js
    3. cc.Class({
    4.     extends: cc.Component,
    5.     editor: {
    6.         executionOrder: 1
    7.     },
    9.     onLoad: function () {
    10.         cc.log('Menu onLoad!');
    11.     }
    12. });

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

    继续前往 网络接口。