Character Class

​

@Component
 export default class NewExample extends Script {
     protected onStart(): void {
         GameObject.asyncSpawn<Model>("183107",{transform: new Transform(new Vector(100,0,0),new Rotation(0,0,0),new Vector(1,1,1))}).then(()=>{
             console.log("233娘 success！");
         });
     }
}

@Component
 export default class NewExample extends Script {
     protected onStart(): void {
         GameObject.asyncSpawn<Model>("183107",{transform: new Transform(new Vector(100,0,0),new Rotation(0,0,0),new Vector(1,1,1))}).then(()=>{
             console.log("233娘 success！");
         });
     }
}

@Component
export default class Example_Character_OnDescriptionChange extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色外观描述完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType: HumanoidSlotType.Root});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 给【角色外观描述变化】委托添加函数
            myCharacter.onDescriptionChange.add((operationCode: number, index: number, value: unknown) => {
                console.log("Appearance Changed");
                console.log("OperationCode " + operationCode + " Index " + index);
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class Example_Character_OnDescriptionChange extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色外观描述完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType: HumanoidSlotType.Root});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 给【角色外观描述变化】委托添加函数
            myCharacter.onDescriptionChange.add((operationCode: number, index: number, value: unknown) => {
                console.log("Appearance Changed");
                console.log("OperationCode " + operationCode + " Index " + index);
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class Example_Character extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色换装完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType:HumanoidSlotType.Hair});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class Example_Character extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色换装完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType:HumanoidSlotType.Hair});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class NewScript1 extends Script {
    private character: Character;
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        Player.asyncGetLocalPlayer().then((player) => {
            this.character = player.character;
            this.character.onStateChanged.add((pre, curr)=>{
                console.log(`pre: ${pre} curr: ${curr}`);

            })
        });
      InputUtil.onKeyDown(Keys.Zero, ()=>{
            this.character.changeState(CharacterStateType.None);
        })
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.character.changeState(CharacterStateType.Running);
        })
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.character.changeState(CharacterStateType.Flying);
        })
        InputUtil.onKeyDown(Keys.Three, ()=>{
            this.character.changeState(CharacterStateType.Swimming);
        })
        InputUtil.onKeyDown(Keys.Four, ()=>{
            this.character.changeState(CharacterStateType.Jumping);
        })
        InputUtil.onKeyDown(Keys.Five, ()=>{
            this.character.changeState(CharacterStateType.Freefall);
        })
        InputUtil.onKeyDown(Keys.Six, ()=>{
            this.character.changeState(CharacterStateType.Ragdoll);
        })
        InputUtil.onKeyDown(Keys.Seven, ()=>{
            this.character.changeState(CharacterStateType.GettingUp);
        })
        InputUtil.onKeyDown(Keys.Eight, ()=>{
            this.character.changeState(CharacterStateType.Climbing);
        })
        InputUtil.onKeyDown(Keys.Nine, ()=>{
            this.character.changeState(CharacterStateType.Crouching);
        })
        InputUtil.onKeyDown(Keys.Z, ()=>{
            this.character.changeState(CharacterStateType.Pushed);
        })
        InputUtil.onKeyDown(Keys.X, ()=>{
            this.character.changeState(CharacterStateType.Landed);
        })
        InputUtil.onKeyDown(Keys.C, ()=>{
            this.character.changeState(CharacterStateType.Hit);
        })
        InputUtil.onKeyDown(Keys.V, ()=>{
            this.character.changeState(CharacterStateType.Dead);
        })
      InputUtil.onKeyDown(Keys.E, ()=>{
          console.log("currentState=="+this.character.getCurrentState());
        })
      InputUtil.onKeyDown(Keys.R, ()=>{
          this.character.setStateEnabled(CharacterStateType.Flying, false);
        })
    }
}

