Skip to content
Pawn

角色系统 / Pawn

Pawn Class

Pawn作为玩家角色和非对象玩家角色的基类,是一个可以通过玩家控制器或者逻辑脚本控制的游戏对象。

Hierarchy

Table of contents

Properties

click

Properties

onBeforeDestroyDelegate: MulticastDelegate<() => void>
物体销毁前事件回调
onCustomPropertyChange: Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
监听自定义属性同步事件
onDestroyDelegate: MulticastDelegate<() => void>
物体销毁后事件回调
onPropertyChange: Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>>
监听系统属性同步事件

Accessors

customTimeDilation(): number
膨胀时间速度
player(): Player
玩家对象
click

Accessors

assetId(): string
获取当前物体使用资源的GUID
gameObjectId(): string
获取物体的唯一标识(唯一标识一个对象的字符串)。
isDestroyed(): boolean
当前物体是否被销毁
isReady(): boolean
当前物体状态
localTransform(): Transform
当前物体本地变换
name(): string
返回当前物体名称
netStatus(): NetStatus
获取当前物体同步状态
parent(): GameObject
获取当前父物体
tag(): string
获取当前物体的标签
worldTransform(): Transform
当前物体世界变换

Methods

setOutline(enabled: boolean, color?: LinearColor, width?: number): void client
添加描边效果
setPostProcessOutline(enabled: boolean, color?: LinearColor, width?: number): void client
添加后处理描边
click

Methods

