Skip to content
PhysicsService

玩法 / PhysicsService

PhysicsService Class

碰撞组

Table of contents

Accessors

touchesUseCollisionGroups(): boolean
确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件

Methods

addCollisionGroup(name: string): void
添加新碰撞组
boxOverlap(boxPos: Vector, boxExtent: Vector, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): GameObject[]
返回一个与给定盒体重叠的对象数组
boxTraceMulti(start: Vector, end: Vector, halfSize: Vector, orientation: Rotation, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult[]
沿着给定的路线扫描一个盒体,并返回遇到的所有命中,包括第一次拦截命中。
boxTraceSingle(start: Vector, end: Vector, halfSize: Vector, orientation: Rotation, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult
沿着给定的线扫过一个盒体,并返回遇到的第一个阻挡命中。
capsuleOverlap(capsulePos: Vector, radius: number, halfHeight: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): GameObject[]
返回一个与给定胶囊体重叠的对象数组
capsuleTraceMulti(start: Vector, end: Vector, radius: number, halfHeight: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult[]
沿着给定的路线扫描一个胶囊,并返回遇到的所有命中,包括第一次拦截命中。
capsuleTraceSingle(start: Vector, end: Vector, radius: number, halfHeight: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult
沿着给定的线扫过一个胶囊体,并返回遇到的第一个阻挡命中。
deleteCollisionGroup(name: string): void
删除已有碰撞组
getAvailableCollisionGroupsCount(): number
获取当前可剩余使用碰撞组数量
getCollisionBetweenGroups(group1: string, group2: string): boolean
获取两碰撞组之间的碰撞关系(是否可发生碰撞)
getValidCollisionGroups(): string[]
获取当前已添加的碰撞组名列表
isCollisionGroupValid(name: string): boolean
检测碰撞组是否有效(已添加过)
lineTraceMulti(start: Vector, end: Vector, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult[]
沿着给定的行执行碰撞跟踪,并返回遇到的所有命中,直到并包括第一次阻塞命中。
lineTraceSingle(start: Vector, end: Vector, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult
沿着给定的线进行碰撞追踪,并返回遇到的第一个阻挡命中。
renameCollisionGroup(previousName: string, newName: string): void
重命名碰撞组
setCollisionBetweenGroups(group1: string, group2: string, collidable: boolean): void
设置俩碰撞组之间的碰撞关系(是否可发生碰撞)
sphereOverlap(spherePos: Vector, sphereRadius: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): GameObject[]
返回一个与给定球体重叠的对象数组
sphereTraceMulti(start: Vector, end: Vector, radius: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult[]
沿着给定的直线扫过一个球体,并返回所有命中,包括第一次拦截命中。
sphereTraceSingle(start: Vector, end: Vector, radius: number, collisionParams: CollisionQueryParams, renderParams: RenderQueryParams): HitResult
沿着给定的线扫过一个球体,并返回遇到的第一个阻挡命中。

Accessors

touchesUseCollisionGroups

Static get touchesUseCollisionGroups(): boolean

Static set touchesUseCollisionGroups(status): void

确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件

Returns

boolean不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件

确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件

Parameters

status boolean不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件 range: 不限制
使用示例:

在场景中创建一个名为TouchesUseCollisionGroups的脚本,并拖入场景中,并复制以下代码进入脚本。 依次按下1、2之后,会发现服务器会小球会调用onTouch函数并输出对应LOG。

ts
@Component
export default class TouchesUseCollisionGroups extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.touchesUseCollisionGroups = true;
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建正常碰撞的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.serverCreateBall(new Vector(300, 0, 0), "GroupA", false);
        })

        // 创建模拟物理的球体B并设置碰撞组为GroupB
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.serverCreateBall(new Vector(300, 0, 100), "GroupB", true);
        })
    }

    @mw.RemoteFunction(mw.Server)
    serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
    {
        GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
            let ball  = obj as mw.Model;
            ball.worldTransform.position = pos;
            if (bPhysicsSimulate)
            {
                ball.physicsEnabled = true;
                ball.massEnabled = true;
                ball.mass = 50;
            }
            ball.collisionGroup = Group;
            ball.onTouch.add((obj : GameObject) => {
                console.log(`${obj.gameObjectId} - Touch - ${ball.gameObjectId}`);
            }
        );
        })
    }
}
@Component
export default class TouchesUseCollisionGroups extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.touchesUseCollisionGroups = true;
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建正常碰撞的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.serverCreateBall(new Vector(300, 0, 0), "GroupA", false);
        })

        // 创建模拟物理的球体B并设置碰撞组为GroupB
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.serverCreateBall(new Vector(300, 0, 100), "GroupB", true);
        })
    }

    @mw.RemoteFunction(mw.Server)
    serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
    {
        GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
            let ball  = obj as mw.Model;
            ball.worldTransform.position = pos;
            if (bPhysicsSimulate)
            {
                ball.physicsEnabled = true;
                ball.massEnabled = true;
                ball.mass = 50;
            }
            ball.collisionGroup = Group;
            ball.onTouch.add((obj : GameObject) => {
                console.log(`${obj.gameObjectId} - Touch - ${ball.gameObjectId}`);
            }
        );
        })
    }
}