@Component
export default class NewScript1 extends Script {
    private character: Character;
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        Player.asyncGetLocalPlayer().then((player) => {
            this.character = player.character;
            this.character.onStateChanged.add((pre, curr)=>{
                console.log(`pre: ${pre} curr: ${curr}`);

            })
        });
      InputUtil.onKeyDown(Keys.Zero, ()=>{
            this.character.changeState(CharacterStateType.None);
        })
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.character.changeState(CharacterStateType.Running);
        })
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.character.changeState(CharacterStateType.Flying);
        })
        InputUtil.onKeyDown(Keys.Three, ()=>{
            this.character.changeState(CharacterStateType.Swimming);
        })
        InputUtil.onKeyDown(Keys.Four, ()=>{
            this.character.changeState(CharacterStateType.Jumping);
        })
        InputUtil.onKeyDown(Keys.Five, ()=>{
            this.character.changeState(CharacterStateType.Freefall);
        })
        InputUtil.onKeyDown(Keys.Six, ()=>{
            this.character.changeState(CharacterStateType.Ragdoll);
        })
        InputUtil.onKeyDown(Keys.Seven, ()=>{
            this.character.changeState(CharacterStateType.GettingUp);
        })
        InputUtil.onKeyDown(Keys.Eight, ()=>{
            this.character.changeState(CharacterStateType.Climbing);
        })
        InputUtil.onKeyDown(Keys.Nine, ()=>{
            this.character.changeState(CharacterStateType.Crouching);
        })
        InputUtil.onKeyDown(Keys.Z, ()=>{
            this.character.changeState(CharacterStateType.Pushed);
        })
        InputUtil.onKeyDown(Keys.X, ()=>{
            this.character.changeState(CharacterStateType.Landed);
        })
        InputUtil.onKeyDown(Keys.C, ()=>{
            this.character.changeState(CharacterStateType.Hit);
        })
        InputUtil.onKeyDown(Keys.V, ()=>{
            this.character.changeState(CharacterStateType.Dead);
        })
      InputUtil.onKeyDown(Keys.E, ()=>{
          console.log("currentState=="+this.character.getCurrentState());
        })
      InputUtil.onKeyDown(Keys.R, ()=>{
          this.character.setStateEnabled(CharacterStateType.Flying, false);
        })
    }
}

@Component
export default class Example_BrakingDecelerationFlying extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 加载喷射加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 0;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:键盘“1”，角色切换为飞行
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.switchToFlying();
            });
            // 添加一个按键方法:按下键盘“2”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Two, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放飞行动画，修改飞行速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxFlySpeed = 2000;
                    myCharacter.brakingDecelerationFlying = 5000;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原飞行速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxFlySpeed = 500;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.addMovement(new Vector(0, 0, 5));
                    }, 1);
                }
                // 2秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxFlySpeed = 500;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 2000);
                    // 2.2秒后还原角色飞行制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationFlying = 300;
                    }, 2200);
            });
        }
    }
}

@Component
export default class Example_BrakingDecelerationFlying extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 加载喷射加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 0;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:键盘“1”，角色切换为飞行
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.switchToFlying();
            });
            // 添加一个按键方法:按下键盘“2”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Two, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放飞行动画，修改飞行速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxFlySpeed = 2000;
                    myCharacter.brakingDecelerationFlying = 5000;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原飞行速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxFlySpeed = 500;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.addMovement(new Vector(0, 0, 5));
                    }, 1);
                }
                // 2秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxFlySpeed = 500;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 2000);
                    // 2.2秒后还原角色飞行制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationFlying = 300;
                    }, 2200);
            });
        }
    }
}

@Component
export default class Example_BrakingDecelerationSwimming extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 生成拱形容器并适配游泳区域
            GameObject.spawn("WaterVolume",{transform: new Transform(new Vector(0, 0, 500), new Rotation(0, 0, 90), new Vector(20, 20, 10))});
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            let flag = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置游泳属性
            myCharacter.canJumpOutOfWater = true;
            myCharacter.outOfWaterVerticalSpeed = 100;
            // 加载加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 10;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:按下键盘“1”，角色切换游泳 / 行走
            InputUtil.onKeyDown(Keys.One, () => {
                if(flag) {
                    myCharacter.switchToWalking();
                } else {
                    myCharacter.switchToSwimming();
                }
                flag = !flag;
            });
            // 添加一个按键方法:按住键盘“2”，角色上浮
            InputUtil.onKeyPress(Keys.Two, () => {
                myCharacter.swimUp(10);
            });
            // 添加一个按键方法:按住键盘“3”，角色下潜
            InputUtil.onKeyPress(Keys.Three, () => {
                myCharacter.swimDown(10);
            });
            // 添加一个按键方法:按下键盘“4”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Four, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放游泳动画，修改游泳速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxSwimSpeed = 600;
                    myCharacter.brakingDecelerationSwimming = 4096;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原游泳速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxSwimSpeed = 300;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.swimUp(1)
                    }, 1);
                }
                // 1秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxSwimSpeed = 300;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 1000);
                    // 1.2秒后还原角色游泳制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationSwimming = 4096
                    }, 1200);
            });
        }
    }
}