addComponent<T: extends Script<T>>(constructor: (...args: unknown[]) => T: extends Script<T>, bInReplicates?: boolean): T: extends Script<T>
添加一个脚本组件
asyncGetChildByName(name: string): Promise<GameObject>
异步根据名称查找子物体
asyncReady(): Promise<GameObject>
物体准备好后返回
clone(gameObjectInfo?: GameObjectInfo): GameObject
复制对象
destroy(): void
删除对象
getBoundingBox(nonColliding?: boolean, includeFromChild?: boolean, outer?: Vector): Vector
获取物体包围盒大小
getBounds(onlyCollidingComponents: boolean, originOuter: Vector, boxExtentOuter: Vector, includeFromChild?: boolean): void
获取物体边界
getChildByGameObjectId(gameObjectId: string): GameObject
根据 gameObjectId 查找子物体
getChildByName(name: string): GameObject
根据名称查找子物体
getChildByPath(path: string): GameObject
根据路径查找子物体
getChildren(): GameObject[]
获取子物体
getChildrenBoundingBoxCenter(outer?: Vector): Vector
获取所有子对象包围盒中心点(不包含父对象,父对象不可用返回[0,0,0])
getChildrenByName(name: string): GameObject[]
通过名字查找所有的子物体
getComponent<T: extends Script<T>>(constructor?: (...args: unknown[]) => T: extends Script<T>): T: extends Script<T>
获取指定类型的组件
getComponentPropertys<T: extends Script<T>>(constructor: (...args: unknown[]) => T: extends Script<T>): Map<string, IPropertyOptions>
获取脚本组件属性
getComponents<T: extends Script<T>>(constructor?: (...args: unknown[]) => T: extends Script<T>): T: extends Script<T>[]
获取指定类型的所有组件
getCustomProperties(): string[]
获取所有自定义属性
getCustomProperty<T: extends CustomPropertyType>(propertyName: string): T: extends CustomPropertyType
获取自定义属性
getCustomPropertyChangeDelegate(property): Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
给定对象属性修改时触发的事件代理
getPropertyChangeDelegate(property): Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
给定对象属性修改时触发的事件代理
getVisibility(): boolean
获取物体是否被显示
moveBy(velocity: Vector, isLocal?: boolean): void other
按给定的速度矢量随时间平滑地移动对象
moveTo(targetPosition: Vector, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前位置平滑移动至目标位置
rotateBy(rotation: Quaternion Rotation, multiplier: number, isLocal?: boolean): void other
按给定的旋转量随时间平滑地旋转对象
rotateTo(targetRotation: Quaternion Rotation, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前旋转平滑变化至目标旋转
scaleBy(scale: Vector, isLocal?: boolean): void other
按每秒给定的缩放矢量随时间平滑缩放对象
scaleTo(targetScale: Vector, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前缩放平滑变化至目标缩放
setAbsolute(absolutePosition?: boolean, absoluteRotation?: boolean, absoluteScale?: boolean): void
设置物体localTransform是相对于父物体或者世界
setCustomProperty(propertyName: string, value: undefined CustomPropertyType): void
设置自定义属性
setVisibility(status: boolean PropertyStatus, propagateToChildren?: boolean): void
设置物体是否被显示
stopMove(): void other
中断moveTo()、moveBy()的进一步移动
stopRotate(): void other
中断从rotateTo()或rotateBy()的进一步旋转
stopScale(): void other
中断从ScaleTo()或ScaleBy()的进一步缩放
asyncFindGameObjectById(gameObjectId: string): Promise<GameObject>
通过 gameObjectId 异步查找 GameObject
asyncGetGameObjectByPath(path: string): Promise<GameObject>
通过路径异步查找物体
asyncSpawn<T: extends GameObject<T>>(assetId: string, gameObjectInfo?: GameObjectInfo): Promise<T: extends GameObject<T>>
异步构造一个物体
bulkPivotTo(gameObjects: GameObject[], transforms: Transform[]): void
批量设置位置
findGameObjectById(gameObjectId: string): GameObject
通过 gameObjectId 查找物体
findGameObjectByName(name: string): GameObject
通过名字查找物体
findGameObjectsByName(name: string): GameObject[]
通过名字查找物体
findGameObjectsByTag(tag: string): GameObject[]
通过自定义标签获取物体
getGameObjectByPath(path: string): GameObject
通过路径查找物体
spawn<T: extends GameObject<T>>(assetId: string, gameObjectInfo?: GameObjectInfo): T: extends GameObject<T>
构造一个物体

Properties

Accessors


customTimeDilation

get customTimeDilation(): number

set customTimeDilation(value): void

膨胀时间速度

Precautions

Pawn对象的膨胀时间速度,修改后自身时间流速是该值乘世界时间流速。默认值是1。单机模式可以将膨胀设置为0达到时间暂停的效果,联机模式最低设置为0.1

Returns

number

膨胀时间速度

Precautions

Pawn对象的膨胀时间速度,修改后自身时间流速是该值乘世界时间流速。默认值是1。单机模式可以将膨胀设置为0达到时间暂停的效果,联机模式最低设置为0.1

Parameters

valuenumber
使用示例:创建一个名为"Example_Pawn_CustomTimeDilation"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,你将在场景中修改玩家的时间膨胀速度为原来的0.5倍后看到跳跃的延迟效果。代码如下:
ts
@Component
export default class Example_Pawn_CustomTimeDilation extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 当前修改时间膨胀后角色动画不会受到影响,关闭角色相关优化后即可
         Player.asyncGetLocalPlayer().then((player) => {
             console.warn("client close setOptimization")
             mw.AvatarSettings.setOptimization(player.character, false, false);
         })
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,将玩家的时间膨胀速度修改为原来的0.5倍,并跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myPlayer.character.customTimeDilation = 0.5;
                console.log("My pawn customTimeDilation: " + myPlayer.character.customTimeDilation);
                // 使玩家角色进行跳跃
                (myPlayer.character as Character).jump();
            });
        }
    }
}
@Component
export default class Example_Pawn_CustomTimeDilation extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 当前修改时间膨胀后角色动画不会受到影响,关闭角色相关优化后即可
         Player.asyncGetLocalPlayer().then((player) => {
             console.warn("client close setOptimization")
             mw.AvatarSettings.setOptimization(player.character, false, false);
         })
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,将玩家的时间膨胀速度修改为原来的0.5倍,并跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myPlayer.character.customTimeDilation = 0.5;
                console.log("My pawn customTimeDilation: " + myPlayer.character.customTimeDilation);
                // 使玩家角色进行跳跃
                (myPlayer.character as Character).jump();
            });
        }
    }
}
使用示例:创建一个名为"Example_Pawn_CustomTimeDilation"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,你将在场景中修改玩家的时间膨胀速度为原来的0.5倍后看到跳跃的延迟效果.代码如下:
ts
@Component
export default class Example_Pawn_CustomTimeDilation extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 当前修改时间膨胀后角色动画不会受到影响,关闭角色相关优化后即可
         Player.asyncGetLocalPlayer().then((player) => {
             console.warn("client close setOptimization")
             mw.AvatarSettings.setOptimization(player.character, false, false);
         })
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,将玩家的时间膨胀速度修改为原来的0.5倍,并跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myPlayer.character.customTimeDilation = 0.5;
                console.log("My pawn customTimeDilation: " + myPlayer.character.customTimeDilation);
                // 使玩家角色进行跳跃
                (myPlayer.character as Character).jump();
            });
        }
    }
}
@Component
export default class Example_Pawn_CustomTimeDilation extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 当前修改时间膨胀后角色动画不会受到影响,关闭角色相关优化后即可
         Player.asyncGetLocalPlayer().then((player) => {
             console.warn("client close setOptimization")
             mw.AvatarSettings.setOptimization(player.character, false, false);
         })
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,将玩家的时间膨胀速度修改为原来的0.5倍,并跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myPlayer.character.customTimeDilation = 0.5;
                console.log("My pawn customTimeDilation: " + myPlayer.character.customTimeDilation);
                // 使玩家角色进行跳跃
                (myPlayer.character as Character).jump();
            });
        }
    }
}