Methods

addCollisionGroup

Static addCollisionGroup(name): void

添加新碰撞组

Parameters

name string碰撞组名 range: 不限制
使用示例:在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下 1 后可在编辑器窗口客户端内看到输出 "GroupA,GroupB,GroupC"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.addCollisionGroup("GroupC");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.addCollisionGroup("GroupC");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }
}

boxOverlap

Static boxOverlap(boxPos, boxExtent, collisionParams, renderParams): GameObject[]

返回一个与给定盒体重叠的对象数组

Parameters

boxPos Vector检测位置
boxExtent Vector盒体大小
collisionParams CollisionQueryParams碰撞查询渲染参数
renderParams RenderQueryParams空间查询渲染参数

Returns

GameObject[]GameObject数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.boxOverlap(new mw.Vector(0,0,0), new Vector(30, 30, 30), {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.boxOverlap(new mw.Vector(0,0,0), new Vector(30, 30, 30), {}, {});
for (const item of result) {
    // item:  检测结果。
}

boxTraceMulti

Static boxTraceMulti(start, end, halfSize, orientation, collisionParams, renderParams): HitResult[]

沿着给定的路线扫描一个盒体,并返回遇到的所有命中,包括第一次拦截命中。

Parameters

start Vector起始点
end Vector终止点
halfSize Vector盒形大小
orientation Rotation旋转大小
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResult[]HitResult数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.boxTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.boxTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
for (const item of result) {
    // item:  检测结果。
}

boxTraceSingle

Static boxTraceSingle(start, end, halfSize, orientation, collisionParams, renderParams): HitResult

沿着给定的线扫过一个盒体,并返回遇到的第一个阻挡命中。

Parameters

start Vector起始点
end Vector终止点
halfSize Vector盒形大小
orientation Rotation旋转大小
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResultHitResult
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.boxTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
const result = PhysicsService.boxTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});

capsuleOverlap

Static capsuleOverlap(capsulePos, radius, halfHeight, collisionParams, renderParams): GameObject[]

返回一个与给定胶囊体重叠的对象数组

Parameters

capsulePos Vector检测位置
radius number胶囊体半径
halfHeight number胶囊体半高
collisionParams CollisionQueryParams碰撞查询渲染参数
renderParams RenderQueryParams空间查询渲染参数

Returns

GameObject[]GameObject数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.capsuleOverlap(new mw.Vector(0,0,0), 30, 80, {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.capsuleOverlap(new mw.Vector(0,0,0), 30, 80, {}, {});
for (const item of result) {
    // item:  检测结果。
}

capsuleTraceMulti

Static capsuleTraceMulti(start, end, radius, halfHeight, collisionParams, renderParams): HitResult[]

沿着给定的路线扫描一个胶囊,并返回遇到的所有命中,包括第一次拦截命中。

Parameters

start Vector起始点
end Vector终止点
radius number胶囊体半径
halfHeight number胶囊体半高
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResult[]HitResult数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.capsuleTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.capsuleTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
for (const item of result) {
    // item:  检测结果。
}

capsuleTraceSingle

Static capsuleTraceSingle(start, end, radius, halfHeight, collisionParams, renderParams): HitResult

沿着给定的线扫过一个胶囊体,并返回遇到的第一个阻挡命中。

Parameters

start Vector起始点
end Vector终止点
radius number胶囊体半径
halfHeight number胶囊体半高
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResultHitResult
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.capsuleTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
const result = PhysicsService.capsuleTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});