@Component
export default class Example_BrakingDecelerationSwimming extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 生成拱形容器并适配游泳区域
            GameObject.spawn("WaterVolume",{transform: new Transform(new Vector(0, 0, 500), new Rotation(0, 0, 90), new Vector(20, 20, 10))});
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            let flag = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置游泳属性
            myCharacter.canJumpOutOfWater = true;
            myCharacter.outOfWaterVerticalSpeed = 100;
            // 加载加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 10;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:按下键盘“1”，角色切换游泳 / 行走
            InputUtil.onKeyDown(Keys.One, () => {
                if(flag) {
                    myCharacter.switchToWalking();
                } else {
                    myCharacter.switchToSwimming();
                }
                flag = !flag;
            });
            // 添加一个按键方法:按住键盘“2”，角色上浮
            InputUtil.onKeyPress(Keys.Two, () => {
                myCharacter.swimUp(10);
            });
            // 添加一个按键方法:按住键盘“3”，角色下潜
            InputUtil.onKeyPress(Keys.Three, () => {
                myCharacter.swimDown(10);
            });
            // 添加一个按键方法:按下键盘“4”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Four, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放游泳动画，修改游泳速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxSwimSpeed = 600;
                    myCharacter.brakingDecelerationSwimming = 4096;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原游泳速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxSwimSpeed = 300;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.swimUp(1)
                    }, 1);
                }
                // 1秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxSwimSpeed = 300;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 1000);
                    // 1.2秒后还原角色游泳制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationSwimming = 4096
                    }, 1200);
            });
        }
    }
}

@Component
export default class Example_Braking extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            this.useUpdate = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 最大加速度为原来的0.1倍
            myCharacter.maxAcceleration = 0.1 * myCharacter.maxAcceleration;
            // 最大转向速度为原来的0.5倍
            myCharacter.rotateRate = 0.5 * myCharacter.rotateRate;
            // 最大行走速度为原来的2倍
            myCharacter.maxWalkSpeed = 2 * myCharacter.maxWalkSpeed;
            // 最大加速度为原来的0.1倍
            myCharacter.brakingDecelerationWalking = 0.1 * myCharacter.brakingDecelerationWalking;
            myCharacter.groundFriction = 1;
            // 添加一个按键方法：按下键盘“1”，切换角色摩擦力的来源
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.groundFrictionEnabled = !myCharacter.groundFriction;
            });
        }
    }
    // 周期函数每帧执行，此函数执行需要将this.useUpdate赋值为true，dt是当前帧与上一帧的延迟（秒）
    protected onUpdate(dt: number): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 如果角色正在移动，打印角色的移动速度
            if(myCharacter.isMoving) {
                console.log("当前角色速度：" + myCharacter.velocity);
            }
        }
    }
}

@Component
export default class Example_Braking extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            this.useUpdate = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 最大加速度为原来的0.1倍
            myCharacter.maxAcceleration = 0.1 * myCharacter.maxAcceleration;
            // 最大转向速度为原来的0.5倍
            myCharacter.rotateRate = 0.5 * myCharacter.rotateRate;
            // 最大行走速度为原来的2倍
            myCharacter.maxWalkSpeed = 2 * myCharacter.maxWalkSpeed;
            // 最大加速度为原来的0.1倍
            myCharacter.brakingDecelerationWalking = 0.1 * myCharacter.brakingDecelerationWalking;
            myCharacter.groundFriction = 1;
            // 添加一个按键方法：按下键盘“1”，切换角色摩擦力的来源
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.groundFrictionEnabled = !myCharacter.groundFriction;
            });
        }
    }
    // 周期函数每帧执行，此函数执行需要将this.useUpdate赋值为true，dt是当前帧与上一帧的延迟（秒）
    protected onUpdate(dt: number): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 如果角色正在移动，打印角色的移动速度
            if(myCharacter.isMoving) {
                console.log("当前角色速度：" + myCharacter.velocity);
            }
        }
    }
}