player

get player(): Player

玩家对象

Precautions

控制当前Pawn对象的玩家,只读。

Returns

使用示例:创建一个名为"Example_Pawn_Player"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,通过player获取玩家,你将在控制台中看到打印的userId和instanceId。代码如下:
ts
@Component
export default class Example_Pawn_Player extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 打印玩家(自己)userId和instanceId并对比
            console.log("My userId: " + myPlayer.userId);
            // 通过owner获取玩家(自己)并打印userId和instanceId并对比
            let myCharacter = myPlayer.character;
            let mmyPlayer_2 = myCharacter.player;
            console.log("My userId: " + mmyPlayer_2.userId);
        }
    }
}
@Component
export default class Example_Pawn_Player extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
         // 下列代码仅在客户端执行
         if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 打印玩家(自己)userId和instanceId并对比
            console.log("My userId: " + myPlayer.userId);
            // 通过owner获取玩家(自己)并打印userId和instanceId并对比
            let myCharacter = myPlayer.character;
            let mmyPlayer_2 = myCharacter.player;
            console.log("My userId: " + mmyPlayer_2.userId);
        }
    }
}
Player

Methods


setOutline

setOutline(enabled, color?, width?): void client

添加描边效果

Parameters

enabled boolean是否开启描边
color? LinearColor描边颜色 default:LinearColor.black
width? number描边宽度 default:2 range: [0, 10] type: 浮点数

Precautions

为Pawn对象添加描边效果,描边效果会被其他物体遮挡。

使用示例:将使用到的资源:“197386”拖入优先加载栏。创建一个名为"Example_Pawn_Outline"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,给玩家Pawn添加或移除普通描边(会被遮挡),:按下键盘“2”,给玩家Pawn添加或移除后处理描边(不会被遮挡)。代码如下:
ts
@Component
export default class Example_Pawn_Outline extends Script {
    // 声明变量
    flag: boolean;
    flag_advance: boolean;
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 设置当前描边状态
        this.flag = false;
        this.flag_advance = false;
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 创建一个立方体
            let cube = GameObject.spawn("197386",{ transform: new Transform(new Vector(200, 0, 0), Rotation.zero, new Vector(1, 1, 2))}) as Model;
            cube.setCollision(CollisionStatus.Off);
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,给玩家Pawn添加或移除普通描边(会被遮挡)
            InputUtil.onKeyDown(Keys.One, () => {
                if(this.flag) {
                    myPlayer.character.setOutline(false);
                } else {
                    myPlayer.character.setOutline(true, LinearColor.red, 1);
                }
                this.flag = !this.flag;
            });
            // 添加一个按键方法:按下键盘“2”,给玩家Pawn添加或移除后处理描边(不会被遮挡)
            InputUtil.onKeyDown(Keys.Two, () => {
                if(this.flag_advance) {
                    myPlayer.character.setPostProcessOutline(false);
                } else {
                    myPlayer.character.setPostProcessOutline(true, LinearColor.red, 1);
                }
                this.flag_advance = !this.flag_advance;
            });
        }
    }
}
@Component
export default class Example_Pawn_Outline extends Script {
    // 声明变量
    flag: boolean;
    flag_advance: boolean;
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 设置当前描边状态
        this.flag = false;
        this.flag_advance = false;
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 创建一个立方体
            let cube = GameObject.spawn("197386",{ transform: new Transform(new Vector(200, 0, 0), Rotation.zero, new Vector(1, 1, 2))}) as Model;
            cube.setCollision(CollisionStatus.Off);
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,给玩家Pawn添加或移除普通描边(会被遮挡)
            InputUtil.onKeyDown(Keys.One, () => {
                if(this.flag) {
                    myPlayer.character.setOutline(false);
                } else {
                    myPlayer.character.setOutline(true, LinearColor.red, 1);
                }
                this.flag = !this.flag;
            });
            // 添加一个按键方法:按下键盘“2”,给玩家Pawn添加或移除后处理描边(不会被遮挡)
            InputUtil.onKeyDown(Keys.Two, () => {
                if(this.flag_advance) {
                    myPlayer.character.setPostProcessOutline(false);
                } else {
                    myPlayer.character.setPostProcessOutline(true, LinearColor.red, 1);
                }
                this.flag_advance = !this.flag_advance;
            });
        }
    }
}