deleteCollisionGroup

Static deleteCollisionGroup(name): void

删除已有碰撞组

Parameters

name string碰撞组名 range: 不限制
使用示例:在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下 1 后可在编辑器窗口客户端内看到输出"GroupB"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.deleteCollisionGroup("GroupA");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }

    protected onUpdate(dt: number): void {

    }

    // 脚本被销毁时最后一帧执行完调用此函数
    protected onDestroy(): void {

    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.deleteCollisionGroup("GroupA");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }

    protected onUpdate(dt: number): void {

    }

    // 脚本被销毁时最后一帧执行完调用此函数
    protected onDestroy(): void {

    }
}

getAvailableCollisionGroupsCount

Static getAvailableCollisionGroupsCount(): number

获取当前可剩余使用碰撞组数量

Returns

number剩余可用碰撞组数量
使用示例: 在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下 1 后可在编辑器窗口客户端内看到输出 "8"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getAvailableCollisionGroupsCount());
        })
    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getAvailableCollisionGroupsCount());
        })
    }
}

getCollisionBetweenGroups

Static getCollisionBetweenGroups(group1, group2): boolean

获取两碰撞组之间的碰撞关系(是否可发生碰撞)

Parameters

group1 string碰撞组名 1 range: 不限制
group2 string碰撞组名 2 range: 不限制

Returns

boolean碰撞关系(是否可发生碰撞)
使用示例: 在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下 1 后可在编辑器窗口客户端内看到输出 "false"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getCollisionBetweenGroups("GroupA", "GroupB"));
        })
    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getCollisionBetweenGroups("GroupA", "GroupB"));
        })
    }
}

getValidCollisionGroups

Static getValidCollisionGroups(): string[]

获取当前已添加的碰撞组名列表

Returns

string[]当前已添加的碰撞组名列表
使用示例: 在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下1后可在编辑器窗口客户端内看到输出 "GroupA,GroupB"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }
}

isCollisionGroupValid

Static isCollisionGroupValid(name): boolean

检测碰撞组是否有效(已添加过)

Parameters

name string碰撞组名 range: 不限制

Returns

boolean碰撞组是否有效
使用示例:在场景中创建一个名为 CollisionGroup 的脚本,并拖入场景中,并复制以下代码进入脚本。按下 1 后可在编辑器窗口客户端内看到输出 "false"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.isCollisionGroupValid("GroupC"));
        })
    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            console.log(PhysicsService.isCollisionGroupValid("GroupC"));
        })
    }
}

lineTraceMulti

Static lineTraceMulti(start, end, collisionParams, renderParams): HitResult[]

沿着给定的行执行碰撞跟踪,并返回遇到的所有命中,直到并包括第一次阻塞命中。

Parameters

start Vector起始点
end Vector终止点
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResult[]HitResult数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.lineTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.lineTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
for (const item of result) {
    // item:  检测结果。
}

lineTraceSingle

Static lineTraceSingle(start, end, collisionParams, renderParams): HitResult

沿着给定的线进行碰撞追踪,并返回遇到的第一个阻挡命中。

Parameters

start Vector起始点
end Vector终止点
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResultHitResult
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.lineTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
const result = PhysicsService.lineTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});

renameCollisionGroup

Static renameCollisionGroup(previousName, newName): void

重命名碰撞组

Parameters

previousName string碰撞组名 range: 不限制
newName string新碰撞组名 range: 不限制
使用示例:在场景中创建一个名为CollisionGroup的脚本,并拖入场景中,并复制以下代码进入脚本。按下1后可在编辑器窗口客户端内看到输出"GroupB,GroupC"
ts
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.renameCollisionGroup("GroupA","GroupC");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }

    protected onUpdate(dt: number): void {

    }

    // 脚本被销毁时最后一帧执行完调用此函数
    protected onDestroy(): void {

    }
}
@Component
export default class CollisionGroup extends Script {

    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            PhysicsService.renameCollisionGroup("GroupA","GroupC");
            console.log(PhysicsService.getValidCollisionGroups());
        })
    }

    protected onUpdate(dt: number): void {

    }

    // 脚本被销毁时最后一帧执行完调用此函数
    protected onDestroy(): void {

    }
}