@Component
export default class CanJumpOutOfWater extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 生成拱形容器并适配游泳区域
            GameObject.spawn("WaterVolume",{transform: new Transform(new Vector(0, 0, 500), new Rotation(0, 0, 90), new Vector(20, 20, 10))});
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            let flag = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置游泳属性
            myCharacter.canJumpOutOfWater = true;
            myCharacter.outOfWaterVerticalSpeed = 100;
            // 加载加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 10;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:按下键盘“1”，角色切换游泳 / 行走
            InputUtil.onKeyDown(Keys.One, () => {
                if(flag) {
                    myCharacter.switchToWalking();
                } else {
                    myCharacter.switchToSwimming();
                }
                flag = !flag;
            });
            // 添加一个按键方法:按住键盘“2”，角色上浮
            InputUtil.onKeyPress(Keys.Two, () => {
                myCharacter.swimUp(10);
            });
            // 添加一个按键方法:按住键盘“3”，角色下潜
            InputUtil.onKeyPress(Keys.Three, () => {
                myCharacter.swimDown(10);
            });
            // 添加一个按键方法:按下键盘“4”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Four, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放游泳动画，修改游泳速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxSwimSpeed = 600;
                    myCharacter.brakingDecelerationSwimming = 4096;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原游泳速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxSwimSpeed = 300;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.swimUp(1)
                    }, 1);
                }
                // 1秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxSwimSpeed = 300;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 1000);
                    // 1.2秒后还原角色游泳制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationSwimming = 4096
                    }, 1200);
            });
        }
    }
}

@Component
export default class CanJumpOutOfWater extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 生成拱形容器并适配游泳区域
            GameObject.spawn("WaterVolume",{transform: new Transform(new Vector(0, 0, 500), new Rotation(0, 0, 90), new Vector(20, 20, 10))});
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            let flag = true;
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置游泳属性
            myCharacter.canJumpOutOfWater = true;
            myCharacter.outOfWaterVerticalSpeed = 100;
            // 加载加速动画
            let boostAnimation = myCharacter.loadAnimation("53011");
            boostAnimation.loop = 10;
            let isBoost = false
            // 加载上升姿态
            let boostStance = myCharacter.loadSubStance("20307");
            // 添加一个按键方法:按下键盘“1”，角色切换游泳 / 行走
            InputUtil.onKeyDown(Keys.One, () => {
                if(flag) {
                    myCharacter.switchToWalking();
                } else {
                    myCharacter.switchToSwimming();
                }
                flag = !flag;
            });
            // 添加一个按键方法:按住键盘“2”，角色上浮
            InputUtil.onKeyPress(Keys.Two, () => {
                myCharacter.swimUp(10);
            });
            // 添加一个按键方法:按住键盘“3”，角色下潜
            InputUtil.onKeyPress(Keys.Three, () => {
                myCharacter.swimDown(10);
            });
            // 添加一个按键方法:按下键盘“4”，角色进行喷射加速
            InputUtil.onKeyDown(Keys.Four, () => {
                if(isBoost) return;
                let boost_interval = 0;
                if(myCharacter.isMoving) {
                    // 播放游泳动画，修改游泳速度和制动速度
                    boostAnimation.play();
                    myCharacter.maxSwimSpeed = 600;
                    myCharacter.brakingDecelerationSwimming = 4096;
                    // 设置加速周期，每帧检查角色是否移动，当角色停止移动时,执行停止加速操作:停止动画清除姿态，还原游泳速度，清除加速周期
                    boost_interval = setInterval(() => {
                        if(!myCharacter.isMoving) {
                            isBoost = false;
                            clearInterval(boost_interval);
                            myCharacter.maxSwimSpeed = 300;
                            boostAnimation.stop();
                            boostStance.stop();
                        }
                    }, 1);
                // 如果当前角色静止，修改角色为上升姿态，设置加速周期，每帧上升5个单位
                } else {
                    boostStance.play();
                    boost_interval = setInterval(() => {
                        myCharacter.swimUp(1)
                    }, 1);
                }
                // 1秒后执行停止加速操作
                    setTimeout(() => {
                        isBoost = false;
                        clearInterval(boost_interval);
                        myCharacter.maxSwimSpeed = 300;
                        boostAnimation.stop();
                        boostStance.stop();
                    }, 1000);
                    // 1.2秒后还原角色游泳制动速度
                    setTimeout(() => {
                        myCharacter.brakingDecelerationSwimming = 4096
                    }, 1200);
            });
        }
    }
}