setPostProcessOutline

setPostProcessOutline(enabled, color?, width?): void client

添加后处理描边

Parameters

enabled boolean是否开启描边
color? LinearColor描边颜色 default:LinearColor.red
width? number描边宽度 default:1 range: [0, 10] type: 浮点数

Precautions

为Pawn对象添加高级描边效果,描边效果不会被其他物体遮挡。

使用示例:将使用到的资源:“197386”拖入优先加载栏。创建一个名为"Example_Pawn_PostProcessOutline"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,你将在场景中创建一个立方体,按下键盘“2”可以给本地玩家添加或移除不被立方体遮挡的红色描边效果。代码如下:
ts
@Component
export default class Example_Pawn_PostProcessOutline extends Script {
    // 声明变量
    flag: boolean;
    flag_advance: boolean;
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 设置当前描边状态
        this.flag = false;
        this.flag_advance = false;
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 创建一个立方体
            let cube = GameObject.spawn("197386",{ transform: new Transform(new Vector(200, 0, 0), Rotation.zero, new Vector(1, 1, 2))}) as Model;
            cube.setCollision(CollisionStatus.Off);
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,给玩家Pawn添加或移除普通描边(会被遮挡)
            InputUtil.onKeyDown(Keys.One, () => {
                if(this.flag) {
                    myPlayer.character.setOutline(false);
                } else {
                    myPlayer.character.setOutline(true, LinearColor.red, 1);
                }
                this.flag = !this.flag;
            });
            // 添加一个按键方法:按下键盘“2”,给玩家Pawn添加或移除后处理描边(不会被遮挡)
            InputUtil.onKeyDown(Keys.Two, () => {
                if(this.flag_advance) {
                    myPlayer.character.setPostProcessOutline(false);
                } else {
                    myPlayer.character.setPostProcessOutline(true, LinearColor.red, 1);
                }
                this.flag_advance = !this.flag_advance;
            });
        }
    }
}
@Component
export default class Example_Pawn_PostProcessOutline extends Script {
    // 声明变量
    flag: boolean;
    flag_advance: boolean;
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 设置当前描边状态
        this.flag = false;
        this.flag_advance = false;
        // 下列代码仅在服务端执行
        if(SystemUtil.isServer()) {
            // 创建一个立方体
            let cube = GameObject.spawn("197386",{ transform: new Transform(new Vector(200, 0, 0), Rotation.zero, new Vector(1, 1, 2))}) as Model;
            cube.setCollision(CollisionStatus.Off);
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 添加一个按键方法:按下键盘“1”,给玩家Pawn添加或移除普通描边(会被遮挡)
            InputUtil.onKeyDown(Keys.One, () => {
                if(this.flag) {
                    myPlayer.character.setOutline(false);
                } else {
                    myPlayer.character.setOutline(true, LinearColor.red, 1);
                }
                this.flag = !this.flag;
            });
            // 添加一个按键方法:按下键盘“2”,给玩家Pawn添加或移除后处理描边(不会被遮挡)
            InputUtil.onKeyDown(Keys.Two, () => {
                if(this.flag_advance) {
                    myPlayer.character.setPostProcessOutline(false);
                } else {
                    myPlayer.character.setPostProcessOutline(true, LinearColor.red, 1);
                }
                this.flag_advance = !this.flag_advance;
            });
        }
    }
}