setCollisionBetweenGroups

Static setCollisionBetweenGroups(group1, group2, collidable): void

设置俩碰撞组之间的碰撞关系(是否可发生碰撞)

Parameters

group1 string碰撞组名1 range: 不限制
group2 string碰撞组名2 range: 不限制
collidable boolean是否可碰撞
使用示例: 在场景中创建一个名为CollisionGroup的脚本,并拖入场景中,并复制以下代码进入脚本。按下1和2会看到场景中生成了两个小球,并推动距离最近的小球去撞击另一个,会发现玩家可以与球体发生碰撞,但两个小球间可穿透。
ts
@Component
export default class CollisionGroup extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.serverCreateBall(new Vector(300, 0, 0), "GroupA", true);
        })

        // 创建正常碰撞的球体B并设置碰撞组为GroupB
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.serverCreateBall(new Vector(600, 0, 0), "GroupB", false);
        })
    }

    @mw.RemoteFunction(mw.Server)
    serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
    {
        GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
            let ball  = obj as mw.Model;
            ball.worldTransform.position = pos;
            if (bPhysicsSimulate)
            {
                ball.physicsEnabled = true;
                ball.massEnabled = true;
                ball.mass = 50;
            }
            ball.collisionGroup = Group;
        })
    }
}
@Component
export default class CollisionGroup extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        PhysicsService.addCollisionGroup("GroupA");
        PhysicsService.addCollisionGroup("GroupB");
        PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);

        // 创建模拟物理的球体A并设置碰撞组为GroupA
        InputUtil.onKeyDown(Keys.One, ()=>{
            this.serverCreateBall(new Vector(300, 0, 0), "GroupA", true);
        })

        // 创建正常碰撞的球体B并设置碰撞组为GroupB
        InputUtil.onKeyDown(Keys.Two, ()=>{
            this.serverCreateBall(new Vector(600, 0, 0), "GroupB", false);
        })
    }

    @mw.RemoteFunction(mw.Server)
    serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
    {
        GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
            let ball  = obj as mw.Model;
            ball.worldTransform.position = pos;
            if (bPhysicsSimulate)
            {
                ball.physicsEnabled = true;
                ball.massEnabled = true;
                ball.mass = 50;
            }
            ball.collisionGroup = Group;
        })
    }
}

sphereOverlap

Static sphereOverlap(spherePos, sphereRadius, collisionParams, renderParams): GameObject[]

返回一个与给定球体重叠的对象数组

Parameters

spherePos Vector检测位置
sphereRadius number球半径
collisionParams CollisionQueryParams碰撞查询渲染参数
renderParams RenderQueryParams空间查询渲染参数

Returns

GameObject[]GameObject数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.sphereOverlap(new mw.Vector(0,0,0), 30, {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.sphereOverlap(new mw.Vector(0,0,0), 30, {}, {});
for (const item of result) {
    // item:  检测结果。
}

sphereTraceMulti

Static sphereTraceMulti(start, end, radius, collisionParams, renderParams): HitResult[]

沿着给定的直线扫过一个球体,并返回所有命中,包括第一次拦截命中。

Parameters

start Vector起始点
end Vector终止点
radius number球形半径
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResult[]HitResult数组
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.sphereTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
for (const item of result) {
    // item:  检测结果。
}
const result = PhysicsService.sphereTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
for (const item of result) {
    // item:  检测结果。
}

sphereTraceSingle

Static sphereTraceSingle(start, end, radius, collisionParams, renderParams): HitResult

沿着给定的线扫过一个球体,并返回遇到的第一个阻挡命中。

Parameters

start Vector起始点
end Vector终止点
radius number球形半径
collisionParams CollisionQueryParams空间查询碰撞参数
renderParams RenderQueryParams空间查询渲染参数

Returns

HitResultHitResult
使用示例: 如下示例展示使用矩形范围检测的基本流程
ts
const result = PhysicsService.sphereTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
const result = PhysicsService.sphereTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});