@Component
export default class Example_Character_CanStandOn extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 生成拱门带碰撞的拱门
            let arch = GameObject.spawn("36851",{transform: new Transform(new Vector(300, 210, 0), new Rotation(0, 0, 90), new Vector(2, 1, 2))}) as Model;
            arch.setCollision(CollisionStatus.On);
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置角色碰撞属性和跳跃属性
            myCharacter.capsuleCorrectionEnabled = true;
            myCharacter.maxJumpHeight = 250;
            let NPC = Player.spawnDefaultCharacter();
            NPC.worldTransform.position = new Vector(0, 100, 100);
            // 添加一个按键方法：按下键盘“1”，开启/关闭NPC与其他角色的碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                NPC.collisionWithOtherCharacterEnabled = !NPC.collisionWithOtherCharacterEnabled;
                console.log("NPC与角色的碰撞 " + NPC.collisionWithOtherCharacterEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，开启/关闭角色是否可被站立
            InputUtil.onKeyDown(Keys.Two, () => {
                NPC.canStandOn = !NPC.canStandOn;
                console.log("NPC角色可被站立 " + NPC.canStandOn);
            });
            // 添加一个按键方法：按下键盘“3”，修改角色碰撞并打印结果
            InputUtil.onKeyDown(Keys.Three, () => {
                // 碰撞范围collisionExtent内部值全是半值，半径半高半长
                myCharacter.setCollisionShapeAndExtent(CustomShapeType.Box, new Vector(50, 50, 200));
                console.log("当前角色碰撞 " + myCharacter.collisionShape + " " + myCharacter.collisionExtent);
            });
        }
    }
}

@Component
export default class Example_Character_CanStandOn extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 生成拱门带碰撞的拱门
            let arch = GameObject.spawn("36851",{transform: new Transform(new Vector(300, 210, 0), new Rotation(0, 0, 90), new Vector(2, 1, 2))}) as Model;
            arch.setCollision(CollisionStatus.On);
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置角色碰撞属性和跳跃属性
            myCharacter.capsuleCorrectionEnabled = true;
            myCharacter.maxJumpHeight = 250;
            let NPC = Player.spawnDefaultCharacter();
            NPC.worldTransform.position = new Vector(0, 100, 100);
            // 添加一个按键方法：按下键盘“1”，开启/关闭NPC与其他角色的碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                NPC.collisionWithOtherCharacterEnabled = !NPC.collisionWithOtherCharacterEnabled;
                console.log("NPC与角色的碰撞 " + NPC.collisionWithOtherCharacterEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，开启/关闭角色是否可被站立
            InputUtil.onKeyDown(Keys.Two, () => {
                NPC.canStandOn = !NPC.canStandOn;
                console.log("NPC角色可被站立 " + NPC.canStandOn);
            });
            // 添加一个按键方法：按下键盘“3”，修改角色碰撞并打印结果
            InputUtil.onKeyDown(Keys.Three, () => {
                // 碰撞范围collisionExtent内部值全是半值，半径半高半长
                myCharacter.setCollisionShapeAndExtent(CustomShapeType.Box, new Vector(50, 50, 200));
                console.log("当前角色碰撞 " + myCharacter.collisionShape + " " + myCharacter.collisionExtent);
            });
        }
    }
}

