网络

import { Behaviour, syncField, IPointerClickHandler } from "@needle-tools/engine"

export class SyncedNumber extends Behaviour implements IPointerClickHandler {

    // Use `@syncField` to automatically network a field. 
    // You can optionally assign a method or method name to be called when the value changes.
    @syncField("myValueChanged")
    mySyncedValue?: number = 1;
    
    private myValueChanged() {
       console.log("My value changed", this.mySyncedValue);
    }
    
    onPointerClick() {
       this.mySyncedValue = Math.random();
    }
}

import { Behaviour, IPointerClickHandler, PointerEventData, Renderer, RoomEvents, delay, serializable, showBalloonMessage, syncField } from "@needle-tools/engine";
import { Color } from "three"

export class Networking_ClickToChangeColor extends Behaviour implements IPointerClickHandler {

    // START MARKER network color change syncField
    /** syncField does automatically send a property value when it changes */
    @syncField(Networking_ClickToChangeColor.prototype.onColorChanged)
    @serializable(Color)
    color!: Color;

    private onColorChanged() {
        // syncField will network the color as a number, so we need to convert it back to a Color when we receive it
        if (typeof this.color === "number")
            this.color = new Color(this.color);
        this.setColorToMaterials();
    }
    // END MARKER network color change syncField

    /** called when the object is clicked and does generate a random color */
    onPointerClick(_: PointerEventData) {
        const randomColor = new Color(Math.random(), Math.random(), Math.random());
        this.color = randomColor;
    }

    onEnable() {
        this.setColorToMaterials();
    }

    private setColorToMaterials() {
        const renderer = this.gameObject.getComponent(Renderer);
        if (renderer) {
            for (let i = 0; i < renderer.sharedMaterials.length; i++) {
                // we clone the material so that we don't change the original material
                // just for demonstration purposes, you can also change the original material
                const mat = renderer.sharedMaterials[i]?.clone();
                renderer.sharedMaterials[i] = mat;
                if (mat && "color" in mat)
                    mat.color = this.color;
            }
        }
        else console.warn("No renderer found", this.gameObject)
    }

}

this.context.connection.send(key: string, data: IModel | object | boolean | string | number | null);

this.context.connection.beginListen(key:string, callback:(data) => void)

this.context.connection.stopListen(key:string)

// 这条消息将发送给当前在房间中的所有用户，
// 以及稍后加入房间的用户。
this.context.connection.send("my-message", { guid: this.guid, myData: "myValue" });

// 这条消息将发送给当前在房间中的所有用户，
// 但不会发送给稍后加入房间的用户。
this.context.connection.send("my-message", { guid: this.guid, myData: "myValue", dontSave: true });

// 这条消息将发送给当前在房间中的所有用户，
// 但不会发送给稍后加入房间的用户。
this.context.connection.send("my-message", { myData: "myValue" });

// 这条消息将发送给当前在房间中的所有用户，
// 以及稍后加入房间的用户，
// 但将在用户断开连接时从房间状态中删除。
this.context.connection.send("my-message", { guid: this.guid, myData: "myValue", deleteOnDisconnect: true });

this.context.connection.send("delete-state", { guid: "guid_to_delete" });

// 监听 *您* 加入联网房间的事件
this.context.beginListen(RoomEvents.JoinedRoom, ({room, viewId, allowEditing, inRoom}) => { ... });

// 监听 *您* 离开联网房间的事件
this.context.beginListen(RoomEvents.LeftRoom, ({room}) => { ... });

// 监听 *另一个用户* 加入您联网房间的事件
this.context.beginListen(RoomEvents.UserJoinedRoom, ({userId}) => { ... });

// 监听 *另一个用户* 离开您联网房间的事件
this.context.beginListen(RoomEvents.UserLeftRoom, ({userId}) => { ... });

// 在所有当前房间状态已发送到客户端后接收此事件
this.context.beginListen(RoomEvents.RoomStateSent, () => { ... });

setPeerOptions(opts: PeerjsOptions);

this.context.connection.sendBinary(byteArray: Uint8Array);

this.context.connection.beginListenBinary(identifier:string, callback:(data : ByteBuffer) => void);

this.context.connection.stopListenBinary(identifier:string);

// Register a new Flatbuffer schema with the networking system
import { registerBinaryType } from '@needle-tools/engine';
import { MyDataModel } from 'my-data-model.js';

const MySchemaIdentifier = "MYSC";

registerBinaryType(MySchemaIdentifier, MyDataModel.getRootAsSyncedTransformModel);

// Prepare data for sending by creating a Flatbuffer message:
import { MyDataModel } from 'my-data-model.js';

const MySchemaIdentifier = "MYSC";
const builder = new flatbuffers.Builder();

// Construct a Flatbuffer message
function createMyCustomModel(somePayload: string): Uint8Array {
    builder.clear();
    MyDataModel.startMyDataModel(builder);    
    const guidObj = builder.createString(guid);
    MyDataModel.addSomePayload(builder, guidObj);
    const res = MyDataModel.endMyDataModel(builder);
    builder.finish(res, MySchemaIdentifier);
    return builder.asUint8Array();
}

// Send the data
function sendData() {
    const data = createMyCustomModel("your-payload", this, true);
    this.context.connection.sendBinary(data);
}

// Subscribe to receive this specific message type:
import { MyDataModel } from 'my-data-model.js';

const MySchemaIdentifier = "MYSC";

this.context.connection.beginListenBinary(MySchemaIdentifier, (data) => {
    const model = MyDataModel.getRootAsMyDataModel(data);
    console.log("Received binary message", model, model.somePayload());
});