@Component
export default class Example_Character_CapsuleCorrectionEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 生成拱门带碰撞的拱门
            let arch = GameObject.spawn("36851",{transform: new Transform(new Vector(300, 210, 0), new Rotation(0, 0, 90), new Vector(2, 1, 2))}) as Model;
            arch.setCollision(CollisionStatus.On);
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置角色碰撞属性和跳跃属性
            myCharacter.capsuleCorrectionEnabled = true;
            myCharacter.maxJumpHeight = 250;
            let NPC = Player.spawnDefaultCharacter();
            NPC.worldTransform.position = new Vector(0, 100, 100);
            // 添加一个按键方法：按下键盘“1”，开启/关闭NPC与其他角色的碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                NPC.collisionWithOtherCharacterEnabled = !NPC.collisionWithOtherCharacterEnabled;
                console.log("NPC与角色的碰撞 " + NPC.collisionWithOtherCharacterEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，开启/关闭角色是否可被站立
            InputUtil.onKeyDown(Keys.Two, () => {
                NPC.canStandOn = !NPC.canStandOn;
                console.log("NPC角色可被站立 " + NPC.canStandOn);
            });
            // 添加一个按键方法：按下键盘“3”，修改角色碰撞并打印结果
            InputUtil.onKeyDown(Keys.Three, () => {
                // 碰撞范围collisionExtent内部值全是半值，半径半高半长
                myCharacter.setCollisionShapeAndExtent(CustomShapeType.Box, new Vector(50, 50, 200));
                console.log("当前角色碰撞 " + myCharacter.collisionShape + " " + myCharacter.collisionExtent);
            });
        }
    }
}

@Component
export default class Example_Character_CapsuleCorrectionEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 生成拱门带碰撞的拱门
            let arch = GameObject.spawn("36851",{transform: new Transform(new Vector(300, 210, 0), new Rotation(0, 0, 90), new Vector(2, 1, 2))}) as Model;
            arch.setCollision(CollisionStatus.On);
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置角色碰撞属性和跳跃属性
            myCharacter.capsuleCorrectionEnabled = true;
            myCharacter.maxJumpHeight = 250;
            let NPC = Player.spawnDefaultCharacter();
            NPC.worldTransform.position = new Vector(0, 100, 100);
            // 添加一个按键方法：按下键盘“1”，开启/关闭NPC与其他角色的碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                NPC.collisionWithOtherCharacterEnabled = !NPC.collisionWithOtherCharacterEnabled;
                console.log("NPC与角色的碰撞 " + NPC.collisionWithOtherCharacterEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，开启/关闭角色是否可被站立
            InputUtil.onKeyDown(Keys.Two, () => {
                NPC.canStandOn = !NPC.canStandOn;
                console.log("NPC角色可被站立 " + NPC.canStandOn);
            });
            // 添加一个按键方法：按下键盘“3”，修改角色碰撞并打印结果
            InputUtil.onKeyDown(Keys.Three, () => {
                // 碰撞范围collisionExtent内部值全是半值，半径半高半长
                myCharacter.setCollisionShapeAndExtent(CustomShapeType.Box, new Vector(50, 50, 200));
                console.log("当前角色碰撞 " + myCharacter.collisionShape + " " + myCharacter.collisionExtent);
            });
        }
    }
}

@Component
export default class Example_Character extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色外观描述完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType: HumanoidSlotType.Root});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 给【角色外观描述变化】委托添加函数
            myCharacter.onDescriptionChange.add((operationCode: number, index: number, value: unknown) => {
                console.log("Appearance Changed");
                console.log("OperationCode " + operationCode + " Index " + index);
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class Example_Character extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端玩家
            let myPlayer = Player.localPlayer;
            // 获取玩家控制角色
            let myCharacter = myPlayer.character;
            // 如果玩家外观准备完成挥手，反之摊手
            if(myCharacter.isDescriptionReady) {
                let animation = myCharacter.loadAnimation("35391");
                animation.play();
            } else {
                let animation = myCharacter.loadAnimation("14521");
                animation.play();
            }
            let defaultStyle = null;
            // 给【角色外观描述完成】委托添加函数
            myCharacter.onDescriptionComplete.add(() => {
                // 播放换装完成特效
                EffectService.playOnGameObject("161245", myCharacter, {slotType: HumanoidSlotType.Root});
                // 获取角色默认外观风格
                if(defaultStyle == null) {
                    defaultStyle = myCharacter.getDescription();
                }
            });
            // 给【角色外观描述变化】委托添加函数
            myCharacter.onDescriptionChange.add((operationCode: number, index: number, value: unknown) => {
                console.log("Appearance Changed");
                console.log("OperationCode " + operationCode + " Index " + index);
            });
            // 添加一个按键方法:按下键盘“1”，重置为默认角色外观
            InputUtil.onKeyDown(Keys.One, () => {
                myCharacter.setDescription(defaultStyle);
            });
            // 添加一个按键方法:按下键盘“2”，修改角色外观
            InputUtil.onKeyDown(Keys.Two, () => {
                if(myCharacter.characterType == CharacterType.HumanoidV2) {
                    // 修改角色style头部:头大小为1.5倍
                    myCharacter.description.advance.headFeatures.head.headOverallScale = 1.5;
                    // 修改角色style体型:身高为1.2倍
                    myCharacter.description.advance.bodyFeatures.body.height = 1.2;
                    // 修改角色style化妆:腮红为75674
                    myCharacter.description.advance.makeup.blush.blushStyle = "75674";
                    // 修改角色style头发:前发为57731，后发为63910
                    myCharacter.description.advance.hair.frontHair.style = "57731";
                    myCharacter.description.advance.hair.backHair.style = "63910";
                    // 修改角色style:上衣为58694，下衣为58700，手套为60384，鞋子为58696
                    myCharacter.description.advance.clothing.upperCloth.style = "58694";
                    myCharacter.description.advance.clothing.lowerCloth.style = "58700";
                    myCharacter.description.advance.clothing.gloves.style = "60384";
                    myCharacter.description.advance.clothing.shoes.style = "58696";
                }
            });
            // 添加一个按键方法:按下键盘“3”，同步角色外观
            InputUtil.onKeyDown(Keys.Three, () => {
                myCharacter.syncDescription();
            });
            // 添加一个按键方法:按下键盘“4”，清空角色外观
            InputUtil.onKeyDown(Keys.Four, () => {
                myCharacter.clearDescription();
            });
        }
    }
}

@Component
export default class Example_Character_CollisionExtent extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 生成拱门带碰撞的拱门
            let arch = GameObject.spawn("36851",{transform: new Transform(new Vector(300, 210, 0), new Rotation(0, 0, 90), new Vector(2, 1, 2))}) as Model;
            arch.setCollision(CollisionStatus.On);
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 设置角色碰撞属性和跳跃属性
            myCharacter.capsuleCorrectionEnabled = true;
            myCharacter.maxJumpHeight = 250;
            let NPC = Player.spawnDefaultCharacter();
            NPC.worldTransform.position = new Vector(0, 100, 100);
            // 添加一个按键方法：按下键盘“1”，开启/关闭NPC与其他角色的碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                NPC.collisionWithOtherCharacterEnabled = !NPC.collisionWithOtherCharacterEnabled;
                console.log("NPC与角色的碰撞 " + NPC.collisionWithOtherCharacterEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，开启/关闭角色是否可被站立
            InputUtil.onKeyDown(Keys.Two, () => {
                NPC.canStandOn = !NPC.canStandOn;
                console.log("NPC角色可被站立 " + NPC.canStandOn);
            });
            // 添加一个按键方法：按下键盘“3”，修改角色碰撞并打印结果
            InputUtil.onKeyDown(Keys.Three, () => {
                // 碰撞范围collisionExtent内部值全是半值，半径半高半长
                myCharacter.setCollisionShapeAndExtent(CustomShapeType.Box, new Vector(50, 50, 200));
                console.log("当前角色碰撞 " + myCharacter.collisionShape + " " + myCharacter.collisionExtent);
            });
        }
    }
}